GraphQL: Code-First & Schema-First

# Express and Apollo (default)
npm i @nestjs/graphql @nestjs/apollo @apollo/server @as-integrations/express5 graphql

# Fastify and Apollo
npm i @nestjs/graphql @nestjs/apollo @apollo/server @as-integrations/fastify graphql

# Fastify and Mercurius
npm i @nestjs/graphql @nestjs/mercurius graphql mercurius

Missing "driver" option. In the latest version of "@nestjs/graphql" package (v10) a new required
configuration property called "driver" has been introduced. ...

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';

@Module({
  imports: [
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
      autoSchemaFile: true, // or typePaths for schema first, see below
    }),
  ],
})
export class AppModule {}

// default: ["Query.profile"]
// fieldResolverEnhancers: ['guards']: ["Query.profile","Profile.badge"]
GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  autoSchemaFile: true,
  fieldResolverEnhancers: ['guards'],
});

// 1. write the SDL to disk (committed to the repository, useful for review and codegen)
GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
});

// 2. in memory only
GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  autoSchemaFile: true,
});

// 3. sort the types, fields and arguments lexicographically (stable diffs of the SDL file)
GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
  sortSchema: true,
});

directive @upper on FIELD_DEFINITION

scalar Date

enum BookStatus {
  DRAFT
  PUBLISHED
  OUT_OF_PRINT
}

interface Node {
  id: ID!
}

type Author implements Node {
  id: ID!
  name: String!
  books: [Book!]!
}

type Book implements Node {
  id: ID!
  title: String! @upper
  status: BookStatus!
  publishedAt: Date!
  author: Author!
}

union SearchResult = Author | Book

input CreateBookInput {
  title: String!
  authorId: ID!
}

type Query {
  books(status: BookStatus, limit: Int = 10): [Book!]!
  book(id: ID!): Book
  search(term: String!): [SearchResult!]!
}

type Mutation {
  createBook(input: CreateBookInput!): Book!
}

GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  typePaths: ['./**/*.graphql'],
  definitions: {
    path: join(process.cwd(), 'src/graphql.ts'),
    outputAs: 'class', // interfaces are the default
  },
});

import { GraphQLDefinitionsFactory } from '@nestjs/graphql';
import { join } from 'node:path';

const definitionsFactory = new GraphQLDefinitionsFactory();
await definitionsFactory.generate({
  typePaths: ['./src/graphql-schema-first/*.graphql'],
  path: join(process.cwd(), 'src/graphql-schema-first/graphql.ts'),
  outputAs: 'class',
  emitTypenameField: true,
  defaultScalarType: 'unknown',
  customScalarTypeMapping: { Date: 'Date' },
});

export enum BookStatus {
    DRAFT = "DRAFT",
    PUBLISHED = "PUBLISHED",
    OUT_OF_PRINT = "OUT_OF_PRINT"
}

export class CreateBookInput {
    title: string;
    authorId: string;
}

export interface Node {
    id: string;
}

export class Book implements Node {
    __typename?: 'Book';
    id: string;
    title: string;
    status: BookStatus;
    publishedAt: Date;
    author: Author;
}

export abstract class IQuery {
    __typename?: 'IQuery';

    abstract books(status?: Nullable<BookStatus>, limit?: Nullable<number>): Book[] | Promise<Book[]>;

    abstract book(id: string): Nullable<Book> | Promise<Nullable<Book>>;

    abstract search(term: string): SearchResult[] | Promise<SearchResult[]>;
}

export type SearchResult = Author | Book;
type Nullable<T> = T | null;

import { Directive, Extensions, Field, Int, ObjectType } from '@nestjs/graphql';
import { GraphQLISBN } from 'graphql-scalars';
import { Author } from './author.model.js';
import { BookStatus } from './book-status.enum.js';
import { checkRoleMiddleware } from '../check-role.middleware.js';
import { Node } from './node.interface.js';

@ObjectType({ implements: () => [Node] })
export class Book implements Node {
  id: string;

  @Directive('@upper')
  @Field({ description: 'Title as printed on the cover.' })
  title: string;

  @Field(() => GraphQLISBN, { nullable: true })
  isbn?: string;

  @Field(() => Int, { nullable: true })
  pages?: number;

  @Field(() => BookStatus)
  status: BookStatus;

  @Field()
  publishedAt: Date;

