This type doesn't have documentation.

type ComplexityAccessDefinition struct {
	Limit			ComplexityLimit
	FieldAccessRights	[]ComplexityFieldAccessDefinition
}

This type doesn't have documentation.

type ComplexityChecker interface {
	DepthLimitExceeded(r *http.Request, accessDefinition *ComplexityAccessDefinition) ComplexityFailReason
}

This type doesn't have documentation.

type ComplexityFailReason int

This type doesn't have documentation.

type ComplexityFieldAccessDefinition struct {
	TypeName	string
	FieldName	string
	Limits		ComplexityFieldLimits
}

This type doesn't have documentation.

type ComplexityFieldLimits struct {
	MaxQueryDepth int
}

This type doesn't have documentation.

type ComplexityLimit struct {
	MaxQueryDepth int
}

This type doesn't have documentation.

type ContextRetrieveRequestV1Func func(r *http.Request) *graphql.Request

This type doesn't have documentation.

type ContextRetrieveRequestV2Func func(r *http.Request) *graphqlv2.Request

This type doesn't have documentation.

type ContextStoreRequestV1Func func(r *http.Request, gqlRequest *graphql.Request)

This type doesn't have documentation.

type ContextStoreRequestV2Func func(r *http.Request, gqlRequest *graphqlv2.Request)

This type doesn't have documentation.

type Engine interface {
	Version() EngineVersion
	HasSchema() bool
	Cancel()
	ProcessAndStoreGraphQLRequest(w http.ResponseWriter, r *http.Request) (err error, statusCode int)
	ProcessGraphQLComplexity(r *http.Request, accessDefinition *ComplexityAccessDefinition) (err error, statusCode int)
	ProcessGraphQLGranularAccess(w http.ResponseWriter, r *http.Request, accessDefinition *GranularAccessDefinition) (err error, statusCode int)
	HandleReverseProxy(params ReverseProxyParams) (res *http.Response, hijacked bool, err error)
}

This type doesn't have documentation.

type EngineV1 struct {
	ExecutionEngine	*graphql.ExecutionEngine
	Schema		*graphql.Schema
	ApiDefinition	*apidef.APIDefinition
	HttpClient	*http.Client

	logger				abstractlogger.Logger
	gqlTools			graphqlGoToolsV1
	graphqlRequestProcessor		GraphQLRequestProcessor
	complexityChecker		ComplexityChecker
	granularAccessChecker		GranularAccessChecker
	reverseProxyPreHandler		ReverseProxyPreHandler
	ctxStoreRequestFunc		func(r *http.Request, gqlRequest *graphql.Request)
	ctxRetrieveRequestFunc		func(r *http.Request) *graphql.Request
	newReusableBodyReadCloser	NewReusableBodyReadCloserFunc
}

This type doesn't have documentation.

type EngineV1Injections struct {
	PreSendHttpHook			datasource.PreSendHttpHook
	PostReceiveHttpHook		datasource.PostReceiveHttpHook
	ContextStoreRequest		ContextStoreRequestV1Func
	ContextRetrieveRequest		ContextRetrieveRequestV1Func
	NewReusableBodyReadCloser	NewReusableBodyReadCloserFunc
}

This type doesn't have documentation.

type EngineV1Options struct {
	Logger		*logrus.Logger
	ApiDefinition	*apidef.APIDefinition
	Schema		*graphql.Schema
	HttpClient	*http.Client
	Injections	EngineV1Injections
}

This type doesn't have documentation.

type EngineV2 struct {
	ExecutionEngine	*graphql.ExecutionEngineV2
	Schema		*graphql.Schema
	ApiDefinition	*apidef.APIDefinition
	HttpClient	*http.Client
	StreamingClient	*http.Client
	OpenTelemetry	*EngineV2OTelConfig

	logger				abstractlogger.Logger
	gqlTools			graphqlGoToolsV1
	graphqlRequestProcessor		GraphQLRequestProcessor
	complexityChecker		ComplexityChecker
	granularAccessChecker		GranularAccessChecker
	reverseProxyPreHandler		ReverseProxyPreHandler
	contextCancel			context.CancelFunc
	beforeFetchHook			resolve.BeforeFetchHook
	afterFetchHook			resolve.AfterFetchHook
	ctxStoreRequestFunc		func(r *http.Request, gqlRequest *graphql.Request)
	ctxRetrieveRequestFunc		func(r *http.Request) *graphql.Request
	newReusableBodyReadCloser	NewReusableBodyReadCloserFunc
	seekReadCloser			SeekReadCloserFunc
	tykVariableReplacer		TykVariableReplacer
}

This type doesn't have documentation.

type EngineV2Injections struct {
	BeforeFetchHook			resolve.BeforeFetchHook
	AfterFetchHook			resolve.AfterFetchHook
	WebsocketOnBeforeStart		graphql.WebsocketBeforeStartHook
	ContextStoreRequest		ContextStoreRequestV1Func
	ContextRetrieveRequest		ContextRetrieveRequestV1Func
	NewReusableBodyReadCloser	NewReusableBodyReadCloserFunc
	SeekReadCloser			SeekReadCloserFunc
	TykVariableReplacer		TykVariableReplacer
}

This type doesn't have documentation.

type EngineV2OTelConfig struct {
	Enabled		bool
	Config		otel.OpenTelemetry
	TracerProvider	otel.TracerProvider
	Executor	graphqlinternal.TykOtelExecutorI
}

This type doesn't have documentation.

type EngineV2Options struct {
	Logger		*logrus.Logger
	Schema		*graphql.Schema
	ApiDefinition	*apidef.APIDefinition
	HttpClient	*http.Client
	StreamingClient	*http.Client
	OpenTelemetry	EngineV2OTelConfig
	Injections	EngineV2Injections
}

This type doesn't have documentation.

type EngineV3 struct {
	engine		*graphqlv2.ExecutionEngineV2
	schema		*graphqlv2.Schema
	logger		abstractlogger.Logger
	openTelemetry	*EngineV2OTelConfig
	apiDefinition	*apidef.APIDefinition

	ctxStoreRequestFunc	ContextStoreRequestV2Func
	ctxRetrieveRequestFunc	ContextRetrieveRequestV2Func

	gqlTools			graphqlGoToolsV2
	graphqlRequestProcessor		GraphQLRequestProcessor
	complexityChecker		ComplexityChecker
	granularAccessChecker		GranularAccessChecker
	reverseProxyPreHandler		ReverseProxyPreHandler
	contextCancel			context.CancelFunc
	newReusableBodyReadCloser	NewReusableBodyReadCloserFunc
	seekReadCloser			SeekReadCloserFunc
	tykVariableReplacer		TykVariableReplacer
}

This type doesn't have documentation.

type EngineV3Injections struct {
	WebsocketOnBeforeStart		graphqlv2.WebsocketBeforeStartHook
	ContextStoreRequest		ContextStoreRequestV2Func
	ContextRetrieveRequest		ContextRetrieveRequestV2Func
	NewReusableBodyReadCloser	NewReusableBodyReadCloserFunc
	SeekReadCloser			SeekReadCloserFunc
	TykVariableReplacer		TykVariableReplacer
}

This type doesn't have documentation.

type EngineV3Options struct {
	Logger		*logrus.Logger
	Schema		*graphqlv2.Schema
	ApiDefinition	*apidef.APIDefinition
	HttpClient	*http.Client
	StreamingClient	*http.Client
	OpenTelemetry	EngineV2OTelConfig
	Injections	EngineV3Injections
}

This type doesn't have documentation.

type EngineVersion int

This type doesn't have documentation.

type GranularAccessChecker interface {
	CheckGraphQLRequestFieldAllowance(w http.ResponseWriter, r *http.Request, accessDefinition *GranularAccessDefinition) GraphQLGranularAccessResult
}

