schema

type Argument struct {
	Name  string
	Value interface{}
}

type Directive struct {
	Definition *DirectiveDefinition
	Arguments  []*Argument
}

type DirectiveDefinition struct {
	Description string
	Arguments   map[string]*InputValueDefinition
	Locations   []DirectiveLocation

	// If non-nil, this function will be invoked during field collection for each selection with
	// this directive present. If the function returns false, the selection will be skipped.
	FieldCollectionFilter func(arguments map[string]interface{}) bool
}

type DirectiveLocation string

type EnumType struct {
	Name        string
	Description string
	Directives  []*Directive
	Values      map[string]*EnumValueDefinition

	// This type is only available for introspection and use when the given features are enabled.
	RequiredFeatures FeatureSet
}

type EnumValueDefinition struct {
	Description       string
	Directives        []*Directive
	Value             interface{}
	DeprecationReason string
}

type FeatureSet map[string]struct{}

type FieldContext struct {
	Context   context.Context
	Schema    *Schema
	Object    interface{}
	Features  FeatureSet
	Arguments map[string]interface{}

	// IsSubscribe is true if this is a subscription field being invoked for a subscribe operation.
	// Subselections of this field will not be executed, and the return value will be returned
	// immediately to the caller of Subscribe.
	IsSubscribe bool
}

type FieldCost struct {
	// If non-nil, this context will be passed on to sub-selections of the current field.
	Context context.Context

	// This is the cost of executing the resolver. Typically it will be 1, but if a resolver is
	// particularly expensive, it may be greater.
	Resolver int

	// This is a multiplier applied to all sub-selections of the current field. For fields that
	// return arrays, this is typically the number of expected results (e.g. the "first" or "last"
	// argument to a connection field). Defaults to 1 if not set.
	Multiplier int
}

type FieldCostContext struct {
	Context context.Context

	// The arguments that were provided.
	Arguments map[string]interface{}
}

type FieldDefinition struct {
	Description       string
	Arguments         map[string]*InputValueDefinition
	Type              Type
	Directives        []*Directive
	DeprecationReason string

	// This field is only available for introspection and use when the given features are enabled.
	RequiredFeatures FeatureSet

	// This function can be used to define the cost of resolving the field. The total cost of an
	// operation can be calculated before the operation is executed, enabling rate limiting and
	// metering.
	Cost func(FieldCostContext) FieldCost

	Resolve func(FieldContext) (interface{}, error)
}

type InputObjectType struct {
	Name        string
	Description string
	Directives  []*Directive
	Fields      map[string]*InputValueDefinition

	// This type is only available for introspection and use when the given features are enabled.
	RequiredFeatures FeatureSet

	// If given, input objects can validated and converted to other types via this function.
	// Otherwise the objects will remain as maps. This function is called after all fields are fully
	// coerced.
	InputCoercion func(map[string]interface{}) (interface{}, error)

	// Normally input objects only need to be coerced from inputs. However, if an argument of this
	// type is given a default value, we need to be able to do the reverse in order to serialize it
	// for introspection queries.
	//
	// For most use-cases, this function is optional. If it is required, but nil, you will get an
	// error when you attempt to create the schema.
	ResultCoercion func(interface{}) (map[string]interface{}, error)
}

type InputValueDefinition struct {
	Description string
	Type        Type

	// For null, set this to Null.
	DefaultValue interface{}

	Directives []*Directive
}

type InterfaceType struct {
	Name        string
	Description string
	Directives  []*Directive
	Fields      map[string]*FieldDefinition

	// This type is only available for introspection and use when the given features are enabled.
	RequiredFeatures FeatureSet
}

type ListType struct {
	Type Type
}

type NamedType interface {
	Type
	TypeName() string
}

type NonNullType struct {
	Type Type
}

type ObjectType struct {
	Name        string
	Description string
	Directives  []*Directive
	Fields      map[string]*FieldDefinition

	// This type is only available for introspection and use when the given features are enabled.
	RequiredFeatures FeatureSet

	ImplementedInterfaces []*InterfaceType

	// Objects that implement one or more interfaces must define this. The function should return
	// true if obj is an object of this type.
	IsTypeOf func(obj interface{}) bool
}

type ScalarType struct {
	Name        string
	Description string
	Directives  []*Directive

	// This type is only available for introspection and use when the given features are enabled.
	RequiredFeatures FeatureSet

	// Should return nil if coercion is impossible.
	LiteralCoercion func(ast.Value) interface{}

	// Should return nil if coercion is impossible.
	VariableValueCoercion func(interface{}) interface{}

	// Should return nil if coercion is impossible. In many cases, this can be the same as
	// VariableValueCoercion.
	ResultCoercion func(interface{}) interface{}
}

type Schema struct {
	// contains filtered or unexported fields
}

type SchemaDefinition struct {
	// Directives to define within the schema. For example, you might want to add IncludeDirective
	// and SkipDirective here.
	Directives map[string]*DirectiveDefinition

	Query        *ObjectType
	Mutation     *ObjectType
	Subscription *ObjectType

	// AdditionalTypes is used to add otherwise unreferenced types to the schema.
	AdditionalTypes []NamedType
}

type Type interface {
	String() string
	IsInputType() bool
	IsOutputType() bool
	IsSubTypeOf(Type) bool
	IsSameType(Type) bool
	TypeRequiredFeatures() FeatureSet
}

type UnionType struct {
	Name        string
	Description string
	Directives  []*Directive
	MemberTypes []*ObjectType

	// This type is only available for introspection and use when the given features are enabled.
	RequiredFeatures FeatureSet
}

type WrappedType interface {
	Type
	Unwrap() Type
}