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.
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:
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));
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:
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:
import { ApolloServer } from "@apollo/server";
import fastifyApollo, {
fastifyApolloHandler,
ApolloFastifyContextFunction,
} from "@as-integrations/fastify";
// ...
interface MyContext {
authorization: JWTPayload | false;
}
const apollo = new ApolloServer<MyContext>(...);
const myContextFunction: ApolloFastifyContextFunction<MyContext> = 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,
}));
// 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.
fastifyApollo
function fastifyApollo<Context extends BaseContext = BaseContext>(
apollo: ApolloServer<Context>,
): FastifyPluginAsync<ApolloFastifyPluginOptions<Context>>;
fastifyApolloHandler
function fastifyApolloHandler<Context extends BaseContext = BaseContext>(
apollo: ApolloServer<Context>,
options?: ApolloFastifyHandlerOptions<Context>,
): RouteHandlerMethod;
ApolloFastifyContextFunction
type ApolloFastifyContextFunction<Context> = (
request: FastifyRequest,
reply: FastifyReply,
) => Promise<Context>;
ApolloFastifyHandlerOptions
interface ApolloFastifyHandlerOptions<Context extends BaseContext = BaseContext> {
context?: ApolloFastifyContextFunction<Context>; // default: async () => ({})
}
ApolloFastifyPluginOptions
interface ApolloFastifyPluginOptions<Context extends BaseContext = BaseContext>
extends ApolloFastifyHandlerOptions<Context> {
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.
Please pass in forceCloseConnections: true
to Fastify in combination with fastifyApolloDrainPlugin
to correctly shutdown you're server on close and not hang incoming requests.