bramble

type AllowedFields struct {
	AllowAll         bool
	AllowedSubfields map[string]AllowedFields
}

type BasePlugin struct{}

type BoundaryField struct {
	Field string
	// Name of the received id argument
	Argument string
	// Whether the query is in the array format
	Array bool
}

type BoundaryFieldsMap map[string]map[string]BoundaryField

type ClientOpt func(*GraphQLClient)

type Config struct {
	IdFieldName            string        `json:"id-field-name"`
	GatewayListenAddress   string        `json:"gateway-address"`
	DisableIntrospection   bool          `json:"disable-introspection"`
	MetricsListenAddress   string        `json:"metrics-address"`
	PrivateListenAddress   string        `json:"private-address"`
	GatewayPort            int           `json:"gateway-port"`
	MetricsPort            int           `json:"metrics-port"`
	PrivatePort            int           `json:"private-port"`
	DefaultTimeouts        TimeoutConfig `json:"default-timeouts"`
	GatewayTimeouts        TimeoutConfig `json:"gateway-timeouts"`
	PrivateTimeouts        TimeoutConfig `json:"private-timeouts"`
	Services               []string      `json:"services"`
	LogLevel               log.Level     `json:"loglevel"`
	PollInterval           string        `json:"poll-interval"`
	PollIntervalDuration   time.Duration
	MaxRequestsPerQuery    int64           `json:"max-requests-per-query"`
	MaxServiceResponseSize int64           `json:"max-service-response-size"`
	Telemetry              TelemetryConfig `json:"telemetry"`
	Plugins                []PluginConfig
	// Config extensions that can be shared among plugins
	Extensions map[string]json.RawMessage
	// HTTP client to customize for downstream services query
	QueryHTTPClient *http.Client
	// contains filtered or unexported fields
}

type DebugInfo struct {
	Variables bool
	Query     bool
	Plan      bool
	Timing    bool
	TraceID   bool
}

type EventFields map[string]interface{}

type ExecutableSchema struct {
	MergedSchema        *ast.Schema
	Locations           FieldURLMap
	IsBoundary          map[string]bool
	Services            map[string]*Service
	BoundaryQueries     BoundaryFieldsMap
	GraphqlClient       *GraphQLClient
	MaxRequestsPerQuery int64
	// contains filtered or unexported fields
}

type FieldURLMap map[string]string

type Gateway struct {
	ExecutableSchema *ExecutableSchema
	// contains filtered or unexported fields
}

type GraphQLClient struct {
	HTTPClient      *http.Client
	MaxResponseSize int64
	UserAgent       string
	// contains filtered or unexported fields
}

type GraphqlError struct {
	Message    string                 `json:"message"`
	Path       ast.Path               `json:"path,omitempty"`
	Extensions map[string]interface{} `json:"extensions"`
}

type GraphqlErrors []GraphqlError

type OperationPermissions struct {
	AllowedRootQueryFields        AllowedFields `json:"query"`
	AllowedRootMutationFields     AllowedFields `json:"mutation"`
	AllowedRootSubscriptionFields AllowedFields `json:"subscription"`
}

type PlanningContext struct {
	Operation  *ast.OperationDefinition
	Schema     *ast.Schema
	Locations  FieldURLMap
	IsBoundary map[string]bool
	Services   map[string]*Service
}

type Plugin interface {
	// ID must return the plugin identifier (name). This is the id used to match
	// the plugin in the configuration.
	ID() string
	// Configure is called during initialization and every time the config is modified.
	// The pluginCfg argument is the raw json contained in the "config" key for that plugin.
	Configure(cfg *Config, pluginCfg json.RawMessage) error
	// Init is called once on initialization
	Init(schema *ExecutableSchema)
	SetupPublicMux(mux *http.ServeMux)
	SetupPrivateMux(mux *http.ServeMux)
	// Should return true and the query path if the plugin is a service that
	// should be federated by Bramble
	GraphqlQueryPath() (bool, string)
	ApplyMiddlewarePublicMux(http.Handler) http.Handler
	ApplyMiddlewarePrivateMux(http.Handler) http.Handler
	WrapGraphQLClientTransport(http.RoundTripper) http.RoundTripper

	InterceptRequest(ctx context.Context, operationName, rawQuery string, variables map[string]interface{})
	InterceptResponse(ctx context.Context, operationName, rawQuery string, variables map[string]interface{}, response *graphql.Response) *graphql.Response
}

type PluginConfig struct {
	Name   string
	Config json.RawMessage
}

type QueryPlan struct {
	RootSteps []*QueryPlanStep
}

type QueryPlanStep struct {
	ServiceURL     string
	ServiceName    string
	ParentType     string
	SelectionSet   ast.SelectionSet
	InsertionPoint []string
	Then           []*QueryPlanStep
}

type Request struct {
	OperationType string                 `json:"operationType,omitempty"`
	Query         string                 `json:"query"`
	OperationName string                 `json:"operationName,omitempty"`
	Variables     map[string]interface{} `json:"variables,omitempty"`
	Headers       http.Header            `json:"-"`
}

type Response struct {
	Errors GraphqlErrors `json:"errors"`
	Data   interface{}
}

type Service struct {
	ServiceURL   string
	Name         string
	Version      string
	SchemaSource string
	Schema       *ast.Schema
	Status       string
	// contains filtered or unexported fields
}

type TelemetryConfig struct {
	Enabled     bool   `json:"enabled"`      // Enabled enables OpenTelemetry tracing and metrics.
	Insecure    bool   `json:"insecure"`     // Insecure enables insecure communication with the OpenTelemetry collector.
	Endpoint    string `json:"endpoint"`     // Endpoint is the OpenTelemetry collector endpoint.
	ServiceName string `json:"service_name"` // ServiceName is the name of the service.
}

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

type TimeoutConfig struct {
	ReadTimeout          string        `json:"read"`
	ReadTimeoutDuration  time.Duration `json:"-"`
	WriteTimeout         string        `json:"write"`
	WriteTimeoutDuration time.Duration `json:"-"`
	IdleTimeout          string        `json:"idle"`
	IdleTimeoutDuration  time.Duration `json:"-"`
}