@apollo/gateway 0.300.0-alpha.2 → 2.0.0-alpha.2

package/src/executeQueryPlan.ts

@@ -7,22 +7,29 @@ import {
   execute,
   GraphQLError,
   Kind,
-  SelectionSetNode,
   TypeNameMetaFieldDef,
   GraphQLFieldResolver,
+  GraphQLFormattedError,
+  isAbstractType,
+  GraphQLSchema,
 } from 'graphql';
-import { Trace, google } from 'apollo-engine-reporting-protobuf';
-import { defaultRootOperationNameLookup } from '@apollo/federation';
-import { GraphQLDataSource } from './datasources/types';
+import { Trace, google } from 'apollo-reporting-protobuf';
+import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
+import { OperationContext } from './operationContext';
 import {
   FetchNode,
   PlanNode,
   QueryPlan,
   ResponsePath,
-  OperationContext,
-} from './QueryPlan';
+  QueryPlanSelectionNode,
+  QueryPlanFieldNode,
+  getResponseName,
+} from '@apollo/query-planner';
 import { deepMerge } from './utilities/deepMerge';
-import { getResponseName } from './utilities/graphql';
+import { isNotNullOrUndefined } from './utilities/array';
+import { SpanStatusCode } from "@opentelemetry/api";
+import { OpenTelemetrySpanNames, tracer } from "./utilities/opentelemetry";
+import { defaultRootName } from '@apollo/federation-internals';
 
 export type ServiceMap = {
   [serviceName: string]: GraphQLDataSource;
@@ -44,64 +51,122 @@ export async function executeQueryPlan<TContext>(
   requestContext: GraphQLRequestContext<TContext>,
   operationContext: OperationContext,
 ): Promise<GraphQLExecutionResult> {
-  const errors: GraphQLError[] = [];
-
-  const context: ExecutionContext<TContext> = {
-    queryPlan,
-    operationContext,
-    serviceMap,
-    requestContext,
-    errors,
-  };
 
-  let data: ResultMap | undefined | null = Object.create(null);
+  const logger = requestContext.logger || console;
 
-  const captureTraces = !!(
-    requestContext.metrics && requestContext.metrics.captureTraces
-  );
+  return tracer.startActiveSpan(OpenTelemetrySpanNames.EXECUTE, async span => {
+    try {
+      const errors: GraphQLError[] = [];
 
-  if (queryPlan.node) {
-    const traceNode = await executeNode(
-      context,
-      queryPlan.node,
-      data!,
-      [],
-      captureTraces,
-    );
-    if (captureTraces) {
-      requestContext.metrics!.queryPlanTrace = traceNode;
-    }
-  }
+      const context: ExecutionContext<TContext> = {
+        queryPlan,
+        operationContext,
+        serviceMap,
+        requestContext,
+        errors,
+      };
 
-  // FIXME: Re-executing the query is a pretty heavy handed way of making sure
-  // only explicitly requested fields are included and field ordering follows
-  // the original query.
-  // It is also used to allow execution of introspection queries though.
-  try {
-    ({ data } = await execute({
-      schema: operationContext.schema,
-      document: {
-        kind: Kind.DOCUMENT,
-        definitions: [
-          operationContext.operation,
-          ...Object.values(operationContext.fragments),
-        ],
-      },
-      rootValue: data,
-      variableValues: requestContext.request.variables,
-      fieldResolver: defaultFieldResolverWithAliasSupport,
-    }));
-  } catch (error) {
-    return { errors: [error] };
-  }
+      let data: ResultMap | undefined | null = Object.create(null);
+
+      const captureTraces = !!(
+          requestContext.metrics && requestContext.metrics.captureTraces
+      );
+
+      if (queryPlan.node) {
+        const traceNode = await executeNode(
+          context,
+          queryPlan.node,
+          data!,
+          [],
+          captureTraces,
+        );
+        if (captureTraces) {
+          requestContext.metrics!.queryPlanTrace = traceNode;
+        }
+      }
+
+      const result = await tracer.startActiveSpan(OpenTelemetrySpanNames.POST_PROCESSING, async (span) => {
+
+        // FIXME: Re-executing the query is a pretty heavy handed way of making sure
+        // only explicitly requested fields are included and field ordering follows
+        // the original query.
+        // It is also used to allow execution of introspection queries though.
+        try {
+          const schema = operationContext.schema;
+          ({ data } = await execute({
+            schema,
+            document: {
+              kind: Kind.DOCUMENT,
+              definitions: [
+                operationContext.operation,
+                ...Object.values(operationContext.fragments),
+              ],
+            },
+            rootValue: data,
+            variableValues: requestContext.request.variables,
+            // See also `wrapSchemaWithAliasResolver` in `gateway-js/src/index.ts`.
+            fieldResolver: defaultFieldResolverWithAliasSupport,
+          }));
+        } catch (error) {
+          span.setStatus({ code:SpanStatusCode.ERROR });
+          if (error instanceof GraphQLError) {
+            return { errors: [error] };
+          } else if (error instanceof Error) {
+            return {
+              errors: [
+                new GraphQLError(
+                  error.message,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  error as Error,
+                )
+              ]
+            };
+          } else {
+            // The above cases should cover the known cases, but if we received
+            // something else in the `catch` — like an object or something, we
+            // may not want to merely return this to the client.
+            logger.error(
+              "Unexpected error during query plan execution: " + error);
+            return {
+              errors: [
+                new GraphQLError(
+                  "Unexpected error during query plan execution",
+                )
+              ]
+            };
+          }
+        }
+        finally {
+          span.end()
+        }
+        if(errors.length > 0) {
+          span.setStatus({ code:SpanStatusCode.ERROR });
+        }
+        return errors.length === 0 ? { data } : { errors, data };
+      });
 
-  return errors.length === 0 ? { data } : { errors, data };
+      if(result.errors) {
+        span.setStatus({ code:SpanStatusCode.ERROR });
+      }
+      return result;
+    }
+    catch (err) {
+      span.setStatus({ code:SpanStatusCode.ERROR });
+      throw err;
+    }
+    finally {
+      span.end();
+    }
+  });
 }
 
 // Note: this function always returns a protobuf QueryPlanNode tree, even if
 // we're going to ignore it, because it makes the code much simpler and more
 // typesafe. However, it doesn't actually ask for traces from the backend
-// service unless we are capturing traces for Engine.
+// service unless we are capturing traces for Studio.
 async function executeNode<TContext>(
   context: ExecutionContext<TContext>,
   node: PlanNode,
@@ -189,92 +254,120 @@ async function executeNode<TContext>(
 async function executeFetch<TContext>(
   context: ExecutionContext<TContext>,
   fetch: FetchNode,
-  results: ResultMap | ResultMap[],
+  results: ResultMap | (ResultMap | null | undefined)[],
   _path: ResponsePath,
   traceNode: Trace.QueryPlanNode.FetchNode | null,
 ): Promise<void> {
+
   const logger = context.requestContext.logger || console;
   const service = context.serviceMap[fetch.serviceName];
-  if (!service) {
-    throw new Error(`Couldn't find service with name "${fetch.serviceName}"`);
-  }
 
-  const entities = Array.isArray(results) ? results : [results];
-  if (entities.length < 1) return;
+  return tracer.startActiveSpan(OpenTelemetrySpanNames.FETCH, {attributes:{service:fetch.serviceName}}, async span => {
+    try {
+      if (!service) {
+        throw new Error(`Couldn't find service with name "${fetch.serviceName}"`);
+      }
 
-  let variables = Object.create(null);
-  if (fetch.variableUsages) {
-    for (const variableName of Object.keys(fetch.variableUsages)) {
-      const providedVariables = context.requestContext.request.variables;
-      if (
-        providedVariables &&
-        typeof providedVariables[variableName] !== 'undefined'
-      ) {
-        variables[variableName] = providedVariables[variableName];
+      let entities: ResultMap[];
+      if (Array.isArray(results)) {
+        // Remove null or undefined entities from the list
+        entities = results.filter(isNotNullOrUndefined);
+      } else {
+        entities = [results];
       }
-    }
-  }
 
-  if (!fetch.requires) {
-    const dataReceivedFromService = await sendOperation(
-      context,
-      fetch.source,
-      variables,
-    );
+      if (entities.length < 1) return;
+
+      const variables = Object.create(null);
+      if (fetch.variableUsages) {
+        for (const variableName of fetch.variableUsages) {
+          const providedVariables = context.requestContext.request.variables;
+          if (
+              providedVariables &&
+              typeof providedVariables[variableName] !== 'undefined'
+          ) {
+            variables[variableName] = providedVariables[variableName];
+          }
+        }
+      }
 
-    for (const entity of entities) {
-      deepMerge(entity, dataReceivedFromService);
-    }
-  } else {
-    const requires = fetch.requires;
+      if (!fetch.requires) {
+        const dataReceivedFromService = await sendOperation(
+            context,
+            fetch.operation,
+            variables,
+        );
 
-    const representations: ResultMap[] = [];
-    const representationToEntity: number[] = [];
+        for (const entity of entities) {
+          deepMerge(entity, dataReceivedFromService);
+        }
+      } else {
+        const requires = fetch.requires;
 
-    entities.forEach((entity, index) => {
-      const representation = executeSelectionSet(entity, requires);
-      if (representation && representation[TypeNameMetaFieldDef.name]) {
-        representations.push(representation);
-        representationToEntity.push(index);
-      }
-    });
+        const representations: ResultMap[] = [];
+        const representationToEntity: number[] = [];
 
-    if ('representations' in variables) {
-      throw new Error(`Variables cannot contain key "representations"`);
-    }
+        entities.forEach((entity, index) => {
+          const representation = executeSelectionSet(
+            context.operationContext,
+            entity,
+            requires,
+          );
+          if (representation && representation[TypeNameMetaFieldDef.name]) {
+            representations.push(representation);
+            representationToEntity.push(index);
+          }
+        });
 
-    const dataReceivedFromService = await sendOperation(
-      context,
-      fetch.source,
-      { ...variables, representations },
-    );
+        // If there are no representations, that means the type conditions in
+        // the requires don't match any entities.
+        if (representations.length < 1) return;
 
-    if (!dataReceivedFromService) {
-      return;
-    }
+        if ('representations' in variables) {
+          throw new Error(`Variables cannot contain key "representations"`);
+        }
 
-    if (
-      !(
-        dataReceivedFromService._entities &&
-        Array.isArray(dataReceivedFromService._entities)
-      )
-    ) {
-      throw new Error(`Expected "data._entities" in response to be an array`);
-    }
+        const dataReceivedFromService = await sendOperation(
+            context,
+            fetch.operation,
+            {...variables, representations},
+        );
 
-    const receivedEntities = dataReceivedFromService._entities;
+        if (!dataReceivedFromService) {
+          return;
+        }
 
-    if (receivedEntities.length !== representations.length) {
-      throw new Error(
-        `Expected "data._entities" to contain ${representations.length} elements`,
-      );
-    }
+        if (
+            !(
+                dataReceivedFromService._entities &&
+                Array.isArray(dataReceivedFromService._entities)
+            )
+        ) {
+          throw new Error(`Expected "data._entities" in response to be an array`);
+        }
 
-    for (let i = 0; i < entities.length; i++) {
-      deepMerge(entities[representationToEntity[i]], receivedEntities[i]);
-    }
-  }
+        const receivedEntities = dataReceivedFromService._entities;
 
+        if (receivedEntities.length !== representations.length) {
+          throw new Error(
+              `Expected "data._entities" to contain ${representations.length} elements`,
+          );
+        }
+
+        for (let i = 0; i < entities.length; i++) {
+          deepMerge(entities[representationToEntity[i]], receivedEntities[i]);
+        }
+      }
+    }
+    catch (err) {
+      span.setStatus({ code:SpanStatusCode.ERROR });
+      throw err;
+    }
+    finally
+    {
+      span.end();
+    }
+  });
   async function sendOperation(
     context: ExecutionContext<TContext>,
     source: string,
@@ -284,7 +377,7 @@ async function executeFetch<TContext>(
     // GraphQLRequest.http is supposed to have if it exists.
     let http: any;
 
-    // If we're capturing a trace for Engine, then save the operation text to
+    // If we're capturing a trace for Studio, then save the operation text to
     // the node we're building and tell the federated service to include a trace
     // in its response.
     if (traceNode) {
@@ -303,29 +396,24 @@ async function executeFetch<TContext>(
     }
 
     const response = await service.process({
+      kind: GraphQLDataSourceRequestKind.INCOMING_OPERATION,
       request: {
         query: source,
         variables,
         http,
       },
+      incomingRequestContext: context.requestContext,
       context: context.requestContext.context,
     });
 
     if (response.errors) {
-      const errors = response.errors.map(error =>
-        downstreamServiceError(
-          error.message,
-          fetch.serviceName,
-          source,
-          variables,
-          error.extensions,
-          error.path,
-        ),
+      const errors = response.errors.map((error) =>
+        downstreamServiceError(error, fetch.serviceName),
       );
       context.errors.push(...errors);
     }
 
-    // If we're capturing a trace for Engine, save the received trace into the
+    // If we're capturing a trace for Studio, save the received trace into the
     // query plan.
     if (traceNode) {
       traceNode.receivedTime = dateToProtoTimestamp(new Date());
@@ -362,10 +450,7 @@ async function executeFetch<TContext>(
           // to have the default names (Query, Mutation, Subscription) even
           // if the implementing services choose different names, so we override
           // whatever the implementing service reported here.
-          const rootTypeName =
-            defaultRootOperationNameLookup[
-              context.operationContext.operation.operation
-            ];
+          const rootTypeName = defaultRootName(context.operationContext.operation.operation);
           traceNode.trace.root?.child?.forEach((child) => {
             child.parentType = rootTypeName;
           });
@@ -384,8 +469,9 @@ async function executeFetch<TContext>(
  * @param selectionSet
  */
 function executeSelectionSet(
+  operationContext: OperationContext,
   source: Record<string, any> | null,
-  selectionSet: SelectionSetNode,
+  selections: QueryPlanSelectionNode[],
 ): Record<string, any> | null {
 
   // If the underlying service has returned null for the parent (source)
@@ -396,23 +482,26 @@ function executeSelectionSet(
 
   const result: Record<string, any> = Object.create(null);
 
-  for (const selection of selectionSet.selections) {
+  for (const selection of selections) {
     switch (selection.kind) {
       case Kind.FIELD:
-        const responseName = getResponseName(selection);
-        const selectionSet = selection.selectionSet;
+        const responseName = getResponseName(selection as QueryPlanFieldNode);
+        const selections = (selection as QueryPlanFieldNode).selections;
 
         if (typeof source[responseName] === 'undefined') {
           throw new Error(`Field "${responseName}" was not found in response.`);
         }
         if (Array.isArray(source[responseName])) {
           result[responseName] = source[responseName].map((value: any) =>
-            selectionSet ? executeSelectionSet(value, selectionSet) : value,
+            selections
+              ? executeSelectionSet(operationContext, value, selections)
+              : value,
           );
-        } else if (selectionSet) {
+        } else if (selections) {
           result[responseName] = executeSelectionSet(
+            operationContext,
             source[responseName],
-            selectionSet,
+            selections,
           );
         } else {
           result[responseName] = source[responseName];
@@ -424,10 +513,10 @@ function executeSelectionSet(
         const typename = source && source['__typename'];
         if (!typename) continue;
 
-        if (typename === selection.typeCondition.name.value) {
+        if (doesTypeConditionMatch(operationContext.schema, selection.typeCondition, typename)) {
           deepMerge(
             result,
-            executeSelectionSet(source, selection.selectionSet),
+            executeSelectionSet(operationContext, source, selection.selections),
           );
         }
         break;
@@ -437,6 +526,32 @@ 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 schema.isSubType(conditionalType, type);
+  }
+
+  return false;
+}
+
 function flattenResultsAtPath(value: any, path: ResponsePath): any {
   if (path.length === 0) return value;
   if (value === undefined || value === null) return value;
@@ -450,13 +565,11 @@ function flattenResultsAtPath(value: any, path: ResponsePath): any {
 }
 
 function downstreamServiceError(
-  message: string | undefined,
+  originalError: GraphQLFormattedError,
   serviceName: string,
-  query: string,
-  variables?: Record<string, any>,
-  extensions?: Record<string, any>,
-  path?: ReadonlyArray<string | number> | undefined,
 ) {
+  let { message, extensions } = originalError;
+
   if (!message) {
     message = `Error while fetching subquery from service "${serviceName}"`;
   }
@@ -465,8 +578,6 @@ function downstreamServiceError(
     // XXX The presence of a serviceName in extensions is used to
     // determine if this error should be captured for metrics reporting.
     serviceName,
-    query,
-    variables,
     ...extensions,
   };
   return new GraphQLError(
@@ -474,8 +585,8 @@ function downstreamServiceError(
     undefined,
     undefined,
     undefined,
-    path,
     undefined,
+    originalError as Error,
     extensions,
   );
 }