core

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

type ApiTransportFactory interface {
	RoundTripper(enableSingleFlight bool, transport http.RoundTripper) http.RoundTripper
	DefaultTransportTimeout() time.Duration
	DefaultHTTPProxyURL() *url.URL
}

type AuthorizationExtension struct {
	MissingScopes []MissingScopesError `json:"missingScopes,omitempty"`
	ActualScopes  []string             `json:"actualScopes"`
}

type Cleaner interface {
	// Cleanup is called after the server stops
	Cleanup() error
}

type ClientInfo struct {
	// Name contains the client name, derived from the request headers
	Name string
	// Version contains the client version, derived from the request headers
	Version string
	// WGRequestToken contains the token to authenticate the request from the platform
	WGRequestToken string
}

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

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

type CosmoAuthorizerOptions struct {
	FieldConfigurations           []*nodev1.FieldConfiguration
	RejectOperationIfUnauthorized bool
}

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

type CosmoRateLimiterOptions struct {
	RedisClient *redis.Client
	Debug       bool
}

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

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

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

type EnginePostOriginHandler interface {
	// OnOriginResponse is called after the request is sent to the origin.
	// Might be called multiple times if there are multiple origins
	OnOriginResponse(resp *http.Response, ctx RequestContext) *http.Response
}

type EnginePreOriginHandler interface {
	// OnOriginRequest is called before the request is sent to the origin
	// Might be called multiple times if there are multiple origins
	OnOriginRequest(req *http.Request, ctx RequestContext) (*http.Request, *http.Response)
}

type ErrUpgradeFailed struct {
	StatusCode int
	SubgraphID string
}

type ExecutionPlanCache interface {
	Get(key interface{}) (interface{}, bool)
	Set(key, value interface{}, cost int64) bool
}

type Executor struct {
	PlanConfig      plan.Configuration
	Definition      *ast.Document
	Resolver        *resolve.Resolver
	RenameTypeNames []resolve.RenameTypeName
}

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

type Extensions struct {
	RateLimit     json.RawMessage `json:"rateLimit,omitempty"`
	Authorization json.RawMessage `json:"authorization,omitempty"`
	Trace         json.RawMessage `json:"trace,omitempty"`
	StatusCode    int             `json:"statusCode,omitempty"`
}

type FactoryResolver interface {
	ResolveGraphqlFactory() (plan.PlannerFactory[graphql_datasource.Configuration], error)
	ResolveStaticFactory() (plan.PlannerFactory[staticdatasource.Configuration], error)
	ResolvePubsubFactory() (plan.PlannerFactory[pubsub_datasource.Configuration], error)
}

type GraphQLErrorResponse struct {
	Errors     []graphqlError `json:"errors"`
	Data       any            `json:"data"`
	Extensions *Extensions    `json:"extensions,omitempty"`
}

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

type GraphQLMetricsConfig struct {
	Enabled           bool
	CollectorEndpoint string
}

type HandlerOptions struct {
	Executor                               *Executor
	Log                                    *zap.Logger
	EnableExecutionPlanCacheResponseHeader bool
	WebSocketStats                         WebSocketsStatistics
	TracerProvider                         trace.TracerProvider
	Authorizer                             *CosmoAuthorizer
	RateLimiter                            *CosmoRateLimiter
	RateLimitConfig                        *config.RateLimitConfiguration
	SubgraphErrorPropagation               config.SubgraphErrorPropagationConfiguration
	EngineLoaderHooks                      resolve.LoaderHooks
}

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

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

type IPAnonymizationConfig struct {
	Enabled bool
	Method  IPAnonymizationMethod
}

type IPAnonymizationMethod string

type InputError interface {
	error
	// Message represents a human readable error message to be sent to the client/user
	Message() string
	// StatusCode is the status code to be sent to the client
	StatusCode() int
}

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

type MissingScopesError struct {
	Coordinate       resolve.GraphCoordinate `json:"coordinate"`
	RequiredOrScopes [][]string              `json:"required"`
}

type Module interface {
	Module() ModuleInfo
}

type ModuleContext struct {
	stdContext.Context
	Module Module
	Logger *zap.Logger
}

type ModuleID string

type ModuleInfo struct {
	// Name is the name of the module
	ID ModuleID
	// New is the function that creates a new instance of the module
	New func() Module
}

type NoopWebSocketStats struct{}

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

