graphql_datasource

package
v2.0.0-rc.43 Latest Latest
Warning

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

Go to latest
Published: May 21, 2024 License: MIT Imports: 36 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 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(sub Subscription)
	SubscribeCH() chan<- Subscription
}

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]

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(ctx *resolve.Context, options GraphQLSubscriptionOptions, updater resolve.SubscriptionUpdater) error
	UniqueRequestID(ctx *resolve.Context, options GraphQLSubscriptionOptions, hash *xxhash.Digest) (err error)
}

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"`
}

type InvalidWsSubprotocolError

type InvalidWsSubprotocolError struct {
	InvalidProtocol string
}

func NewInvalidWsSubprotocolError

func NewInvalidWsSubprotocolError(invalidProtocol string) InvalidWsSubprotocolError

func (InvalidWsSubprotocolError) Error

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 WithOnWsConnectionInitCallback

func WithOnWsConnectionInitCallback(callback *OnWsConnectionInitCallback) 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]) EnableQueryPlanLogging

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

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]) 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)

func (*Planner[T]) UpstreamSchema

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

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, writer io.Writer) (err error)

type Subscription

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

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) Start

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

func (*SubscriptionSource) UniqueRequestID

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

Jump to

Keyboard shortcuts

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