@apollo/gateway 2.3.3 → 2.4.0-alpha.0

package/src/executeQueryPlan.ts

@@ -28,12 +28,13 @@ import {
   getResponseName,
   FetchDataInputRewrite,
   FetchDataOutputRewrite,
+  evaluateCondition,
 } from '@apollo/query-planner';
 import { deepMerge } from './utilities/deepMerge';
 import { isNotNullOrUndefined } from './utilities/array';
 import { SpanStatusCode } from "@opentelemetry/api";
 import { OpenTelemetrySpanNames, tracer } from "./utilities/opentelemetry";
-import { assert, defaultRootName, errorCodeDef, ERRORS, isDefined, operationFromDocument, Schema } from '@apollo/federation-internals';
+import { assert, defaultRootName, errorCodeDef, ERRORS, isDefined, Operation, operationFromDocument, Schema } from '@apollo/federation-internals';
 import { GatewayGraphQLRequestContext, GatewayExecutionResult } from '@apollo/server-gateway-interface';
 import { computeResponse } from './resultShaping';
 
@@ -64,6 +65,7 @@ type ResultCursor = {
 interface ExecutionContext {
   queryPlan: QueryPlan;
   operationContext: OperationContext;
+  operation: Operation,
   serviceMap: ServiceMap;
   requestContext: GatewayGraphQLRequestContext;
   supergraphSchema: GraphQLSchema;
@@ -114,9 +116,39 @@ export async function executeQueryPlan(
     try {
       const errors: GraphQLError[] = [];
 
+      let operation: Operation;
+      try {
+        operation = operationFromDocument(
+          apiSchema,
+          {
+            kind: Kind.DOCUMENT,
+            definitions: [
+              operationContext.operation,
+              ...Object.values(operationContext.fragments),
+            ],
+          },
+          {
+            validate: false,
+          }
+        );
+      } catch (err) {
+        // We shouldn't really have errors as the operation should already have been validated, but if something still
+        // happens, we should report it properly (plus, some of our tests call this method directly and blow up if we don't
+        // handle this correctly).
+        // TODO: we are doing some duplicate work by building both `OperationContext` and this `Operation`. Ideally we
+        // would remove `OperationContext`, pass the `Operation` directly to this method, and only use that. This would change
+        // the signature of this method though and it is exported so ... maybe later ?
+        //
+        if (err instanceof GraphQLError) {
+          return { errors: [err] };
+        }
+        throw err;
+      }
+
       const context: ExecutionContext = {
         queryPlan,
         operationContext,
+        operation,
         serviceMap,
         requestContext,
         supergraphSchema,
@@ -129,6 +161,10 @@ export async function executeQueryPlan(
           requestContext.metrics && requestContext.metrics.captureTraces
       );
 
+      if (queryPlan.node?.kind === 'Subscription') {
+        throw new Error('Execution of subscriptions not supported by gateway');
+      }
+
       if (queryPlan.node) {
         const traceNode = await executeNode(
           context,
@@ -148,20 +184,6 @@ export async function executeQueryPlan(
       const result = await tracer.startActiveSpan(OpenTelemetrySpanNames.POST_PROCESSING, async (span) => {
         let data;
         try {
-          const operation = operationFromDocument(
-            apiSchema,
-            {
-              kind: Kind.DOCUMENT,
-              definitions: [
-                operationContext.operation,
-                ...Object.values(operationContext.fragments),
-              ],
-            },
-            {
-              validate: false,
-            }
-          );
-
           let postProcessingErrors: GraphQLError[];
           ({ data, errors: postProcessingErrors } = computeResponse({
             operation,
@@ -326,12 +348,30 @@ async function executeNode(
       }
       return new Trace.QueryPlanNode({ fetch: traceNode });
     }
+    case 'Condition': {
+      const condition = evaluateCondition(node, context.operation.variableDefinitions, context.requestContext.request.variables); 
+      const pickedBranch = condition ? node.ifClause : node.elseClause;
+      let branchTraceNode: Trace.QueryPlanNode | undefined = undefined;
+      if (pickedBranch) {
+        branchTraceNode = await executeNode(
+          context,
+          pickedBranch,
+          currentCursor,
+          captureTraces
+        );
+      }
+
+      return new Trace.QueryPlanNode({
+        condition: new Trace.QueryPlanNode.ConditionNode({
+          condition: node.condition,
+          ifClause: condition ? branchTraceNode : undefined,
+          elseClause: condition ? undefined : branchTraceNode,
+        }),
+      });
+    }
     case 'Defer': {
       assert(false, `@defer support is not available in the gateway`);
     }
-    case 'Condition': {
-      assert(false, `Condition nodes are not available in the gateway`);
-    }
   }
 }
 

package/src/index.ts

@@ -1,7 +1,8 @@
 import { deprecate } from 'util';
 import { createHash } from '@apollo/utils.createhash';
 import type { Logger } from '@apollo/utils.logger';
-import LRUCache from 'lru-cache';
+import { QueryPlanCache } from '@apollo/query-planner'
+import { InMemoryLRUCache } from '@apollo/utils.keyvaluecache';
 import {
   GraphQLSchema,
   VariableDefinitionNode
@@ -123,7 +124,7 @@ export class ApolloGateway implements GatewayInterface {
   private serviceMap: DataSourceMap = Object.create(null);
   private config: GatewayConfig;
   private logger: Logger;
-  private queryPlanStore: LRUCache<string, QueryPlan>;
+  private queryPlanStore: QueryPlanCache;
   private apolloConfig?: ApolloConfigFromAS3;
   private onSchemaChangeListeners = new Set<(schema: GraphQLSchema) => void>();
   private onSchemaLoadOrUpdateListeners = new Set<
@@ -189,6 +190,9 @@ export class ApolloGateway implements GatewayInterface {
   }
 
   private initQueryPlanStore(approximateQueryPlanStoreMiB?: number) {
+    if(this.config.queryPlannerConfig?.cache){
+      return this.config.queryPlannerConfig?.cache
+    }
     // Create ~about~ a 30MiB InMemoryLRUCache (or 50MiB if the full operation ASTs are
     // enabled in query plans as this requires plans to use more memory). This is
     // less than precise since the technique to calculate the size of a DocumentNode is
@@ -196,7 +200,7 @@ export class ApolloGateway implements GatewayInterface {
     // for unicode characters, etc.), but it should do a reasonable job at
     // providing a caching document store for most operations.
     const defaultSize = this.config.queryPlannerConfig?.exposeDocumentNodeInFetchNode ? 50 : 30;
-    return new LRUCache<string, QueryPlan>({
+    return new InMemoryLRUCache<QueryPlan>({
       maxSize: Math.pow(2, 20) * (approximateQueryPlanStoreMiB || defaultSize),
       sizeCalculation: approximateObjectSize,
     });
@@ -770,7 +774,7 @@ export class ApolloGateway implements GatewayInterface {
             span.setStatus({ code: SpanStatusCode.ERROR });
             return { errors: validationErrors };
           }
-          let queryPlan = this.queryPlanStore.get(queryPlanStoreKey);
+          let queryPlan = await this.queryPlanStore.get(queryPlanStoreKey);
 
           if (!queryPlan) {
             queryPlan = tracer.startActiveSpan(
@@ -794,7 +798,7 @@ export class ApolloGateway implements GatewayInterface {
             );
 
             try {
-              this.queryPlanStore.set(queryPlanStoreKey, queryPlan);
+              await this.queryPlanStore.set(queryPlanStoreKey, queryPlan);
             } catch (err) {
               this.logger.warn(
                 'Could not store queryPlan' + ((err && err.message) || err),
@@ -969,6 +973,7 @@ export class ApolloGateway implements GatewayInterface {
       state: this.state,
       compositionId: this.compositionId,
       supergraphSdl: this.supergraphSdl,
+      queryPlanner: this.queryPlanner,
     };
   }
 }

package/src/resultShaping.ts

@@ -26,7 +26,7 @@ import { GraphQLError } from "graphql";
  * Performs post-query plan execution processing of internally fetched data to produce the final query response.
  *
  * The reason for this post-processing are the following ones:
- * 1. executing the query plan will usually query more fields that are strictly requested. That is because key, required 
+ * 1. executing the query plan will usually query more fields that are strictly requested. That is because key, required
  *   and __typename fields must often be requested to subgraphs even when they are not part of the query. So this method
  *   will filter out anything that has been fetched but isn't part of the user query.
  * 2. query plan execution does not guarantee that in the data fetched, the fields will respect the ordering that the
@@ -60,7 +60,7 @@ export function computeResponse({
   variables?: Record<string, any>,
   input: Record<string, any> | null | undefined,
   introspectionHandling: (introspectionSelection: FieldSelection) => any,
-}): { 
+}): {
   data: Record<string, any> | null | undefined,
   errors: GraphQLError[],
 } {
@@ -70,7 +70,11 @@ export function computeResponse({
 
   const parameters = {
     schema: operation.schema,
-    variables: variables ?? {},
+    variables: {
+      ...operation.collectDefaultedVariableValues(),
+      // overwrite any defaulted variables if they are provided
+      ...variables,
+    },
     errors: [],
     introspectionHandling,
   };
@@ -119,7 +123,7 @@ function ifValue(directive: Directive<any, { if: boolean | Variable }>, variable
   }
 }
 
-enum ApplyResult { OK, NULL_BUBBLE_UP };
+enum ApplyResult { OK, NULL_BUBBLE_UP }
 
 function typeConditionApplies(
   schema: Schema,