graphql_datasource

package
v2.0.0-rc.32 Latest Latest
Warning

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

 Go to latest Published: May 10, 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"`
}

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

func WithWSSubProtocol 

func WithWSSubProtocol(protocol string) 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
}

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)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.