  @Extensions({ role: 'editor' })
  @Field({ nullable: true, description: 'Editorial notes, editors only.', middleware: [checkRoleMiddleware] })
  internalNotes?: string;

  // not a @Field(): the BooksResolver resolves it with @ResolveField()
  authorId: string;

  // resolved by BooksResolver; the type only exists for TypeScript
  author?: Author;
}

import { Field, ObjectType } from '@nestjs/graphql';
import { Book } from './book.model.js';
import { Node } from './node.interface.js';

@ObjectType({ implements: () => [Node], description: 'Someone who wrote at least one book.' })
export class Author implements Node {
  id: string;

  @Field()
  name: string;

  @Field(() => [Book])
  books: Book[];
}

import { Args, Context, ID, Int, Mutation, Parent, Query, ResolveField, Resolver } from '@nestjs/graphql';
import { NotFoundException } from '@nestjs/common';
import { BooksArgs } from './dto/books.args.js';
import { CreateBookInput } from './dto/create-book.input.js';
import { UpdateBookInput } from './dto/update-book.input.js';
import type { GqlContext } from './loaders.js';
import { Author } from './models/author.model.js';
import { Book } from './models/book.model.js';
import { SearchResult } from './models/search-result.union.js';
import { BookshelfStore } from './store.js';

@Resolver(() => Book)
export class BooksResolver {
  constructor(private readonly store: BookshelfStore) {}

  @Query(() => [Book], { description: 'A page of books, newest catalogue order.' })
  books(@Args() args: BooksArgs): Book[] {
    return this.store.findBooks(args.offset, args.limit, args.status, args.titleContains);
  }

  @Query(() => Book, { name: 'book', nullable: true })
  getBook(@Args('id', { type: () => ID }) id: string): Book | undefined {
    return this.store.findBook(id);
  }

  @Query(() => [SearchResult])
  search(@Args('term') term: string): Array<typeof SearchResult> {
    const needle = term.toLowerCase();
    const books = this.store.books.filter((b) => b.title.toLowerCase().includes(needle));
    const authors = this.store.authors.filter((a) => a.name.toLowerCase().includes(needle));
    return [...books, ...authors];
  }

  @Mutation(() => Book)
  createBook(@Args('input') input: CreateBookInput): Book {
    return this.store.create(input);
  }

  @Mutation(() => Book)
  updateBook(@Args('id', { type: () => ID }) id: string, @Args('input') input: UpdateBookInput): Book {
    const updated = this.store.update(id, input);
    if (!updated) throw new NotFoundException(`Book ${id} does not exist`);
    return updated;
  }

  @ResolveField(() => Author)
  author(@Parent() book: Book, @Context() ctx: GqlContext): Promise<Author | undefined> {
    return ctx.loaders.authorById.load(book.authorId);
  }

  @ResolveField(() => Int, { description: 'How many years ago the book came out.' })
  ageInYears(@Parent() book: Book): number {
    return new Date('2026-10-02T00:00:00Z').getUTCFullYear() - book.publishedAt.getUTCFullYear();
  }
}

import { Args, ID, Query, ResolveField, Resolver, Parent } from '@nestjs/graphql';
import { Author } from './models/author.model.js';
import { Book } from './models/book.model.js';
import { BookshelfStore } from './store.js';

@Resolver(() => Author)
export class AuthorsResolver {
  constructor(private readonly store: BookshelfStore) {}

  @Query(() => Author, { nullable: true })
  author(@Args('id', { type: () => ID }) id: string): Author | undefined {
    return this.store.findAuthor(id);
  }

  @ResolveField(() => [Book])
  books(@Parent() author: Author): Book[] {
    return this.store.booksOf(author.id);
  }
}

@Module({
  providers: [BookshelfStore, BooksResolver, AuthorsResolver, { provide: APP_PIPE, useValue: new ValidationPipe({ transform: true }) }],
  exports: [BookshelfStore],
})
export class BookshelfModule {}

@Module({
  imports: [
    BookshelfModule,
    GraphQLModule.forRootAsync<ApolloDriverConfig>({
      driver: ApolloDriver,
      imports: [BookshelfModule],
      inject: [BookshelfStore],
      useFactory: (store: BookshelfStore) => ({
        autoSchemaFile: true, // build the schema in memory; pass a path to also write it to disk
        sortSchema: true,
        // one set of DataLoaders per request, next to the Express request object
        context: ({ req }: { req: unknown }) => ({ req, loaders: createLoaders(store) }),
        transformSchema: (schema) => upperDirectiveTransformer(schema, 'upper'),
        buildSchemaOptions: {
          directives: [new GraphQLDirective({ name: 'upper', locations: [DirectiveLocation.FIELD_DEFINITION] })],
        },
      }),
    }),
  ],
})
export class AppModule {}

