graphql_datasource

type Configuration struct {
	Fetch                  FetchConfiguration
	Subscription           SubscriptionConfiguration
	Federation             FederationConfiguration
	UpstreamSchema         string
	CustomScalarTypeFields []SingleTypeField
}

type ConnectionHandler interface {
	StartBlocking(sub Subscription)
	SubscribeCH() chan<- Subscription
}

type DefaultSubscriptionClientFactory struct{}

type Factory struct {
	HTTPClient                 *http.Client
	StreamingClient            *http.Client
	OnWsConnectionInitCallback *OnWsConnectionInitCallback
	SubscriptionClient         *SubscriptionClient
	Logger                     abstractlogger.Logger
}

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

type GraphQLSubscriptionClientFactory interface {
	NewSubscriptionClient(httpClient, streamingClient *http.Client, engineCtx context.Context, options ...Options) 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 []*regexp.Regexp `json:"forwarded_client_header_regular_expressions"`
}

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

type Options func(options *opts)

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

type SingleTypeField struct {
	TypeName  string
	FieldName string
}

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

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

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

type SubscriptionConfiguration struct {
	URL           string
	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 struct {
	// contains filtered or unexported fields
}