Improve Fastify example (#6)

- Change plugin to be just a handler. Users get to install it where they
  want. Uses a simpler API.

- Add drain plugin.

- Fix build issue with exactOptionalPropertyTypes

- Put assertStarted in correct place.

- Decide that we did multiple header values correctly.

- Set search correctly when path is non-trivial.

- Upgrade integration suite to be more lax about certain errors; remove
  extra JSON-related code that was only there to make those tests pass.

Paired with @trevor-scheer.

Author: glasser

package-lock.json

@@ -28,7 +28,7 @@
     "packages/*"
   ],
   "devDependencies": {
-    "@apollo/server-integration-testsuite": "4.0.0-alpha.1",
+    "@apollo/server-integration-testsuite": "4.0.0-alpha.2",
     "@apollo/utils.withrequired": "1.0.0",
     "@jest/types": "28.1.3",
     "@types/aws-lambda": "8.10.101",

package.json

@@ -26,7 +26,7 @@
     "fastify-plugin": "^4.0.0"
   },
   "peerDependencies": {
-    "@apollo/server": "^4.0.0-alpha.1",
+    "@apollo/server": "^4.0.0-alpha.2",
     "fastify": "^4.3.0",
     "graphql": "^16.5.0"
   }

packages/fastify/package.json

@@ -3,23 +3,31 @@ import {
   CreateServerForIntegrationTestsOptions,
   defineIntegrationTestSuite,
 } from "@apollo/server-integration-testsuite";
