Repository Pattern and Working with Entities in NestJS

The Repository Pattern is a structural pattern that provides an abstraction layer between the data access logic and business logic in your application. By using repositories, you can decouple your database queries from the rest of your application and encapsulate the logic for querying and manipulating data. In NestJS, the Repository Pattern works seamlessly with ORMs like TypeORM and Prisma, offering a clean and maintainable approach to managing database operations.

In this module, we’ll dive into the Repository Pattern, explain its benefits, and show you how to use it effectively in NestJS. We will also cover how to work with Entities in NestJS to model your database tables and interact with them using repositories.

Table of Contents

1. Introduction to Repository Pattern
2. Working with Entities in NestJS
3. Implementing the Repository Pattern in NestJS
4. Example: Creating and Retrieving Data with Repository Pattern
5. Benefits of the Repository Pattern
6. Conclusion

Introduction to Repository Pattern

The Repository Pattern is used to isolate the domain layer from the persistence layer (e.g., database). This separation helps to keep your business logic clean and focused, without mixing it with database-specific operations.

In the Repository Pattern:

• The repository serves as an intermediary between the business logic and the data storage (usually a database).
• It encapsulates the logic needed to retrieve and store entities, abstracting away the details of the data source.
• This pattern is especially useful when your application requires complex queries or if you are working with multiple data sources.

By using this pattern, you can easily switch your database provider (e.g., from PostgreSQL to MongoDB) or modify your query logic without affecting the rest of your application.

Working with Entities in NestJS

In NestJS, entities are used to define the structure of database tables. They represent the schema of your database, with each entity corresponding to a table.

To define an entity in NestJS using TypeORM, you use decorators like @Entity(), @Column(), and @PrimaryGeneratedColumn(). These decorators define the properties of the entity and map them to the database columns.

Example: Defining an Entity

Let’s say we want to create a User entity. Here’s how you would define it in NestJS using TypeORM:

typescriptCopyEdit// src/user/user.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

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

  @Column()
  name: string;

  @Column()
  email: string;
}

In this example:

• @Entity() marks the class as an entity, representing a table in the database.
• @PrimaryGeneratedColumn() specifies that id will be the primary key and automatically generated.
• @Column() is used to define regular columns in the table, like name and email.

Once the entity is defined, you can use it to create and query data from the database.

Implementing the Repository Pattern in NestJS

To implement the Repository Pattern in NestJS, we typically create a repository class that abstracts the logic for interacting with the database. Repositories are typically injected into services, where business logic is implemented.

In TypeORM, repositories can be accessed using @InjectRepository() and used to perform operations on the database.

Step 1: Create a Repository Class

A repository class serves as a wrapper around TypeORM’s repository, providing methods to interact with the database. Here’s an example of a repository class for managing User entities.

typescriptCopyEdit// src/user/user.repository.ts
import { EntityRepository, Repository } from 'typeorm';
import { User } from './user.entity';

@EntityRepository(User)
export class UserRepository extends Repository<User> {
  async findByEmail(email: string): Promise<User | undefined> {
    return this.findOne({ where: { email } });
  }
}

In this example:

• @EntityRepository(User) tells TypeORM that this repository is for the User entity.
• UserRepository extends Repository<User>, which provides basic CRUD operations.
• We added a custom method findByEmail(), which allows us to query users by their email.

Step 2: Inject the Repository into a Service

Now, we’ll inject the repository into a service and use it to interact with the database.

typescriptCopyEdit// src/user/user.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from './user.entity';
import { UserRepository } from './user.repository';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: UserRepository,
  ) {}

  async createUser(name: string, email: string): Promise<User> {
    const user = this.userRepository.create({ name, email });
    return this.userRepository.save(user);
  }

  async getUserByEmail(email: string): Promise<User | undefined> {
    return this.userRepository.findByEmail(email);
  }

  async getAllUsers(): Promise<User[]> {
    return this.userRepository.find();
  }
}

In this example:

• The UserRepository is injected into the UserService using @InjectRepository().
• We use the repository’s methods to perform database operations such as creating a user and retrieving users by email.

Example: Creating and Retrieving Data with Repository Pattern

Let’s walk through an example where we create a user and retrieve them by email.

Step 1: Create a User

You can call the createUser method from the service to create a new user.

typescriptCopyEdit// src/user/user.controller.ts
import { Controller, Post, Body } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post()
  async createUser(@Body() body: { name: string; email: string }) {
    return this.userService.createUser(body.name, body.email);
  }
}

Step 2: Get User by Email

You can call the getUserByEmail method from the service to retrieve a user by their email.

typescriptCopyEdit// src/user/user.controller.ts
import { Controller, Get, Param } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get(':email')
  async getUser(@Param('email') email: string) {
    return this.userService.getUserByEmail(email);
  }
}

Benefits of the Repository Pattern

Using the Repository Pattern in your application offers several benefits:

1. Separation of Concerns: The repository abstracts away the data access logic, allowing you to focus on business logic in your services.
2. Maintainability: By encapsulating data operations in repositories, it becomes easier to modify or replace data access logic without affecting the rest of the application.
3. Testability: With the repository pattern, it’s easier to mock or stub data access layers during unit testing, as your services do not directly interact with the database.
4. Consistency: Using repositories ensures consistent methods for interacting with the database throughout the application.

Conclusion

In this module, we explored the Repository Pattern and how it can be implemented in NestJS using TypeORM. We covered the process of defining entities, creating repository classes, and injecting repositories into services to manage database operations.

The Repository Pattern helps to improve maintainability, testability, and separation of concerns in your NestJS application. By using repositories and entities, you can effectively manage data and keep your application’s business logic clean and focused.