Schema-first approach in NestJS

Introduction

The schema-first approach helps you design your data and API structure first using a clear schema. This makes it easy to understand and share how your API works before writing code.

When you want to clearly define your API structure before coding.

When working with a team that needs a shared contract for data and operations.

When you want to generate code or documentation automatically from your schema.

When you prefer to design your GraphQL API visually or with tools before implementation.

Syntax

NestJS

type Query {
  hello: String
}

type Mutation {
  setMessage(message: String): String
}

This is a GraphQL schema written in SDL (Schema Definition Language).

You define types like Query and Mutation with fields and their return types.

Examples

This defines a Query type with a greet field that takes a name and returns a string.

NestJS

type Query {
  greet(name: String): String
}

This defines a Mutation type with updateAge field that takes an integer and returns true or false.

NestJS

type Mutation {
  updateAge(age: Int): Boolean
}

Sample Program

This NestJS module sets up GraphQL with a schema-first approach by generating the schema file automatically. The resolver defines the Query and Mutation fields matching the schema. The hello query returns a message, and setMessage mutation updates it.

NestJS

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { join } from 'path';
import { Resolver, Query, Mutation, Args } from '@nestjs/graphql';

// Resolver implementing schema fields
@Resolver()
export class AppResolver {
  private message = 'Hello World!';

  @Query(() => String)
  hello() {
    return this.message;
  }

  @Mutation(() => String)
  setMessage(@Args('message') message: string) {
    this.message = message;
    return this.message;
  }
}

@Module({
  imports: [
    GraphQLModule.forRoot({
      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
      // Using schema-first means you can also provide a schema file here
    }),
  ],
  providers: [AppResolver],
})
export class AppModule {}

Important Notes

Schema-first means you start by writing the GraphQL schema, then write resolvers to match it.

You can generate the schema file automatically or write it manually and load it.

This approach helps teams agree on API design early.

Summary

Schema-first approach means designing your API schema before coding.

It uses GraphQL SDL to define types, queries, and mutations.

Resolvers implement the schema fields in NestJS.