Apollo Server Fastify

Introduction

An Apollo Server integration for use with Fastify.

This is a simple package that easily allows you to connect your own Fastify server implementation to an Apollo Server instance.

Requirements

• Node.js v14 or later
• Fastify v4 or later
• GraphQL.js v16 or later
• Apollo Server v4 or later

Installation

npm install @as-integrations/fastify @apollo/server graphql fastify

Usage

Setup Fastify & Apollo Server like you usually would and then connect the two by using the fastifyApollo plugin:

import Fastify from "fastify";
import { ApolloServer, BaseContext } from "@apollo/server";
import fastifyApollo, { fastifyApolloDrainPlugin } from "@as-integrations/fastify";
// ...

const fastify = Fastify();

const apollo = new ApolloServer<BaseContext>({
	typeDefs,
	resolvers,
	plugins: [fastifyApolloDrainPlugin(fastify)],
});

await apollo.start();

// ...

await fastify.register(fastifyApollo(apollo));

Alternatively you can use the exported function fastifyApolloHandler which can be passed into any Fastify route handler. This allows you to explicitly set all routing options, for example the URL path and accepted methods.

Examples shown below:

import { fastifyApolloHandler } from "@as-integrations/fastify";

// ... setup Fastify & Apollo

fastify.post("/graphql", fastifyApolloHandler(apollo));
// OR
fastify.get("/api", fastifyApolloHandler(apollo));
// OR
fastify.route({
	url: "/graphql",
	method: ["GET", "POST", "OPTIONS"],
	handler: fastifyApolloHandler(apollo),
});

Please see the example.

Context

Apollo Server 4 (AS4) has moved context setup outside of the ApolloServer constructor.

Define you're own context function and pass it in to the context option. For example:

import { ApolloServer } from "@apollo/server";
import fastifyApollo, {
	fastifyApolloHandler,
	ApolloFastifyContextFunction,
} from "@as-integrations/fastify";
// ...

interface MyContext {
	authorization: JWTPayload | false;
}

const apollo = new ApolloServer<MyContext>({ resolvers, typeDefs });

const myContextFunction: ApolloFastifyContextFunction<MyContext> = async request => ({
	authorization: await isAuthorized(request.headers.authorization),
});

await fastify.register(fastifyApollo(apollo), {
	context: myContextFunction,
});

// OR

await fastify.post(
	"/graphql",
	fastifyApolloHandler(apollo, {
		context: myContextFunction,
	}),
);

API

All options and generics are optional other than passing in the ApolloServer instance.

fastifyApollo

export default function fastifyApollo<Context extends BaseContext = BaseContext>(
	apollo: ApolloServer<Context>,
): FastifyPluginAsync<ApolloFastifyPluginOptions<Context>>;

fastifyApolloHandler

export function fastifyApolloHandler<Context extends BaseContext = BaseContext>(
	apollo: ApolloServer<Context>,
	options?: ApolloFastifyHandlerOptions<Context>,
): RouteHandlerMethod;

ApolloFastifyContextFunction

export type ApolloFastifyContextFunction<Context> = (
	request: FastifyRequest,
	reply: FastifyReply,
) => Promise<Context>;

ApolloFastifyPluginOptions:

• path
  • type: string | undefined
  • default: "/graphql"
• method
  • type: HTTPMethod | HTTPMethod[]
  • default: ["GET", "POST", "OPTIONS"]
• context
  • type: ApolloFastifyContextFunction
  • default: async () => ({})

HTTPMethod is exported from Fastify.

ApolloFastifyHandlerOptions:

• context
  • type: ApolloFastifyContextFunction
  • default: async () => ({})

HTTPS/HTTP2

All functions and types optionally allow you to pass in a Server type to Fastify (the default is http.Server).

Node.JS v14

Please pass in forceConnections: true to Fastify to correctly shutdown you're server on close and not hang incoming requests.

Contributors

• Oliver Plummer (olyop)
• Trevor Scheer (trevor-scheer)