Schema definition in NestJS - Step-by-Step Execution

Concept Flow - Schema definition

Define Schema Class

↓

Add Decorators (@Schema, @Prop)

↓

Create Schema Factory

↓

Use Schema in Module

↓

Inject Model in Service

↓

Perform DB Operations

This flow shows how to define a schema class with decorators, create a schema factory, and use it in NestJS modules and services for database operations.

Execution Sample

NestJS

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class Cat extends Document {
  @Prop() name: string;
  @Prop() age: number;
}

export const CatSchema = SchemaFactory.createForClass(Cat);

Defines a Cat schema with name and age properties using decorators and creates a schema factory for use in NestJS.

Execution Table

Step	Action	Code Line	Result
1	Import decorators and Document	import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'; import { Document } from 'mongoose';	Decorators and Document class available
2	Define Cat class with @Schema decorator	@Schema() export class Cat extends Document { ... }	Cat class marked as schema
3	Add @Prop() to name property	@Prop() name: string;	name property registered in schema
4	Add @Prop() to age property	@Prop() age: number;	age property registered in schema
5	Create schema factory	export const CatSchema = SchemaFactory.createForClass(Cat);	CatSchema created from Cat class
6	Use CatSchema in module imports	MongooseModule.forFeature([{ name: Cat.name, schema: CatSchema }])	Schema registered in module
7	Inject Cat model in service	constructor(@InjectModel(Cat.name) private catModel: Model<Cat>) {}	Model ready for DB operations
8	Perform DB operations	this.catModel.create({ name: 'Tom', age: 3 })	New Cat document saved in DB
9	Exit	End of schema definition and usage flow	Schema fully defined and usable

💡 Schema class defined, schema factory created, and schema integrated into NestJS module and service for database use.

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 7	Final
Cat class	undefined	Defined as schema class	Used to create CatSchema	Used as model injection token	Used for DB operations
CatSchema	undefined	undefined	Created from Cat class	Registered in module	Used in service for DB
catModel	undefined	undefined	undefined	Injected Model<Cat>	Used to create documents

Key Moments - 3 Insights

Why do we use @Schema() decorator on the class?

The @Schema() decorator marks the class as a schema definition so NestJS knows to create a Mongoose schema from it, as shown in step 2 and step 5.

What does @Prop() do on class properties?

@Prop() tells NestJS which properties to include in the schema. Without it, the property won't be part of the database schema, as seen in steps 3 and 4.

How is the schema connected to the database model?

The schema factory creates a schema from the class (step 5), which is then registered in the module (step 6) and injected as a model in the service (step 7) for DB operations.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the CatSchema created?

A Step 3

B Step 5

C Step 7

D Step 2

💡 Hint

Check the 'Action' column for 'Create schema factory' in the execution table.

According to variable_tracker, what is the state of catModel after step 7?

A Undefined

B Schema class

C Injected Model<Cat>

D Schema factory

💡 Hint

Look at the 'catModel' row under 'After Step 7' in variable_tracker.

If we remove @Prop() from a property, what happens in the execution flow?

A Property is not part of the schema

B Schema creation fails

C Property is still included in schema

D Model injection fails

💡 Hint

Refer to key_moments about the role of @Prop() and steps 3-4 in execution_table.

Concept Snapshot

NestJS Schema Definition:
- Use @Schema() on a class to mark it as a schema.
- Use @Prop() on properties to include them in the schema.
- Create schema with SchemaFactory.createForClass(Class).
- Register schema in module with MongooseModule.forFeature.
- Inject model in service with @InjectModel(Class.name).
- Use model for DB operations.

Full Transcript

In NestJS, schema definition starts by importing necessary decorators and Document from mongoose. You define a class and decorate it with @Schema() to mark it as a schema. Each property you want in the database schema is decorated with @Prop(). Then, you create a schema factory using SchemaFactory.createForClass with your class. This schema is registered in your module using MongooseModule.forFeature. In your service, you inject the model using @InjectModel with the class name. This model lets you perform database operations like creating or querying documents. The execution table shows each step from defining the class to using the model. The variable tracker follows how the class, schema, and model variables change through these steps. Key moments clarify why decorators are needed and how schema connects to the model. The quiz tests understanding of when schema is created, model injection, and the role of @Prop(). This process helps you organize your data structure clearly and use it easily in your NestJS app.

Practice

1. What is the main purpose of using @Schema() in NestJS?

easy

A. To define the structure and rules of a data model

B. To create a new controller

