graphql/schema/meta.gql.go

// Code generated by scripts/gengraphql.go. DO NOT EDIT.

package schema

import (
	errors "errors"
	graphql1 "github.com/graphql-go/graphql"
	graphql "github.com/sensu/sensu-go/graphql"
)

// KVPairStringKeyFieldResolver implement to resolve requests for the KVPairString's key field.
type KVPairStringKeyFieldResolver interface {
	// Key implements response to request for key field.
	Key(p graphql.ResolveParams) (string, error)
}

// KVPairStringValFieldResolver implement to resolve requests for the KVPairString's val field.
type KVPairStringValFieldResolver interface {
	// Val implements response to request for val field.
	Val(p graphql.ResolveParams) (string, error)
}

//
// KVPairStringFieldResolvers represents a collection of methods whose products represent the
// response values of the 'KVPairString' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type KVPairStringFieldResolvers interface {
	KVPairStringKeyFieldResolver
	KVPairStringValFieldResolver
}

// KVPairStringAliases implements all methods on KVPairStringFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type KVPairStringAliases struct{}

// Key implements response to request for 'key' field.
func (_ KVPairStringAliases) Key(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'key'")
	}
	return ret, err
}

// Val implements response to request for 'val' field.
func (_ KVPairStringAliases) Val(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'val'")
	}
	return ret, err
}

/*
KVPairStringType The KVPairString type respresents a name-value relationship where the value is
always a string.
*/
var KVPairStringType = graphql.NewType("KVPairString", graphql.ObjectKind)

// RegisterKVPairString registers KVPairString object type with given service.
func RegisterKVPairString(svc *graphql.Service, impl KVPairStringFieldResolvers) {
	svc.RegisterObject(_ObjectTypeKVPairStringDesc, impl)
}
func _ObjTypeKVPairStringKeyHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(KVPairStringKeyFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Key(frp)
	}
}

func _ObjTypeKVPairStringValHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(KVPairStringValFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Val(frp)
	}
}

func _ObjectTypeKVPairStringConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "The KVPairString type respresents a name-value relationship where the value is\nalways a string.",
		Fields: graphql1.Fields{
			"key": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "key",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"val": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "val",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
		},
		Interfaces: []*graphql1.Interface{},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see KVPairStringFieldResolvers.")
		},
		Name: "KVPairString",
	}
}

// describe KVPairString's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeKVPairStringDesc = graphql.ObjectDesc{
	Config: _ObjectTypeKVPairStringConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"key": _ObjTypeKVPairStringKeyHandler,
		"val": _ObjTypeKVPairStringValHandler,
	},
}

// ObjectMetaNameFieldResolver implement to resolve requests for the ObjectMeta's name field.
type ObjectMetaNameFieldResolver interface {
	// Name implements response to request for name field.
	Name(p graphql.ResolveParams) (string, error)
}

// ObjectMetaNamespaceFieldResolver implement to resolve requests for the ObjectMeta's namespace field.
type ObjectMetaNamespaceFieldResolver interface {
	// Namespace implements response to request for namespace field.
	Namespace(p graphql.ResolveParams) (string, error)
}

// ObjectMetaLabelsFieldResolver implement to resolve requests for the ObjectMeta's labels field.
type ObjectMetaLabelsFieldResolver interface {
	// Labels implements response to request for labels field.
	Labels(p graphql.ResolveParams) (interface{}, error)
}

// ObjectMetaAnnotationsFieldResolver implement to resolve requests for the ObjectMeta's annotations field.
type ObjectMetaAnnotationsFieldResolver interface {
	// Annotations implements response to request for annotations field.
	Annotations(p graphql.ResolveParams) (interface{}, error)
}

//
// ObjectMetaFieldResolvers represents a collection of methods whose products represent the
// response values of the 'ObjectMeta' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type ObjectMetaFieldResolvers interface {
	ObjectMetaNameFieldResolver
	ObjectMetaNamespaceFieldResolver
	ObjectMetaLabelsFieldResolver
	ObjectMetaAnnotationsFieldResolver
}

// ObjectMetaAliases implements all methods on ObjectMetaFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type ObjectMetaAliases struct{}

// Name implements response to request for 'name' field.
func (_ ObjectMetaAliases) Name(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'name'")
	}
	return ret, err
}

// Namespace implements response to request for 'namespace' field.
func (_ ObjectMetaAliases) Namespace(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'namespace'")
	}
	return ret, err
}

// Labels implements response to request for 'labels' field.
func (_ ObjectMetaAliases) Labels(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Annotations implements response to request for 'annotations' field.
func (_ ObjectMetaAliases) Annotations(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// ObjectMetaType ObjectMeta is metadata all persisted objects have.
var ObjectMetaType = graphql.NewType("ObjectMeta", graphql.ObjectKind)

// RegisterObjectMeta registers ObjectMeta object type with given service.
func RegisterObjectMeta(svc *graphql.Service, impl ObjectMetaFieldResolvers) {
	svc.RegisterObject(_ObjectTypeObjectMetaDesc, impl)
}
func _ObjTypeObjectMetaNameHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(ObjectMetaNameFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Name(frp)
	}
}

func _ObjTypeObjectMetaNamespaceHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(ObjectMetaNamespaceFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Namespace(frp)
	}
}

func _ObjTypeObjectMetaLabelsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(ObjectMetaLabelsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Labels(frp)
	}
}

func _ObjTypeObjectMetaAnnotationsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(ObjectMetaAnnotationsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Annotations(frp)
	}
}

func _ObjectTypeObjectMetaConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "ObjectMeta is metadata all persisted objects have.",
		Fields: graphql1.Fields{
			"annotations": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "annotations",
				Type:              graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("KVPairString"))),
			},
			"labels": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "labels",
				Type:              graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("KVPairString"))),
			},
			"name": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "name",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"namespace": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "namespace",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
		},
		Interfaces: []*graphql1.Interface{},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see ObjectMetaFieldResolvers.")
		},
		Name: "ObjectMeta",
	}
}

// describe ObjectMeta's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeObjectMetaDesc = graphql.ObjectDesc{
	Config: _ObjectTypeObjectMetaConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"annotations": _ObjTypeObjectMetaAnnotationsHandler,
		"labels":      _ObjTypeObjectMetaLabelsHandler,
		"name":        _ObjTypeObjectMetaNameHandler,
		"namespace":   _ObjTypeObjectMetaNamespaceHandler,
	},
}