@InputType()
export class CreateBookInput {
  @Length(3, 120)
  @Field()
  title: string;

  @Field(() => ID)
  authorId: string;

  @Min(1)
  @IsOptional()
  @Field(() => Int, { nullable: true })
  pages?: number;
}

import { InputType, OmitType, PartialType } from '@nestjs/graphql';
import { CreateBookInput } from './create-book.input.js';

@InputType()
export class UpdateBookInput extends PartialType(OmitType(CreateBookInput, ['authorId'] as const)) {}

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"mutation { updateBook(id: \"b5\", input: { authorId: \"a2\" }) { id } }"}'

{"errors":[{"message":"Field \"authorId\" is not defined by type \"UpdateBookInput\".","locations":[{"line":1,"column":42}],"extensions":{"code":"GRAPHQL_VALIDATION_FAILED"}}]}

import { registerEnumType } from '@nestjs/graphql';

export enum BookStatus {
  DRAFT = 'DRAFT',
  PUBLISHED = 'PUBLISHED',
  OUT_OF_PRINT = 'OUT_OF_PRINT',
}

registerEnumType(BookStatus, {
  name: 'BookStatus',
  description: 'Where a book is in its life cycle.',
  valuesMap: {
    DRAFT: { description: 'Not visible to readers yet.' },
    OUT_OF_PRINT: { deprecationReason: 'Use a status filter on the catalogue instead.' },
  },
});

{"data":{"__type":{"enumValues":[{"name":"DRAFT","description":"Not visible to readers yet.","deprecationReason":null},{"name":"OUT_OF_PRINT","description":null,"deprecationReason":"Use a status filter on the catalogue instead."},{"name":"PUBLISHED","description":null,"deprecationReason":null}]}}}

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"query($s: BookStatus) { books(status: $s) { id } }","variables":{"s":"DRAFT"}}'

{"data":{"books":[{"id":"b3"}]}}

import { Field, ID, InterfaceType } from '@nestjs/graphql';

@InterfaceType()
export abstract class Node {
  @Field(() => ID)
  id: string;
}

@InterfaceType({
  resolveType(book: { colors?: string[] }) {
    return book.colors ? ColoringBook : TextBook;
  },
})
export abstract class Edition {
  @Field(() => ID)
  id: string;

  @Field()
  title: string;
}

@ObjectType({ implements: () => [Edition] })
export class TextBook implements Edition {
  id: string;
  title: string;
}

@ObjectType({ implements: () => [Edition] })
export class ColoringBook implements Edition {
  id: string;
  title: string;

  @Field(() => [String])
  colors: string[];
}

@Resolver(() => Edition)
export class EditionInterfaceResolver {
  @ResolveField(() => [Edition])
  related(
    @Parent() edition: Edition,
    @Info() info: { parentType: { name: string } },
    @Args('search', { type: () => String }) term: string,
  ) {
    return [{ id: 'x1', title: `${term} (related to ${edition.id}, seen as ${info.parentType.name})` }];
  }
}

GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  autoSchemaFile: true,
  inheritResolversFromInterfaces: true, // required for the interface resolver
});

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"{ editions { __typename id title related(search: \"x\") { title } } }"}'

{"data":{"editions":[{"__typename":"TextBook","id":"e1","title":"Plain text","related":[{"title":"x (related to e1, seen as TextBook)"}]},{"__typename":"ColoringBook","id":"e2","title":"Colour me","related":[{"title":"x (related to e2, seen as ColoringBook)"}]}]}}

import { createUnionType } from '@nestjs/graphql';
import { Author } from './author.model.js';
import { Book } from './book.model.js';

export const SearchResult = createUnionType({
  name: 'SearchResult',
  types: () => [Book, Author] as const,
});

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"{ search(term: \"a\") { __typename ... on Book { title } ... on Author { name } } }"}'

{"data":{"search":[{"__typename":"Book","title":"GRAPHS IN PRACTICE"},{"__typename":"Book","title":"TYPED APIS"},{"__typename":"Book","title":"SCHEMAS FIRST"},{"__typename":"Author","name":"Ada Park"},{"__typename":"Author","name":"Grace Lindqvist"},{"__typename":"Author","name":"Linus Okafor"}]}}

