federation

type Entity struct {
	Name      string // The same name as the type declaration
	Def       *ast.Definition
	Resolvers []*EntityResolver
	Requires  []*Requires
	Multi     bool
	// PerEntity selects one resolver for the entity, taking a representation
	// input, instead of one resolver per @key. Set from the
	// entity_resolver_per_entity option.
	PerEntity bool
	// RepresentationType is the Go type of a per-entity resolver's argument:
	// one representation, or a list of them for a batch resolver.
	RepresentationType *config.TypeReference
	// RequiresStrategy is how this entity's @requires fields are delivered to
	// the resolver. Resolved per entity in buildEntity.
	RequiresStrategy RequiresStrategy
	Type             types.Type
	// ImplDirectives are the resolved non-federation OBJECT-level directives
	// with full type information, populated in GenerateCode for use in the
	// federation template to wrap entity resolver calls.
	ImplDirectives []*codegen.Directive
}

type EntityResolver struct {
	ResolverName   string      // The resolver name, such as FindUserByID
	KeyFields      []*KeyField // The fields declared in @key.
	InputType      types.Type  // The Go generated input type for multi entity resolvers
	InputTypeName  string
	ReturnType     types.Type // The Go generated return type for the entity
	ReturnTypeName string
}

type Federation struct {
	Entities         []*Entity
	RequiresEntities map[string]*Entity
	PackageOptions   PackageOptions
	// contains filtered or unexported fields
}

type KeyField struct {
	Definition *ast.FieldDefinition
	Field      fieldset.Field        // len > 1 for nested fields
	Type       *config.TypeReference // The Go representation of that field type
	// GoName is the field name this key takes in the generated multi-resolver
	// input struct. It is normally Field.ToGo(), but is disambiguated with a
	// numeric suffix when two key paths in the same resolver would otherwise
	// produce the same Go name (e.g. "id" and "i { d }" both yield "ID").
	// Using a single stored name keeps the SDL input field, the modelgen struct
	// field, and the template's struct literal in agreement.
	GoName string
}

type PackageOptions struct {
	// ExplicitRequires will generate a function in the execution context
	// to populate fields using the @required directive into the entity.
	//
	// You can only set one of ExplicitRequires or ComputedRequires to true.
	ExplicitRequires bool
	// ComputedRequires generates resolver functions to compute values for
	// fields using the @required directive.
	ComputedRequires bool
	// EntityResolverMulti is default engine for entityResolver generation.
	// This can be overriding by @entityResolver(multi: Boolean) directive.
	// false by default.
	EntityResolverMulti bool
	// EntityResolverPerEntity generates one resolver per entity, taking a
	// representation input, instead of one per @key, for every entity. A
	// temporary opt-in: it is planned to become the default. false by default.
	EntityResolverPerEntity bool
	// PreloadedRequires sets "preloaded" as the package-level default @requires
	// strategy; individual entities may override it via
	// @entityResolver(requires: "…"). Under preloaded, the generated multi
	// resolver input (<Entity>By<Keys>sInput) carries the entity's @requires
	// fields, unmarshaled before the resolver runs, so a multi resolver sees
	// every entity's @requires data in one scope — enabling a naturally-batched
	// computation (e.g. one ML-inference call across the whole batch). Multi
	// entities only, unless EntityResolverPerEntity is set: then the
	// <Type>Representation of every entity, single or multi, carries them,
	// nullable, nested and list paths included. false by default.
	PreloadedRequires bool
}

type Requires struct {
	Name  string                // the name of the field
	Field fieldset.Field        // source Field, len > 1 for nested fields
	Type  *config.TypeReference // The Go representation of that field type
	// Computed reports whether this @requires field is delivered via a standalone
	// field resolver (the computed strategy) rather than through the entity
	// resolver. It is true when the field carries @computedRequires, or when the whole
	// entity resolves to RequiresComputed (the computed_requires package option,
	// which computes every @requires field). Set in buildRequires.
	Computed bool
}

type RequiresStrategy string