This type doesn't have documentation.

type GranularAccessDefinition struct {
	AllowedTypes		[]GranularAccessType
	RestrictedTypes		[]GranularAccessType
	DisableIntrospection	bool
}

This type doesn't have documentation.

type GranularAccessFailReason int

This type doesn't have documentation.

type GranularAccessType struct {
	Name	string
	Fields	[]string
}

This type doesn't have documentation.

type GraphQLEngineTransport struct {
	originalTransport		http.RoundTripper
	transportType			GraphQLEngineTransportType
	newReusableBodyReadCloser	NewReusableBodyReadCloserFunc
	headersConfig			ReverseProxyHeadersConfig
}

This type doesn't have documentation.

type GraphQLEngineTransportType int

This type doesn't have documentation.

type GraphQLGranularAccessResult struct {
	FailReason		GranularAccessFailReason
	ValidationError		error
	InternalErr		error
	writeErrorResponse	func(w io.Writer, providedErr error) (n int, err error)
}

This type doesn't have documentation.

type GraphQLProxyOnlyContext struct {
	context.Context
	forwardedRequest	*http.Request
	upstreamResponse	*http.Response
	ignoreForwardedHeaders	map[string]bool
}

This type doesn't have documentation.

type GraphQLProxyOnlyContextValues struct {
	forwardedRequest	*http.Request
	upstreamResponse	*http.Response
	ignoreForwardedHeaders	map[string]bool
}

This type doesn't have documentation.

type GraphQLRequestProcessor interface {
	ProcessRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) (error, int)
}

This type doesn't have documentation.

type NewReusableBodyReadCloserFunc func(io.ReadCloser) (io.ReadCloser, error)

This type doesn't have documentation.

type ProcessGraphQLComplexityParams struct {
	w	http.ResponseWriter
	r	*http.Request
}

This type doesn't have documentation.

type ProxyOnlyHeadersConfig struct {
	UseImmutableHeaders	bool
	RequestHeadersRewrite	map[string]apidef.RequestHeadersRewriteConfig
}

This type doesn't have documentation.

type ReverseProxyHeadersConfig struct {
	ProxyOnly ProxyOnlyHeadersConfig
}

This type doesn't have documentation.

type ReverseProxyParams struct {
	RoundTripper		http.RoundTripper
	ResponseWriter		http.ResponseWriter
	OutRequest		*http.Request
	WebSocketUpgrader	*websocket.Upgrader
	NeedsEngine		bool
	IsCORSPreflight		bool
	IsWebSocketUpgrade	bool
	HeadersConfig		ReverseProxyHeadersConfig
}

This type doesn't have documentation.

type ReverseProxyPreHandler interface {
	PreHandle(params ReverseProxyParams) (reverseProxyType ReverseProxyType, err error)
}

This type doesn't have documentation.

type ReverseProxyType int

This type doesn't have documentation.

type SeekReadCloserFunc func(io.ReadCloser) (io.ReadCloser, error)

This type doesn't have documentation.

type TransportModifier func(roundTripper http.RoundTripper, apiDefinition *apidef.APIDefinition) http.RoundTripper

This type doesn't have documentation.

type TykVariableReplacer func(r *http.Request, in string, escape bool) string

This type doesn't have documentation.

type complexityCheckerV1 struct {
	logger			abstractlogger.Logger
	schema			*graphql.Schema
	ctxRetrieveRequest	ContextRetrieveRequestV1Func
}

This type doesn't have documentation.

type complexityCheckerV2 struct {
	schema			*graphqlv2.Schema
	logger			abstractlogger.Logger
	ctxRetrieveRequest	ContextRetrieveRequestV2Func
}

This type doesn't have documentation.

type contextKey struct{}

This type doesn't have documentation.

type createExecutionEngineV1Params struct {
	logger			abstractlogger.Logger
	apiDef			*apidef.APIDefinition
	schema			*graphql.Schema
	httpClient		*http.Client
	preSendHttpHook		datasource.PreSendHttpHook
	postReceiveHttpHook	datasource.PostReceiveHttpHook
}

This type doesn't have documentation.

type granularAccessCheckerV1 struct {
	logger				abstractlogger.Logger
	schema				*graphql.Schema
	ctxRetrieveGraphQLRequest	ContextRetrieveRequestV1Func
}

This type doesn't have documentation.

type granularAccessCheckerV2 struct {
	logger				abstractlogger.Logger
	schema				*graphqlv2.Schema
	ctxRetrieveGraphQLRequest	ContextRetrieveRequestV2Func
}

graphqlGoToolsV1 is a stateless utility struct that abstracts graphql-go-tools/v1 functionality. Also useful for namespacing.

type graphqlGoToolsV1 struct{}

This type doesn't have documentation.

type graphqlGoToolsV2 struct{}

This type doesn't have documentation.

type graphqlRequestProcessorV1 struct {
	logger			abstractlogger.Logger
	schema			*graphql.Schema
	ctxRetrieveRequest	ContextRetrieveRequestV1Func
}

This type doesn't have documentation.

type graphqlRequestProcessorWithOTelV1 struct {
	logger			abstractlogger.Logger
	schema			*graphql.Schema
	otelExecutor		internalgraphql.TykOtelExecutorI
	ctxRetrieveRequest	ContextRetrieveRequestV1Func
}

This type doesn't have documentation.

type reverseProxyPreHandlerV1 struct {
	ctxRetrieveGraphQLRequest	ContextRetrieveRequestV1Func
	apiDefinition			*apidef.APIDefinition
	httpClient			*http.Client
	newReusableBodyReadCloser	NewReusableBodyReadCloserFunc
}

This type doesn't have documentation.

type reverseProxyPreHandlerV2 struct {
	ctxRetrieveGraphQLRequest	ContextRetrieveRequestV2Func
	apiDefinition			*apidef.APIDefinition
	httpClient			*http.Client
	newReusableBodyReadCloser	NewReusableBodyReadCloserFunc
}

func DetermineGraphQLEngineTransportType(apiDefinition *apidef.APIDefinition) GraphQLEngineTransportType {
	switch apiDefinition.GraphQL.ExecutionMode {
	case apidef.GraphQLExecutionModeSubgraph:
		fallthrough
	case apidef.GraphQLExecutionModeProxyOnly:
		return GraphQLEngineTransportTypeProxyOnly
	}

	return GraphQLEngineTransportTypeMultiUpstream
}

Cognitive complexity: 4, Cyclomatic complexity: 4

func GetProxyOnlyContextValue(ctx context.Context) *GraphQLProxyOnlyContextValues {
	val, ok := ctx.Value(graphqlProxyContextInfo).(*GraphQLProxyOnlyContextValues)
	if !ok {
		return nil
	}
	return val
}

Cognitive complexity: 2, Cyclomatic complexity: 2

func GetSchemaV1(engine Engine) (*graphql.Schema, error) {
	switch engine.Version() {
	case EngineVersionV1:
		return engine.(*EngineV1).Schema, nil
	case EngineVersionV2:
		return engine.(*EngineV2).Schema, nil
	}
	return nil, errors.New("schema not supported for engine type")
}

Cognitive complexity: 4, Cyclomatic complexity: 4

func GetSchemaV2(engine Engine) (*graphqlv2.Schema, error) {
	switch engine.Version() {
	case EngineVersionV3:
		// Handle for tyk graph engine v3
	}
	return nil, errors.New("schema not supported for engine type")
}

Cognitive complexity: 3, Cyclomatic complexity: 3