{"errors":[{"message":"Return type for \"Work\" cannot be resolved. If you did not pass a custom implementation (the \"resolveType\" function), you must return an instance of a class instead of a plain JavaScript object.","locations":[{"line":1,"column":3}],"path":["works",0],"extensions":{"code":"INTERNAL_SERVER_ERROR"}}],"data":null}

export const Hit = createUnionType({
  name: 'Hit',
  types: () => [TextBook, ColoringBook] as const,
  resolveType(value) {
    return 'colors' in value ? ColoringBook : TextBook;
  },
});

@Scalar('Date', () => Date)
export class DateScalar implements CustomScalar<number, Date> {
  description = 'Date custom scalar type';

  parseValue(value: unknown): Date {
    return new Date(value as number); // value from the client (variables)
  }

  serialize(value: unknown): number {
    return (value as Date).getTime(); // value sent to the client
  }

  parseLiteral(ast: ValueNode): Date | null {
    return ast.kind === Kind.INT ? new Date(parseInt(ast.value, 10)) : null;
  }
}

@Module({ providers: [EventsResolver, DateScalar] })
export class ScalarsOverrideModule {}

const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
function validate(uuid: unknown): string | never {
  if (typeof uuid !== 'string' || !regex.test(uuid)) {
    throw new Error('invalid uuid');
  }
  return uuid;
}
export const CustomUuidScalar = new GraphQLScalarType({
  name: 'UUID',
  description: 'A simple UUID parser',
  serialize: (value) => validate(value),
  parseValue: (value) => validate(value),
  parseLiteral: (ast) => validate(ast.kind === Kind.STRING ? ast.value : undefined),
});

@ObjectType()
export class Event {
  @Field(() => CustomUuidScalar)
  id: string;

  @Field()
  at: Date;

  @Field(() => GraphQLJSON)
  meta: Record<string, unknown>;

  @Field()
  ratio: number;

  @Field(() => Int)
  count: number;
}

import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils';
import { defaultFieldResolver, type GraphQLSchema } from 'graphql';

export function upperDirectiveTransformer(schema: GraphQLSchema, directiveName: string): GraphQLSchema {
  return mapSchema(schema, {
    [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
      const upperDirective = getDirective(schema, fieldConfig, directiveName)?.[0];
      if (upperDirective) {
        const { resolve = defaultFieldResolver } = fieldConfig;
        // replace the resolver with one that calls the original, then upper-cases a string result
        fieldConfig.resolve = async function (source, args, context, info) {
          const result = await resolve(source, args, context, info);
          return typeof result === 'string' ? result.toUpperCase() : result;
        };
        return fieldConfig;
      }
      return undefined;
    },
  });
}

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"{ book(id: \"b1\") { title } }"}'

{"data":{"book":{"title":"GRAPHS IN PRACTICE"}}}

import { ForbiddenException } from '@nestjs/common';
import type { FieldMiddleware, MiddlewareContext, NextFn } from '@nestjs/graphql';

export const checkRoleMiddleware: FieldMiddleware = async (ctx: MiddlewareContext, next: NextFn) => {
  const info = ctx.info!;
  const { extensions } = info.parentType.getFields()[info.fieldName];
  const header = (ctx.context as { req?: { headers: Record<string, string> } }).req?.headers['x-role'];
  if (header !== extensions.role) {
    throw new ForbiddenException(`Missing role "${String(extensions.role)}" for field "${info.fieldName}".`);
  }
  return next();
};

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"{ book(id: \"b1\") { internalNotes } }"}'

{"errors":[{"message":"Missing role \"editor\" for field \"internalNotes\".","locations":[{"line":1,"column":20}],"path":["book","internalNotes"],"extensions":{"code":"FORBIDDEN","originalError":{"message":"Missing role \"editor\" for field \"internalNotes\".","error":"Forbidden","statusCode":403}}}],"data":{"book":{"internalNotes":null}}}

export function Paginated<T>(classRef: Type<T>): Type<IPaginatedType<T>> {
  @ObjectType(`${classRef.name}Edge`)
  abstract class EdgeType {
    @Field(() => String)
    cursor: string;

    @Field(() => classRef)
    node: T;
  }

  @ObjectType({ isAbstract: true })
  abstract class PaginatedType implements IPaginatedType<T> {
    @Field(() => [EdgeType], { nullable: true })
    edges: EdgeType[];

    @Field(() => [classRef], { nullable: true })
    nodes: T[];

    @Field(() => Int)
    totalCount: number;

    @Field()
    hasNextPage: boolean;
  }
  return PaginatedType as Type<IPaginatedType<T>>;
}

