Use an object, rather than positional params for willResolveField.

This should prove to be more ergonomic, and also allow us to attach other
useful properties to this object (for either external or internal use) in
the future.

Also, adds a test to make sure we're passing _something_!

Ref: #3998 (comment)

packages/apollo-server-core/src/__tests__/runQuery.test.ts

@@ -691,6 +691,43 @@ describe('runQuery', () => {
           expect(executionDidEnd).toHaveBeenCalledTimes(1);
         });
 
+        it('receives an object with the resolver arguments', async () => {
+          const willResolveField = jest.fn();
+          const executionDidEnd = jest.fn();
+          const executionDidStart = jest.fn(
+            (): GraphQLRequestExecutionListener => ({
+              willResolveField,
+              executionDidEnd,
+            }),
+          );
+
+          await runQuery({
+            schema,
+            context: { ourSpecialContext: true },
+            queryString: '{ testString }',
+            plugins: [
+              {
+                requestDidStart() {
+                  return {
+                    executionDidStart,
+                  };
+                },
+              },
+            ],
+            request: new MockReq(),
+          });
+
+          expect(executionDidStart).toHaveBeenCalledTimes(1);
+          expect(willResolveField).toHaveBeenCalledTimes(1);
+          expect(willResolveField).toHaveBeenNthCalledWith(1, {
+            source: undefined,
+            args: {},
+            context: expect.objectContaining({ ourSpecialContext: true }),
+            info: expect.objectContaining({ fieldName: 'testString' }),
+          });
+          expect(executionDidEnd).toHaveBeenCalledTimes(1);
+        });
+
         it('calls the end handler', async () => {
           const didResolveField: GraphQLRequestListenerDidResolveField =
             jest.fn();

packages/apollo-server-core/src/utils/schemaInstrumentation.ts

@@ -51,7 +51,7 @@ function wrapField(field: GraphQLField<any, any>): void {
     // resolution is complete.
     const didResolveField =
       typeof willResolveField === 'function' &&
-      willResolveField(source, args, context, info);
+      willResolveField({ source, args, context, info });
 
     const resolveObject: GraphQLObjectResolver<
       any,

packages/apollo-server-plugin-base/src/index.ts

@@ -7,6 +7,7 @@ import {
   GraphQLResponse,
   ValueOrPromise,
   WithRequired,
+  GraphQLFieldResolverParams,
   GraphQLRequestContextDidResolveSource,
   GraphQLRequestContextParsingDidStart,
   GraphQLRequestContextValidationDidStart,
@@ -16,7 +17,6 @@ import {
   GraphQLRequestContextExecutionDidStart,
   GraphQLRequestContextWillSendResponse,
 } from 'apollo-server-types';
-import { GraphQLFieldResolver } from "graphql";
 
 // We re-export all of these so plugin authors only need to depend on a single
 // package.  The overall concept of `apollo-server-types` and this package
@@ -34,6 +34,7 @@ export {
   GraphQLResponse,
   ValueOrPromise,
   WithRequired,
+  GraphQLFieldResolverParams,
   GraphQLRequestContextDidResolveSource,
   GraphQLRequestContextParsingDidStart,
   GraphQLRequestContextValidationDidStart,
@@ -102,6 +103,6 @@ export interface GraphQLRequestExecutionListener<
 > extends AnyFunctionMap {
   executionDidEnd?: GraphQLRequestListenerExecutionDidEnd;
   willResolveField?(
-    ...fieldResolverArgs: Parameters<GraphQLFieldResolver<any, TContext>>
+    fieldResolverParams: GraphQLFieldResolverParams<any, TContext>
   ): GraphQLRequestListenerDidResolveField | void;
 }

packages/apollo-server-types/src/index.ts

@@ -7,6 +7,7 @@ import {
   OperationDefinitionNode,
   DocumentNode,
   GraphQLError,
+  GraphQLResolveInfo,
 } from 'graphql';
 
 // This seems like it could live in this package too.
@@ -147,6 +148,27 @@ export type Logger = {
   error(message?: any): void;
 }
 
+/**
+ * This is an object form of the parameters received by typical
+ * `graphql-js` resolvers.  The function type is `GraphQLFieldResolver`
+ * and normally uses positional parameters.  In order to facilitate better
+ * ergonomics in the Apollo Server plugin API, these have been converted to
+ * named properties on the object using their names from the upstream
+ * `GraphQLFieldResolver` type signature.  Ergonomic wins, in this case,
+ * include not needing to have three unused variables in scope just because
+ * there was a need to access the `info` property in a wrapped plugin.
+ */
+export type GraphQLFieldResolverParams<
+  TSource,
+  TContext,
+  TArgs = { [argName: string]: any }
+> = {
+  source: TSource;
+  args: TArgs;
+  context: TContext;
+  info: GraphQLResolveInfo;
+};
+
 export type GraphQLRequestContextDidResolveSource<TContext> =
   WithRequired<GraphQLRequestContext<TContext>,
     | 'metrics'