Initial Lambda implementation (#3)

Author: trevor-scheer

jest.config.base.ts

@@ -5,6 +5,7 @@ const config: Config.InitialOptions = {
   preset: "ts-jest",
   testEnvironment: "node",
   roots: ["src"],
+  testMatch: ["**/*.test.ts"],
   globals: {
     "ts-jest": {
       tsconfig: "<rootDir>/src/__tests__/tsconfig.json",

package-lock.json

@@ -28,11 +28,12 @@
     "packages/*"
   ],
   "devDependencies": {
-    "@apollo/server-integration-testsuite": "^4.0.0-alpha.1",
+    "@apollo/server-integration-testsuite": "4.0.0-alpha.1",
+    "@apollo/utils.withrequired": "1.0.0",
     "@jest/types": "28.1.3",
-    "@types/aws-lambda": "^8.10.101",
+    "@types/aws-lambda": "8.10.101",
     "@types/jest": "28.1.5",
-    "fastify": "^4.3.0",
+    "fastify": "4.3.0",
     "graphql": "16.5.0",
     "jest": "28.1.3",
     "jest-junit": "14.0.0",

package.json

@@ -23,6 +23,7 @@
     "node": ">=16"
   },
   "peerDependencies": {
-    "@apollo/server": "^4.0.0-alpha.1"
+    "@apollo/server": "^4.0.0-alpha.1",
+    "graphql": "^16.5.0"
   }
 }

packages/lambda/package.json

@@ -1,8 +1,65 @@
+import { ApolloServer, ApolloServerOptions, BaseContext } from "@apollo/server";
+import { ApolloServerPluginDrainHttpServer } from "@apollo/server/plugin/drainHttpServer";
+import {
+  CreateServerForIntegrationTestsOptions,
+  defineIntegrationTestSuite,
+} from "@apollo/server-integration-testsuite";
+import { createServer, Server } from "http";
+import type { AddressInfo } from "net";
+import { format } from "url";
 import { lambdaHandler } from "..";
+import { createMockServer as createAPIGatewayMockServer } from "./mockAPIGatewayServer";
 
 describe("lambdaHandler", () => {
-  it("integration", () => {
-    lambdaHandler();
-    expect(true).toBeTruthy();
-  });
+  defineIntegrationTestSuite(
+    async function (
+      serverOptions: ApolloServerOptions<BaseContext>,
+      testOptions?: CreateServerForIntegrationTestsOptions,
+    ) {
+      const httpServer = createServer();
+      const server = new ApolloServer({
+        ...serverOptions,
+        plugins: [
+          ...(serverOptions.plugins ?? []),
+          ApolloServerPluginDrainHttpServer({
+            httpServer,
+          }),
+        ],
+      });
+
+      const handler = testOptions
+        ? lambdaHandler(server, testOptions)
+        : lambdaHandler(server);
+
+      httpServer.addListener("request", createAPIGatewayMockServer(handler));
+
+      await new Promise<void>((resolve) => {
+        httpServer.listen({ port: 0 }, resolve);
+      });
+
+      return { server, url: urlForHttpServer(httpServer) };
+    },
+    {
+      serverIsStartedInBackground: true,
+    },
+  );
 });
+
+// Stolen from apollo server integration tests
+export function urlForHttpServer(httpServer: Server): string {
+  const { address, port } = httpServer.address() as AddressInfo;
+
+  // Convert IPs which mean "any address" (IPv4 or IPv6) into localhost
+  // corresponding loopback ip. Note that the url field we're setting is
+  // primarily for consumption by our test suite. If this heuristic is wrong for
+  // your use case, explicitly specify a frontend host (in the `host` option
+  // when listening).
+  const hostname = address === "" || address === "::" ? "localhost" : address;
+
+  return format({
+    protocol: "http",
+    hostname,
+    port,
+    pathname: "/",
+  });
+}

packages/lambda/src/__tests__/integration.test.ts

@@ -0,0 +1,88 @@
+import url from "url";
+import type { IncomingMessage, ServerResponse } from "http";
+import type {
+  APIGatewayProxyEventV2,
+  APIGatewayProxyStructuredResultV2,
+  Context as LambdaContext,
+  Handler,
+} from "aws-lambda";
+
+// Returns a Node http handler that invokes a Lambda handler as if via
+// APIGatewayProxy with payload version 2.0.
+export function createMockServer(
+  handler: Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>,
+) {
+  return (req: IncomingMessage, res: ServerResponse) => {
+    let body = "";
+    req.on("data", (chunk) => (body += chunk));
+    // this is an unawaited async function, but anything that causes it to
+    // reject should cause a test to fail
+    req.on("end", async () => {
+      const event = eventFromRequest(req, body);
+      const result = (await handler(
+        event,
+        { functionName: "someFunc" } as LambdaContext, // we don't bother with all the fields
+        () => {
+          throw Error("we don't use callback");
+        },
+      )) as APIGatewayProxyStructuredResultV2;
+      res.statusCode = result.statusCode!;
+      Object.entries(result.headers ?? {}).forEach(([key, value]) => {
+        res.setHeader(key, value.toString());
+      });
+      res.write(result.body);
+      res.end();
+    });
+  };
+}
+
+// Create an APIGatewayProxy V2 event from a Node request. Note that
+// `@vendia/serverless-express` supports a bunch of different kinds of events
+// including gateway V1, but for now we're just testing with this one. Based on
+// https://github.com/vendia/serverless-express/blob/mainline/jest-helpers/api-gateway-v2-event.js
+function eventFromRequest(
+  req: IncomingMessage,
+  body: string,
+): APIGatewayProxyEventV2 {
+  const urlObject = url.parse(req.url || "", false);
+  return {
+    version: "2.0",
+    routeKey: "$default",
+    rawQueryString: urlObject.search?.replace(/^\?/, "") ?? "",
+    headers: Object.fromEntries(
+      Object.entries(req.headers).map(([name, value]) => {
+        if (Array.isArray(value)) {
+          return [name, value.join(",")];
+        } else {
+          return [name, value];
+        }
+      }),
+    ),
+    // as of now, @vendia/serverless-express's v2
+    // getRequestValuesFromApiGatewayEvent only looks at rawQueryString and
+    // not queryStringParameters; for the sake of tests this is good enough.
+    queryStringParameters: {},
+    requestContext: {
+      accountId: "347971939225",
+      apiId: "6bwvllq3t2",
+      domainName: "6bwvllq3t2.execute-api.us-east-1.amazonaws.com",
+      domainPrefix: "6bwvllq3t2",
+      http: {
+        method: req.method!,
+        path: req.url!,
+        protocol: "HTTP/1.1",
+        sourceIp: "203.123.103.37",
+        userAgent:
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
+      },
+      requestId: "YuSJQjZfoAMESbg=",
+      routeKey: "$default",
+      stage: "$default",
+      time: "06/Jan/2021:10:55:03 +0000",
+      timeEpoch: 1609930503973,
+    },
+    isBase64Encoded: false,
+    rawPath: urlObject.pathname!,
+    body,
+  };
+}

packages/lambda/src/__tests__/mockAPIGatewayServer.ts

@@ -1,5 +1,130 @@
-import { ApolloServer } from "@apollo/server";
+import type {
+  ApolloServer,
+  BaseContext,
+  ContextFunction,
+  HTTPGraphQLRequest,
+} from "@apollo/server";
+import type { WithRequired } from "@apollo/utils.withrequired";
+import type {
+  Handler,
+  Context,
+  APIGatewayProxyStructuredResultV2,
+  APIGatewayProxyEventV2,
+} from "aws-lambda";
+export interface LambdaContextFunctionArgument {
+  event: APIGatewayProxyEventV2;
+  context: Context;
+}
+
+export interface LambdaHandlerOptions<TContext extends BaseContext> {
+  context?: ContextFunction<[LambdaContextFunctionArgument], TContext>;
+}
+
+type LambdaHandler = Handler<
+  APIGatewayProxyEventV2,
+  APIGatewayProxyStructuredResultV2
+>;
+
+export function lambdaHandler(
+  server: ApolloServer<BaseContext>,
+  options?: LambdaHandlerOptions<BaseContext>,
+): LambdaHandler;
+export function lambdaHandler<TContext extends BaseContext>(
+  server: ApolloServer<TContext>,
+  options: WithRequired<LambdaHandlerOptions<TContext>, "context">,
+): LambdaHandler;
+export function lambdaHandler<TContext extends BaseContext>(
+  server: ApolloServer<TContext>,
+  options?: LambdaHandlerOptions<TContext>,
+): LambdaHandler {
+  server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
+
+  // This `any` is safe because the overload above shows that context can
+  // only be left out if you're using BaseContext as your context, and {} is a
+  // valid BaseContext.
+  const defaultContext: ContextFunction<
+    [LambdaContextFunctionArgument],
+    any
+  > = async () => ({});
+
+  const contextFunction: ContextFunction<
+    [LambdaContextFunctionArgument],
+    TContext
+  > = options?.context ?? defaultContext;
+
+  return async function (event, context) {
+    let parsedBody: object | string | undefined = undefined;
+    try {
+      if (!event.body) {
+        // assert there's a query string?
+      } else if (event.headers["content-type"] === "application/json") {
+        try {
+          parsedBody = JSON.parse(event.body);
+        } catch (e: unknown) {
+          return {
+            statusCode: 400,
+            body: (e as Error).message,
+          };
+        }
+      } else if (event.headers["content-type"] === "text/plain") {
+        parsedBody = event.body;
+      }
+    } catch (error: unknown) {
+      // The json body-parser *always* sets req.body to {} if it's unset (even
+      // if the Content-Type doesn't match), so if it isn't set, you probably
+      // forgot to set up body-parser. (Note that this may change in the future
+      // body-parser@2.)
+      // return {
+      //   statusCode: 500,
+      //   body:
+      //     '`event.body` is not set; this probably means you forgot to set up the ' +
+      //     '`body-parser` middleware before the Apollo Server middleware.',
+      // };
+      throw error;
+    }
+
+    const headers = new Map<string, string>();
+    for (const [key, value] of Object.entries(event.headers)) {
+      if (value !== undefined) {
+        // Node/Express headers can be an array or a single value. We join
+        // multi-valued headers with `, ` just like the Fetch API's `Headers`
+        // does. We assume that keys are already lower-cased (as per the Node
+        // docs on IncomingMessage.headers) and so we don't bother to lower-case
+        // them or combine across multiple keys that would lower-case to the
+        // same value.
+        headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+      }
+    }
+
+    const httpGraphQLRequest: HTTPGraphQLRequest = {
+      method: event.requestContext.http.method,
+      headers,
+      search: event.rawQueryString,
+      body: parsedBody,
+    };
+
+    try {
+      const httpGraphQLResponse = await server.executeHTTPGraphQLRequest({
+        httpGraphQLRequest,
+        context: () => contextFunction({ event, context }),
+      });
+
+      if (httpGraphQLResponse.completeBody === null) {
+        throw Error("Incremental delivery not implemented");
+      }
 
-export function lambdaHandler() {
-  new ApolloServer({ typeDefs: `type Query { hello: String! }` });
+      return {
+        statusCode: httpGraphQLResponse.statusCode || 200,
+        headers: {
+          ...Object.fromEntries(httpGraphQLResponse.headers),
+          "content-length": Buffer.byteLength(
+            httpGraphQLResponse.completeBody,
+          ).toString(),
+        },
+        body: httpGraphQLResponse.completeBody,
+      };
+    } catch (error) {
+      throw error;
+    }
+  };
 }