@ObjectType()
export class PaginatedShelf extends Paginated(Shelf) {}

function BaseResolver<T extends Type<unknown>>(classRef: T): Type<FindAll<InstanceType<T>>> {
  @Resolver({ isAbstract: true })
  abstract class BaseResolverHost {
    @Query(() => [classRef], { name: `findAll${classRef.name}` })
    async findAll(): Promise<InstanceType<T>[]> {
      return [];
    }
  }
  return BaseResolverHost as Type<FindAll<InstanceType<T>>>;
}

@Resolver(() => Shelf)
export class ShelvesResolver extends BaseResolver(Shelf) { /* ... */ }

type PaginatedShelf {
  edges: [ShelfEdge!]
  hasNextPage: Boolean!
  nodes: [Shelf!]
  totalCount: Int!
}

type Query {
  findAllShelf: [Shelf!]!
  shelfPage: PaginatedShelf!
  warrior: Warrior!
}

type ShelfEdge {
  cursor: String!
  node: Shelf!
}

{"data":{"findAllShelf":[],"shelfPage":{"totalCount":1,"edges":[{"cursor":"c1","node":{"label":"new arrivals"}}]}}}

@Resolver('Book')
export class BooksResolver {
  constructor(private readonly store: BookshelfStore) {}

  @Query()
  books(@Args('status') status?: InternalStatus, @Args('limit') limit = 10) {
    return this.store.books.filter((b) => !status || b.status === status).slice(0, limit);
  }

  @Query('book')
  getBook(@Args('id') id: string) {
    return this.store.books.find((b) => b.id === id) ?? null;
  }

  @Query()
  search(@Args('term') term: string) {
    const needle = term.toLowerCase();
    return [
      ...this.store.books.filter((b) => b.title.toLowerCase().includes(needle)).map((b) => ({ ...b, __kind: 'Book' })),
      ...this.store.authors.filter((a) => a.name.toLowerCase().includes(needle)).map((a) => ({ ...a, __kind: 'Author' })),
    ];
  }

  @Mutation()
  createBook(@Args('input') input: CreateBookInput) {
    return this.store.create(input);
  }

  @ResolveField('author')
  author(@Parent() book: { authorId: string }, @Context() ctx: Ctx) {
    return ctx.authorLoader.load(book.authorId);
  }
}

// unions and interfaces need __resolveType in schema first: it returns the *name* of the concrete type
@Resolver('SearchResult')
export class SearchResultResolver {
  @ResolveField()
  __resolveType(value: { __kind: string }) {
    return value.__kind;
  }
}

GraphQLModule.forRootAsync<ApolloDriverConfig>({
  driver: ApolloDriver,
  imports: [BookshelfModule],
  inject: [BookshelfStore],
  useFactory: (store: BookshelfStore) => ({
    typePaths: ['./src/graphql-schema-first/*.graphql'],
    // internal values for an enum: the API says OUT_OF_PRINT, resolvers see "out-of-print"
    resolvers: { BookStatus: { OUT_OF_PRINT: 'out-of-print' } },
    transformSchema: (schema) => upperDirectiveTransformer(schema, 'upper'),
    context: () => ({ authorLoader: store.authorLoader() }),
  }),
}),

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"{ books(status: OUT_OF_PRINT) { id status } }"}'

{"data":{"books":[{"id":"b2","status":"OUT_OF_PRINT"}]}}

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"mutation { createBook(input: { title: \"SDL first\", authorId: \"a1\" }) { id title status } }"}'

{"data":{"createBook":{"id":"b3","title":"SDL FIRST","status":"DRAFT"}}}

GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  context: ({ req, res }) => ({ req, res }),
}),

// in a resolver
@Query(() => String)
userAgent(@Context('req') req: Request): string {
  return req.headers['user-agent'] ?? '';
}

GraphQLModule.forRootAsync<ApolloDriverConfig>({
  driver: ApolloDriver,
  inject: [ConfigService],
  useFactory: (config: ConfigService) => ({
    autoSchemaFile: true,
    graphiql: config.get<string>('GRAPHQL_IDE') === 'on',
    introspection: config.get<string>('GRAPHQL_INTROSPECTION', 'on') === 'on',
  }),
}),

GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  graphiql: {
    url: '/graphql',
    headers: {
      authorization: 'Bearer <token>', // placeholder: never put a real token in source
    },
    shouldPersistHeaders: true,
    isHeadersEditorEnabled: true,
    inputValueDeprecation: false,
  },
}),

import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';

GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  graphiql: false,
  plugins: [ApolloServerPluginLandingPageLocalDefault()],
}),

import { NestFactory } from '@nestjs/core';
import { GraphQLSchemaBuilderModule, GraphQLSchemaFactory } from '@nestjs/graphql';
import { printSchema } from 'graphql';
import { AuthorsResolver } from './authors.resolver.js';
import { BooksResolver } from './books.resolver.js';

/** Print the SDL without starting the server, a database or any resolver dependency. */
export async function generateSchema(): Promise<string> {
  const app = await NestFactory.create(GraphQLSchemaBuilderModule, { logger: false });
  await app.init();

  const gqlSchemaFactory = app.get(GraphQLSchemaFactory);
  const schema = await gqlSchemaFactory.create([BooksResolver, AuthorsResolver]);
  await app.close();
  return printSchema(schema);
}

const { schema } = app.get(GraphQLSchemaHost);
const result = await graphql({ schema, source: '{ __type(name: "BookStatus") { name } }' });
console.log(printSchema(schema));

directive @upper on FIELD_DEFINITION

"""Someone who wrote at least one book."""
type Author implements Node {
  books: [Book!]!
  id: ID!
  name: String!
}

type Book implements Node {
  """How many years ago the book came out."""
  ageInYears: Int!
  author: Author!
  id: ID!

  """Editorial notes, editors only."""
  internalNotes: String
  isbn: ISBN
  pages: Int
  publishedAt: DateTime!
  status: BookStatus!

  """Title as printed on the cover."""
  title: String!
}

"""Where a book is in its life cycle."""
enum BookStatus {
  """Not visible to readers yet."""
  DRAFT
  OUT_OF_PRINT @deprecated(reason: "Use a status filter on the catalogue instead.")
  PUBLISHED
}

input CreateBookInput {
  authorId: ID!
  pages: Int
  title: String!
}

type Mutation {
  createBook(input: CreateBookInput!): Book!
  updateBook(id: ID!, input: UpdateBookInput!): Book!
}

interface Node {
  id: ID!
}

type Query {
  author(id: ID!): Author

  book(id: ID!): Book

  """A page of books, newest catalogue order."""
  books(limit: Int! = 10, offset: Int! = 0, status: BookStatus, titleContains: String! = ""): [Book!]!

  search(term: String!): [SearchResult!]!
}

union SearchResult = Author | Book

input UpdateBookInput {
  pages: Int
  title: String
}

import DataLoader from 'dataloader';
import { BookshelfStore } from './store.js';
import { Author } from './models/author.model.js';

export interface GqlContext {
  loaders: { authorById: DataLoader<string, Author | undefined> };
  req?: { headers: Record<string, string | string[] | undefined> };
}

/** One set of loaders per GraphQL request: batching and the cache must never outlive a request. */
export function createLoaders(store: BookshelfStore): GqlContext['loaders'] {
  return {
    authorById: new DataLoader<string, Author | undefined>(async (ids) => store.findAuthorsByIds(ids)),
  };
}

curl -s localhost:3000/graphql -H 'content-type: application/json' \
  -d '{"query":"{ books { title author { name } } }"}'

{"data":{"books":[{"title":"GRAPHS IN PRACTICE","author":{"name":"Ada Park"}},{"title":"TYPED APIS","author":{"name":"Ada Park"}},{"title":"SCHEMAS FIRST","author":{"name":"Grace Lindqvist"}},{"title":"OLD RESOLVERS","author":{"name":"Linus Okafor"}}]}}

{
  "$schema": "https://json.schemastore.org/nest-cli",
  "collection": "@nestjs/schematics",
  "sourceRoot": "src",
  "compilerOptions": {
    "deleteOutDir": true,
    "plugins": [
      { "name": "@nestjs/graphql", "options": { "introspectComments": true, "esmCompatible": true } }
    ]
  }
}

/** A book in the catalogue. */
@ObjectType()
export class Book {
  @Field(() => ID)
  id: number;

