grpcdatasource

type CallKind uint8

type ConnectEncoding string

type ConnectTransportConfig struct {
	// BaseURL is the base URL of the Connect service (e.g., "http://localhost:8080").
	BaseURL string
	// HTTPClient is the HTTP client to use. If nil, http.DefaultClient is used.
	HTTPClient connect.HTTPClient
	// Encoding specifies the serialization format (Protobuf or JSON).
	Encoding ConnectEncoding
	// Interceptors are applied, in order, to every Connect client this
	// transport constructs. Use them for cross-cutting concerns such as
	// tracing, logging, retries, or auth header injection. The slice is
	// captured at construction time; mutating it after NewConnectTransport
	// returns has no effect.
	Interceptors []connect.Interceptor
}

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

type DataSourceConfig struct {
	// Operation is the GraphQL operation to plan.
	Operation *ast.Document
	// Definition is the GraphQL schema of the subgraph.
	Definition *ast.Document
	// Compiler holds the compiled protobuf schema.
	Compiler *RPCCompiler
	// SubgraphName is the name of the subgraph.
	SubgraphName string
	// Mapping maps GraphQL types and fields to gRPC messages and RPCs.
	Mapping *GRPCMapping
	// FederationConfigs holds the federation field configurations.
	FederationConfigs plan.FederationFieldConfigurations
	// Disabled returns an error instead of executing the operation.
	Disabled bool
	// UseProtoReflect builds gRPC requests with protoreflect instead of wire encoding.
	UseProtoReflect bool
}

type DataType int8

type Document struct {
	Package  string    // The package name of the protobuf document
	Imports  []string  // The imports of the protobuf document
	Services []Service // All services defined in the document
	Enums    []Enum    // All enums defined in the document
	Messages []Message // All messages defined in the document
	Methods  []Method  // All methods from all services in the document
	// contains filtered or unexported fields
}

type EntityRPCConfig struct {
	// RPCConfig is the embedded configuration for the RPC operation
	RPCConfig

	// Key is a list of field names that uniquely identify the entity
	Key string

	// RequiredFields is the configuration for the required fields method
	RequiredFields RequiredFieldsRPCMapping
}

type Enum struct {
	Name   string      // The name of the enum
	Values []EnumValue // The values in the enum
}

type EnumValue struct {
	Name         string // The name of the enum value
	GraphqlValue string // The target value of the enum value
	Number       int32  // The numeric value of the enum value
}

type EnumValueMapping struct {
	Value       string // The GraphQL enum value
	TargetValue string // The gRPC enum value
}

type FieldArgumentMap map[string]string

type FieldMap map[string]FieldMapData

type FieldMapData struct {
	TargetName       string           // The name of the gRPC field
	ArgumentMappings FieldArgumentMap // The mapping between GraphQL field arguments and gRPC request arguments
}

type GRPCConfiguration struct {
	Disabled        bool         // Whether the RPC is disabled
	Mapping         *GRPCMapping // The mapping between GraphQL types and gRPC messages
	Compiler        *RPCCompiler // The compiler for the RPC
	UseProtoReflect bool         // Whether to use protoreflect instead of wire encoding for gRPC requests
}

type GRPCMapping struct {
	// Service is the name of the gRPC service to use
	Service string
	// QueryRPCs maps GraphQL query fields to the corresponding gRPC RPC configurations
	QueryRPCs RPCConfigMap[RPCConfig]
	// MutationRPCs maps GraphQL mutation fields to the corresponding gRPC RPC configurations
	MutationRPCs RPCConfigMap[RPCConfig]
	// SubscriptionRPCs maps GraphQL subscription fields to the corresponding gRPC RPC configurations
	SubscriptionRPCs RPCConfigMap[RPCConfig]
	// ResolveRPCs maps GraphQL resolve fields to the corresponding gRPC RPC configurations
	ResolveRPCs RPCConfigMap[ResolveRPCMapping]
	// EntityRPCs defines how GraphQL types are resolved as entities using specific RPCs
	// The key is the type name and the value is a list of EntityRPCConfig for that type
	EntityRPCs map[string][]EntityRPCConfig
	// Fields defines the field mappings between GraphQL types and gRPC messages
	// The key is the type name and the value is a map of field name to FieldMapData for that type
	Fields map[string]FieldMap
	// EnumValues defines the enum values for each enum type
	// The key is the enum type name and the value is a list of EnumValueMapping for that enum type
	EnumValues map[string][]EnumValueMapping
}

type LevelInfo struct {
	// Optional indicates if the field is optional
	Optional bool
}

type ListMetadata struct {
	// NestingLevel is the nesting level of the list type
	NestingLevel int
	// LevelInfo contains the metadata for each nesting level of the list
	LevelInfo []LevelInfo
}