func NewEngineV1(options EngineV1Options) (*EngineV1, error) {
	logger := createAbstractLogrusLogger(options.Logger)
	gqlTools := graphqlGoToolsV1{}

	var parsedSchema = options.Schema
	if parsedSchema == nil {
		var err error
		parsedSchema, err = gqlTools.parseSchema(options.ApiDefinition.GraphQL.Schema)
		if err != nil {
			logger.Error("error on schema parsing", abstractlogger.Error(err))
			return nil, err
		}
	}

	executionEngine, err := gqlTools.createExecutionEngine(createExecutionEngineV1Params{
		logger:			logger,
		apiDef:			options.ApiDefinition,
		schema:			parsedSchema,
		httpClient:		options.HttpClient,
		preSendHttpHook:	options.Injections.PreSendHttpHook,
		postReceiveHttpHook:	options.Injections.PostReceiveHttpHook,
	})
	if err != nil {
		logger.Error("error on execution engine creation", abstractlogger.Error(err))
		return nil, err
	}

	requestProcessor := &graphqlRequestProcessorV1{
		logger:			logger,
		schema:			parsedSchema,
		ctxRetrieveRequest:	options.Injections.ContextRetrieveRequest,
	}

	complexityChecker := &complexityCheckerV1{
		logger:			logger,
		schema:			parsedSchema,
		ctxRetrieveRequest:	options.Injections.ContextRetrieveRequest,
	}

	granularAccessChecker := &granularAccessCheckerV1{
		logger:				logger,
		schema:				parsedSchema,
		ctxRetrieveGraphQLRequest:	options.Injections.ContextRetrieveRequest,
	}

	reverseProxyPreHandler := &reverseProxyPreHandlerV1{
		ctxRetrieveGraphQLRequest:	options.Injections.ContextRetrieveRequest,
		apiDefinition:			options.ApiDefinition,
		httpClient:			options.HttpClient,
		newReusableBodyReadCloser:	options.Injections.NewReusableBodyReadCloser,
	}

	return &EngineV1{
		ExecutionEngine:		executionEngine,
		Schema:				parsedSchema,
		ApiDefinition:			options.ApiDefinition,
		HttpClient:			options.HttpClient,
		logger:				logger,
		gqlTools:			gqlTools,
		graphqlRequestProcessor:	requestProcessor,
		complexityChecker:		complexityChecker,
		granularAccessChecker:		granularAccessChecker,
		reverseProxyPreHandler:		reverseProxyPreHandler,
		ctxStoreRequestFunc:		options.Injections.ContextStoreRequest,
		ctxRetrieveRequestFunc:		options.Injections.ContextRetrieveRequest,
	}, nil
}

Cognitive complexity: 13, Cyclomatic complexity: 4

func NewEngineV2(options EngineV2Options) (*EngineV2, error) {
	logger := createAbstractLogrusLogger(options.Logger)
	gqlTools := graphqlGoToolsV1{}

	var parsedSchema = options.Schema
	if parsedSchema == nil {
		var err error
		parsedSchema, err = gqlTools.parseSchema(options.ApiDefinition.GraphQL.Schema)
		if err != nil {
			logger.Error("error on schema parsing", abstractlogger.Error(err))
			return nil, err
		}
	}

	configAdapter := adapter.NewGraphQLConfigAdapter(options.ApiDefinition,
		adapter.WithHttpClient(options.HttpClient),
		adapter.WithStreamingClient(options.StreamingClient),
		adapter.WithSchema(parsedSchema),
	)

	engineConfig, err := configAdapter.EngineConfigV2()
	if err != nil {
		options.Logger.WithError(err).Error("could not create engine v2 config")
		return nil, err
	}
	engineConfig.SetWebsocketBeforeStartHook(options.Injections.WebsocketOnBeforeStart)
	specCtx, cancel := context.WithCancel(context.Background())

	executionEngine, err := graphql.NewExecutionEngineV2(specCtx, logger, *engineConfig)
	if err != nil {
		options.Logger.WithError(err).Error("could not create execution engine v2")
		cancel()
		return nil, err
	}

	requestProcessor := &graphqlRequestProcessorV1{
		logger:			logger,
		schema:			parsedSchema,
		ctxRetrieveRequest:	options.Injections.ContextRetrieveRequest,
	}

	complexityChecker := &complexityCheckerV1{
		logger:			logger,
		schema:			parsedSchema,
		ctxRetrieveRequest:	options.Injections.ContextRetrieveRequest,
	}

	granularAccessChecker := &granularAccessCheckerV1{
		logger:				logger,
		schema:				parsedSchema,
		ctxRetrieveGraphQLRequest:	options.Injections.ContextRetrieveRequest,
	}

	reverseProxyPreHandler := &reverseProxyPreHandlerV1{
		ctxRetrieveGraphQLRequest:	options.Injections.ContextRetrieveRequest,
		apiDefinition:			options.ApiDefinition,
		httpClient:			options.HttpClient,
		newReusableBodyReadCloser:	options.Injections.NewReusableBodyReadCloser,
	}

	engineV2 := &EngineV2{
		ExecutionEngine:		executionEngine,
		Schema:				parsedSchema,
		ApiDefinition:			options.ApiDefinition,
		HttpClient:			options.HttpClient,
		StreamingClient:		options.StreamingClient,
		OpenTelemetry:			&options.OpenTelemetry,
		logger:				logger,
		gqlTools:			gqlTools,
		graphqlRequestProcessor:	requestProcessor,
		complexityChecker:		complexityChecker,
		granularAccessChecker:		granularAccessChecker,
		reverseProxyPreHandler:		reverseProxyPreHandler,
		contextCancel:			cancel,
		beforeFetchHook:		options.Injections.BeforeFetchHook,
		afterFetchHook:			options.Injections.AfterFetchHook,
		ctxStoreRequestFunc:		options.Injections.ContextStoreRequest,
		ctxRetrieveRequestFunc:		options.Injections.ContextRetrieveRequest,
		newReusableBodyReadCloser:	options.Injections.NewReusableBodyReadCloser,
		seekReadCloser:			options.Injections.SeekReadCloser,
		tykVariableReplacer:		options.Injections.TykVariableReplacer,
	}

	if engineV2.OpenTelemetry == nil {
		engineV2.OpenTelemetry = &EngineV2OTelConfig{}
	}

	if engineV2.OpenTelemetry.Enabled {
		var executor graphqlinternal.TykOtelExecutorI
		if options.ApiDefinition.DetailedTracing {
			executor, err = graphqlinternal.NewOtelGraphqlEngineV2Detailed(engineV2.OpenTelemetry.TracerProvider, executionEngine, parsedSchema)
		} else {
			executor, err = graphqlinternal.NewOtelGraphqlEngineV2Basic(engineV2.OpenTelemetry.TracerProvider, executionEngine)
		}
		if err != nil {
			options.Logger.WithError(err).Error("error creating custom execution engine v2")
			cancel()
			return nil, err
		}

		otelRequestProcessor := &graphqlRequestProcessorWithOTelV1{
			logger:			logger,
			schema:			parsedSchema,
			otelExecutor:		executor,
			ctxRetrieveRequest:	options.Injections.ContextRetrieveRequest,
		}
		engineV2.graphqlRequestProcessor = otelRequestProcessor
		engineV2.OpenTelemetry.Executor = executor
	}

	if isSupergraph(options.ApiDefinition) {
		engineV2.ApiDefinition.GraphQL.Schema = engineV2.ApiDefinition.GraphQL.Supergraph.MergedSDL
	}

	return engineV2, nil
}

Cognitive complexity: 28, Cyclomatic complexity: 10

