Entity definition in NestJS - Step-by-Step Execution

Concept Flow - Entity definition

Define Entity Class

↓

Add @Entity Decorator

↓

Define Properties with @Column

↓

Add Primary Key with @PrimaryGeneratedColumn

↓

Use Entity in Repository

↓

Database Table Created

↓

CRUD Operations on Entity

This flow shows how to define an entity class with decorators, which maps to a database table used for data operations.

Execution Sample

NestJS

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;
}

Defines a User entity with an auto-generated id and a name column.

Execution Table

Step	Action	Decorator/Property	Effect	Resulting Entity State
1	Define class User	None	Class created	User class exists with no decorators
2	Add @Entity decorator	@Entity()	Marks class as DB entity	User class mapped to DB table 'user'
3	Add @PrimaryGeneratedColumn to id	@PrimaryGeneratedColumn()	id is primary key, auto-generated	id property set as PK with auto increment
4	Add @Column to name	@Column()	name is a regular column	name property mapped to DB column
5	Compile and run	N/A	Entity registered with ORM	User entity ready for DB operations
6	Use repository to save User	N/A	Insert SQL generated	New user row inserted in DB
7	Use repository to find User	N/A	Select SQL generated	User data retrieved from DB

💡 Entity class fully defined and ready for database CRUD operations

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
User class	Defined	Marked as entity	id property set as PK	name property added	Complete entity with id and name

Key Moments - 3 Insights

Why do we need the @Entity decorator?

The @Entity decorator tells NestJS and TypeORM that this class represents a database table. Without it, the class is just a normal TypeScript class and won't map to the database. See execution_table step 2.

What does @PrimaryGeneratedColumn do?

@PrimaryGeneratedColumn marks a property as the primary key and tells the database to auto-generate its value. This is important for uniquely identifying rows. See execution_table step 3.

Can we have properties without @Column decorator?

Properties without @Column are not saved in the database. Only properties with @Column or special decorators like @PrimaryGeneratedColumn are mapped. See execution_table step 4.

Visual Quiz - 3 Questions

Look at the execution table, what decorator marks the class as a database entity?

A @Entity()

B @Column()

C @PrimaryGeneratedColumn()

D No decorator needed

💡 Hint

Check execution_table step 2 where the class is marked as an entity.

At which step is the primary key defined in the entity?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at execution_table step 3 where @PrimaryGeneratedColumn is added.

If we remove @Column from the name property, what happens?

A name is still saved in the database

B name becomes the primary key

C name is not saved in the database

D Entity definition fails to compile

💡 Hint

Refer to key_moments about properties without @Column decorator.

Concept Snapshot

Entity definition in NestJS with TypeORM:
- Use @Entity() to mark a class as a DB table
- Use @PrimaryGeneratedColumn() for auto-increment primary key
- Use @Column() for regular table columns
- Only decorated properties map to DB
- Entity classes enable CRUD via repositories

Full Transcript

In NestJS, defining an entity means creating a class that represents a database table. We add the @Entity decorator to mark the class as an entity. Then, we define properties with decorators like @PrimaryGeneratedColumn for the primary key and @Column for other columns. This setup tells the ORM how to map the class to the database. When running, the ORM creates the table and allows CRUD operations through repositories. Properties without decorators are ignored in the database mapping. This visual trace showed each step from class definition to database usage.