graphql

type BeginCaller ¶

type BeginCaller[P any] func(context.Context, P) (CallerExecution, error)

type CallerAnalyticsExecution ¶

type CallerAnalyticsExecution interface {
	ExecuteFrozenAnalytics(context.Context, golem.FrozenAnalyticsRequest) ([][]golem.RuntimeAnalyticsCell, error)
}

CallerAnalyticsExecution is required only when the selected operation contains an explicitly generated P6 analytics root.

type CallerCustomExecution ¶

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

func (execution *CallerCustomExecution) Execute(ctx context.Context, operation CustomOperation, name string, arguments map[string]any) (CustomResult, error)

type CallerEventExecution ¶

type CallerEventExecution interface {
	SubscribeFrozenEvents(context.Context, golem.FrozenReadRequest, bool) (EventStream, error)
}

CallerEventExecution is the generated caller-only capability used by P7. System and transaction clients deliberately do not implement it.

type CallerExecution ¶

type CallerExecution interface {
	ExecuteFrozenRead(context.Context, golem.FrozenReadRequest) ([]golem.RuntimeModelRow, error)
}

CallerExecution is the caller-only runtime capability accepted by generated GraphQL. *runtime.Caller implements it directly; System deliberately does not. One instance is created and shared by all roots in one operation.

type CallerMutationExecution ¶

type CallerMutationExecution interface {
	ExecuteFrozenMutation(context.Context, golem.RuntimeMutationRequest) (golem.RuntimeMutationResult, error)
}

CallerMutationExecution is the caller-only mutation capability consumed by generated GraphQL. runtime.CallerMutationExecution implements it; System deliberately cannot.

type ComputedArgument ¶

type ComputedArgument struct {
	Name  string
	Value any
}

ComputedArgument is one already-coerced argument supplied to generated application glue. Value has the exact declared Go scalar/list representation.

type ComputedBatchFunc ¶

type ComputedBatchFunc func(context.Context, []ComputedBatchParent, []ComputedArgument) (map[string]ComputedBatchResult, error)

type ComputedBatchParent ¶

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

func (value ComputedBatchParent) CacheKey() string

func (value ComputedBatchParent) Parent() golem.RuntimeModelRow

type ComputedBatchResult ¶

type ComputedBatchResult struct {
	Value any
	Err   error
}

type ComputedBinding ¶

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

ComputedBinding is an opaque generated binding. Constructors are the only way to create one, keeping the executor-facing capability closed and small.

func BindBatchedComputed(extensionID string, cacheKey ComputedCacheKeyFunc, batch ComputedBatchFunc) (ComputedBinding, error)

func BindComputed(extensionID string, resolve ComputedResolveFunc) (ComputedBinding, error)

func BindGeneratedBatchedComputed[M any, K comparable, A, R any](extensionID string, descriptor golem.ModelDescriptor[M], key golem.ScalarColumn[M, K], loader func(context.Context, []K, A) (map[K]R, error), codec func(K) (string, error)) (ComputedBinding, error)

func BindGeneratedComputed[M, A, R any](extensionID string, descriptor golem.ModelDescriptor[M], resolver func(context.Context, golem.Row[M], A) (R, error)) (ComputedBinding, error)

type ComputedCacheKeyFunc ¶

type ComputedCacheKeyFunc func(context.Context, ComputedRequest) (key string, present bool, err error)

type ComputedRequest ¶

type ComputedRequest struct {
	Parent    golem.RuntimeModelRow
	Arguments []ComputedArgument
}

ComputedRequest contains only the masked dependency row and typed arguments. It deliberately carries no caller, database, system, or transaction handle.

type ComputedResolveFunc ¶

type ComputedResolveFunc func(context.Context, ComputedRequest) (any, error)

type Config ¶