func NewEngineV3(options EngineV3Options) (*EngineV3, error) {
	logger := createAbstractLogrusLogger(options.Logger)
	gqlTools := graphqlGoToolsV2{}

	var parsedSchema = options.Schema
	if parsedSchema == nil {
		var err error
		parsedSchema, err = gqlTools.parseSchema(options.ApiDefinition.GraphQL.Schema)
		if err != nil {
			logger.Error("error on schema parsing", abstractlogger.Error(err))
			return nil, err
		}
	}

	// TODO check the streaming client usage here
	configAdapter := adapter.NewGraphQLConfigAdapter(options.ApiDefinition,
		adapter.WithHttpClient(options.HttpClient),
		adapter.WithV2Schema(options.Schema),
		adapter.WithStreamingClient(options.StreamingClient),
	)

	engineConfig, err := configAdapter.EngineConfigV3()
	if err != nil {
		options.Logger.WithError(err).Error("could not create engine v2 config")
		return nil, err
	}
	engineConfig.SetWebsocketBeforeStartHook(options.Injections.WebsocketOnBeforeStart)
	specCtx, cancel := context.WithCancel(context.Background())

	executionEngine, err := graphqlv2.NewExecutionEngineV2(specCtx, logger, *engineConfig)
	if err != nil {
		options.Logger.WithError(err).Error("could not create execution engine v2")
		cancel()
		return nil, err
	}
	//
	//requestProcessor := &graphqlRequestProcessorV1{
	//	logger:             logger,
	//	schema:             parsedSchema,
	//	ctxRetrieveRequest: options.Injections.ContextRetrieveRequest,
	//}
	//
	complexityChecker := &complexityCheckerV2{
		logger:			logger,
		schema:			parsedSchema,
		ctxRetrieveRequest:	options.Injections.ContextRetrieveRequest,
	}

	granularAccessChecker := &granularAccessCheckerV2{
		logger:				logger,
		schema:				parsedSchema,
		ctxRetrieveGraphQLRequest:	options.Injections.ContextRetrieveRequest,
	}

	reverseProxyPreHandler := &reverseProxyPreHandlerV2{
		ctxRetrieveGraphQLRequest:	options.Injections.ContextRetrieveRequest,
		apiDefinition:			options.ApiDefinition,
		httpClient:			options.HttpClient,
		newReusableBodyReadCloser:	options.Injections.NewReusableBodyReadCloser,
	}

	engine := EngineV3{
		logger:			logger,
		schema:			options.Schema,
		engine:			executionEngine,
		ctxRetrieveRequestFunc:	options.Injections.ContextRetrieveRequest,
		ctxStoreRequestFunc:	options.Injections.ContextStoreRequest,
		openTelemetry:		&options.OpenTelemetry,
		apiDefinition:		options.ApiDefinition,
		reverseProxyPreHandler:	reverseProxyPreHandler,
		gqlTools:		gqlTools,
		tykVariableReplacer:	options.Injections.TykVariableReplacer,
		seekReadCloser:		options.Injections.SeekReadCloser,
		contextCancel:		cancel,
		complexityChecker:	complexityChecker,
		granularAccessChecker:	granularAccessChecker,
	}

	if engine.openTelemetry == nil {
		engine.openTelemetry = &EngineV2OTelConfig{}
	}

	if engine.openTelemetry.Enabled {
		var executor graphqlinternal.TykOtelExecutorI
		if options.ApiDefinition.DetailedTracing {
			//executor, err = graphqlinternal.NewOtelGraphqlEngineV2Detailed(engine.openTelemetry.TracerProvider, executionEngine, parsedSchema)
		} else {
			//executor, err = graphqlinternal.NewOtelGraphqlEngineV2Basic(engine.openTelemetry.TracerProvider, executionEngine)
		}
		if err != nil {
			options.Logger.WithError(err).Error("error creating custom execution engine v2")
			cancel()
			return nil, err
		}

		otelRequestProcessor := &graphqlRequestProcessorWithOTelV1{
			logger:	logger,
			//schema:             parsedSchema,
			otelExecutor:	executor,
			//ctxRetrieveRequest: options.Injections.ContextRetrieveRequest,
		}
		engine.graphqlRequestProcessor = otelRequestProcessor
		engine.openTelemetry.Executor = executor
	}

	if isSupergraph(options.ApiDefinition) {
		engine.apiDefinition.GraphQL.Schema = engine.apiDefinition.GraphQL.Supergraph.MergedSDL
	}

	return &engine, nil
}

Cognitive complexity: 27, Cyclomatic complexity: 10

func NewGraphQLEngineTransport(
	transportType GraphQLEngineTransportType,
	originalTransport http.RoundTripper,
	newReusableBodyReadCloser NewReusableBodyReadCloserFunc,
	headersConfig ReverseProxyHeadersConfig,
) *GraphQLEngineTransport {
	transport := &GraphQLEngineTransport{
		originalTransport:		originalTransport,
		transportType:			transportType,
		newReusableBodyReadCloser:	newReusableBodyReadCloser,
		headersConfig:			headersConfig,
	}
	return transport
}

Cognitive complexity: 1, Cyclomatic complexity: 1

func NewGraphQLProxyOnlyContext(ctx context.Context, forwardedRequest *http.Request) *GraphQLProxyOnlyContext {
	return &GraphQLProxyOnlyContext{
		Context:		ctx,
		forwardedRequest:	forwardedRequest,
		ignoreForwardedHeaders: map[string]bool{
			http.CanonicalHeaderKey("date"):		true,
			http.CanonicalHeaderKey("content-type"):	true,
			http.CanonicalHeaderKey("content-length"):	true,
		},
	}
}

Cognitive complexity: 2, Cyclomatic complexity: 1

func SetProxyOnlyContextValue(ctx context.Context, req *http.Request) context.Context {
	value := &GraphQLProxyOnlyContextValues{
		forwardedRequest:	req,
		ignoreForwardedHeaders: map[string]bool{
			http.CanonicalHeaderKey("date"):		true,
			http.CanonicalHeaderKey("content-type"):	true,
			http.CanonicalHeaderKey("content-length"):	true,
		},
	}

	return context.WithValue(ctx, graphqlProxyContextInfo, value)
}

Cognitive complexity: 2, Cyclomatic complexity: 1

func (e *EngineV1) Cancel() {
	// V1 does not have a cancel callback
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV1) HandleReverseProxy(params ReverseProxyParams) (res *http.Response, hijacked bool, err error) {
	reverseProxyType, err := e.reverseProxyPreHandler.PreHandle(params)
	if err != nil {
		e.logger.Error("error on reverse proxy pre handler", abstractlogger.Error(err))
		return nil, false, err
	}

	gqlRequest := e.ctxRetrieveRequestFunc(params.OutRequest)

	switch reverseProxyType {
	case ReverseProxyTypeIntrospection:
		return e.gqlTools.handleIntrospection(e.Schema)
	case ReverseProxyTypeWebsocketUpgrade:
		return e.handoverWebSocketConnectionToGraphQLExecutionEngine(&params)
	case ReverseProxyTypeGraphEngine:
		return e.handoverRequestToGraphQLExecutionEngine(gqlRequest, params.OutRequest)
	case ReverseProxyTypePreFlight:
		if e.ApiDefinition.GraphQL.ExecutionMode == apidef.GraphQLExecutionModeProxyOnly {
			return nil, false, nil
		}
		return nil, false, errors.New("options passthrough not allowed")
	case ReverseProxyTypeNone:
		return nil, false, nil
	}

	e.logger.Error("unknown reverse proxy type", abstractlogger.Int("reverseProxyType", int(reverseProxyType)))
	return nil, false, ErrUnknownReverseProxyType
}

Cognitive complexity: 11, Cyclomatic complexity: 9

