handler

type DefaultErrorPresenter struct {
	// ResultPresenter is used to present ErrPrepare.Errs in an ExecutionResult.
	ResultPresenter ResultPresenter
}

type DefaultRequestBuilder struct {
	Config *DefaultRequestBuilderConfig
}

type DefaultRequestBuilderConfig struct {
	HTTPRequestParserOptions ParseHTTPRequestOptions
	QueryParserOptions       []parser.ParseOption
	DefaultFieldResolver     graphql.FieldResolver
}

type DefaultResultPresenter struct{}

type ErrEmptyQuery struct {
	Request *http.Request
}

type ErrParseQuery struct {
	Request       *http.Request
	ParsedRequest *HTTPRequest
	Err           error
}

type ErrPrepare struct {
	Request       *http.Request
	ParsedRequest *HTTPRequest
	Document      ast.Document
	Errs          graphql.Errors
}

type ErrorPresenter interface {
	// Write sends the given error to w.
	Write(w http.ResponseWriter, err error)
}

type HTTPHandler interface {
	// Schema served by this handler
	Schema() graphql.Schema

	// OperationCache for the parsed queries
	OperationCache() OperationCache
}

type HTTPRequest struct {
	Query         string                 `json:"query"`
	OperationName string                 `json:"operationName"`
	Variables     map[string]interface{} `json:"variables"`
}

type HTTPRequestParseError struct {
	Request *http.Request
	Options *ParseHTTPRequestOptions
	Err     error
}

type LLConfig struct {
	// Schema to be working on
	Schema graphql.Schema

	// OperationCache caches graphql.PreparedOperation created from a query to save parsing efforts.
	OperationCache OperationCache

	// Middlewares to be applied before executing a Request
	Middlewares []RequestMiddleware
}

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

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

type NopOperationCache struct{}

type OperationCache interface {
	// Get looks up operation for the given query.
	Get(query string) (operation *executor.PreparedOperation, ok bool)

	// Add adds an operation that associated with the query to the cache.
	Add(query string, operation *executor.PreparedOperation)
}

type Option func(h *httpHandlerConfig)

type ParseHTTPRequestOptions struct {
	// Maximum size in bytes to be read when parsing a GraphQL query from HTTP request body. If it is
	// not set, the size is capped at 10MB.
	MaxBodySize uint
}

type Request struct {
	Ctx         context.Context
	Operation   *executor.PreparedOperation
	ExecuteOpts []executor.ExecuteOption
}

type RequestBuilder interface {
	// Build turns a http.Request r into a Request for h. w is used for sending errors.
	Build(r *http.Request, h HTTPHandler) (*Request, error)
}

type RequestMiddleware interface {
	// Apply modifies request. next specifies the next action to do after applying the middleware.
	Apply(request *Request, next *RequestMiddlewareNext)
}

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

type ResultPresenter interface {
	// Write writes an ExecutionResult to w.
	Write(
		w http.ResponseWriter,
		httpRequest *http.Request,
		graphqlRequest *Request,
		result *executor.ExecutionResult)
}