-import { fastifyPlugin } from "..";
+import { fastifyDrainPlugin, fastifyHandler } from "..";
 import fastify from "fastify";
 
 describe("fastifyPlugin", () => {
   defineIntegrationTestSuite(async function (
     serverOptions: ApolloServerOptions<BaseContext>,
     testOptions?: CreateServerForIntegrationTestsOptions,
   ) {
+    const app = fastify();
+
     const server = new ApolloServer({
       ...serverOptions,
-      plugins: [...(serverOptions.plugins ?? [])],
+      plugins: [...(serverOptions.plugins ?? []), fastifyDrainPlugin(app)],
     });
 
-    const app = fastify();
-
     await server.start();
-    app.register(fastifyPlugin(server, testOptions));
+
+    app.route({
+      // Note: we register for HEAD mostly because the integration test suite
+      // ensures that our middleware appropriate rejects such requests. In your
+      // app, you would only want to register for GET and POST.
+      method: ["GET", "POST", "HEAD"],
+      url: "/",
+      handler: fastifyHandler(server, { context: testOptions?.context }),
+    });
 
     const url = await app.listen({ port: 0 });
 

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

@@ -1,132 +1,116 @@
 import type {
   ApolloServer,
+  ApolloServerPlugin,
   BaseContext,
   ContextFunction,
   HTTPGraphQLRequest,
 } from "@apollo/server";
 import type { WithRequired } from "@apollo/utils.withrequired";
 import type {
-  FastifyPluginCallback,
+  FastifyInstance,
   FastifyReply,
   FastifyRequest,
+  RouteHandlerMethod,
 } from "fastify";
-import type { PluginMetadata } from "fastify-plugin";
-import fp from "fastify-plugin";
-
-const pluginMetadata: PluginMetadata = {
-  fastify: "4.x",
-  name: "apollo-server-integration-fastify",
-};
+import { parse as urlParse } from "url";
 
 export interface FastifyContextFunctionArgument {
   request: FastifyRequest;
   reply: FastifyReply;
 }
 
-export interface LambdaHandlerOptions<TContext extends BaseContext> {
-  context?: ContextFunction<[FastifyContextFunctionArgument], TContext>;
-}
-
-export function fastifyPlugin(
-  server: ApolloServer<BaseContext>,
-  options?: LambdaHandlerOptions<BaseContext>,
-): FastifyPluginCallback;
-export function fastifyPlugin<TContext extends BaseContext>(
-  server: ApolloServer<TContext>,
-  options: WithRequired<LambdaHandlerOptions<TContext>, "context">,
-): FastifyPluginCallback;
-export function fastifyPlugin(
-  server: ApolloServer<BaseContext>,
-  options?: LambdaHandlerOptions<BaseContext>,
-) {
-  return fp(fastifyHandler(server, options), pluginMetadata);
+export interface FastifyHandlerOptions<TContext extends BaseContext> {
+  context?:
+    | ContextFunction<[FastifyContextFunctionArgument], TContext>
+    | undefined;
 }
 
-function fastifyHandler(
+export function fastifyHandler(
   server: ApolloServer<BaseContext>,
-  options?: LambdaHandlerOptions<BaseContext>,
-): FastifyPluginCallback;
-function fastifyHandler<TContext extends BaseContext>(
+  options?: FastifyHandlerOptions<BaseContext>,
+): RouteHandlerMethod;
+export function fastifyHandler<TContext extends BaseContext>(
   server: ApolloServer<TContext>,
-  options: WithRequired<LambdaHandlerOptions<TContext>, "context">,
-): FastifyPluginCallback;
-function fastifyHandler<TContext extends BaseContext>(
+  options: WithRequired<FastifyHandlerOptions<TContext>, "context">,
+): RouteHandlerMethod;
+export function fastifyHandler<TContext extends BaseContext>(
   server: ApolloServer<TContext>,
-  options?: LambdaHandlerOptions<TContext>,
-): FastifyPluginCallback {
-  return async (fastify) => {
-    server.assertStarted("fastifyHandler()");
-
-    // 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<
-      [FastifyContextFunctionArgument],
-      any
-    > = async () => ({});
+  options?: FastifyHandlerOptions<TContext>,
+): RouteHandlerMethod {
+  server.assertStarted("fastifyHandler()");
 
-    const contextFunction: ContextFunction<
-      [FastifyContextFunctionArgument],
-      TContext
-    > = options?.context ?? defaultContext;
+  // 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<
+    [FastifyContextFunctionArgument],
+    any
+  > = async () => ({});
 
-    fastify.removeContentTypeParser(["application/json"]);
-    fastify.addContentTypeParser(
-      "application/json",
-      { parseAs: "string" },
-      async (_request, body, _done) => {
-        try {
-          return JSON.parse(body as string);
-        } catch (err) {
-          if ((body as string).trim() === "") {
-            return {};
-          }
-          (err as any).statusCode = 400;
-          throw err;
-        }
-      },
-    );
-
-    // This is dumb but it gets the integration testsuite passing. We should
-    // maybe consider relaxing some of the tests in order to accommodate server
-    // frameworks that behave well or better than Apollo Server.
-    fastify.addContentTypeParser("*", (_, __, done) => {
-      done(null, null);
-    });
+  const contextFunction: ContextFunction<
+    [FastifyContextFunctionArgument],
+    TContext
+  > = options?.context ?? defaultContext;
 
-    fastify.addHook("preHandler", async (request, reply) => {
-      const headers = new Map<string, string>();
-      for (const [key, value] of Object.entries(request.headers)) {
-        // TODO: how does fastify handle duplicate headers?
-        if (value !== undefined) {
-          headers.set(key, Array.isArray(value) ? value.join(", ") : value);
-        }
+  return async (request, reply) => {
+    const headers = new Map<string, string>();
+    for (const [key, value] of Object.entries(request.headers)) {
+      if (value !== undefined) {
+        headers.set(key, Array.isArray(value) ? value.join(", ") : value);
       }
+    }
 
-      const httpGraphQLRequest: HTTPGraphQLRequest = {
-        method: request.method,
-        headers,
-        search:
-          typeof request.raw.url === "string"
-            ? request.raw.url.substring(1)
-            : "",
-        body: request.body,
-      };
+    const httpGraphQLRequest: HTTPGraphQLRequest = {
+      method: request.method,
+      headers,
+      search: urlParse(request.url).search ?? "",
+      body: request.body,
+    };
 
-      const httpGraphQLResponse = await server.executeHTTPGraphQLRequest({
-        httpGraphQLRequest,
-        context: () => contextFunction({ request, reply }),
-      });
+    const httpGraphQLResponse = await server.executeHTTPGraphQLRequest({
+      httpGraphQLRequest,
+      context: () => contextFunction({ request, reply }),
+    });
 
-      if (httpGraphQLResponse.completeBody === null) {
-        throw Error("Incremental delivery not implemented");
-      }
+    if (httpGraphQLResponse.completeBody === null) {
+      throw Error("Incremental delivery not implemented");
+    }
 
-      reply.code(httpGraphQLResponse.statusCode ?? 200);
-      reply.headers(Object.fromEntries(httpGraphQLResponse.headers));
-      reply.send(httpGraphQLResponse.completeBody);
+    reply.code(httpGraphQLResponse.statusCode ?? 200);
+    reply.headers(Object.fromEntries(httpGraphQLResponse.headers));
+    reply.send(httpGraphQLResponse.completeBody);
 
-      return reply;
-    });
+    return reply;
+  };
+}
+
+// Add this plugin to your ApolloServer to drain the server during shutdown.
+// This works best with Node 18.2.0 or newer; with that version, Fastify will
+// use the new server.closeIdleConnections() to close idle connections, and the
+// plugin will close any other connections 10 seconds later. (With older Node,
+// the drain phase will hang until all connections naturally close; you can also
+// call `fastify({forceCloseConnections: true})` to make all connections immediately
+// close without grace.)
+export function fastifyDrainPlugin<TContext extends BaseContext>(
+  app: FastifyInstance,
+): ApolloServerPlugin<TContext> {
+  return {
+    async serverWillStart() {
+      return {
+        async drainServer() {
+          let timeout;
+          if ("closeAllConnections" in app.server) {
+            timeout = setTimeout(
+              () => (app.server as any).closeAllConnections(),
+              10_000,
+            );
+          }
+          await app.close();
+          if (timeout) {
+            clearTimeout(timeout);
+          }
+        },
+      };
+    },
   };
 }