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.

Practice

1. What is the main idea behind the Schema-first approach in NestJS GraphQL?

easy

A. Use REST endpoints before adding GraphQL

B. Write resolvers first, then generate the schema automatically

C. Define the GraphQL schema first, then write resolvers to match it

D. Skip schema and use only TypeScript interfaces

Solution

1. Step 1: Understand Schema-first approach concept

   Schema-first means you write the GraphQL schema (types, queries, mutations) before coding the logic.

2. Step 2: Match resolvers to schema

   Resolvers are then implemented to fulfill the schema's fields and operations.

3. Final Answer:

   Define the GraphQL schema first, then write resolvers to match it -> Option C

4. Quick Check:

   Schema-first = Define schema first [OK]

Hint: Schema-first means schema before code [OK]

Common Mistakes:

• Thinking resolvers come before schema
• Confusing schema-first with code-first
• Assuming REST is involved
• Skipping schema definition

2. Which of the following is the correct way to define a GraphQL type in a schema-first approach SDL file?

easy

A. type User { id: ID! name: String! }

B. class User { id: number; name: string; }

C. interface User { id: ID; name: String }

D. schema User { id: ID! name: String! }

Solution

1. Step 1: Recognize GraphQL SDL syntax

   GraphQL SDL defines types with the keyword type followed by fields and their types.

2. Step 2: Check each option

   type User { id: ID! name: String! } uses correct SDL syntax. Options B and C use TypeScript syntax, and A uses invalid keyword schema for type definition.

3. Final Answer:

   type User { id: ID! name: String! } -> Option A

4. Quick Check:

   SDL type syntax = type User { id: ID! name: String! } [OK]

Hint: SDL uses 'type' keyword with fields and types [OK]

Common Mistakes:

• Using TypeScript syntax instead of SDL
• Confusing 'schema' keyword with 'type'
• Omitting exclamation marks for required fields

3. Given this schema snippet:

type Query { hello: String! }

And this resolver in NestJS:

@Resolver('Query')
export class HelloResolver {
  @Query()
  hello() {
    return 'Hi there!';
  }
}

What will be the result of querying { hello }?

medium

A. "Hi there!"

B. null

C. Error: Resolver method missing

D. undefined

Solution

1. Step 1: Match schema and resolver

   The schema defines a Query field hello returning a non-null String. The resolver implements a method hello() returning 'Hi there!'.

2. Step 2: Query execution result

   When querying { hello }, the resolver returns 'Hi there!', so the response is the string "Hi there!".

3. Final Answer:

   "Hi there!" -> Option A

4. Quick Check:

   Schema and resolver match = returns 'Hi there!' [OK]

Hint: Resolver method name matches schema field [OK]

Common Mistakes:

• Not matching resolver method name to schema field
• Returning undefined or null in resolver
• Missing @Query decorator

4. Identify the error in this schema-first resolver code snippet:

@Resolver('Query')
export class UserResolver {
  @Query()
  user(id: string) {
    return { id, name: 'Alice' };
  }
}

Assuming the schema defines user(id: ID!): User.

medium

A. Resolver class name must be UserQueryResolver

B. Missing @Args decorator for the id parameter

C. Return type must be a string, not an object

D. Schema should not have arguments in schema-first

Solution

1. Step 1: Check resolver method parameters

   The resolver method user expects an argument id. In NestJS schema-first, arguments must be decorated with @Args() to map schema args.

2. Step 2: Identify missing decorator

   The code misses @Args('id') before the id parameter, so NestJS won't pass the argument correctly.

3. Final Answer:

   Missing @Args decorator for the id parameter -> Option B

4. Quick Check:

   Arguments need @Args decorator [OK]

Hint: Use @Args() for resolver method arguments [OK]

Common Mistakes:

• Forgetting @Args decorator on parameters
• Wrong resolver class naming (not required)
• Returning wrong types
• Thinking schema can't have arguments

5. You have this schema-first GraphQL SDL:

type Mutation {
  updateUser(id: ID!, name: String): User
}

type User {
  id: ID!
  name: String!
}

Which resolver implementation correctly updates the user name and returns the updated user in NestJS?

hard

A. @Mutation()
updateUser(@Args('id') id: string, @Args('name') name: string) {
return { id, name };
}

B. @Mutation()
updateUser(id: string, name: string) {
const user = users.find(u => u.id === id);
user.name = name;
return user;
}

C. @Mutation()
updateUser(@Args() args) {
const user = users.find(u => u.id === args.id);
user.name = args.name;
return user;
}

D. @Mutation()
updateUser(@Args('id') id: string, @Args('name') name?: string) {
const user = users.find(u => u.id === id);
if (user && name) user.name = name;
return user;
}

Solution

1. Step 1: Match resolver signature to schema

   The schema defines updateUser(id: ID!, name: String): User. The resolver must use @Args('id') and optional @Args('name') parameters.

2. Step 2: Check update logic and return

   @Mutation() updateUser(@Args('id') id: string, @Args('name') name?: string) { const user = users.find(u => u.id === id); if (user && name) user.name = name; return user; } finds the user by id, updates name only if provided, and returns the user object, matching schema and logic.

3. Step 3: Analyze other options

   @Mutation() updateUser(id: string, name: string) { const user = users.find(u => u.id === id); user.name = name; return user; } misses @Args decorators, so arguments won't map. @Mutation() updateUser(@Args() args) { const user = users.find(u => u.id === args.id); user.name = args.name; return user; } uses @Args() args but does not check if user exists before setting user.name, causing runtime error if user not found. @Mutation() updateUser(@Args('id') id: string, @Args('name') name: string) { return { id, name }; } returns a new object without updating the stored user.

4. Final Answer:

   The resolver using @Args('id') id: string, @Args('name') name?: string with conditional update logic -> Option D

5. Quick Check:

   Use @Args and update logic correctly [OK]

Hint: Use @Args for each param and update data before return [OK]

Common Mistakes:

• Missing @Args decorators
• Not checking if user exists before update
• Returning new object without updating data
• Using @Args() without destructuring