[](https://www.npmjs.com/package/@as-integrations/fastify)
[](https://www.npmjs.com/package/@as-integrations/fastify)
# 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](https://nodejs.org/)** or later
- **[Fastify v5.3.0](https://www.fastify.io/)** or later
- **[GraphQL.js v16](https://graphql.org/graphql-js/)** or later
- **[Apollo Server v4](https://www.apollographql.com/docs/apollo-server/)** or later
## **Installation**
```bash
npm install @as-integrations/fastify @apollo/server graphql fastify
```
## **Usage**
Setup [Fastify](https://www.fastify.io/) & [Apollo Server](https://www.apollographql.com/docs/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](https://www.fastify.io/docs/latest/Reference/Routes/).
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](https://github.com/apollo-server-integrations/apollo-server-integration-fastify/tree/main/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.
### `fastifyApollo`
```typescript
function fastifyApollo(
apollo: ApolloServer,
): FastifyPluginAsync>;
```
### `fastifyApolloHandler`
```typescript
function fastifyApolloHandler(
apollo: ApolloServer,
options?: ApolloFastifyHandlerOptions,
): RouteHandlerMethod;
```
### `ApolloFastifyContextFunction`
```typescript
type ApolloFastifyContextFunction = (
request: FastifyRequest,
reply: FastifyReply,
) => Promise;
```
### `ApolloFastifyHandlerOptions`
```typescript
interface ApolloFastifyHandlerOptions {
context?: ApolloFastifyContextFunction; // default: async () => ({})
}
```
### `ApolloFastifyPluginOptions`
```typescript
interface ApolloFastifyPluginOptions
extends ApolloFastifyHandlerOptions {
path?: string; // default: "/graphql"
method?: HTTPMethod | HTTPMethod[]; // default: ["GET", "POST", "OPTIONS"]
}
```
[`HTTPMethod`](https://www.fastify.io/docs/latest/Reference/TypeScript/#fastifyhttpmethods) 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](https://github.com/olyop))
- Trevor Scheer ([trevor-scheer](https://github.com/trevor-scheer))