Repository pattern in NestJS - Step-by-Step Execution

Concept Flow - Repository pattern

Start

↓

Service calls Repository

↓

Repository handles data logic

↓

Repository calls Database

↓

Database returns data

↓

Repository returns data to Service

↓

Service returns data to Controller

↓

Controller sends response

↓

End

The Repository pattern separates data access logic from business logic by having the Service call the Repository, which interacts with the Database and returns data back.

Execution Sample

NestJS

class UserRepository {
  findUser(id) {
    return db.find('users', id);
  }
}

class UserService {
  constructor(userRepository) {
    this.userRepository = userRepository;
  }

  getUser(id) { return this.userRepository.findUser(id); }
}

This code shows a Service calling a Repository method to get user data from the database.

Execution Table

Step	Action	Input	Process	Output
1	Controller receives request	userId=5	Passes to Service	Calls UserService.getUser(5)
2	Service calls Repository	id=5	Calls UserRepository.findUser(5)	Repository starts DB query
3	Repository queries DB	id=5	db.find('users', 5)	DB returns user data {id:5, name:'Anna'}
4	Repository returns data	{id:5, name:'Anna'}	Returns to Service	UserService.getUser returns user data
5	Service returns data	{id:5, name:'Anna'}	Returns to Controller	Controller sends response with user data
6	End	-	-	Response sent, process complete

💡 Process ends after Controller sends response to client

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
userId	undefined	5	5	5	5
userData	undefined	undefined	{id:5, name:'Anna'}	{id:5, name:'Anna'}	{id:5, name:'Anna'}

Key Moments - 2 Insights

Why does the Service call the Repository instead of directly querying the database?

The Service calls the Repository to keep business logic separate from data access. The Repository handles all database queries, making the code cleaner and easier to maintain, as shown in steps 2 and 3.

What happens if the Repository does not find the user in the database?

If the Repository finds no user, it returns null or undefined. The Service then handles this case before returning data to the Controller. This flow is implied between steps 3 and 4.

Visual Quiz - 3 Questions

Look at the execution table, what data does the Repository return to the Service at step 4?

A {id:5, name:'Anna'}

B userId=5

C null

D db.find('users', 5)

💡 Hint

Check the 'Output' column at step 4 in the execution table.

At which step does the database return the user data?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Process' and 'Output' columns to find when db.find returns data.

If the Service called the database directly, which step would be skipped?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

The Service calling the Repository is shown in step 2.

Concept Snapshot

Repository pattern separates data access from business logic.
Service calls Repository, Repository queries database.
Repository returns data to Service.
Keeps code clean and maintainable.
Common in NestJS for database operations.

Full Transcript

The Repository pattern in NestJS helps separate how data is fetched from how business rules are applied. The Controller receives a request and calls the Service. The Service then calls the Repository, which handles database queries. The database returns data to the Repository, which passes it back to the Service. Finally, the Controller sends the response. This separation keeps code organized and easier to maintain.

Practice

1. What is the main purpose of the Repository pattern in NestJS?

easy

A. To separate data access logic from business logic

B. To handle HTTP requests directly

C. To manage application configuration settings

D. To create UI components

Solution

1. Step 1: Understand the role of Repository pattern

   The Repository pattern is designed to isolate data access logic from the rest of the application.

2. Step 2: Identify what Repository does in NestJS

   In NestJS, repositories handle database operations, keeping business logic clean and testable.

3. Final Answer:

   To separate data access logic from business logic -> Option A

4. Quick Check:

   Repository pattern = separate data access [OK]

Hint: Repository = data access layer, not UI or config [OK]

Common Mistakes:

• Confusing repository with controller responsibilities
• Thinking repository manages UI or HTTP directly
• Mixing repository with configuration management

2. Which of the following is the correct way to inject a repository in a NestJS service using TypeORM?

easy

A. @Inject(UserRepository) private userRepository: Repository<User>;

B. @InjectableRepository(User) private userRepository: Repository<User>;

C. @RepositoryInject(User) private userRepository: Repository<User>;

D. @InjectRepository(User) private userRepository: Repository<User>;

Solution

1. Step 1: Recall the correct decorator for repository injection

   In NestJS with TypeORM, @InjectRepository() is used to inject repositories.

2. Step 2: Match the syntax with the correct option

   @InjectRepository(User) private userRepository: Repository<User>; uses @InjectRepository(User) which is the official and correct syntax.

3. Final Answer:

   @InjectRepository(User) private userRepository: Repository<User>; -> Option D

4. Quick Check:

   @InjectRepository = correct injection [OK]

Hint: Use @InjectRepository to inject TypeORM repositories [OK]

Common Mistakes:

• Using wrong decorator names like @InjectableRepository
• Confusing @Inject with @InjectRepository
• Omitting the entity inside @InjectRepository()

3. Given the following NestJS service code, what will findAll() return?

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(@InjectRepository(User) private userRepo: Repository<User>) {}

  async findAll() {
    return await this.userRepo.find();
  }
}

medium

A. Undefined, because find() is not a valid method

B. A single User entity

C. An array of all User entities from the database

D. A Promise that resolves to null

Solution

1. Step 1: Understand what this.userRepo.find() does

   The find() method of TypeORM repository returns all records of the entity as an array.

2. Step 2: Analyze the return type of findAll()

   Since find() returns a Promise resolving to an array of User entities, findAll() returns that array.

3. Final Answer:

   An array of all User entities from the database -> Option C

4. Quick Check:

   Repository.find() returns array [OK]

Hint: Repository.find() returns all records as an array [OK]

Common Mistakes:

• Thinking find() returns a single entity
• Assuming find() is not a valid method
• Confusing Promise with null return

4. Identify the error in this NestJS repository injection code snippet:

@Injectable()
export class ProductService {
  constructor(private productRepository: Repository<Product>) {}
}

medium

A. Missing @InjectRepository decorator for productRepository

B. Repository should be injected using @InjectableRepository

C. Constructor should not have parameters

D. Repository cannot be injected in services

Solution

1. Step 1: Check how repositories are injected in NestJS

   Repositories must be injected with @InjectRepository(Entity) decorator to work properly.

2. Step 2: Identify missing decorator in the code

   The code misses @InjectRepository(Product) before the repository parameter.

3. Final Answer:

   Missing @InjectRepository decorator for productRepository -> Option A

4. Quick Check:

   Repository injection needs @InjectRepository [OK]

Hint: Always use @InjectRepository for repositories in constructor [OK]

Common Mistakes:

• Forgetting @InjectRepository decorator
• Using wrong decorator names
• Assuming repositories inject automatically without decorators

5. You want to create a custom method findActiveUsers() in your UserRepository that returns only users with isActive = true. Which approach correctly applies the Repository pattern in NestJS?

hard

A. Add findActiveUsers() method directly in the UserService without modifying repository

B. Extend the Repository class and add findActiveUsers() method, then inject this custom repository

C. Use a global function outside repository and service to filter active users

D. Modify the User entity to include a static method findActiveUsers()

Solution

1. Step 1: Understand extending repository for custom methods

   To add custom queries, extend the Repository class and add methods like findActiveUsers().

2. Step 2: Confirm proper injection of custom repository

   Inject the custom repository in services to keep data access logic encapsulated.

3. Final Answer:

   Extend the Repository class and add findActiveUsers() method, then inject this custom repository -> Option B

4. Quick Check:

   Custom repo methods = extend Repository [OK]

Hint: Add custom queries by extending Repository class [OK]

Common Mistakes:

• Putting query logic in service instead of repository
• Using global functions outside repository pattern
• Adding static methods to entity instead of repository