C. To handle HTTP requests

D. To style components

Solution

1. Step 1: Understand the role of @Schema()

   @Schema() is used to define how data should be structured and validated in NestJS models.

2. Step 2: Compare with other options

   Creating controllers, handling HTTP requests, and styling components are unrelated to schema definition.

3. Final Answer:

   To define the structure and rules of a data model -> Option A

4. Quick Check:

   Schema decorator defines data structure [OK]

Hint: Remember: @Schema() sets data shape, not controllers or styles [OK]

Common Mistakes:

• Confusing @Schema() with controller decorators
• Thinking @Schema() handles HTTP logic
• Mixing schema with UI styling

2. Which of the following is the correct way to define a string property named title in a NestJS schema?

easy

A. @Prop() title: number;

B. @Prop() title: string;

C. @Prop() title = 123;

D. @Prop() title: boolean;

Solution

1. Step 1: Identify the correct type for a string property

   The property title should be of type string to hold text data.

2. Step 2: Check the syntax of @Prop()

   The correct syntax is @Prop() title: string; which declares a string property.

3. Final Answer:

   @Prop() title: string; -> Option B

4. Quick Check:

   String property uses type string [OK]

Hint: Use @Prop() with correct TypeScript type for properties [OK]

Common Mistakes:

• Using wrong types like number or boolean for string data
• Assigning values instead of declaring types
• Missing @Prop() decorator

3. Given this schema snippet:

@Schema()
export class Book {
  @Prop()
  author: string;

  @Prop({ required: true })
  pages: number;
}

What happens if you try to save a Book without pages?

medium

A. The save will throw a syntax error

B. The save will succeed and pages will be undefined

C. The save will succeed and pages will default to 0

D. The save will fail because pages is required

Solution

1. Step 1: Understand the required: true option

   The pages property is marked as required, so it must be provided when saving.

2. Step 2: Predict behavior when missing required property

   Omitting pages causes validation to fail and the save operation to be rejected.

3. Final Answer:

   The save will fail because pages is required -> Option D

4. Quick Check:

   Required props must be present [OK]

Hint: Required props block save if missing [OK]

Common Mistakes:

• Assuming missing required props default silently
• Confusing validation errors with syntax errors
• Ignoring the required option in @Prop()

4. Identify the error in this schema definition:

@Schema()
export class User {
  @Prop({ type: String })
  age: number;
}

medium

A. No error, this is correct

B. Missing @Schema() decorator

C. The type in @Prop() does not match the property type

D. Property name cannot be 'age'

Solution

1. Step 1: Compare @Prop() type and property type

   The decorator says type: String but the property is declared as number.

2. Step 2: Understand type mismatch consequences

   This mismatch can cause runtime errors or incorrect schema behavior.

3. Final Answer:

   The type in @Prop() does not match the property type -> Option C

4. Quick Check:

   Decorator type must match property type [OK]

Hint: Match @Prop() type with property type exactly [OK]

Common Mistakes:

• Using wrong type in @Prop() options
• Ignoring type mismatch warnings
• Assuming property name causes errors

5. How would you define a schema for a Product with a required name (string), optional price (number), and a default inStock (boolean) set to true?

hard

A. @Schema()
export class Product {
@Prop({ required: true })
name: string;

@Prop()
price?: number;

@Prop({ default: true })
inStock: boolean;
}

B. @Schema()
export class Product {
@Prop()
name: string;

@Prop({ required: true })
price: number;

@Prop({ default: false })
inStock: boolean;
}

C. @Schema()
export class Product {
@Prop({ required: true })
name: number;

@Prop()
price: string;

@Prop({ default: true })
inStock: boolean;
}

D. @Schema()
export class Product {
@Prop({ required: true })
name: string;

@Prop({ default: 0 })
price: number;

@Prop()
inStock: boolean;
}

Solution

1. Step 1: Define required name as string

   Use @Prop({ required: true }) name: string; to make name mandatory.

2. Step 2: Define optional price as number

   Use @Prop() price?: number; to allow price to be optional.

3. Step 3: Define inStock with default true

   Use @Prop({ default: true }) inStock: boolean; to set default value.

4. Final Answer:

   Schema with required name (string), optional price (number), and inStock default true -> Option A

5. Quick Check:

   Required, optional, default props set properly [OK]

Hint: Use required, optional ?, and default in @Prop() [OK]

Common Mistakes:

• Mixing types for properties
• Forgetting to mark required props
• Setting wrong default values