type OperationBlockerOptions struct {
	BlockMutations     bool
	BlockSubscriptions bool
	BlockNonPersisted  bool
}

type OperationContext interface {
	// Name is the name of the operation
	Name() string
	// Type is the type of the operation (query, mutation, subscription)
	Type() string
	// Hash is the hash of the operation
	Hash() uint64
	// Content is the content of the operation
	Content() string
	// ClientInfo returns information about the client that initiated this operation
	ClientInfo() ClientInfo
}

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

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

type OperationParserOptions struct {
	Executor                *Executor
	MaxOperationSizeInBytes int64
	PersistentOpClient      *cdn.PersistentOperationClient
}

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

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

type OperationProtocol string

type Option func(svr *Router)

type ParsedOperation struct {
	// ID represents a unique-ish ID for the operation calculated by hashing
	// its normalized representation and its variables
	ID uint64
	// Name is the operation name, if any
	Name string
	// Type is a string representing the operation type. One of
	// "query", "mutation", "subscription"
	Type string
	// Variables in the "variables" field value in the JSON payload
	Variables []byte
	// NormalizedRepresentation is the normalized representation of the operation
	// as a string. This is provided for modules to be able to access the
	// operation. Only available after the operation has been normalized.
	NormalizedRepresentation string
	Extensions               []byte
	PersistedID              string
}

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

type PreHandlerOptions struct {
	Logger                      *zap.Logger
	Executor                    *Executor
	Metrics                     RouterMetrics
	OperationProcessor          *OperationProcessor
	Planner                     *OperationPlanner
	AccessController            *AccessController
	OperationBlocker            *OperationBlocker
	DevelopmentMode             bool
	RouterPublicKey             *ecdsa.PublicKey
	EnableRequestTracing        bool
	TracerProvider              *sdktrace.TracerProvider
	FlushTelemetryAfterResponse bool
	TraceExportVariables        bool
}

type Provisioner interface {
	// Provision is called before the server starts
	Provision(*ModuleContext) error
}

type RateLimitStats struct {
	RequestRate            int   `json:"requestRate"`
	Remaining              int   `json:"remaining"`
	RetryAfterMilliseconds int64 `json:"retryAfterMs"`
	ResetAfterMilliseconds int64 `json:"resetAfterMs"`
}

type ReportError interface {
	error
	Report() *operationreport.Report
}

type RequestContext interface {
	// ResponseWriter is the original response writer received by the router.
	ResponseWriter() http.ResponseWriter

	// Request is the original request received by the router.
	Request() *http.Request

	// Logger is the logger for the request
	Logger() *zap.Logger

	// Operation is the GraphQL operation
	Operation() OperationContext

	// SendError returns the most recent error occurred while trying to make the origin request.
	SendError() error

	// Set is used to store a new key/value pair exclusively for this context.
	Set(string, any)

	// Get returns the value for the given key, ie: (value, true).
	Get(string) (value any, exists bool)

	// GetString returns the value associated with the key as a string.
	GetString(string) string

	// MustGet returns the value for the given key if it exists, otherwise it panics.
	MustGet(string) any

	// GetBool returns the value associated with the key as a boolean.
	GetBool(string) bool

	// GetInt returns the value associated with the key as an integer.
	GetInt(string) int

	// GetInt64 returns the value associated with the key as an integer.
	GetInt64(string) int64

	// GetUint returns the value associated with the key as an unsigned integer.
	GetUint(string) uint

	// GetUint64 returns the value associated with the key as an unsigned integer.
	GetUint64(string) uint64

	// GetFloat64 returns the value associated with the key as a float64.
	GetFloat64(string) float64

	// GetTime returns the value associated with the key as time.
	GetTime(string) time.Time

	// GetDuration returns the value associated with the key as a duration.
	GetDuration(string) time.Duration

	// GetStringSlice returns the value associated with the key as a slice of strings.
	GetStringSlice(string) []string

	// GetStringMap returns the value associated with the key as a map of interfaces.
	GetStringMap(string) map[string]any

	// GetStringMapString returns the value associated with the key as a map of strings.
	GetStringMapString(string) map[string]string

	// GetStringMapStringSlice returns the value associated with the key as a map to a slice of strings.
	GetStringMapStringSlice(string) map[string][]string

	// ActiveSubgraph returns the current subgraph to which the request is made to
	ActiveSubgraph(subgraphRequest *http.Request) *Subgraph

	// SubgraphByID return the subgraph by its ID
	SubgraphByID(subgraphID string) *Subgraph

	// Authentication returns the authentication information for the request, if any
	Authentication() authentication.Authentication
}

