An Apollo Server integration for use with Fastify
npm install @as-integrations/fastify

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.
- Node.js v20 or later
- Fastify v5.3.0 or later
- GraphQL.js v16 or later
- Apollo Server v4 or later
``bash`
npm install @as-integrations/fastify @apollo/server graphql fastify
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.
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
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 :)";
},
},
};
`
All options and generics are optional other than passing in the ApolloServer instance.
`typescript`
function fastifyApollo
apollo: ApolloServer
): FastifyPluginAsync
`typescript`
function fastifyApolloHandler
apollo: ApolloServer
options?: ApolloFastifyHandlerOptions
): RouteHandlerMethod;
`typescript`
type ApolloFastifyContextFunction
request: FastifyRequest,
reply: FastifyReply,
) => Promise
`typescript`
interface ApolloFastifyHandlerOptions
context?: ApolloFastifyContextFunction
}
`typescript`
interface ApolloFastifyPluginOptions
extends ApolloFastifyHandlerOptions
path?: string; // default: "/graphql"
method?: HTTPMethod | HTTPMethod[]; // default: ["GET", "POST", "OPTIONS"]
}
HTTPMethod is exported from Fastify.
All functions and types optionally allow you to pass in or infer a Server` type from Fastify.
- Oliver Plummer (olyop)
- Trevor Scheer (trevor-scheer)