  /** Title as printed on the cover. */
  title: string;

  subtitle?: string;

  tags: string[];

  publishedAt: Date;
}

"""A book in the catalogue."""
type Book {
  id: ID!

  """Title as printed on the cover."""
  title: String!
  subtitle: String
  tags: [String!]!
  publishedAt: DateTime!
}

resolve: {
  alias: {
    "@nestjs/graphql": path.resolve(__dirname, "../node_modules/@nestjs/graphql/dist/extra/graphql-model-shim")
  }
}

nest g resource users

? What transport layer do you use? GraphQL (code first)
? Would you like to generate CRUD entry points? Yes
CREATE src/users/users.module.ts (231 bytes)
CREATE src/users/users.resolver.spec.ts (531 bytes)
CREATE src/users/users.resolver.ts (1121 bytes)
CREATE src/users/users.service.spec.ts (456 bytes)
CREATE src/users/users.service.ts (631 bytes)
CREATE src/users/dto/create-user.input.ts (196 bytes)
CREATE src/users/dto/update-user.input.ts (246 bytes)
CREATE src/users/entities/user.entity.ts (187 bytes)
UPDATE src/app.module.ts (161 bytes)

import { Resolver, Query, Mutation, Args, Int } from '@nestjs/graphql';
import { UsersService } from './users.service.js';
import { User } from './entities/user.entity.js';
import { CreateUserInput } from './dto/create-user.input.js';
import { UpdateUserInput } from './dto/update-user.input.js';

@Resolver(() => User)
export class UsersResolver {
  constructor(private readonly usersService: UsersService) {}

  @Mutation(() => User)
  createUser(@Args('createUserInput') createUserInput: CreateUserInput) {
    return this.usersService.create(createUserInput);
  }

  @Query(() => [User], { name: 'users' })
  findAll() {
    return this.usersService.findAll();
  }

  @Query(() => User, { name: 'user' })
  findOne(@Args('id', { type: () => Int }) id: number) {
    return this.usersService.findOne(id);
  }

  @Mutation(() => User)
  updateUser(@Args('updateUserInput') updateUserInput: UpdateUserInput) {
    return this.usersService.update(updateUserInput.id, updateUserInput);
  }

  @Mutation(() => User)
  removeUser(@Args('id', { type: () => Int }) id: number) {
    return this.usersService.remove(id);
  }
}

@ObjectType({ registerIn: () => AdminModule })
export class AuditEntry {
  @Field()
  action: string;
}

@Module({
  imports: [
    PublicModule,
    AdminModule,
    GraphQLModule.forRoot<ApolloDriverConfig>({ driver: ApolloDriver, path: '/graphql', include: [PublicModule], autoSchemaFile: true }),
    GraphQLModule.forRoot<ApolloDriverConfig>({ driver: ApolloDriver, path: '/admin/graphql', include: [AdminModule], autoSchemaFile: true }),
  ],
})
export class MultiEndpointModule {}

/** Fastify + Apollo Server: needs @as-integrations/fastify; the request is { request, reply }. */
@Module({
  imports: [
    BookshelfModule,
    GraphQLModule.forRootAsync<ApolloDriverConfig>({
      driver: ApolloDriver,
      imports: [BookshelfModule],
      inject: [BookshelfStore],
      useFactory: (store: BookshelfStore) => ({
        autoSchemaFile: true,
        context: ({ request }: { request: FastifyRequest }) => ({ req: request, loaders: createLoaders(store) }),
      }),
    }),
  ],
})
export class FastifyApolloModule {}

/** Fastify + Mercurius: context is a function of the Fastify request and reply. */
@Module({
  imports: [
    BookshelfModule,
    GraphQLModule.forRootAsync<MercuriusDriverConfig>({
      driver: MercuriusDriver,
      imports: [BookshelfModule],
      inject: [BookshelfStore],
      useFactory: (store: BookshelfStore) => ({
        autoSchemaFile: true,
        graphiql: true,
        context: (req: FastifyRequest, _reply: FastifyReply) => ({ req, loaders: createLoaders(store) }),
        transformSchema: (schema) => upperDirectiveTransformer(schema, 'upper'),
        buildSchemaOptions: {
          directives: [new GraphQLDirective({ name: 'upper', locations: [DirectiveLocation.FIELD_DEFINITION] })],
        },
      }),
    }),
  ],
})
export class MercuriusModule {}