Repository pattern in NestJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Repository pattern in NestJS?

The Repository pattern is a way to organize data access logic. It acts like a middleman between your app and the database, making it easier to manage and test data operations.

intermediate

How does the Repository pattern help in testing?

It allows you to replace the real database calls with fake ones, so you can test your app without needing a real database. This makes tests faster and more reliable.

beginner

In NestJS, which package provides the Repository pattern support?

The @nestjs/typeorm package provides Repository pattern support by integrating TypeORM, which offers Repository classes to manage entities.

beginner

What is the role of an Entity in the Repository pattern?

An Entity represents a table or collection in the database. The Repository manages these Entities by providing methods to create, read, update, and delete data.

intermediate

Why is it better to use Repository pattern instead of direct database queries in NestJS?

Using the Repository pattern keeps your code clean and organized. It separates database logic from business logic, making your app easier to maintain and change.

What does a Repository in NestJS typically manage?

A Application configuration files

B User interface components

C HTTP request routing

D Entities and their database operations

Repositories manage Entities and handle database operations like create, read, update, and delete.

Which NestJS package is commonly used to implement the Repository pattern?

A @nestjs/common

B @nestjs/microservices

C @nestjs/typeorm

D @nestjs/config

@nestjs/typeorm integrates TypeORM, which provides Repository classes for data access.

How does the Repository pattern improve testing in NestJS?

A By allowing database calls to be mocked

B By making UI tests easier

C By speeding up HTTP requests

D By reducing server memory usage

Repositories can be mocked or replaced with fake versions, so tests don't need a real database.

What is an Entity in the context of the Repository pattern?

A A database table or record model

B A network protocol

C A configuration file

D A UI component

An Entity represents a database table or a model of data stored in the database.

Why should you avoid writing direct database queries in your NestJS services?

A It improves performance

B It makes the code harder to maintain and test

C It reduces the number of files

D It increases the app size

Direct queries mix database logic with business logic, making code harder to maintain and test.

Explain the Repository pattern and its benefits in NestJS applications.

Think about how you organize your data access code and why that helps.

Describe how you would use the Repository pattern with TypeORM in a NestJS service.

Focus on how NestJS connects your service to the database through Repository.

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