@apollo/gateway 2.4.0-alpha.1 → 2.4.1

package/src/dataRewrites.ts

@@ -0,0 +1,130 @@
+import { FetchDataRewrite } from "@apollo/query-planner";
+import { assert } from "console";
+import { GraphQLSchema, isAbstractType, isInterfaceType, isObjectType } from "graphql";
+
+const FRAGMENT_PREFIX = '... on ';
+
+export function applyRewrites(schema: GraphQLSchema, rewrites: FetchDataRewrite[] | undefined,  value: Record<string, any>) {
+  if (!rewrites) {
+    return;
+  }
+
+  for (const rewrite of rewrites) {
+    applyRewrite(schema, rewrite, value);
+  }
+}
+
+function applyRewrite(schema: GraphQLSchema, rewrite: FetchDataRewrite,  value: Record<string, any>) {
+  const splitted = splitPathLastElement(rewrite.path);
+  if (!splitted) {
+    return;
+  }
+
+  const [parent, last] = splitted;
+  const { kind, value: fieldName } = parsePathElement(last);
+  // So far, all rewrites finish by a field name. If this ever changes, this assertion will catch it early and we can update.
+  assert(kind === 'fieldName', () => `Unexpected fragment as last element of ${rewrite.path}`);
+  applyAtPath(schema, parent, value, rewriteAtPathFunction(rewrite, fieldName));
+}
+
+function rewriteAtPathFunction(rewrite: FetchDataRewrite, fieldAtPath: string): (obj: Record<string, any>) => void {
+  switch (rewrite.kind) {
+    case 'ValueSetter':
+      return (obj) => {
+        obj[fieldAtPath] = rewrite.setValueTo;
+      };
+    case 'KeyRenamer':
+      return (obj) => {
+        obj[rewrite.renameKeyTo] = obj[fieldAtPath];
+        obj[fieldAtPath] = undefined;
+      };
+  }
+}
+
+
+/**
+ * Given a path, separates the last element of path and the rest of it and return them as a pair.
+ * This will return `undefined` if the path is empty.
+ */
+function splitPathLastElement(path: string[]): [string[], string] | undefined {
+  if (path.length === 0) {
+    return undefined;
+  }
+
+  const lastIdx = path.length - 1;
+  return [path.slice(0, lastIdx), path[lastIdx]];
+}
+
+function applyAtPath(schema: GraphQLSchema, path: string[], value: any, fct: (objAtPath: Record<string, any>) => void) {
+  if (Array.isArray(value)) {
+    for (const arrayValue of value) {
+      applyAtPath(schema, path, arrayValue, fct);
+    }
+    return;
+  }
+
+  if (typeof value !== 'object') {
+    return;
+  }
+
+  if (path.length === 0) {
+    fct(value);
+    return;
+  }
+
+  const [first, ...rest] = path;
+  const { kind, value: eltValue } = parsePathElement(first);
+  switch (kind) {
+    case 'fieldName':
+      applyAtPath(schema, rest, value[eltValue], fct);
+      break;
+    case 'typeName':
+      // When we apply rewrites, we don't always have the __typename of all object we would need to, but the code expects that
+      // this does not stop the rewrite to applying, hence the modified to `true` when the object typename is not found.
+      if (isObjectOfType(schema, value, eltValue, true)) {
+        applyAtPath(schema, rest, value, fct);
+      }
+      break;
+  }
+}
+
+function parsePathElement(elt: string): { kind: 'fieldName' | 'typeName', value: string } {
+  if (elt.startsWith(FRAGMENT_PREFIX)) {
+    return { kind: 'typeName', value: elt.slice(FRAGMENT_PREFIX.length) };
+  } else {
+    return { kind: 'fieldName', value: elt };
+  }
+}
+
+
+export function isObjectOfType(
+  schema: GraphQLSchema,
+  obj: Record<string, any>,
+  typeCondition: string,
+  defaultOnUnknownObjectType: boolean = false,
+): boolean {
+  const objTypename = obj['__typename'];
+  if (!objTypename) {
+    return defaultOnUnknownObjectType;
+  }
+
+  if (typeCondition === objTypename) {
+    return true;
+  }
+
+  const type = schema.getType(objTypename);
+  if (!type) {
+    return false;
+  }
+
+  const conditionalType = schema.getType(typeCondition);
+  if (!conditionalType) {
+    return false;
+  }
+
+  if (isAbstractType(conditionalType)) {
+    return (isObjectType(type) || isInterfaceType(type)) && schema.isSubType(conditionalType, type);
+  }
+
+  return false;
+}

