graphql_datasource

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

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

	GRPC *grpcdatasource.GRPCConfiguration
}

type DefaultSubscriptionClientFactory struct{}

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

type FederationConfiguration struct {
	Enabled    bool
	ServiceSDL string
}

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

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 interface {
	// Subscribe to the origin source. The implementation must not block the calling goroutine.
	Subscribe(ctx *resolve.Context, options GraphQLSubscriptionOptions, updater resolve.SubscriptionUpdater) error
}

type GraphQLSubscriptionClientFactory interface {
	NewSubscriptionClient(ctx context.Context, options ...SubscriptionClientOption) GraphQLSubscriptionClient
}

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 []RegularExpression `json:"forwarded_client_header_regular_expressions"`
	WsSubProtocol                           string              `json:"ws_sub_protocol"`
	// contains filtered or unexported fields
}

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

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

type RegularExpression struct {
	Pattern     *regexp.Regexp
	NegateMatch bool
}

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

type SingleTypeField struct {
	TypeName  string
	FieldName string
}

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

type SubscriptionClientOption func(*subscriptionClientConfig)

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 []RegularExpression
	WsSubProtocol                           string
	// StartupHooks contains the method called when a subscription is started
	StartupHooks []SubscriptionOnStartFn
}

type SubscriptionOnStartFn func(ctx resolve.StartupHookContext, input []byte) (err error)

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