type Message struct {
	Name string                     // The name of the message
	Desc protoref.MessageDescriptor // The protobuf descriptor for the message
}

type Method struct {
	Name      string // The name of the method
	InputRef  int    // Reference to the input message in the Document.Messages slice
	OutputRef int    // Reference to the output message in the Document.Messages slice
}

type NodeKind int

type OneOfType uint8

type PlanVisitor interface {
	PlanOperation(operation, definition *ast.Document) (*RPCExecutionPlan, error)
}

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

type RPCCall struct {
	// ID indicates the expected index of the call in the execution plan
	ID int
	// Kind of call, used to decide how to execute the call
	// This is used to identify the call type and execution behaviour.
	Kind CallKind
	// DependentCalls is a list of calls that must be executed before this call
	DependentCalls []int
	// ServiceName is the name of the gRPC service to call
	ServiceName string
	// MethodName is the name of the method on the service to call
	MethodName string
	// Request contains the message structure for the gRPC request
	Request RPCMessage
	// Response contains the message structure for the gRPC response
	Response RPCMessage
	// ResponsePath is the path to the response in the JSON response
	ResponsePath ast.Path
	// RequestedEntityType is the type of the entity that is being requested
	// Empty if the call is not an entity lookup.
	RequestedEntityType string
}

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

type RPCConfig struct {
	// RPC is the name of the RPC method to call
	RPC string
	// Request is the name of the request message type
	Request string
	// Response is the name of the response message type
	Response string
}

type RPCConfigMap[T RPCMapping] map[string]T

type RPCExecutionPlan struct {
	// Calls is a list of gRPC calls that are executed in the same group
	Calls []RPCCall
}

type RPCField struct {
	// Alias can be used to rename the field in the request message
	// This is needed to make sure that during the json composition,
	// the field names match the GraphQL request naming.
	Alias string
	// Repeated indicates if the field is a repeated field (array/list)
	Repeated bool
	// Name is the name of the field as defined in the protobuf message
	Name string
	// ProtoTypeName is the name of the type of the field in the protobuf definition
	ProtoTypeName DataType
	// JSONPath either holds the path to the variable definition for the request message,
	// or defines the name of the response field in the message.
	JSONPath string
	// ResolvePath is used to resolve values from another message.
	ResolvePath ast.Path
	// EnumName is the name of the enum if the field is an enum type
	EnumName string
	// StaticValue is the static value of the field
	StaticValue string
	// Optional indicates if the field is optional
	Optional bool
	// IsListType indicates if the field is a list wrapper type
	IsListType bool
	// ListMetadata contains the metadata for the list type
	ListMetadata *ListMetadata
	// Message represents the nested message type definition for complex fields.
	// This enables recursive construction of nested protobuf message structures.
	Message *RPCMessage
}

type RPCFieldSelectionSet map[string]RPCFields

type RPCFields []RPCField

type RPCMapping interface {
	RPCConfig | ResolveRPCMapping
}

type RPCMessage struct {
	// Name is the name of the message type in the protobuf definition
	Name string
	// Fields is a list of fields in the message
	Fields RPCFields
	// FragmentFields are field selections based on inline fragments
	FragmentFields RPCFieldSelectionSet
	// OneOfType indicates the type of the oneof field
	OneOfType OneOfType
	// MemberTypes provides the names of the types that are implemented by the Interface or Union
	MemberTypes []string
}

type RPCTransport interface {
	// Invoke dispatches a unary call against the remote service.
	//   - methodFullName is the gRPC-style procedure path "/package.Service/Method"
	//     (leading slash required). The gRPC transport passes it directly to
	//     grpc.ClientConnInterface.Invoke; the Connect transport appends it to
	//     the configured base URL.
	//   - input is a *PreWiredInputMessage (pre-encoded wire bytes) for the gRPC
	//     transport, or a *dynamicpb.Message populated by the caller for the
	//     Connect transport.
	//   - output must be a *dynamicpb.Message bound to the expected response
	//     descriptor; Invoke populates it on success.
	Invoke(ctx context.Context, methodFullName string, input, output any) error
}

type RequiredFieldsRPCMapping map[string]RequiredFieldsRPCTypeField

type RequiredFieldsRPCTypeField struct {
	RPCConfig

	// TargetName is the name of the gRPC field that is used to store the required fields arguments
	TargetName string
}

type ResolveRPCMapping map[string]ResolveRPCTypeField

type ResolveRPCTypeField struct {
	FieldMappingData FieldMapData // The mapping between GraphQL field arguments and gRPC request arguments
	RPC              string       // The name of the RPC method to call
	Request          string       // The name of the request message type
	Response         string       // The name of the response message type
}

type Service struct {
	Name        string // The name of the service
	FullName    string // The full name of the service
	MethodsRefs []int  // References to methods in the Document.Methods slice
}