func (e *EngineV1) HasSchema() bool {
	return e.Schema != nil
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV1) ProcessAndStoreGraphQLRequest(w http.ResponseWriter, r *http.Request) (err error, statusCode int) {
	var gqlRequest graphql.Request
	err = graphql.UnmarshalRequest(r.Body, &gqlRequest)
	if err != nil {
		e.logger.Debug("error while unmarshalling GraphQL request", abstractlogger.Error(err))
		return err, http.StatusBadRequest
	}

	e.ctxStoreRequestFunc(r, &gqlRequest)
	return e.graphqlRequestProcessor.ProcessRequest(r.Context(), w, r)
}

Cognitive complexity: 2, Cyclomatic complexity: 2

func (e *EngineV1) ProcessGraphQLComplexity(r *http.Request, accessDefinition *ComplexityAccessDefinition) (err error, statusCode int) {
	return complexityFailReasonAsHttpStatusCode(e.complexityChecker.DepthLimitExceeded(r, accessDefinition))
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV1) ProcessGraphQLGranularAccess(w http.ResponseWriter, r *http.Request, accessDefinition *GranularAccessDefinition) (err error, statusCode int) {
	result := e.granularAccessChecker.CheckGraphQLRequestFieldAllowance(w, r, accessDefinition)
	return granularAccessFailReasonAsHttpStatusCode(e.logger, &result, w)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV1) Version() EngineVersion {
	return EngineVersionV1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV2) Cancel() {
	if e.contextCancel != nil {
		e.contextCancel()
	}
}

Cognitive complexity: 2, Cyclomatic complexity: 2

func (e *EngineV2) HandleReverseProxy(params ReverseProxyParams) (res *http.Response, hijacked bool, err error) {
	reverseProxyType, err := e.reverseProxyPreHandler.PreHandle(params)
	if err != nil {
		e.logger.Error("error on reverse proxy pre handler", abstractlogger.Error(err))
		return nil, false, err
	}

	switch reverseProxyType {
	case ReverseProxyTypeIntrospection:
		return e.gqlTools.handleIntrospection(e.Schema)
	case ReverseProxyTypeWebsocketUpgrade:
		return e.handoverWebSocketConnectionToGraphQLExecutionEngine(&params)
	case ReverseProxyTypeGraphEngine:
		gqlRequest := e.ctxRetrieveRequestFunc(params.OutRequest)
		// Cleanup method frees allocated resources if they are eligible for freeing up.
		// Currently, it only frees up the allocated resources of a GraphQL query that
		// has a cached query plan.
		//
		// graphql-go-tools uses the parsed query (ast.Document in graphql-go-tools codebase)
		// in the planner and caches the plans. If a plan has been cached, we can reset the created
		// ast.Document struct and put it back in the pool for later use. In this way, we can reduce the GC
		// pressure and number of allocations per GraphQL query.
		// See TT-9864 for the details.
		defer gqlRequest.Cleanup()
		return e.handoverRequestToGraphQLExecutionEngine(gqlRequest, params.OutRequest)
	case ReverseProxyTypePreFlight:
		if e.ApiDefinition.GraphQL.ExecutionMode == apidef.GraphQLExecutionModeProxyOnly {
			return nil, false, nil
		}
		return nil, false, errors.New("options passthrough not allowed")
	case ReverseProxyTypeNone:
		return nil, false, nil
	}

	e.logger.Error("unknown reverse proxy type", abstractlogger.Int("reverseProxyType", int(reverseProxyType)))
	return nil, false, ErrUnknownReverseProxyType
}

Cognitive complexity: 11, Cyclomatic complexity: 9

func (e *EngineV2) HasSchema() bool {
	return e.Schema != nil
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV2) ProcessAndStoreGraphQLRequest(w http.ResponseWriter, r *http.Request) (err error, statusCode int) {
	var gqlRequest graphql.Request
	err = graphql.UnmarshalRequest(r.Body, &gqlRequest)
	if err != nil {
		e.logger.Debug("error while unmarshalling GraphQL request", abstractlogger.Error(err))
		return err, http.StatusBadRequest
	}

	e.ctxStoreRequestFunc(r, &gqlRequest)
	if e.OpenTelemetry.Enabled && e.ApiDefinition.DetailedTracing {
		ctx, span := e.OpenTelemetry.TracerProvider.Tracer().Start(r.Context(), "GraphqlMiddleware Validation")
		defer span.End()
		*r = *r.WithContext(ctx)
	}

	return e.graphqlRequestProcessor.ProcessRequest(r.Context(), w, r)
}

Cognitive complexity: 4, Cyclomatic complexity: 4

func (e *EngineV2) ProcessGraphQLComplexity(r *http.Request, accessDefinition *ComplexityAccessDefinition) (err error, statusCode int) {
	return complexityFailReasonAsHttpStatusCode(e.complexityChecker.DepthLimitExceeded(r, accessDefinition))
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV2) ProcessGraphQLGranularAccess(w http.ResponseWriter, r *http.Request, accessDefinition *GranularAccessDefinition) (err error, statusCode int) {
	result := e.granularAccessChecker.CheckGraphQLRequestFieldAllowance(w, r, accessDefinition)
	return granularAccessFailReasonAsHttpStatusCode(e.logger, &result, w)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV2) Version() EngineVersion {
	return EngineVersionV2
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV3) Cancel() {
	if e.contextCancel != nil {
		e.contextCancel()
	}
}

Cognitive complexity: 2, Cyclomatic complexity: 2

func (e *EngineV3) HandleReverseProxy(params ReverseProxyParams) (res *http.Response, hijacked bool, err error) {
	reverseProxyType, err := e.reverseProxyPreHandler.PreHandle(params)
	if err != nil {
		e.logger.Error("error on reverse proxy pre handler", abstractlogger.Error(err))
		return nil, false, err
	}

	gqlRequest := e.ctxRetrieveRequestFunc(params.OutRequest)
	switch reverseProxyType {
	case ReverseProxyTypeIntrospection:
		return e.gqlTools.handleIntrospection(e.schema)
	case ReverseProxyTypeWebsocketUpgrade:
		return e.handoverWebSocketConnectionToGraphQLExecutionEngine(&params)
	case ReverseProxyTypeGraphEngine:
		return e.handoverRequestToGraphQLExecutionEngine(gqlRequest, params.OutRequest)
	case ReverseProxyTypePreFlight:
		if e.apiDefinition.GraphQL.ExecutionMode == apidef.GraphQLExecutionModeProxyOnly {
			return nil, false, nil
		}
		return nil, false, errors.New("options passthrough not allowed")
	case ReverseProxyTypeNone:
		return nil, false, nil
	}

	e.logger.Error("unknown reverse proxy type", abstractlogger.Int("reverseProxyType", int(reverseProxyType)))
	return nil, false, ErrUnknownReverseProxyType
}

Cognitive complexity: 11, Cyclomatic complexity: 9

func (e *EngineV3) HasSchema() bool {
	return e.schema != nil
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV3) ProcessAndStoreGraphQLRequest(w http.ResponseWriter, r *http.Request) (err error, statusCode int) {
	var gqlRequest graphqlv2.Request
	err = graphqlv2.UnmarshalRequest(r.Body, &gqlRequest)
	if err != nil {
		e.logger.Debug("error while unmarshalling GraphQL request", abstractlogger.Error(err))
		return err, http.StatusBadRequest
	}

	e.ctxStoreRequestFunc(r, &gqlRequest)
	if e.openTelemetry.Enabled && e.apiDefinition.DetailedTracing {
		ctx, span := e.openTelemetry.TracerProvider.Tracer().Start(r.Context(), "GraphqlMiddleware Validation")
		defer span.End()
		*r = *r.WithContext(ctx)
	}

	return e.ProcessRequest(r.Context(), w, r)
}

Cognitive complexity: 4, Cyclomatic complexity: 4