type Config[P any] struct {
	PrincipalFromContext func(context.Context) (P, bool)
	Limits               Limits
	Introspection        bool
	ContractFingerprint  golem.SchemaDigest
	ReportInternalError  func(context.Context, error)
	ExecutableSchema     gqlgengraphql.ExecutableSchema
	EventLimits          events.Limits
	Observer             observe.Observer
	Provider             golem.Provider
	WebSocketInit        func(context.Context, json.RawMessage) (context.Context, error)
}

type CustomArgument ¶

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

CustomArgument is one already-coerced exact value in declaration order. Generated glue converts it into the statically known application Args field.

func (argument CustomArgument) Name() string

func (argument CustomArgument) Value() any

type CustomArgumentDecoder ¶

type CustomArgumentDecoder[A any] func([]CustomArgument) (A, error)

type CustomBinding ¶

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

CustomBinding is opaque generated glue. Its invocation receives exactly the caller object supplied for this execution; no System/DB/Tx/raw-SQL channel is present in the registry API. Explicit transactions remain methods on Caller.

func BindCustomMutation[C, A, R any](spec CustomBindingSpec, decode CustomArgumentDecoder[A], resolver func(context.Context, C, A) (R, error), encode CustomResultEncoder[R]) (CustomBinding, error)

func BindCustomQuery[C, A, R any](spec CustomBindingSpec, decode CustomArgumentDecoder[A], resolver func(context.Context, C, A) (R, error), encode CustomResultEncoder[R]) (CustomBinding, error)

func BindGeneratedCustomMutationContract[C, A, R any](bundle golem.SchemaBundle, spec CustomBindingSpec, resolver func(context.Context, C, A) (R, error), conversions ...GeneratedCustomArgumentConversion) (CustomBinding, error)

func BindGeneratedCustomMutationModelContract[M, C, A, R any](bundle golem.SchemaBundle, spec CustomBindingSpec, _ golem.ModelDescriptor[M], resolver func(context.Context, C, A) (R, error), conversions ...GeneratedCustomArgumentConversion) (CustomBinding, error)

func BindGeneratedCustomQueryContract[C, A, R any](bundle golem.SchemaBundle, spec CustomBindingSpec, resolver func(context.Context, C, A) (R, error), conversions ...GeneratedCustomArgumentConversion) (CustomBinding, error)

func BindGeneratedCustomQueryModelContract[M, C, A, R any](bundle golem.SchemaBundle, spec CustomBindingSpec, _ golem.ModelDescriptor[M], resolver func(context.Context, C, A) (R, error), conversions ...GeneratedCustomArgumentConversion) (CustomBinding, error)

type CustomBindingSpec ¶

type CustomBindingSpec struct {
	ExtensionID     string
	ResolverPackage string
	ResolverName    string
}

CustomBindingSpec is emitted from one statically interpreted AttachedMethod. The runtime registry matches every field against canonical ContractIR before any resolver becomes callable.

type CustomCallerCapability ¶

type CustomCallerCapability interface {
	GolemGraphQLCallerCapability()
}

CustomCallerCapability is implemented by runtime Caller and by the generated application Caller wrapper. System, DB, and transaction handles do not implement it and therefore cannot be installed into custom execution.

type CustomOperation ¶

type CustomOperation string

CustomOperation is the closed public custom-root vocabulary.

const (
	CustomQuery    CustomOperation = "query"
	CustomMutation CustomOperation = "mutation"
)

type CustomRegistry ¶

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

CustomRegistry is immutable process-wide binding metadata. ForCaller creates a request-scoped execution carrying only the generated caller value.

func NewCustomRegistry(bundle golem.SchemaBundle, supplied ...CustomBinding) (*CustomRegistry, error)

func (registry *CustomRegistry) ForCaller(caller CustomCallerCapability) (*CallerCustomExecution, error)

type CustomResult ¶

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

func (result CustomResult) Value() any

type CustomResultEncoder ¶

type CustomResultEncoder[R any] func(R) (any, error)

type Error ¶

type Error struct {
	Message    string         `json:"message"`
	Path       []any          `json:"path,omitempty"`
	Extensions map[string]any `json:"extensions"`
}