type RequiredAndScopes struct {
	RequiredAndScopes []string `json:"and"`
}

type Router struct {
	Config

	WebsocketStats WebSocketsStatistics
	// contains filtered or unexported fields
}

type RouterEngineConfiguration struct {
	Execution                config.EngineExecutionConfiguration
	Headers                  config.HeaderRules
	Events                   config.EventsConfiguration
	SubgraphErrorPropagation config.SubgraphErrorPropagationConfiguration
}

type RouterMetrics interface {
	StartOperation(clientInfo *ClientInfo, logger *zap.Logger, requestContentLength int64) *OperationMetrics
	ExportSchemaUsageInfo(operationContext *operationContext, statusCode int, hasError bool)
	GqlMetricsExporter() graphqlmetrics.SchemaUsageExporter
	MetricStore() metric.Store
}

type RouterMiddlewareHandler interface {
	// Middleware is the middleware handler
	Middleware(ctx RequestContext, next http.Handler)
}

type Server interface {
	HttpServer() *http.Server
	HealthChecks() health.Checker
	BaseURL() string
}

type Subgraph struct {
	Id   string
	Name string
	Url  *url.URL
}

type SubgraphTransportOptions struct {
	RequestTimeout         time.Duration
	ResponseHeaderTimeout  time.Duration
	ExpectContinueTimeout  time.Duration
	KeepAliveIdleTimeout   time.Duration
	DialTimeout            time.Duration
	TLSHandshakeTimeout    time.Duration
	KeepAliveProbeInterval time.Duration
}

type TlsClientAuthConfig struct {
	Required bool
	CertFile string
}

type TlsConfig struct {
	Enabled  bool
	CertFile string
	KeyFile  string

	ClientAuth *TlsClientAuthConfig
}

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

type TransportOptions struct {
	PreHandlers                   []TransportPreHandler
	PostHandlers                  []TransportPostHandler
	RetryOptions                  retrytransport.RetryOptions
	RequestTimeout                time.Duration
	LocalhostFallbackInsideDocker bool
	MetricStore                   metric.Store
	Logger                        *zap.Logger
	TracerProvider                *sdktrace.TracerProvider
}

type TransportPostHandler func(resp *http.Response, ctx RequestContext) *http.Response

type TransportPreHandler func(req *http.Request, ctx RequestContext) (*http.Request, *http.Response)

type UsageReport struct {
	Connections   uint64
	Subscriptions uint64
	MessagesSent  uint64
	Triggers      uint64
}

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

type WebSocketConnectionHandlerOptions struct {
	Config             *config.WebSocketConfiguration
	OperationProcessor *OperationProcessor
	OperationBlocker   *OperationBlocker
	Planner            *OperationPlanner
	GraphQLHandler     *GraphQLHandler
	Metrics            RouterMetrics
	ResponseWriter     http.ResponseWriter
	Request            *http.Request
	Connection         *wsConnectionWrapper
	Protocol           wsproto.Proto
	Logger             *zap.Logger
	Stats              WebSocketsStatistics
	ConnectionID       int64
	RequestContext     context.Context
	ClientInfo         *ClientInfo
	InitRequestID      string
}

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

type WebSocketsStatistics interface {
	Subscribe(ctx context.Context) chan *UsageReport
	GetReport() *UsageReport
	SubscriptionUpdateSent()
	ConnectionsInc()
	ConnectionsDec()
	SubscriptionCountInc(count int)
	SubscriptionCountDec(count int)
	TriggerCountInc(count int)
	TriggerCountDec(count int)
}

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

type WebsocketMiddlewareOptions struct {
	OperationProcessor *OperationProcessor
	OperationBlocker   *OperationBlocker
	Planner            *OperationPlanner
	GraphQLHandler     *GraphQLHandler
	Metrics            RouterMetrics
	AccessController   *AccessController
	Logger             *zap.Logger
	Stats              WebSocketsStatistics
	ReadTimeout        time.Duration

	EnableWebSocketEpollKqueue bool
	EpollKqueuePollTimeout     time.Duration
	EpollKqueueConnBufferSize  int

	WebSocketConfiguration *config.WebSocketConfiguration
}

type WgRequestParams struct {
	UseSse        bool
	SubscribeOnce bool
}