func (e *EngineV3) ProcessGraphQLComplexity(r *http.Request, accessDefinition *ComplexityAccessDefinition) (err error, statusCode int) {
	return complexityFailReasonAsHttpStatusCode(e.complexityChecker.DepthLimitExceeded(r, accessDefinition))
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV3) ProcessGraphQLGranularAccess(w http.ResponseWriter, r *http.Request, accessDefinition *GranularAccessDefinition) (err error, statusCode int) {
	result := e.granularAccessChecker.CheckGraphQLRequestFieldAllowance(w, r, accessDefinition)
	return granularAccessFailReasonAsHttpStatusCode(e.logger, &result, w)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (e *EngineV3) ProcessRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) (error, int) {
	if r == nil {
		e.logger.Error("request is nil")
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	gqlRequest := e.ctxRetrieveRequestFunc(r)
	normalizationResult, err := gqlRequest.Normalize(e.schema)
	if err != nil {
		e.logger.Error("error while normalizing GraphQL request", abstractlogger.Error(err))
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	if normalizationResult.Errors != nil && normalizationResult.Errors.Count() > 0 {
		return writeGraphQLError(e.logger, w, normalizationResult.Errors)
	}

	validationResult, err := gqlRequest.ValidateForSchema(e.schema)
	if err != nil {
		e.logger.Error("error while validating GraphQL request", abstractlogger.Error(err))
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	if validationResult.Errors != nil && validationResult.Errors.Count() > 0 {
		return writeGraphQLError(e.logger, w, validationResult.Errors)
	}

	inputValidationResult, err := gqlRequest.ValidateInput(e.schema)
	if err != nil {
		e.logger.Error("error while validating variables for request", abstractlogger.Error(err))
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}
	if inputValidationResult.Errors != nil && inputValidationResult.Errors.Count() > 0 {
		return writeGraphQLError(e.logger, w, inputValidationResult.Errors)
	}
	return nil, http.StatusOK
}

Cognitive complexity: 14, Cyclomatic complexity: 11

func (e *EngineV3) Version() EngineVersion {
	return EngineVersionV3
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (g *GraphQLEngineTransport) RoundTrip(request *http.Request) (res *http.Response, err error) {
	switch g.transportType {
	case GraphQLEngineTransportTypeProxyOnly:
		val := GetProxyOnlyContextValue(request.Context())
		if val != nil {
			return g.handleProxyOnly(val, request)
		}
	}

	return g.originalTransport.RoundTrip(request)
}

Cognitive complexity: 5, Cyclomatic complexity: 4

func (g *GraphQLProxyOnlyContext) Response() *http.Response {
	return g.upstreamResponse
}

Cognitive complexity: 0, Cyclomatic complexity: 1

func (c *complexityCheckerV1) DepthLimitExceeded(r *http.Request, accessDefinition *ComplexityAccessDefinition) ComplexityFailReason {
	if !c.depthLimitEnabled(accessDefinition) {
		return ComplexityFailReasonNone
	}

	gqlRequest := c.ctxRetrieveRequest(r)
	if gqlRequest == nil {
		return ComplexityFailReasonNone
	}

	isIntrospectionQuery, err := gqlRequest.IsIntrospectionQuery()
	if err != nil {
		c.logger.Debug("error while checking for introspection query", abstractlogger.Error(err))
		return ComplexityFailReasonInternalError
	}

	if isIntrospectionQuery {
		return ComplexityFailReasonNone
	}

	complexityRes, err := gqlRequest.CalculateComplexity(graphql.DefaultComplexityCalculator, c.schema)
	if err != nil {
		c.logger.Error("error while calculating complexity of GraphQL request", abstractlogger.Error(err))
		return ComplexityFailReasonInternalError
	}

	if complexityRes.Errors != nil && complexityRes.Errors.Count() > 0 {
		c.logger.Error("error while calculating complexity of GraphQL request", abstractlogger.Error(complexityRes.Errors.ErrorByIndex(0)))
		return ComplexityFailReasonInternalError
	}

	// do per query depth check
	if len(accessDefinition.FieldAccessRights) == 0 {
		if accessDefinition.Limit.MaxQueryDepth > 0 && complexityRes.Depth > accessDefinition.Limit.MaxQueryDepth {
			c.logger.Debug("complexity of the request is higher than the allowed limit", abstractlogger.Int("maxQueryDepth", accessDefinition.Limit.MaxQueryDepth))
			return ComplexityFailReasonDepthLimitExceeded
		}
		return ComplexityFailReasonNone
	}

	// do per query field depth check
	for _, fieldComplexityRes := range complexityRes.PerRootField {
		var (
			fieldAccessDefinition	ComplexityFieldAccessDefinition
			hasPerFieldLimits	bool
		)

		for _, fieldAccessRight := range accessDefinition.FieldAccessRights {
			if fieldComplexityRes.TypeName != fieldAccessRight.TypeName {
				continue
			}
			if fieldComplexityRes.FieldName != fieldAccessRight.FieldName {
				continue
			}

			fieldAccessDefinition = fieldAccessRight
			hasPerFieldLimits = true
			break
		}

		if hasPerFieldLimits {
			if greaterThanIntConsideringUnlimited(fieldComplexityRes.Depth, fieldAccessDefinition.Limits.MaxQueryDepth) {
				c.logger.Debug(
					"depth of the root field is higher than the allowed field limit",
					abstractlogger.Int("depth", fieldComplexityRes.Depth),
					abstractlogger.String("rootField", fmt.Sprintf("%s.%s", fieldAccessDefinition.TypeName, fieldAccessDefinition.FieldName)),
					abstractlogger.Int("maxQueryDepth", fieldAccessDefinition.Limits.MaxQueryDepth),
				)

				return ComplexityFailReasonDepthLimitExceeded
			}
			continue
		}

		// favour global limit for query field
		// have to increase resulting field depth by 1 to get a global depth
		queryDepth := fieldComplexityRes.Depth + 1
		if greaterThanIntConsideringUnlimited(queryDepth, accessDefinition.Limit.MaxQueryDepth) {
			c.logger.Debug(
				"depth of the root field is higher than the allowed global limit",
				abstractlogger.Int("depth", queryDepth),
				abstractlogger.String("rootField", fmt.Sprintf("%s.%s", fieldComplexityRes.TypeName, fieldComplexityRes.FieldName)),
				abstractlogger.Int("maxQueryDepth", accessDefinition.Limit.MaxQueryDepth),
			)

			return ComplexityFailReasonDepthLimitExceeded
		}
	}
	return ComplexityFailReasonNone
}

Cognitive complexity: 32, Cyclomatic complexity: 18

func (c *complexityCheckerV2) DepthLimitExceeded(r *http.Request, accessDefinition *ComplexityAccessDefinition) ComplexityFailReason {
	if !c.depthLimitEnabled(accessDefinition) {
		return ComplexityFailReasonNone
	}

	gqlRequest := c.ctxRetrieveRequest(r)
	if gqlRequest == nil {
		return ComplexityFailReasonNone
	}

	isIntrospectionQuery, err := gqlRequest.IsIntrospectionQuery()
	if err != nil {
		c.logger.Debug("error while checking for introspection query", abstractlogger.Error(err))
		return ComplexityFailReasonInternalError
	}

	if isIntrospectionQuery {
		return ComplexityFailReasonNone
	}

	complexityRes, err := gqlRequest.CalculateComplexity(graphqlv2.DefaultComplexityCalculator, c.schema)
	if err != nil {
		c.logger.Error("error while calculating complexity of GraphQL request", abstractlogger.Error(err))
		return ComplexityFailReasonInternalError
	}

	if complexityRes.Errors != nil && complexityRes.Errors.Count() > 0 {
		c.logger.Error("error while calculating complexity of GraphQL request", abstractlogger.Error(complexityRes.Errors.ErrorByIndex(0)))
		return ComplexityFailReasonInternalError
	}

	// do per query depth check
	if len(accessDefinition.FieldAccessRights) == 0 {
		if accessDefinition.Limit.MaxQueryDepth > 0 && complexityRes.Depth > accessDefinition.Limit.MaxQueryDepth {
			c.logger.Debug("complexity of the request is higher than the allowed limit", abstractlogger.Int("maxQueryDepth", accessDefinition.Limit.MaxQueryDepth))
			return ComplexityFailReasonDepthLimitExceeded
		}
		return ComplexityFailReasonNone
	}

	// do per query field depth check
	for _, fieldComplexityRes := range complexityRes.PerRootField {
		var (
			fieldAccessDefinition	ComplexityFieldAccessDefinition
			hasPerFieldLimits	bool
		)

		for _, fieldAccessRight := range accessDefinition.FieldAccessRights {
			if fieldComplexityRes.TypeName != fieldAccessRight.TypeName {
				continue
			}
			if fieldComplexityRes.FieldName != fieldAccessRight.FieldName {
				continue
			}

			fieldAccessDefinition = fieldAccessRight
			hasPerFieldLimits = true
			break
		}

		if hasPerFieldLimits {
			if greaterThanIntConsideringUnlimited(fieldComplexityRes.Depth, fieldAccessDefinition.Limits.MaxQueryDepth) {
				c.logger.Debug(
					"depth of the root field is higher than the allowed field limit",
					abstractlogger.Int("depth", fieldComplexityRes.Depth),
					abstractlogger.String("rootField", fmt.Sprintf("%s.%s", fieldAccessDefinition.TypeName, fieldAccessDefinition.FieldName)),
					abstractlogger.Int("maxQueryDepth", fieldAccessDefinition.Limits.MaxQueryDepth),
				)

				return ComplexityFailReasonDepthLimitExceeded
			}
			continue
		}

		// favour global limit for query field
		// have to increase resulting field depth by 1 to get a global depth
		queryDepth := fieldComplexityRes.Depth + 1
		if greaterThanIntConsideringUnlimited(queryDepth, accessDefinition.Limit.MaxQueryDepth) {
			c.logger.Debug(
				"depth of the root field is higher than the allowed global limit",
				abstractlogger.Int("depth", queryDepth),
				abstractlogger.String("rootField", fmt.Sprintf("%s.%s", fieldComplexityRes.TypeName, fieldComplexityRes.FieldName)),
				abstractlogger.Int("maxQueryDepth", accessDefinition.Limit.MaxQueryDepth),
			)

			return ComplexityFailReasonDepthLimitExceeded
		}
	}
	return ComplexityFailReasonNone

}

Cognitive complexity: 32, Cyclomatic complexity: 18

func (g *granularAccessCheckerV1) CheckGraphQLRequestFieldAllowance(w http.ResponseWriter, r *http.Request, accessDefinition *GranularAccessDefinition) GraphQLGranularAccessResult {
	gqlRequest := g.ctxRetrieveGraphQLRequest(r)
	if gqlRequest == nil {
		return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonNone}
	}

	isIntrospection, err := gqlRequest.IsIntrospectionQueryStrict()
	if err != nil {
		return GraphQLGranularAccessResult{
			FailReason:	GranularAccessFailReasonInternalError,
			InternalErr:	err,
		}
	}
	if isIntrospection {
		if accessDefinition.DisableIntrospection {
			return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonIntrospectionDisabled}
		}

		// See TT-11260
		//
		// Introspection should be possible when Disable Introspection is turned off in policy settings,
		// regardless of Allow List or Block List settings.
		//
		// Agreed solution: if Disable Introspection is turned off, then the Allow or Block list settings
		// should be ignored, but only for the introspection query.
		return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonNone}
	}

	if len(accessDefinition.AllowedTypes) != 0 {
		fieldRestrictionList := graphql.FieldRestrictionList{
			Kind:	graphql.AllowList,
			Types:	g.convertGranularAccessTypeToGraphQLType(accessDefinition.AllowedTypes),
		}
		return g.validateFieldRestrictions(gqlRequest, fieldRestrictionList, g.schema)
	}

	if len(accessDefinition.RestrictedTypes) != 0 {
		fieldRestrictionList := graphql.FieldRestrictionList{
			Kind:	graphql.BlockList,
			Types:	g.convertGranularAccessTypeToGraphQLType(accessDefinition.RestrictedTypes),
		}
		return g.validateFieldRestrictions(gqlRequest, fieldRestrictionList, g.schema)
	}

	// There are no restricted types. Every field is allowed access.
	return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonNone}
}

