Schema-first approach in NestJS - Mini Project: Build & Apply

Building a GraphQL API with NestJS Using Schema-First Approach

📖 Scenario: You are creating a simple GraphQL API for a bookstore. You want to define your data types and queries using GraphQL schema language first, then implement the resolvers in NestJS.

🎯 Goal: Build a NestJS GraphQL API using the schema-first approach. Define a GraphQL schema for books, configure the GraphQL module, implement resolvers to return book data, and complete the setup to serve the API.

📋 What You'll Learn

Create a GraphQL schema file with a Book type and a Query to get all books

Configure the NestJS GraphQL module to use the schema file

Implement a resolver class with a method to return a list of books

Complete the module setup to include the resolver and GraphQL configuration

💡 Why This Matters

🌍 Real World

Many modern backend APIs use GraphQL to allow clients to request exactly the data they need. The schema-first approach helps teams design the API contract before coding.

💼 Career

Understanding schema-first GraphQL with NestJS is valuable for backend developers working on scalable APIs and microservices.

1

Create GraphQL Schema File

Create a file named books.schema.graphql with a Book type that has id (ID!), title (String!), and author (String!) fields. Also add a Query type with a field books that returns a list of Book.

NestJS

# Create books.schema.graphql with Book type and Query type
# Your code here

Hint

Use GraphQL SDL syntax. Define Book type first, then Query with books field returning a list of Book.

2

Configure GraphQL Module in NestJS

In app.module.ts, import GraphQLModule from @nestjs/graphql and configure it with typePaths pointing to ./**/*.schema.graphql. Use autoSchemaFile: false to disable auto schema generation.

NestJS

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';

@Module({
  imports: [
    // Configure GraphQLModule here
  ],
})
export class AppModule {}

# Your code here

Hint

Use GraphQLModule.forRoot with typePaths array and set autoSchemaFile to false.

3

Implement Books Resolver

Create a resolver class named BooksResolver with a method books() decorated with @Query('books'). Return an array of book objects with id, title, and author matching the schema.

NestJS

import { Resolver, Query } from '@nestjs/graphql';

@Resolver('Book')
export class BooksResolver {
  // Add books query method here
  // Your code here
}

Hint

Use @Resolver('Book') on the class and @Query('books') on the method. Return an array of objects matching the Book type.

4

Complete Module Setup with Resolver

In app.module.ts, import BooksResolver and add it to the providers array in the @Module decorator to complete the GraphQL API setup.

NestJS

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { BooksResolver } from './books.resolver';

@Module({
  imports: [
    GraphQLModule.forRoot({
      typePaths: ['./**/*.schema.graphql'],
      autoSchemaFile: false,
    }),
  ],
  providers: [
    // Add BooksResolver here
  ],
})
export class AppModule {}

# Your code here

Hint

Import BooksResolver and add it to the providers array inside the @Module decorator.

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