package/src/executeQueryPlan.ts

@@ -5,15 +5,15 @@ import {
   TypeNameMetaFieldDef,
   GraphQLFieldResolver,
   GraphQLFormattedError,
-  isAbstractType,
   GraphQLSchema,
-  isObjectType,
-  isInterfaceType,
   GraphQLErrorOptions,
   DocumentNode,
   executeSync,
   OperationTypeNode,
   FieldNode,
+  visit,
+  ASTNode,
+  VariableDefinitionNode,
 } from 'graphql';
 import { Trace, google } from '@apollo/usage-reporting-protobuf';
 import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
@@ -26,17 +26,16 @@ import {
   QueryPlanSelectionNode,
   QueryPlanFieldNode,
   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, Operation, operationFromDocument, Schema } from '@apollo/federation-internals';
+import { assert, defaultRootName, errorCodeDef, ERRORS, Operation, operationFromDocument, Schema } from '@apollo/federation-internals';
 import { GatewayGraphQLRequestContext, GatewayExecutionResult } from '@apollo/server-gateway-interface';
 import { computeResponse } from './resultShaping';
+import { applyRewrites, isObjectOfType } from './dataRewrites';
 
 export type ServiceMap = {
   [serviceName: string]: GraphQLDataSource;
@@ -72,13 +71,33 @@ interface ExecutionContext {
   errors: GraphQLError[];
 }
 
-function makeIntrospectionQueryDocument(introspectionSelection: FieldNode): DocumentNode {
+function collectUsedVariables(node: ASTNode): Set<string> {
+  const usedVariables = new Set<string>();
+  visit(node, {
+    Variable: ({ name }) => {
+      usedVariables.add(name.value);
+    }
+  });
+  return usedVariables;
+}
+
+function makeIntrospectionQueryDocument(
+  introspectionSelection: FieldNode,
+  variableDefinitions?: readonly VariableDefinitionNode[],
+): DocumentNode {
+  const usedVariables = collectUsedVariables(introspectionSelection);
+  const usedVariableDefinitions = variableDefinitions?.filter((def) => usedVariables.has(def.variable.name.value));
+  assert(
+    usedVariables.size === (usedVariableDefinitions?.length ?? 0), 
+    () => `Should have found all used variables ${[...usedVariables]} in definitions ${JSON.stringify(variableDefinitions)}`,
+  );
   return {
     kind: Kind.DOCUMENT,
     definitions: [
       {
         kind: Kind.OPERATION_DEFINITION,
         operation: OperationTypeNode.QUERY,
+        variableDefinitions: usedVariableDefinitions,
         selectionSet: {
           kind: Kind.SELECTION_SET,
           selections: [ introspectionSelection ],
@@ -91,14 +110,21 @@ function makeIntrospectionQueryDocument(introspectionSelection: FieldNode): Docu
 function executeIntrospection(
   schema: GraphQLSchema,
   introspectionSelection: FieldNode,
+  variableDefinitions: ReadonlyArray<VariableDefinitionNode> | undefined,
+  variableValues: Record<string, any> | undefined,
 ): any {
-  const { data } = executeSync({
+  const { data, errors } = executeSync({
     schema,
-    document: makeIntrospectionQueryDocument(introspectionSelection),
+    document: makeIntrospectionQueryDocument(introspectionSelection, variableDefinitions),
     rootValue: {},
+    variableValues,
   });
+  assert(
+    !errors || errors.length === 0,
+    () => `Introspection query for ${JSON.stringify(introspectionSelection)} should not have failed but got ${JSON.stringify(errors)}`
+  );
   assert(data, () => `Introspection query for ${JSON.stringify(introspectionSelection)} should not have failed`);
-  return data[introspectionSelection.name.value];
+  return data[introspectionSelection.alias?.value ?? introspectionSelection.name.value];
 }
 
 export async function executeQueryPlan(
@@ -185,11 +211,17 @@ export async function executeQueryPlan(
         let data;
         try {
           let postProcessingErrors: GraphQLError[];
+          const variables = requestContext.request.variables;
           ({ data, errors: postProcessingErrors } = computeResponse({
             operation,
-            variables: requestContext.request.variables,
+            variables,
             input: unfilteredData,
-            introspectionHandling: (f) => executeIntrospection(operationContext.schema, f.expandFragments().toSelectionNode()),
+            introspectionHandling: (f) => executeIntrospection(
+              operationContext.schema,
+              f.expandAllFragments().toSelectionNode(),
+              operationContext.operation.variableDefinitions,
+              variables,
+            ),
           }));
 
           // If we have errors during the post-processing, we ignore them if any other errors have been thrown during
@@ -416,9 +448,12 @@ async function executeFetch(
 
       if (!fetch.requires) {
         const dataReceivedFromService = await sendOperation(variables);
+        if (dataReceivedFromService) {
+          applyRewrites(context.supergraphSchema, fetch.outputRewrites, dataReceivedFromService);
+        }
 
         for (const entity of entities) {
-          deepMerge(entity, withFetchRewrites(dataReceivedFromService, fetch.outputRewrites));
+          deepMerge(entity, dataReceivedFromService);
         }
       } else {
         const requires = fetch.requires;
@@ -434,9 +469,9 @@ async function executeFetch(
             context.supergraphSchema,
             entity,
             requires,
-            fetch.inputRewrites,
           );
           if (representation && representation[TypeNameMetaFieldDef.name]) {
+            applyRewrites(context.supergraphSchema, fetch.inputRewrites, representation);
             representations.push(representation);
             representationToEntity.push(index);
           }
@@ -473,8 +508,11 @@ async function executeFetch(
           );
         }
 
+
         for (let i = 0; i < entities.length; i++) {
-          deepMerge(entities[representationToEntity[i]], withFetchRewrites(receivedEntities[i], filterEntityRewrites(representations[i], fetch.outputRewrites)));
+          const receivedEntity = receivedEntities[i];
+          applyRewrites(context.supergraphSchema, fetch.outputRewrites, receivedEntity);
+          deepMerge(entities[representationToEntity[i]], receivedEntity);
         }
       }
     }
@@ -707,84 +745,6 @@ export function generateHydratedPaths(
   }
 }
 
-function applyOrMapRecursive(value: any | any[], fct: (v: any) => any | undefined): any | any[] | undefined {
-  if (Array.isArray(value)) {
-    const res = value.map((elt) => applyOrMapRecursive(elt, fct)).filter(isDefined);
-    return res.length === 0 ? undefined : res;
-  }
-  return fct(value);
-}
-
-function withFetchRewrites(fetchResult: ResultMap | null | void, rewrites: FetchDataOutputRewrite[] | undefined): ResultMap | null | void {
-  if (!rewrites || !fetchResult) {
-    return fetchResult;
-  }
-
-  for (const rewrite of rewrites) {
-    let obj: any = fetchResult;
-    let i = 0;
-    while (obj && i < rewrite.path.length - 1) {
-      const p = rewrite.path[i++];
-      if (p.startsWith('... on ')) {
-        const typename = p.slice('... on '.length);
-        // Filter only objects that match the condition.
-        obj = applyOrMapRecursive(obj, (elt) => elt[TypeNameMetaFieldDef.name] === typename ? elt : undefined);
-      } else {
-        obj = applyOrMapRecursive(obj, (elt) => elt[p]);
-      }
-    }
-    if (obj) {
-      applyOrMapRecursive(obj, (elt) => {
-        if (typeof elt === 'object') {
-          // We need to move the value at path[i] to `renameKeyTo`.
-          const removedKey = rewrite.path[i];
-          elt[rewrite.renameKeyTo] = elt[removedKey];
-          elt[removedKey] = undefined;
-        }
-      });
-    }
-  }
-  return fetchResult;
-}
-
-function filterEntityRewrites(entity: Record<string, any>, rewrites: FetchDataOutputRewrite[] | undefined): FetchDataOutputRewrite[] | undefined {
-  if (!rewrites) {
-    return undefined;
-  }
-
-  const typename = entity[TypeNameMetaFieldDef.name] as string;
-  const typenameAsFragment = `... on ${typename}`;
-  return rewrites.map((r) => r.path[0] === typenameAsFragment ? { ...r, path: r.path.slice(1) } : undefined).filter(isDefined)
-}
-
-function updateRewrites(rewrites: FetchDataInputRewrite[] | undefined, pathElement: string): {
-  updated: FetchDataInputRewrite[],
-  completeRewrite?: any,
-} | undefined {
-  if (!rewrites) {
-    return undefined;
-  }
-
-  let completeRewrite: any = undefined;
-  const updated = rewrites
-    .map((r) => {
-      let u: FetchDataInputRewrite | undefined = undefined;
-      if (r.path[0] === pathElement) {
-        const updatedPath = r.path.slice(1);
-        if (updatedPath.length === 0) {
-          completeRewrite = r.setValueTo;
-        } else {
-          u = { ...r, path: updatedPath };
-        }
-      }
-      return u;
-    })
-    .filter(isDefined);
-  return updated.length === 0 && completeRewrite === undefined
-    ? undefined
-    : { updated, completeRewrite };
-}
-
 /**
  *
  * @param source Result of GraphQL execution.
@@ -794,7 +754,6 @@ function executeSelectionSet(
   schema: GraphQLSchema,
   source: Record<string, any> | null,
   selections: QueryPlanSelectionNode[],
-  activeRewrites?: FetchDataInputRewrite[],
 ): Record<string, any> | null {
 
   // If the underlying service has returned null for the parent (source)
@@ -825,16 +784,10 @@ function executeSelectionSet(
           return null;
         }
 
-        const updatedRewrites = updateRewrites(activeRewrites, responseName);
-        if (updatedRewrites?.completeRewrite !== undefined) {
-          result[responseName] = updatedRewrites.completeRewrite;
-          continue;
-        }
-
         if (Array.isArray(source[responseName])) {
           result[responseName] = source[responseName].map((value: any) =>
             selections
-              ? executeSelectionSet(schema, value, selections, updatedRewrites?.updated)
+              ? executeSelectionSet(schema, value, selections)
               : value,
           );
         } else if (selections) {
@@ -842,23 +795,18 @@ function executeSelectionSet(
             schema,
             source[responseName],
             selections,
-            updatedRewrites?.updated,
           );
         } else {
           result[responseName] = source[responseName];
         }
         break;
       case Kind.INLINE_FRAGMENT:
-        if (!selection.typeCondition) continue;
+        if (!selection.typeCondition || !source) continue;
 
-        const typename = source && source['__typename'];
-        if (!typename) continue;
-
-        if (doesTypeConditionMatch(schema, selection.typeCondition, typename)) {
-          const updatedRewrites = activeRewrites ? updateRewrites(activeRewrites, `... on ${selection.typeCondition}`) : undefined;
+        if (isObjectOfType(schema, source, selection.typeCondition)) {
           deepMerge(
             result,
-            executeSelectionSet(schema, source, selection.selections, updatedRewrites?.updated),
+            executeSelectionSet(schema, source, selection.selections),
           );
         }
         break;
@@ -868,32 +816,6 @@ function executeSelectionSet(
   return result;
 }
 
-function doesTypeConditionMatch(
-  schema: GraphQLSchema,
-  typeCondition: string,
-  typename: string,
-): boolean {
-  if (typeCondition === typename) {
-    return true;
-  }
-
-  const type = schema.getType(typename);
-  if (!type) {
-    return false;
-  }
-
-  const conditionalType = schema.getType(typeCondition);
-  if (!conditionalType) {
-    return false;
-  }
-
-  if (isAbstractType(conditionalType)) {
-    return (isObjectType(type) || isInterfaceType(type)) && schema.isSubType(conditionalType, type);
-  }
-
-  return false;
-}
-
 function moveIntoCursor(cursor: ResultCursor, pathInCursor: ResponsePath): ResultCursor | undefined {
   const data = flattenResultsAtPath(cursor.data, pathInCursor);
   return data ? {

package/src/resultShaping.ts

@@ -161,12 +161,12 @@ function applySelectionSet({
   parentType: CompositeType,
 }): ApplyResult {
   for (const selection of selectionSet.selections()) {
-    if (shouldSkip(selection.element(), parameters)) {
+    if (shouldSkip(selection.element, parameters)) {
       continue;
     }
 
     if (selection.kind === 'FieldSelection') {
-      const field = selection.element();
+      const field = selection.element;
       const fieldType = field.definition.type!;
       const responseName = field.responseName();
       const outputValue = output[responseName];
@@ -241,7 +241,7 @@ function applySelectionSet({
         return ApplyResult.NULL_BUBBLE_UP;
       }
     } else {
-      const fragment = selection.element();
+      const fragment = selection.element;
       const typename = input[typenameFieldName];
       assert(!typename || typeof typename === 'string', () => `Got unexpected value for __typename: ${typename}`);
       if (typeConditionApplies(parameters.schema, fragment.typeCondition, typename, parentType)) {