Cognitive complexity: 19, Cyclomatic complexity: 7

func (g *granularAccessCheckerV2) CheckGraphQLRequestFieldAllowance(w http.ResponseWriter, r *http.Request, accessDefinition *GranularAccessDefinition) GraphQLGranularAccessResult {
	gqlRequest := g.ctxRetrieveGraphQLRequest(r)
	if gqlRequest == nil {
		return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonNone}
	}

	isIntrospection, err := gqlRequest.IsIntrospectionQueryStrict()
	if err != nil {
		return GraphQLGranularAccessResult{
			FailReason:	GranularAccessFailReasonInternalError,
			InternalErr:	err,
		}
	}
	if isIntrospection {
		if accessDefinition.DisableIntrospection {
			return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonIntrospectionDisabled}
		}

		// See TT-11260
		//
		// Introspection should be possible when Disable Introspection is turned off in policy settings,
		// regardless of Allow List or Block List settings.
		//
		// Agreed solution: if Disable Introspection is turned off, then the Allow or Block list settings
		// should be ignored, but only for the introspection query.
		return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonNone}
	}

	if len(accessDefinition.AllowedTypes) != 0 {
		fieldRestrictionList := graphqlv2.FieldRestrictionList{
			Kind:	graphqlv2.AllowList,
			Types:	g.convertGranularAccessTypeToGraphQLType(accessDefinition.AllowedTypes),
		}
		return g.validateFieldRestrictions(gqlRequest, fieldRestrictionList, g.schema)
	}

	if len(accessDefinition.RestrictedTypes) != 0 {
		fieldRestrictionList := graphqlv2.FieldRestrictionList{
			Kind:	graphqlv2.BlockList,
			Types:	g.convertGranularAccessTypeToGraphQLType(accessDefinition.RestrictedTypes),
		}
		return g.validateFieldRestrictions(gqlRequest, fieldRestrictionList, g.schema)
	}

	// There are no restricted types. Every field is allowed access.
	return GraphQLGranularAccessResult{FailReason: GranularAccessFailReasonNone}
}

Cognitive complexity: 19, Cyclomatic complexity: 7

