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.

Practice

1. What is the purpose of the @Entity() decorator in a NestJS application using TypeORM?

easy

A. It marks a class as a database table representation.

B. It defines a method to fetch data from the database.

C. It creates a new database connection.

D. It styles the output of a component.

Solution

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

   The @Entity() decorator tells NestJS and TypeORM that the class represents a database table.

2. Step 2: Differentiate from other decorators

   Other decorators like @Column() define table columns, but @Entity() marks the whole class as a table.

3. Final Answer:

   It marks a class as a database table representation. -> Option A

4. Quick Check:

   @Entity() = Table marker [OK]

Hint: Remember: @Entity() means 'this class is a table' [OK]

Common Mistakes:

• Confusing @Entity() with database connection setup
• Thinking @Entity() defines methods or styles
• Mixing up @Entity() with @Column()

2. Which of the following is the correct way to define a string column named title in a NestJS entity using TypeORM?

easy

A. @Column({ type: 'number' }) title: string;

B. @Column('boolean') title: string;

C. @Column() title: string;

D. @Column({ length: 255 }) title: number;

Solution

1. Step 1: Identify the correct @Column() usage for a string

   By default, @Column() without options assumes a string type in TypeORM.

2. Step 2: Check type consistency

   The property type should be string to match the column type.

3. Final Answer:

   @Column() title: string; -> Option C

4. Quick Check:

   Default @Column() = string column [OK]

Hint: Use @Column() alone for simple string columns [OK]

Common Mistakes:

• Setting wrong type in @Column() options
• Mismatching property type and column type
• Using number type for string properties

3. Given the following entity code, what will be the type of the age column in the database?

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

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

  @Column()
  name: string;

  @Column({ type: 'int' })
  age: number;
}

medium

A. INTEGER (number)

B. VARCHAR (string)

C. BOOLEAN

D. DATE

Solution

1. Step 1: Check the @Column() decorator on age

   The decorator specifies { type: 'int' }, which means an integer column in the database.

2. Step 2: Match the property type

   The property age is a number, matching the integer database type.

3. Final Answer:

   INTEGER (number) -> Option A

4. Quick Check:

   { type: 'int' } means integer column [OK]

Hint: Look for { type: 'int' } to identify integer columns [OK]

Common Mistakes:

• Assuming default string type without checking options
• Confusing int with boolean or date
• Ignoring the explicit type option in @Column()

4. Identify the error in the following entity definition:

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

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

  @Column({ type: 'varchar', length: 100 })
  name: number;
}

medium

A. Missing @Entity() decorator

B. Property type number does not match column type varchar

C. Primary key column missing

D. Incorrect import statement

Solution

1. Step 1: Check property and column type consistency

   The name property is typed as number but the column type is varchar, which expects a string.

2. Step 2: Confirm other parts are correct

   @Entity() is present, primary key is defined, and imports are correct.

3. Final Answer:

   Property type number does not match column type varchar -> Option B

4. Quick Check:

   Property type must match column type [OK]

Hint: Match property type with @Column() type options [OK]

Common Mistakes:

• Using wrong property type for string columns
• Forgetting to add @Entity()
• Missing primary key decorator

5. You want to define an entity Order with an auto-generated primary key id, a string customerName limited to 150 characters, and an optional numeric discount that can be null. Which is the correct entity definition?

hard

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

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

@Column({ length: 150 })
customerName: string;

@Column({ type: 'int', nullable: false })
discount: number;
}

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

@Entity()
export class Order {
@PrimaryGeneratedColumn()
id: string;

@Column({ length: 150 })
customerName: string;

@Column({ type: 'float' })
discount: number;
}

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

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

@Column({ type: 'varchar', length: 150 })
customerName: number;

@Column({ type: 'float', nullable: true })
discount: number;
}

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

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

@Column({ length: 150 })
customerName: string;

@Column({ type: 'float', nullable: true })
discount?: number;
}

Solution

1. Step 1: Verify primary key definition

   @PrimaryGeneratedColumn() on id: number creates an auto-incrementing integer primary key. A string type would be incorrect without additional configuration like UUID.

2. Step 2: Check customerName

   @Column({ length: 150 }) with string type creates a VARCHAR(150) column. A number type mismatches.

3. Step 3: Confirm discount

   @Column({ type: 'float', nullable: true }) with optional discount?: number allows null values. Missing nullable: true, wrong type like 'int', or non-optional fails.

4. Final Answer:

   The entity with number id, string customerName({length:150}), optional nullable float discount -> Option D

5. Quick Check:

   Match types, nullable, and optional properties carefully [OK]

Hint: Use nullable: true and optional property for nullable columns [OK]

Common Mistakes:

• Mismatching property types and column types
• Forgetting to mark nullable columns as optional
• Using wrong primary key type