feat: compute static costs (#1359)

First release of essential features for the static cost analysis on
fields, lists.

All parameters of "cost" and "listSize" directives are supported, except
for "sizedFields":

* "cost" and "listSize" directives on fields of various types
* variables passed as values to argumets
* interfaces and unions, lists

## Notes

Planning visitor collects information for the costCalculator via
EnterField and LeaveField hooks.
Calculator builds a tree of nodes, each node corresponding to the
requested field.
After the planning is done, a callee could get a ref to the calculator
and request cost calculation.
Cost calculation walks the previously built tree and using variables
provided with operation,
estimates the static cost.

It builds on top of IBM spec for @cost and @listsize directive with a
few changes:
* It uses Int! for weights instead of stringified floats.
* When weight is specified for the type and a field returns the list of
that type,
this weight (along with children's costs) is multiplied too.

A few things on the TBD list:
* Support of SizedFields of @listsize
* Weights on fields of InputObjects with recursion
* Weights on arguments of directives

Fixes ENG-8732

Author: ysmolski

execution/engine/execution_engine.go

@@ -38,12 +38,6 @@ func newInternalExecutionContext() *internalExecutionContext {
 	}
 }
 
-func (e *internalExecutionContext) prepare(ctx context.Context, variables []byte, request resolve.Request) {
-	e.setContext(ctx)
-	e.setVariables(variables)
-	e.setRequest(request)
-}
-
 func (e *internalExecutionContext) setRequest(request resolve.Request) {
 	e.resolveContext.Request = request
 }
@@ -194,7 +188,10 @@ func (e *ExecutionEngine) Execute(ctx context.Context, operation *graphql.Reques
 	}
 
 	execContext := newInternalExecutionContext()
-	execContext.prepare(ctx, operation.Variables, operation.InternalRequest())
+	execContext.setContext(ctx)
+	execContext.setVariables(operation.Variables)
+	execContext.setRequest(operation.InternalRequest())
+
 	for i := range options {
 		options[i](execContext)
 	}
@@ -210,10 +207,13 @@ func (e *ExecutionEngine) Execute(ctx context.Context, operation *graphql.Reques
 	}
 
 	var report operationreport.Report
-	cachedPlan := e.getCachedPlan(execContext, operation.Document(), e.config.schema.Document(), operation.OperationName, &report)
+	cachedPlan, costCalculator := e.getCachedPlan(execContext, operation.Document(), e.config.schema.Document(), operation.OperationName, &report)
 	if report.HasErrors() {
 		return report
 	}
+	operation.ComputeStaticCost(costCalculator, e.config.plannerConfig, execContext.resolveContext.Variables)
+	// Debugging of cost trees. Do not remove.
+	// fmt.Println(costCalculator.DebugPrint(e.config.plannerConfig, execContext.resolveContext.Variables))
 
 	if execContext.resolveContext.TracingOptions.Enable && !execContext.resolveContext.TracingOptions.ExcludePlannerStats {
 		planningTime := resolve.GetDurationNanoSinceTraceStart(execContext.resolveContext.Context()) - tracePlanStart
@@ -236,33 +236,33 @@ func (e *ExecutionEngine) Execute(ctx context.Context, operation *graphql.Reques
 	}
 }
 
-func (e *ExecutionEngine) getCachedPlan(ctx *internalExecutionContext, operation, definition *ast.Document, operationName string, report *operationreport.Report) plan.Plan {
+func (e *ExecutionEngine) getCachedPlan(ctx *internalExecutionContext, operation, definition *ast.Document, operationName string, report *operationreport.Report) (plan.Plan, *plan.CostCalculator) {
 	hash := pool.Hash64.Get()
 	hash.Reset()
 	defer pool.Hash64.Put(hash)
 	err := astprinter.Print(operation, hash)
 	if err != nil {
 		report.AddInternalError(err)
-		return nil
+		return nil, nil
 	}
 
 	cacheKey := hash.Sum64()
 
 	if cached, ok := e.executionPlanCache.Get(cacheKey); ok {
 		if p, ok := cached.(plan.Plan); ok {
-			return p
+			return p, p.GetStaticCostCalculator()
 		}
 	}
 
 	planner, _ := plan.NewPlanner(e.config.plannerConfig)
 	planResult := planner.Plan(operation, definition, operationName, report)
 	if report.HasErrors() {
-		return nil
+		return nil, nil
 	}
 
 	ctx.postProcessor.Process(planResult)
 	e.executionPlanCache.Add(cacheKey, planResult)
-	return planResult
+	return planResult, planResult.GetStaticCostCalculator()
 }
 
 func (e *ExecutionEngine) GetWebsocketBeforeStartHook() WebsocketBeforeStartHook {