func (g *graphqlRequestProcessorV1) ProcessRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) (error, int) {
	if r == nil {
		g.logger.Error("request is nil")
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	gqlRequest := g.ctxRetrieveRequest(r)
	normalizationResult, err := gqlRequest.Normalize(g.schema)
	if err != nil {
		g.logger.Error("error while normalizing GraphQL request", abstractlogger.Error(err))
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	if normalizationResult.Errors != nil && normalizationResult.Errors.Count() > 0 {
		return writeGraphQLError(g.logger, w, normalizationResult.Errors)
	}

	validationResult, err := gqlRequest.ValidateForSchema(g.schema)
	if err != nil {
		g.logger.Error("error while validating GraphQL request", abstractlogger.Error(err))
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	if validationResult.Errors != nil && validationResult.Errors.Count() > 0 {
		return writeGraphQLError(g.logger, w, validationResult.Errors)
	}

	inputValidationResult, err := gqlRequest.ValidateInput(g.schema)
	if err != nil {
		g.logger.Error("error while validating variables for request", abstractlogger.Error(err))
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}
	if inputValidationResult.Errors != nil && inputValidationResult.Errors.Count() > 0 {
		return writeGraphQLError(g.logger, w, inputValidationResult.Errors)
	}
	return nil, http.StatusOK
}

Cognitive complexity: 14, Cyclomatic complexity: 11

func (g *graphqlRequestProcessorWithOTelV1) ProcessRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) (error, int) {
	if r == nil {
		g.logger.Error("request is nil")
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	g.otelExecutor.SetContext(ctx)
	gqlRequest := g.ctxRetrieveRequest(r)

	// normalization
	err := g.otelExecutor.Normalize(gqlRequest)
	if err != nil {
		g.logger.Error("error while normalizing GraphqlRequest", abstractlogger.Error(err))
		var reqErr graphql.RequestErrors
		if errors.As(err, &reqErr) {
			return writeGraphQLError(g.logger, w, reqErr)
		}
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	// validation
	err = g.otelExecutor.ValidateForSchema(gqlRequest)
	if err != nil {
		g.logger.Error("error while validating GraphQL request", abstractlogger.Error(err))
		var reqErr graphql.RequestErrors
		if errors.As(err, &reqErr) {
			return writeGraphQLError(g.logger, w, reqErr)
		}
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}

	// input validation
	err = g.otelExecutor.InputValidation(gqlRequest)
	if err != nil {
		g.logger.Error("error while validating variables for request", abstractlogger.Error(err))
		var reqErr graphql.RequestErrors
		if errors.As(err, &reqErr) {
			return writeGraphQLError(g.logger, w, reqErr)
		}
		return ProxyingRequestFailedErr, http.StatusInternalServerError
	}
	return nil, http.StatusOK
}

Cognitive complexity: 14, Cyclomatic complexity: 8

func (r *reverseProxyPreHandlerV1) PreHandle(params ReverseProxyParams) (reverseProxyType ReverseProxyType, err error) {
	r.httpClient.Transport = NewGraphQLEngineTransport(
		DetermineGraphQLEngineTransportType(r.apiDefinition),
		params.RoundTripper,
		r.newReusableBodyReadCloser,
		params.HeadersConfig,
	)

	switch {
	case params.IsCORSPreflight:
		return ReverseProxyTypePreFlight, nil
	case params.IsWebSocketUpgrade:
		if params.NeedsEngine {
			return ReverseProxyTypeWebsocketUpgrade, nil
		}
	default:
		gqlRequest := r.ctxRetrieveGraphQLRequest(params.OutRequest)
		if gqlRequest == nil {
			err = errors.New("graphql request is nil")
			return
		}
		gqlRequest.SetHeader(params.OutRequest.Header)

		var isIntrospection bool
		isIntrospection, err = gqlRequest.IsIntrospectionQuery()
		if err != nil {
			return
		}

		if isIntrospection {
			return ReverseProxyTypeIntrospection, nil
		}
		if params.NeedsEngine {
			return ReverseProxyTypeGraphEngine, nil
		}
	}

	return ReverseProxyTypeNone, nil
}

Cognitive complexity: 14, Cyclomatic complexity: 9

func (r *reverseProxyPreHandlerV2) PreHandle(params ReverseProxyParams) (reverseProxyType ReverseProxyType, err error) {
	r.httpClient.Transport = NewGraphQLEngineTransport(
		DetermineGraphQLEngineTransportType(r.apiDefinition),
		params.RoundTripper,
		r.newReusableBodyReadCloser,
		params.HeadersConfig,
	)

	switch {
	case params.IsCORSPreflight:
		return ReverseProxyTypePreFlight, nil
	case params.IsWebSocketUpgrade:
		if params.NeedsEngine {
			return ReverseProxyTypeWebsocketUpgrade, nil
		}
	default:
		gqlRequest := r.ctxRetrieveGraphQLRequest(params.OutRequest)
		if gqlRequest == nil {
			err = errors.New("graphql request is nil")
			return
		}
		gqlRequest.SetHeader(params.OutRequest.Header)

		var isIntrospection bool
		isIntrospection, err = gqlRequest.IsIntrospectionQuery()
		if err != nil {
			return
		}

		if isIntrospection {
			return ReverseProxyTypeIntrospection, nil
		}
		if params.NeedsEngine {
			return ReverseProxyTypeGraphEngine, nil
		}
	}

	return ReverseProxyTypeNone, nil
}

Cognitive complexity: 14, Cyclomatic complexity: 9

MockComplexityChecker is a mock of ComplexityChecker interface.

type MockComplexityChecker struct {
	ctrl		*gomock.Controller
	recorder	*MockComplexityCheckerMockRecorder
}

MockComplexityCheckerMockRecorder is the mock recorder for MockComplexityChecker.

type MockComplexityCheckerMockRecorder struct {
	mock *MockComplexityChecker
}

MockEngine is a mock of Engine interface.

type MockEngine struct {
	ctrl		*gomock.Controller
	recorder	*MockEngineMockRecorder
}

MockEngineMockRecorder is the mock recorder for MockEngine.

type MockEngineMockRecorder struct {
	mock *MockEngine
}

MockGranularAccessChecker is a mock of GranularAccessChecker interface.

type MockGranularAccessChecker struct {
	ctrl		*gomock.Controller
	recorder	*MockGranularAccessCheckerMockRecorder
}

MockGranularAccessCheckerMockRecorder is the mock recorder for MockGranularAccessChecker.

type MockGranularAccessCheckerMockRecorder struct {
	mock *MockGranularAccessChecker
}

MockGraphQLRequestProcessor is a mock of GraphQLRequestProcessor interface.

type MockGraphQLRequestProcessor struct {
	ctrl		*gomock.Controller
	recorder	*MockGraphQLRequestProcessorMockRecorder
}

MockGraphQLRequestProcessorMockRecorder is the mock recorder for MockGraphQLRequestProcessor.

type MockGraphQLRequestProcessorMockRecorder struct {
	mock *MockGraphQLRequestProcessor
}

MockReverseProxyPreHandler is a mock of ReverseProxyPreHandler interface.

type MockReverseProxyPreHandler struct {
	ctrl		*gomock.Controller
	recorder	*MockReverseProxyPreHandlerMockRecorder
}

MockReverseProxyPreHandlerMockRecorder is the mock recorder for MockReverseProxyPreHandler.

type MockReverseProxyPreHandlerMockRecorder struct {
	mock *MockReverseProxyPreHandler
}

This type doesn't have documentation.

type engineV1Mocks struct {
	controller		*gomock.Controller
	requestProcessor	*MockGraphQLRequestProcessor
	complexityChecker	*MockComplexityChecker
	granularAccessChecker	*MockGranularAccessChecker
	reverseProxyPreHandler	*MockReverseProxyPreHandler
}

This type doesn't have documentation.

type engineV2Mocks struct {
	controller		*gomock.Controller
	requestProcessor	*MockGraphQLRequestProcessor
	complexityChecker	*MockComplexityChecker
	granularAccessChecker	*MockGranularAccessChecker
	reverseProxyPreHandler	*MockReverseProxyPreHandler
}

This type doesn't have documentation.

type nopRoundTripper struct{}

This type doesn't have documentation.

type testComplexityCheckerV1Option func(*testComplexityCheckerV1Options)

This type doesn't have documentation.

type testComplexityCheckerV1Options struct {
	schema string
}

This type doesn't have documentation.

type testEngineV1Option func(*testEngineV1Options)

This type doesn't have documentation.

type testEngineV1Options struct {
	targetURL	string
	executionMode	apidef.GraphQLExecutionMode
}

This type doesn't have documentation.

type testEngineV2Option func(*testEngineV2Options)

This type doesn't have documentation.

type testEngineV2Options struct {
	targetURL	string
	apiDefinition	*apidef.APIDefinition
	otelConfig	EngineV2OTelConfig
}