Fix Lambda context function typing

In AS3 we made apollo-server-lambda inherit from apollo-server-express,
but didn't realize that it also inherited the more precise TS typings on
its constructor that meant that its `context` function would take
Express-specific parameters (rather than the default unconstrained
parameter).

This change makes it easier for any ApolloServer subclass to declare its
context function typing, and updates apollo-server-express and
apollo-server-lambda to do so. The other integrations are left with the
vaguer defaults.

Tests didn't catch this before because they didn't pass a `context`
function *directly* to the Lambda ApolloServer constructor, just via a
function with a looser signature.

Fixes #5480.

CHANGELOG.md

@@ -9,6 +9,8 @@ The version headers in this history reflect the versions of Apollo Server itself
 
 ## vNEXT
 
+- `apollo-server-lambda`: Fix TypeScript types for `context` function. (In 3.0.0, the TS types for the `context` function were accidentally inherited from `apollo-server-express` instead of using the correct Lambda-specific types). [PR #XXXX](https://github.com/apollographql/apollo-server/pull/XXXX)
+
 ## v3.0.0
 
 ### BREAKING CHANGES

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

@@ -109,26 +109,29 @@ class UnreachableCaseError extends Error {
     super(`Unreachable case: ${val}`);
   }
 }
-export class ApolloServerBase {
+export class ApolloServerBase<
+  // The type of the argument to the `context` function for this integration.
+  ContextFunctionParams = any,
+> {
   private logger: Logger;
   public graphqlPath: string = '/graphql';
   public requestOptions: Partial<GraphQLServerOptions<any>> =
     Object.create(null);
 
-  private context?: Context | ContextFunction;
+  private context?: Context | ContextFunction<ContextFunctionParams>;
   private apolloConfig: ApolloConfig;
   protected plugins: ApolloServerPlugin[] = [];
 
   private parseOptions: ParseOptions;
-  private config: Config;
+  private config: Config<ContextFunctionParams>;
   private state: ServerState;
   private toDispose = new Set<() => Promise<void>>();
   private toDisposeLast = new Set<() => Promise<void>>();
   private experimental_approximateDocumentStoreMiB: Config['experimental_approximateDocumentStoreMiB'];
   private landingPage: LandingPage | null = null;
 
   // The constructor should be universal across all environments. All environment specific behavior should be set by adding or overriding methods
-  constructor(config: Config) {
+  constructor(config: Config<ContextFunctionParams>) {
     if (!config) throw new Error('ApolloServer requires options.');
     this.config = config;
     const {
@@ -824,7 +827,13 @@ export class ApolloServerBase {
   // from an object containing the request and other integration specific
   // options
   protected async graphQLServerOptions(
-    integrationContextArgument?: Record<string, any>,
+    // We ought to be able to declare this as taking ContextFunctionParams, but
+    // that gets us into weird business around inheritance, since a subclass (eg
+    // Lambda subclassing Express) may have a different ContextFunctionParams.
+    // So it's the job of the subclass's function that calls this function to
+    // make sure that its argument properly matches the particular subclass's
+    // context params type.
+    integrationContextArgument?: any,
   ): Promise<GraphQLServerOptions> {
     const { schema, schemaHash, documentStore } = await this._ensureStarted();
 
@@ -877,7 +886,7 @@ export class ApolloServerBase {
     request: Omit<GraphQLRequest, 'query'> & {
       query?: string | DocumentNode;
     },
-    integrationContextArgument?: Record<string, any>,
+    integrationContextArgument?: ContextFunctionParams,
   ) {
     // Since this function is mostly for testing, you don't need to explicitly
     // start your server before calling it. (That also means you can use it with

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

@@ -69,13 +69,14 @@ export interface GraphQLService extends GatewayInterface {}
 
 // This configuration is shared between all integrations and should include
 // fields that are not specific to a single integration
-export interface Config extends BaseConfig {
+export interface Config<ContextFunctionParams = any>
+  extends BaseConfig {
   modules?: GraphQLSchemaModule[];
   typeDefs?: DocumentNode | Array<DocumentNode> | string | Array<string>;
   parseOptions?: ParseOptions;
   resolvers?: IResolvers | Array<IResolvers>;
   schema?: GraphQLSchema;
-  context?: Context | ContextFunction;
+  context?: Context | ContextFunction<ContextFunctionParams>;
   introspection?: boolean;
   mocks?: boolean | IMocks;
   mockEntireSchema?: boolean;

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

@@ -4,8 +4,6 @@ import { json, OptionsJson } from 'body-parser';
 import {
   GraphQLOptions,
   ApolloServerBase,
-  ContextFunction,
-  Context,
   Config,
   runHttpQuery,
   HttpQueryError,
@@ -41,23 +39,20 @@ export interface ExpressContext {
   res: express.Response;
 }
 
-export interface ApolloServerExpressConfig extends Config {
-  context?: ContextFunction<ExpressContext, Context> | Context;
-}
-
-export class ApolloServer extends ApolloServerBase {
-  constructor(config: ApolloServerExpressConfig) {
-    super(config);
-  }
+export type ApolloServerExpressConfig = Config<ExpressContext>;
 
+export class ApolloServer<
+  ContextFunctionParams = ExpressContext,
+> extends ApolloServerBase<ContextFunctionParams> {
   // This translates the arguments from the middleware into graphQL options It
   // provides typings for the integration specific behavior, ideally this would
   // be propagated with a generic to the super class
   async createGraphQLServerOptions(
     req: express.Request,
     res: express.Response,
   ): Promise<GraphQLOptions> {
-    return super.graphQLServerOptions({ req, res });
+    const contextParams: ExpressContext = { req, res };
+    return super.graphQLServerOptions(contextParams);
   }
 
   public applyMiddleware({ app, ...rest }: ServerRegistration) {

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

@@ -1,6 +1,7 @@
 import type { Handler } from 'aws-lambda';
 import {
   ApolloServer as ApolloServerExpress,
+  ExpressContext,
   GetMiddlewareOptions,
 } from 'apollo-server-express';
 import type { GraphQLOptions } from 'apollo-server-core';
@@ -16,14 +17,20 @@ export interface CreateHandlerOptions {
   expressGetMiddlewareOptions?: GetMiddlewareOptions;
 }
 
+export interface LambdaContextFunctionParams {
+  event: ReturnType<typeof getCurrentInvoke>['event'];
+  context: ReturnType<typeof getCurrentInvoke>['context'];
+  express: ExpressContext;
+}
+
 function defaultExpressAppFromMiddleware(
   middleware: express.RequestHandler,
 ): express.Application {
   const app = express();
   app.use(middleware);
   return app;
 }
-export class ApolloServer extends ApolloServerExpress {
+export class ApolloServer extends ApolloServerExpress<LambdaContextFunctionParams> {
   protected override serverlessFramework(): boolean {
     return true;
   }
@@ -56,10 +63,11 @@ export class ApolloServer extends ApolloServerExpress {
     res: express.Response,
   ): Promise<GraphQLOptions> {
     const { event, context } = getCurrentInvoke();
-    return super.graphQLServerOptions({
+    const contextParams: LambdaContextFunctionParams = {
       event,
       context,
       express: { req, res },
-    });
+    };
+    return super.graphQLServerOptions(contextParams);
   }
 }

packages/apollo-server-lambda/src/__tests__/ApolloServer.test.ts

@@ -3,7 +3,11 @@ import request from 'supertest';
 import express from 'express';
 import { createMockServer } from './mockAPIGatewayServer';
 import { Config, gql } from 'apollo-server-core';
-import { ApolloServer, CreateHandlerOptions } from '../ApolloServer';
+import {
+  ApolloServer,
+  CreateHandlerOptions,
+  LambdaContextFunctionParams,
+} from '../ApolloServer';
 import {
   createServerInfo,
   testApolloServer,
@@ -52,14 +56,29 @@ describe('apollo-server-lambda', () => {
 
   const createLambda = (
     createHandlerOptions: CreateHandlerOptions = {},
-    config: Config = { typeDefs, resolvers },
+    config: Config<LambdaContextFunctionParams> = { typeDefs, resolvers },
   ) => {
     const server = new ApolloServer(config);
     const handler = server.createHandler(createHandlerOptions);
     return createMockServer(handler);
   };
 
   describe('context', () => {
+    it('context functions typecheck', async () => {
+      // We want to make sure that TS allows you to write the context function
+      // arguments. Note that the calls to createLambda that set context below
+      // are only good enough if we're confident that the declaration of the
+      // `config` argument on `createLambda` above matches the generics used in
+      // ApolloServer itself, so it's reasonable for us to validate against
+      // ApolloServer directly.
+      new ApolloServer({
+        typeDefs: 'type Query { x: Int }',
+        context({ event: _event, context: _context, express }) {
+          const { req: _req, res: _res } = express;
+        },
+      });
+    });
+
     it('receives both Express and Lambda context', async () => {
       const app = createLambda(
         {},

packages/apollo-server/src/index.ts

@@ -7,7 +7,7 @@ import express from 'express';
 import http from 'http';
 import stoppable from 'stoppable';
 import {
-  ApolloServer as ApolloServerBase,
+  ApolloServer as ApolloServerExpress,
   CorsOptions,
   ApolloServerExpressConfig,
 } from 'apollo-server-express';
@@ -24,7 +24,7 @@ export interface ServerInfo {
   server: http.Server;
 }
 
-export class ApolloServer extends ApolloServerBase {
+export class ApolloServer extends ApolloServerExpress {
   private httpServer?: stoppable.StoppableServer;
   private cors?: CorsOptions | boolean;
   private onHealthCheck?: (req: express.Request) => Promise<any>;