graphql_datasource

package
v2.0.0-rc.136 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 16, 2024 License: MIT Imports: 50 Imported by: 3

Documentation

Index

Constants

View Source
const EntityInterfacesDefinition = `` /* 696-byte string literal not displayed */
View Source
const (
	ProtocolGraphQLTWS = "graphql-transport-ws"
)

websocket sub-protocol: https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md

View Source
const (
	ProtocolGraphQLWS = "graphql-ws"
)

websocket sub-protocol: https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md

Variables

View Source
var (
	DefaultPostProcessingConfiguration = resolve.PostProcessingConfiguration{
		SelectResponseDataPath:   []string{"data"},
		SelectResponseErrorsPath: []string{"errors"},
	}
	EntitiesPostProcessingConfiguration = resolve.PostProcessingConfiguration{
		SelectResponseDataPath:   []string{"data", "_entities"},
		SelectResponseErrorsPath: []string{"errors"},
	}
	SingleEntityPostProcessingConfiguration = resolve.PostProcessingConfiguration{
		SelectResponseDataPath:   []string{"data", "_entities", "0"},
		SelectResponseErrorsPath: []string{"errors"},
	}
)

Functions

func EntityInterfacesPlanConfiguration

func EntityInterfacesPlanConfiguration(t *testing.T, factory plan.PlannerFactory[Configuration]) *plan.Configuration

func EntityInterfacesPlanConfigurationBench

func EntityInterfacesPlanConfigurationBench(t *testing.B, factory plan.PlannerFactory[Configuration]) *plan.Configuration

func IsDefaultGraphQLSubscriptionClient

func IsDefaultGraphQLSubscriptionClient(client GraphQLSubscriptionClient) bool

Types

type Configuration

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

func NewConfiguration

func NewConfiguration(input ConfigurationInput) (Configuration, error)

func (*Configuration) FederationConfiguration

func (c *Configuration) FederationConfiguration() *FederationConfiguration

func (*Configuration) IsFederationEnabled

func (c *Configuration) IsFederationEnabled() bool

func (*Configuration) UpstreamSchema

func (c *Configuration) UpstreamSchema() (*ast.Document, error)

type ConfigurationInput

type ConfigurationInput struct {
	Fetch                  *FetchConfiguration
	Subscription           *SubscriptionConfiguration
	SchemaConfiguration    *SchemaConfiguration
	CustomScalarTypeFields []SingleTypeField
}

type ConnectionHandler

type ConnectionHandler interface {
	StartBlocking() error
	HandleMessage(data []byte) (done bool)
	ServerClose()
	ClientClose()
	Subscribe() error
}

type DefaultSubscriptionClientFactory

type DefaultSubscriptionClientFactory struct{}

func (*DefaultSubscriptionClientFactory) NewSubscriptionClient

func (d *DefaultSubscriptionClientFactory) NewSubscriptionClient(httpClient, streamingClient *http.Client, engineCtx context.Context, options ...Options) GraphQLSubscriptionClient

type Factory

type Factory[T Configuration] struct {
	// contains filtered or unexported fields
}

func NewFactory

func NewFactory(executionContext context.Context, httpClient *http.Client, subscriptionClient GraphQLSubscriptionClient) (*Factory[Configuration], error)

NewFactory creates a new factory for the GraphQL datasource planner Graphql Datasource could be stateful in case you are using subscriptions, make sure you are using the same execution context for all datasources

func (*Factory[T]) Context

func (f *Factory[T]) Context() context.Context

func (*Factory[T]) Planner

func (f *Factory[T]) Planner(logger abstractlogger.Logger) plan.DataSourcePlanner[T]

func (*Factory[T]) UpstreamSchema

func (f *Factory[T]) UpstreamSchema(dataSourceConfig plan.DataSourceConfiguration[T]) (*ast.Document, bool)

type FederationConfiguration

type FederationConfiguration struct {
	Enabled    bool
	ServiceSDL string
}

type FetchConfiguration

type FetchConfiguration struct {
	URL    string
	Method string
	Header http.Header
}

type GraphQLBody

type GraphQLBody struct {
	Query         string          `json:"query,omitempty"`
	OperationName string          `json:"operationName,omitempty"`
	Variables     json.RawMessage `json:"variables,omitempty"`
	Extensions    json.RawMessage `json:"extensions,omitempty"`
}

type GraphQLSubscriptionClient

