Apollo Server Integration for 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 v20 or later
- Fastify v5.3.0 or later
- GraphQL.js v16 or later
- Apollo Server v4 or later

Installation

``bash
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:

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

const fastify = Fastify();

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

await apollo.start();

// ...

await fastify.register(fastifyApollo(apollo));
`

Note: You must call and await apollo.start() before using the integration.

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 like the URL path and accepted methods.

Examples shown below:

`typescript
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: ["POST", "OPTIONS"],
handler: fastifyApolloHandler(apollo),
});
`

Please see the example.

Context

Apollo Server v4 has moved context setup outside of the ApolloServer constructor.

Define your own context function and pass it in to the context option. The function accepts two arguments - request and reply. They are of type FastifyRequest and FastifyReply respectively. Whatever is returned from the function will be passed to the context argument in your resolvers.

For example:

`typescript
import { ApolloServer } from "@apollo/server";

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

interface MyContext {
authorization: JWTPayload | false;
}

const apollo = new ApolloServer(...);

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

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

// OR

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

`ts
// Access the context in your resolvers
export const resolvers = {
Query: {
helloWorld: (parent, args, context, info) => {
if (!context.authorization) {
throw new Error("Not authorized");
}

return "Hello world :)";
},
},
};
`

API

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

$3

`typescript
function fastifyApollo(
apollo: ApolloServer,
): FastifyPluginAsync>;
`

$3

`typescript
function fastifyApolloHandler(
apollo: ApolloServer,
options?: ApolloFastifyHandlerOptions,
): RouteHandlerMethod;
`

$3

`typescript
type ApolloFastifyContextFunction = (
request: FastifyRequest,
reply: FastifyReply,
) => Promise;
`

$3

`typescript
interface ApolloFastifyHandlerOptions {
context?: ApolloFastifyContextFunction; // default: async () => ({})
}
`

$3

`typescript
interface ApolloFastifyPluginOptions
extends ApolloFastifyHandlerOptions {
path?: string; // default: "/graphql"
method?: HTTPMethod | HTTPMethod[]; // default: ["GET", "POST", "OPTIONS"]
}
`

HTTPMethod is exported from Fastify.

HTTPS/HTTP2

All functions and types optionally allow you to pass in or infer a Server` type from Fastify.

Contributors

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