codegen

type ArgSet struct {
	Args     []*FieldArgument
	FuncDecl string
}

type AugmentedSource struct {
	// path relative to Config.Exec.Filename
	RelativePath string
	Embeddable   bool
	BuiltIn      bool
	Source       string
}

type Data struct {
	Config *config.Config
	Schema *ast.Schema
	// If a schema is broken up into multiple Data instance, each representing part of the schema,
	// AllDirectives should contain the directives for the entire schema. Directives() can
	// then be used to get the directives that were defined in this Data instance's sources.
	// If a single Data instance is used for the entire schema, AllDirectives and Directives()
	// will be identical.
	// AllDirectives should rarely be used directly.
	AllDirectives   DirectiveList
	Objects         Objects
	Inputs          Objects
	Interfaces      map[string]*Interface
	ReferencedTypes map[string]*config.TypeReference
	ComplexityRoots map[string]*Object

	QueryRoot        *Object
	MutationRoot     *Object
	SubscriptionRoot *Object
	AugmentedSources []AugmentedSource
	Plugins          []interface{}
}

type Directive struct {
	*ast.DirectiveDefinition
	Name    string
	Args    []*FieldArgument
	Builtin bool
}

type DirectiveList map[string]*Directive

type Field struct {
	*ast.FieldDefinition

	TypeReference    *config.TypeReference
	GoFieldType      GoFieldType      // The field type in go, if any
	GoReceiverName   string           // The name of method & var receiver in go, if any
	GoFieldName      string           // The name of the method or var in go, if any
	IsResolver       bool             // Does this field need a resolver
	Args             []*FieldArgument // A list of arguments to be passed to this field
	MethodHasContext bool             // If this is bound to a go method, does the method also take a context
	NoErr            bool             // If this is bound to a go method, does that method have an error as the second argument
	VOkFunc          bool             // If this is bound to a go method, is it of shape (interface{}, bool)
	Object           *Object          // A link back to the parent object
	Default          interface{}      // The default value
	Stream           bool             // does this field return a channel?
	Directives       []*Directive
}

type FieldArgument struct {
	*ast.ArgumentDefinition
	TypeReference *config.TypeReference
	VarName       string      // The name of the var in go
	Object        *Object     // A link back to the parent object
	Default       interface{} // The default value
	Directives    []*Directive
	Value         interface{} // value set in Data
}

type GoFieldType int

type Interface struct {
	*ast.Definition
	Type         types.Type
	Implementors []InterfaceImplementor
	InTypemap    bool
}

type InterfaceImplementor struct {
	*ast.Definition

	Type    types.Type
	TakeRef bool
}

type Object struct {
	*ast.Definition

	Type                    types.Type
	ResolverInterface       types.Type
	Root                    bool
	Fields                  []*Field
	Implements              []*ast.Definition
	DisableConcurrency      bool
	Stream                  bool
	Directives              []*Directive
	PointersInUmarshalInput bool
}

type Objects []*Object