func PresentError(ctx context.Context, err error, path []any, report func(context.Context, error)) Error

type EventStream ¶

type EventStream interface {
	Recv(context.Context) (GeneratedEvent, error)
	Close() error
}

func AdaptGeneratedEventStream[E any](source golem.EventStream[E], adapt func(E) (GeneratedEvent, error)) (EventStream, error)

type Executor ¶

type Executor[P any] interface {
	Execute(context.Context, P, Operation) Response
}

func NewGeneratedExecutor[P any](config GeneratedExecutorConfig[P]) (Executor[P], error)

type GeneratedCustomArgumentConversion ¶

type GeneratedCustomArgumentConversion func(any) (any, error)

func GeneratedCustomMutationInputArgument[M any](descriptor golem.ModelDescriptor[M], kind golem.RuntimeMutationInputKind) GeneratedCustomArgumentConversion

func GeneratedCustomPredicateArgument[M any](descriptor golem.ModelDescriptor[M]) GeneratedCustomArgumentConversion

func GeneratedCustomSelectorArgument[M any](descriptor golem.ModelDescriptor[M]) GeneratedCustomArgumentConversion

type GeneratedEvent ¶

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

func NewGeneratedEvent(metadata golem.EventMetadata, identity []any, entity *golem.RuntimeModelRow) (GeneratedEvent, error)

type GeneratedExecutorConfig ¶

type GeneratedExecutorConfig[P any] struct {
	Bundle              golem.SchemaBundle
	Limits              Limits
	BeginCaller         BeginCaller[P]
	ComputedBindings    []ComputedBinding
	CustomBindings      []CustomBinding
	ReportInternalError func(context.Context, error)
}

type Limits ¶

type Limits struct {
	MaxRequestBytes, MaxVariableBytes, MaxTokens, MaxASTNodes, MaxFragments                int
	MaxDepth, MaxSelectedFields, MaxAliases, MaxInputDepth, MaxInputNodes                  int
	MaxListItems, MaxComplexity, MaxPageSize, MaxResolverConcurrency, MaxComputedBatchSize int
	MaxGroups                                                                              int
}

func NormalizeLimits(input Limits) (Limits, error)

type Operation ¶

type Operation struct {
	Document   *ast.QueryDocument
	Definition *ast.OperationDefinition
	Variables  map[string]any
}

type PreparedInput ¶

type PreparedInput map[string]any

PreparedInput is the gqlgen-only typed wrapper for already validated input objects. Golem binds the original operation AST before this representation is decoded, so generated resolvers never treat it as backend authority.

type PreparedObject ¶

type PreparedObject map[string]any

PreparedObject is the generated executable's opaque view of one already authorized and selected Golem result object. Generated resolvers are the only intended consumers. Values remain in their exact, provider-neutral wire representation; in particular, they are never JSON-round-tripped.

type Request ¶

type Request struct {
	Query         string
	OperationName string
	Variables     map[string]any
}

type Response ¶

type Response struct {
	Data   any     `json:"data,omitempty"`
	Errors []Error `json:"errors,omitempty"`
}

type ResponseStream ¶

type ResponseStream interface {
	Recv(context.Context) (Response, error)
	Close() error
}

type Server ¶

type Server[P any] struct {
	// contains filtered or unexported fields
}

func NewServer[P any](sdl string, config Config[P], executor Executor[P]) (*Server[P], error)

func (server *Server[P]) ContractFingerprint() golem.SchemaDigest

func (server *Server[P]) Execute(ctx context.Context, principal P, request Request) (response Response)

func (server *Server[P]) Handler() http.Handler

func (server *Server[P]) SDL() string

func (server *Server[P]) Shutdown(ctx context.Context) (resultErr error)

type SubscriptionExecutor ¶

type SubscriptionExecutor[P any] interface {
	Subscribe(context.Context, P, Operation) (ResponseStream, error)
}