Add support for willResolveField and corresponding end handler.

packages/apollo-engine-reporting/src/agent.ts

@@ -12,7 +12,7 @@ import { fetch, RequestAgent, Response } from 'apollo-server-env';
 import retry from 'async-retry';
 
 import { EngineReportingExtension } from './extension';
-import { GraphQLRequestContext, Logger } from 'apollo-server-types';
+import { GraphQLRequestContext, Logger, SchemaHash } from 'apollo-server-types';
 import { InMemoryLRUCache } from 'apollo-server-caching';
 import { defaultEngineReportingSignature } from 'apollo-graphql';
 
@@ -202,7 +202,7 @@ export interface AddTraceArgs {
   trace: Trace;
   operationName: string;
   queryHash: string;
-  schemaHash: string;
+  schemaHash: SchemaHash;
   queryString?: string;
   documentAST?: DocumentNode;
 }
@@ -278,7 +278,7 @@ export class EngineReportingAgent<TContext = any> {
     handleLegacyOptions(this.options);
   }
 
-  public newExtension(schemaHash: string): EngineReportingExtension<TContext> {
+  public newExtension(schemaHash: SchemaHash): EngineReportingExtension<TContext> {
     return new EngineReportingExtension<TContext>(
       this.options,
       this.addTrace.bind(this),

packages/apollo-engine-reporting/src/extension.ts

@@ -1,4 +1,9 @@
-import { GraphQLRequestContext, WithRequired, Logger } from 'apollo-server-types';
+import {
+  GraphQLRequestContext,
+  WithRequired,
+  Logger,
+  SchemaHash,
+} from 'apollo-server-types';
 import { Request, Headers } from 'apollo-server-env';
 import {
   GraphQLResolveInfo,
@@ -42,7 +47,7 @@ export class EngineReportingExtension<TContext = any>
   public constructor(
     options: EngineReportingOptions<TContext>,
     addTrace: (args: AddTraceArgs) => Promise<void>,
-    private schemaHash: string,
+    private schemaHash: SchemaHash,
   ) {
     this.options = {
       ...options,

packages/apollo-server-core/src/ApolloServer.ts

@@ -69,7 +69,7 @@ import {
 
 import { Headers } from 'apollo-server-env';
 import { buildServiceDefinition } from '@apollographql/apollo-tools';
-import { Logger } from "apollo-server-types";
+import { Logger, SchemaHash } from "apollo-server-types";
 
 const NoIntrospection = (context: ValidationContext) => ({
   Field(node: FieldDefinitionNode) {
@@ -134,7 +134,7 @@ type SchemaDerivedData = {
   // on the same operation to be executed immediately.
   documentStore?: InMemoryLRUCache<DocumentNode>;
   schema: GraphQLSchema;
-  schemaHash: string;
+  schemaHash: SchemaHash;
   extensions: Array<() => GraphQLExtension>;
 };
 
@@ -782,12 +782,16 @@ export class ApolloServerBase {
     return sdlFieldType.name == 'String';
   }
 
-  private ensurePluginInstantiation(plugins?: PluginDefinition[]): void {
-    if (!plugins || !plugins.length) {
-      return;
-    }
+  private ensurePluginInstantiation(plugins: PluginDefinition[] = []): void {
+    const pluginsToInit: PluginDefinition[] = [];
+
+    // Internal plugins should be added to `pluginsToInit` here.
+    // User's plugins, provided as an argument to this method, will be added
+    // at the end of that list so they take precidence.
+    // A follow-up commit will actually introduce this.
 
-    this.plugins = plugins.map(plugin => {
+    pluginsToInit.push(...plugins);
+    this.plugins = pluginsToInit.map(plugin => {
       if (typeof plugin === 'function') {
         return plugin();
       }

packages/apollo-server-core/src/requestPipeline.ts

@@ -17,7 +17,11 @@ import {
   enableGraphQLExtensions,
 } from 'graphql-extensions';
 import { DataSource } from 'apollo-datasource';
-import { PersistedQueryOptions } from '.';
+import {
+  PersistedQueryOptions,
+  symbolRequestListenerDispatcher,
+  enablePluginsForSchemaResolvers,
+} from '.';
 import {
   CacheControlExtension,
   CacheControlExtensionOptions,
@@ -127,6 +131,9 @@ export async function processGraphQLRequest<TContext>(
   (requestContext.context as any)._extensionStack = extensionStack;
 
   const dispatcher = initializeRequestListenerDispatcher();
+  Object.defineProperty(requestContext.context, symbolRequestListenerDispatcher, {
+    value: dispatcher,
+  });
 
   await initializeDataSources();
 
@@ -571,6 +578,8 @@ export async function processGraphQLRequest<TContext>(
   function initializeRequestListenerDispatcher(): Dispatcher<
     GraphQLRequestListener
   > {
+    enablePluginsForSchemaResolvers(config.schema);
+
     const requestListeners: GraphQLRequestListener<TContext>[] = [];
     if (config.plugins) {
       for (const plugin of config.plugins) {
@@ -633,3 +642,4 @@ export async function processGraphQLRequest<TContext>(
     }
   }
 }
+

packages/apollo-server-core/src/requestPipelineAPI.ts

@@ -1,3 +1,16 @@
+import {
+  GraphQLField,
+  getNamedType,
+  GraphQLObjectType,
+  GraphQLSchema,
+  ResponsePath,
+} from 'graphql/type';
+import { defaultFieldResolver } from "graphql/execution";
+import { FieldNode } from "graphql/language";
+import { Dispatcher } from "./utils/dispatcher";
+import { GraphQLRequestListener } from "apollo-server-plugin-base";
+import { GraphQLObjectResolver } from "@apollographql/apollo-tools";
+
 export {
   GraphQLServiceContext,
   GraphQLRequest,
@@ -10,3 +23,143 @@ export {
   GraphQLExecutor,
   GraphQLExecutionResult,
 } from 'apollo-server-types';
+
+export const symbolRequestListenerDispatcher =
+  Symbol("apolloServerRequestListenerDispatcher");
+export const symbolPluginsEnabled = Symbol("apolloServerPluginsEnabled");
+
+export function enablePluginsForSchemaResolvers(
+  schema: GraphQLSchema & { [symbolPluginsEnabled]?: boolean },
+) {
+  if (schema[symbolPluginsEnabled]) {
+    return schema;
+  }
+  Object.defineProperty(schema, symbolPluginsEnabled, {
+    value: true,
+  });
+
+  forEachField(schema, wrapField);
+
+  return schema;
+}
+
+function wrapField(field: GraphQLField<any, any>): void {
+  const fieldResolver = field.resolve || defaultFieldResolver;
+
+  field.resolve = (source, args, context, info) => {
+    // This is a bit of a hack, but since `ResponsePath` is a linked list,
+    // a new object gets created every time a path segment is added.
+    // So we can use that to share our `whenObjectResolved` promise across
+    // all field resolvers for the same object.
+    const parentPath = info.path.prev as ResponsePath & {
+      __fields?: Record<string, ReadonlyArray<FieldNode>>;
+      __whenObjectResolved?: Promise<any>;
+    };
+
+    // The technique for implementing a  "did resolve field" is accomplished by
+    // returning a function from the `willResolveField` handler.  The
+    // dispatcher will return a callback which will invoke all of those handlers
+    // and we'll save that to call when the object resolution is complete.
+    const endHandler = context && context[symbolRequestListenerDispatcher] &&
+      (context[symbolRequestListenerDispatcher] as Dispatcher<GraphQLRequestListener>)
+        .invokeDidStartHook('willResolveField', source, args, context, info) ||
+          ((_err: Error | null, _result?: any) => { /* do nothing */ });
+
+    const resolveObject: GraphQLObjectResolver<
+      any,
+      any
+    > = (info.parentType as any).resolveObject;
+
+    let whenObjectResolved: Promise<any> | undefined;
+
+    if (parentPath && resolveObject) {
+      if (!parentPath.__fields) {
+        parentPath.__fields = {};
+      }
+
+      parentPath.__fields[info.fieldName] = info.fieldNodes;
+
+      whenObjectResolved = parentPath.__whenObjectResolved;
+      if (!whenObjectResolved) {
+        // Use `Promise.resolve().then()` to delay executing
+        // `resolveObject()` so we can collect all the fields first.
+        whenObjectResolved = Promise.resolve().then(() => {
+          return resolveObject(source, parentPath.__fields!, context, info);
+        });
+        parentPath.__whenObjectResolved = whenObjectResolved;
+      }
+    }
+
+    try {
+      let result: any;
+      if (whenObjectResolved) {
+        result = whenObjectResolved.then((resolvedObject: any) => {
+          return fieldResolver(resolvedObject, args, context, info);
+        });
+      } else {
+        result = fieldResolver(source, args, context, info);
+      }
+
+      // Call the stack's handlers either immediately (if result is not a
+      // Promise) or once the Promise is done. Then return that same
+      // maybe-Promise value.
+      whenResultIsFinished(result, endHandler);
+      return result;
+    } catch (error) {
+      // Normally it's a bad sign to see an error both handled and
+      // re-thrown. But it is useful to allow extensions to track errors while
+      // still handling them in the normal GraphQL way.
+      endHandler(error);
+      throw error;
+    }
+  };;
+}
+
+function isPromise(x: any): boolean {
+  return x && typeof x.then === 'function';
+}
+
+// Given result (which may be a Promise or an array some of whose elements are
+// promises) Promises, set up 'callback' to be invoked when result is fully
+// resolved.
+export function whenResultIsFinished(
+  result: any,
+  callback: (err: Error | null, result?: any) => void,
+) {
+  if (isPromise(result)) {
+    result.then((r: any) => callback(null, r), (err: Error) => callback(err));
+  } else if (Array.isArray(result)) {
+    if (result.some(isPromise)) {
+      Promise.all(result).then(
+        (r: any) => callback(null, r),
+        (err: Error) => callback(err),
+      );
+    } else {
+      callback(null, result);
+    }
+  } else {
+    callback(null, result);
+  }
+}
+
+function forEachField(schema: GraphQLSchema, fn: FieldIteratorFn): void {
+  const typeMap = schema.getTypeMap();
+  Object.entries(typeMap).forEach(([typeName, type]) => {
+
+    if (
+      !getNamedType(type).name.startsWith('__') &&
+      type instanceof GraphQLObjectType
+    ) {
+      const fields = type.getFields();
+      Object.entries(fields).forEach(([fieldName, field]) => {
+        fn(field, typeName, fieldName);
+      });
+    }
+  });
+}
+
+type FieldIteratorFn = (
+  fieldDef: GraphQLField<any, any>,
+  typeName: string,
+  fieldName: string,
+) => void;