Building a GraphQL server with NestJS

This chapter follows Resolvers and execution.

NestJS organizes server code into modules, providers, and decorators. @nestjs/graphql with the Apollo driver generates SDL from TypeScript classes—a code-first workflow. The same resolver ideas apply in Apollo Server or GraphQL Yoga; Nest adds structure and dependency injection.

Install dependencies

From an existing Nest project:

1
pnpm add @nestjs/graphql @nestjs/apollo @apollo/server graphql
2
pnpm add graphql-ws ws subscriptions-transport-ws
3
pnpm add -D @types/ws

Match major versions to your Nest release; @nestjs/graphql 14 targets current Apollo Server integrations.

Register GraphQLModule

Import GraphQLModule in AppModule:

1
import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";
2
import { Module } from "@nestjs/common";
3
import { GraphQLModule } from "@nestjs/graphql";
4
import { join } from "node:path";
5

6
@Module({
7
  imports: [
8
    GraphQLModule.forRoot<ApolloDriverConfig>({
9
      driver: ApolloDriver,
10
      autoSchemaFile: join(process.cwd(), "schema.gql"),
11
      sortSchema: true,
12
      playground: process.env.NODE_ENV !== "production",
13
      subscriptions: {
14
        "graphql-ws": true,
15
      },
16
      context: ({ req }) => ({ req, userId: req.headers["x-user-id"] ?? null }),
17
    }),
18
  ],
19
})
20
export class AppModule {}

autoSchemaFile writes SDL for reviews and codegen. Disable playground in production.

Define object and input types

1
import { Field, ID, ObjectType } from "@nestjs/graphql";
2

3
@ObjectType()
4
export class Book {
5
  @Field(() => ID)
6
  id!: string;
7

8
  @Field()
9
  title!: string;
10
}

1
import { Field, InputType } from "@nestjs/graphql";
2

3
@InputType()
4
export class CreateBookInput {
5
  @Field()
6
  title!: string;
7
}

Generated SDL mirrors these definitions for clients and tools.

Queries, mutations, and field resolvers

1
import { Args, Mutation, Query, Resolver, ResolveField, Parent } from "@nestjs/graphql";
2
import { BooksService } from "./books.service";
3
import { Book } from "./dto/book.model";
4
import { CreateBookInput } from "./dto/create-book.input";
5

6
@Resolver(() => Book)
7
export class BooksResolver {
8
  constructor(private readonly books: BooksService) {}
9

10
  @Query(() => [Book])
11
  books() {
12
    return this.books.findAll();
13
  }
14

15
  @Mutation(() => Book)
16
  createBook(@Args("input") input: CreateBookInput) {
17
    return this.books.create(input);
18
  }
19

20
  @ResolveField(() => String)
21
  slug(@Parent() book: Book) {
22
    return book.title.toLowerCase().replace(/\s+/g, "-");
23
  }
24
}

Validation with class-validator

Enable a global validation pipe and decorate inputs:

1
import { ValidationPipe } from "@nestjs/common";
2

3
async function bootstrap() {
4
  const app = await NestFactory.create(AppModule);
5
  app.useGlobalPipes(new ValidationPipe({ whitelist: true }));
6
  await app.listen(3000);
7
}

1
import { Length } from "class-validator";
2

3
@InputType()
4
export class CreateBookInput {
5
  @Field()
6
  @Length(1, 200)
7
  title!: string;
8
}

GraphQL validates types first; class-validator enforces domain constraints before resolvers run.

Request-scoped DataLoader

Provide a loader factory per request to batch relations:

1
import { Injectable, Scope } from "@nestjs/common";
2
import DataLoader from "dataloader";
3
import { AuthorsService } from "./authors.service";
4

5
@Injectable({ scope: Scope.REQUEST })
6
export class AuthorsLoader {
7
  readonly byId: DataLoader<string, Author>;
8

9
  constructor(authors: AuthorsService) {
10
    this.byId = new DataLoader((ids) => authors.findByIds([...ids]));
11
  }
12
}

Inject AuthorsLoader in a @ResolveField() for Book.author.

Subscriptions

Publish events from a service with @nestjs/graphql PubSub or an Redis-backed pub/sub for multi-instance deployments. Define a subscription resolver:

1
import { Subscription } from "@nestjs/graphql";
2

3
@Subscription(() => Book, { filter: (payload, vars) => payload.bookAdded.id === vars.id })
4
bookAdded() {
5
  return this.pubSub.asyncIterableIterator("bookAdded");
6
}

Clients connect with graphql-ws and the same auth headers or connection params you document in the security chapter.

Next: Schema design in GraphQL.