Schema-first approach in NestJS - Step-by-Step Execution

Concept Flow - Schema-first approach

Define GraphQL Schema (SDL)

↓

Generate TypeScript Types

↓

Implement Resolvers Using Types

↓

NestJS GraphQL Module Loads Schema

↓

GraphQL Server Ready to Handle Queries

Start by writing the GraphQL schema, then generate types and implement resolvers, finally load schema in NestJS to serve requests.

Execution Sample

NestJS

const typeDefs = `
  type Query {
    hello: String
  }
`;

const resolvers = {
  Query: { hello: () => 'Hello World!' }
};

Defines a simple GraphQL schema and resolver that returns a greeting string.

Execution Table

Step	Action	Input/Code	Output/Result
1	Define schema	type Query { hello: String }	Schema with Query type and hello field created
2	Generate types	Schema SDL	TypeScript types generated for Query and hello
3	Implement resolver	hello: () => 'Hello World!'	Resolver function ready to return greeting
4	Load schema in NestJS	typeDefs and resolvers	GraphQL module configured with schema and resolvers
5	Server ready	GraphQL server running	Can respond to { hello } query with 'Hello World!'
6	Query executed	{ hello }	"Hello World!" returned

💡 Execution stops after server responds to query with the expected data.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
typeDefs	undefined	Schema SDL string	Schema SDL string	Schema SDL string	Schema SDL string	Schema SDL string
resolvers	undefined	undefined	undefined	Resolver object with hello function	Resolver object	Resolver object
serverStatus	stopped	stopped	stopped	stopped	running	running

Key Moments - 3 Insights

Why do we write the schema first instead of code?

Writing the schema first defines the API contract clearly before coding, as shown in Step 1 of the execution_table.

How do resolvers connect to the schema fields?

Resolvers match schema fields by name and type, like the 'hello' resolver matches the 'hello' field in the Query type (Step 3).

What happens if the schema and resolvers don't match?

The server will error or fail to respond correctly, because NestJS uses the schema to validate queries and expects matching resolvers (Step 4).

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after Step 3?

A Schema with Query type and hello field created

B Resolver function ready to return greeting

C GraphQL module configured with schema and resolvers

D Can respond to { hello } query with 'Hello World!'

💡 Hint

Check the Output/Result column for Step 3 in the execution_table.

At which step does the GraphQL server start running?

A Step 5

B Step 4

C Step 2

D Step 6

💡 Hint

Look for 'server running' status in the Output/Result column.

If the resolver for 'hello' was missing, what would happen at Step 6?

A Server returns 'Hello World!' anyway

B Schema generation fails

C Server returns null or error for { hello } query

D Server crashes immediately

💡 Hint

Refer to the key_moments about schema and resolver matching.

Concept Snapshot

Schema-first approach in NestJS:
1. Write GraphQL schema (SDL) first.
2. Generate TypeScript types from schema.
3. Implement resolvers matching schema fields.
4. Load schema and resolvers in NestJS GraphQL module.
5. Server runs and responds to queries based on schema.

Full Transcript

In the schema-first approach with NestJS, you start by writing the GraphQL schema using SDL. This schema defines the API's shape and fields. Next, you generate TypeScript types from this schema to help with type safety. Then, you implement resolver functions that match the schema's fields, providing the actual data or logic. After that, you load the schema and resolvers into the NestJS GraphQL module, which sets up the server. Finally, the server runs and can respond to GraphQL queries according to the schema and resolvers. This approach ensures a clear API contract and organized code.