@oly_op/apollo-server-fastify NPM

Apollo Server Fastify

Introduction

A community-maintained package for connecting Fastify to Apollo GraphQL server.

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 @oly_op/apollo-server-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 "@oly_op/apollo-server-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 "@oly_op/apollo-server-fastify"

// ... setup Fastify & Apollo

fastify.post("/graphql", fastifyApolloHandler(apollo))

fastify.get("/api", fastifyApolloHandler(apollo))

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 "@oly_op/apollo-server-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 () => ({})