type GraphQLSubscriptionClient interface {
	// Subscribe to the origin source. The implementation must not block the calling goroutine.
	Subscribe(ctx *resolve.Context, options GraphQLSubscriptionOptions, updater resolve.SubscriptionUpdater) error
	UniqueRequestID(ctx *resolve.Context, options GraphQLSubscriptionOptions, hash *xxhash.Digest) (err error)
	SubscribeAsync(ctx *resolve.Context, id uint64, options GraphQLSubscriptionOptions, updater resolve.SubscriptionUpdater) error
	Unsubscribe(id uint64)
}

func NewGraphQLSubscriptionClient

func NewGraphQLSubscriptionClient(httpClient, streamingClient *http.Client, engineCtx context.Context, options ...Options) GraphQLSubscriptionClient

type GraphQLSubscriptionClientFactory

type GraphQLSubscriptionClientFactory interface {
	NewSubscriptionClient(httpClient, streamingClient *http.Client, engineCtx context.Context, options ...Options) GraphQLSubscriptionClient
}

GraphQLSubscriptionClientFactory abstracts the way of creating a new GraphQLSubscriptionClient. This can be very handy for testing purposes.

type GraphQLSubscriptionOptions

type GraphQLSubscriptionOptions struct {
	URL                                     string           `json:"url"`
	InitialPayload                          json.RawMessage  `json:"initial_payload"`
	Body                                    GraphQLBody      `json:"body"`
	Header                                  http.Header      `json:"header"`
	UseSSE                                  bool             `json:"use_sse"`
	SSEMethodPost                           bool             `json:"sse_method_post"`
	ForwardedClientHeaderNames              []string         `json:"forwarded_client_header_names"`
	ForwardedClientHeaderRegularExpressions []*regexp.Regexp `json:"forwarded_client_header_regular_expressions"`
	WsSubProtocol                           string           `json:"ws_sub_protocol"`
	// contains filtered or unexported fields
}

type InvalidWsSubprotocolError

type InvalidWsSubprotocolError struct {
	InvalidProtocol string
}

func NewInvalidWsSubprotocolError

func NewInvalidWsSubprotocolError(invalidProtocol string) InvalidWsSubprotocolError

func (InvalidWsSubprotocolError) Error

type NetPollConfiguration

type NetPollConfiguration struct {
	// Enable can be set to true to enable netPoll
	Enable bool
	// BufferSize defines the size of the buffer for the netPoll loop
	BufferSize int
	// WaitForNumEvents defines how many events are waited for in the netPoll loop before TickInterval cancels the wait
	WaitForNumEvents int
	// MaxEventWorkers defines the parallelism of how many connections can be handled at the same time
	// The higher the number, the more CPU is used.
	MaxEventWorkers int
	// TickInterval defines the time between each netPoll loop when WaitForNumEvents is not reached
	TickInterval time.Duration
}

func (*NetPollConfiguration) ApplyDefaults

func (e *NetPollConfiguration) ApplyDefaults()

type OnWsConnectionInitCallback

type OnWsConnectionInitCallback func(ctx context.Context, url string, header http.Header) (json.RawMessage, error)

type Options

type Options func(options *opts)

func WithLogger

func WithLogger(log abstractlogger.Logger) Options

func WithNetPollConfiguration

func WithNetPollConfiguration(config NetPollConfiguration) Options

func WithReadTimeout

func WithReadTimeout(timeout time.Duration) Options

type Planner

type Planner[T Configuration] struct {
	// contains filtered or unexported fields
}

func (*Planner[T]) ConfigureFetch

func (p *Planner[T]) ConfigureFetch() resolve.FetchConfiguration

func (*Planner[T]) ConfigureSubscription

func (p *Planner[T]) ConfigureSubscription() plan.SubscriptionConfiguration

func (*Planner[T]) DataSourcePlanningBehavior

func (p *Planner[T]) DataSourcePlanningBehavior() plan.DataSourcePlanningBehavior

func (*Planner[T]) DebugPrint

func (p *Planner[T]) DebugPrint(args ...interface{})

func (*Planner[T]) DownstreamResponseFieldAlias

func (p *Planner[T]) DownstreamResponseFieldAlias(downstreamFieldRef int) (alias string, exists bool)

func (*Planner[T]) EnableDebug

func (p *Planner[T]) EnableDebug()

func (*Planner[T]) EnableDebugQueryPlanLogging

func (p *Planner[T]) EnableDebugQueryPlanLogging()

func (*Planner[T]) EnableSubgraphRequestMinifier

func (p *Planner[T]) EnableSubgraphRequestMinifier()

func (*Planner[T]) EnterArgument

func (p *Planner[T]) EnterArgument(_ int)

func (*Planner[T]) EnterDirective

func (p *Planner[T]) EnterDirective(ref int)

func (*Planner[T]) EnterDocument

func (p *Planner[T]) EnterDocument(_, _ *ast.Document)

