Repository pattern in NestJS - Mini Project: Build & Apply

Repository Pattern in NestJS

📖 Scenario: You are building a simple NestJS service to manage a list of books in a library. You want to organize your code using the Repository pattern to separate data access logic from business logic.

🎯 Goal: Create a basic repository class to store and retrieve books, then use it in a service class to fetch all books.

📋 What You'll Learn

Create a Book interface with id and title properties

Create a BookRepository class with a private array of books

Add a method findAll() in BookRepository to return all books

Create a BookService class that uses BookRepository to get all books

💡 Why This Matters

🌍 Real World

The Repository pattern helps organize code in backend applications like NestJS by separating data access from business logic. This makes code easier to maintain and test.

💼 Career

Understanding the Repository pattern is important for backend developers working with NestJS or similar frameworks to build clean, scalable applications.

1

Define the Book interface and initial data

Create an interface called Book with properties id (number) and title (string). Then create a constant array called books with two books: one with id: 1 and title: 'NestJS Basics', and another with id: 2 and title: 'Advanced NestJS'.

NestJS

// Define the Book interface and the books array
// Your code here

Hint

Use interface to define the shape of a book object. Then create an array with two book objects exactly as described.

2

Create the BookRepository class with books array

Create a class called BookRepository. Inside it, add a private property called books and assign it the books array you created earlier.

NestJS

interface Book {
  id: number;
  title: string;
}

const books: Book[] = [
  { id: 1, title: 'NestJS Basics' },
  { id: 2, title: 'Advanced NestJS' }
];

// Create BookRepository class with private books property
// Your code here

Hint

Define a class and add a private property named exactly books that holds the array of books.

3

Add findAll() method to BookRepository

Inside the BookRepository class, add a method called findAll() that returns the books array.

NestJS

interface Book {
  id: number;
  title: string;
}

const books: Book[] = [
  { id: 1, title: 'NestJS Basics' },
  { id: 2, title: 'Advanced NestJS' }
];

class BookRepository {
  private books = books;

  // Your code here
}

Hint

Write a method named findAll that returns the private books property.

4

Create BookService using BookRepository

Create a class called BookService. Add a private property called bookRepository and initialize it with a new instance of BookRepository. Then add a method called getAllBooks() that calls findAll() on bookRepository and returns the result.

NestJS

interface Book {
  id: number;
  title: string;
}

const books: Book[] = [
  { id: 1, title: 'NestJS Basics' },
  { id: 2, title: 'Advanced NestJS' }
];

class BookRepository {
  private books = books;

  findAll(): Book[] {
    return this.books;
  }
}

// Create BookService class using BookRepository
// Your code here

Hint

Create a service class that holds an instance of BookRepository and uses it to get all books.

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