bramble

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

type BasePlugin struct{}

type BoundaryQueriesMap map[string]map[string]BoundaryQuery

type BoundaryQuery struct {
	Query string
	// Whether the query is in the array format
	Array bool
}

type ClientOpt func(*GraphQLClient)

type Config struct {
	GatewayPort            int       `json:"gateway-port"`
	MetricsPort            int       `json:"metrics-port"`
	PrivatePort            int       `json:"private-port"`
	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"`
	Plugins                []PluginConfig
	// Config extensions that can be shared among plugins
	Extensions map[string]json.RawMessage
	// 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     BoundaryQueriesMap
	GraphqlClient       *GraphQLClient
	Tracer              opentracing.Tracer
	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
	Tracer          opentracing.Tracer
}

type GraphqlError struct {
	Message string `json:"message"`
}

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
	ModifyExtensions(ctx context.Context, e *QueryExecution, extensions map[string]interface{}) error
}

type PluginConfig struct {
	Name   string
	Config json.RawMessage
}

type QueryExecution struct {
	Schema       *ast.Schema
	Errors       []*gqlerror.Error
	RequestCount int64
	// contains filtered or unexported fields
}

type Request struct {
	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
}