func (*Planner[T]) EnterField

func (p *Planner[T]) EnterField(ref int)

func (*Planner[T]) EnterInlineFragment

func (p *Planner[T]) EnterInlineFragment(ref int)

func (*Planner[T]) EnterOperationDefinition

func (p *Planner[T]) EnterOperationDefinition(ref int)

func (*Planner[T]) EnterSelectionSet

func (p *Planner[T]) EnterSelectionSet(ref int)

func (*Planner[T]) EnterVariableDefinition

func (p *Planner[T]) EnterVariableDefinition(ref int)

func (*Planner[T]) ID

func (p *Planner[T]) ID() (id int)

func (*Planner[T]) IncludeQueryPlanInFetchConfiguration

func (p *Planner[T]) IncludeQueryPlanInFetchConfiguration()

func (*Planner[T]) LeaveDocument

func (p *Planner[T]) LeaveDocument(_, _ *ast.Document)

func (*Planner[T]) LeaveField

func (p *Planner[T]) LeaveField(ref int)

func (*Planner[T]) LeaveInlineFragment

func (p *Planner[T]) LeaveInlineFragment(ref int)

func (*Planner[T]) LeaveOperationDefinition

func (p *Planner[T]) LeaveOperationDefinition(_ int)

func (*Planner[T]) LeaveSelectionSet

func (p *Planner[T]) LeaveSelectionSet(ref int)

func (*Planner[T]) LeaveVariableDefinition

func (p *Planner[T]) LeaveVariableDefinition(_ int)

func (*Planner[T]) Register

func (p *Planner[T]) Register(visitor *plan.Visitor, configuration plan.DataSourceConfiguration[T], dataSourcePlannerConfiguration plan.DataSourcePlannerConfiguration) error

func (*Planner[T]) SetID

func (p *Planner[T]) SetID(id int)

type SchemaConfiguration

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

func NewSchemaConfiguration

func NewSchemaConfiguration(upstreamSchema string, federationCfg *FederationConfiguration) (*SchemaConfiguration, error)

func (*SchemaConfiguration) FederationServiceSDL

func (c *SchemaConfiguration) FederationServiceSDL() string

func (*SchemaConfiguration) IsFederationEnabled

func (c *SchemaConfiguration) IsFederationEnabled() bool

type SingleTypeField

type SingleTypeField struct {
	TypeName  string
	FieldName string
}

type Source

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

func (*Source) Load

func (s *Source) Load(ctx context.Context, input []byte, out *bytes.Buffer) (err error)

func (*Source) LoadWithFiles

func (s *Source) LoadWithFiles(ctx context.Context, input []byte, files []httpclient.File, out *bytes.Buffer) (err error)

type SubscriptionConfiguration

type SubscriptionConfiguration struct {
	URL           string
	Header        http.Header
	UseSSE        bool
	SSEMethodPost bool
	// ForwardedClientHeaderNames indicates headers names that might be forwarded from the
	// client to the upstream server. This is used to determine which connections
	// can be multiplexed together, but the subscription engine does not forward
	// these headers by itself.
	ForwardedClientHeaderNames []string
	// ForwardedClientHeaderRegularExpressions regular expressions that if matched to the header
	// name might be forwarded from the client to the upstream server. This is used to determine
	// which connections can be multiplexed together, but the subscription engine does not forward
	// these headers by itself.
	ForwardedClientHeaderRegularExpressions []*regexp.Regexp
	WsSubProtocol                           string
}

type SubscriptionSource

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

func (*SubscriptionSource) AsyncStart

func (s *SubscriptionSource) AsyncStart(ctx *resolve.Context, id uint64, input []byte, updater resolve.SubscriptionUpdater) error

func (*SubscriptionSource) AsyncStop

func (s *SubscriptionSource) AsyncStop(id uint64)

AsyncStop stops the subscription with the given id. AsyncStop is only effective when netPoll is enabled because without netPoll we manage the lifecycle of the connection in the subscription client.

func (*SubscriptionSource) Start

func (s *SubscriptionSource) Start(ctx *resolve.Context, input []byte, updater resolve.SubscriptionUpdater) error

Start the subscription. The updater is called on new events. Start needs to be called in a separate goroutine.

func (*SubscriptionSource) UniqueRequestID

func (s *SubscriptionSource) UniqueRequestID(ctx *resolve.Context, input []byte, xxh *xxhash.Digest) (err error)

type UpgradeRequestError

type UpgradeRequestError struct {
	URL        string
	StatusCode int
}

func (*UpgradeRequestError) Error

func (u *UpgradeRequestError) Error() string

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL