NestJS TypeORM Repository Module

A lightweight module for NestJS that simplifies the implementation of the Repository pattern with TypeORM.

Table of Contents

• Description
• Installation
• Usage
  • Basic Configuration
  • Multiple Data Sources
• Important Notes
• Examples
  • Basic Example
  • Multiple Data Sources Example
  • Data Source Priority
• License

Description

This module provides a clean and efficient way to implement the Repository pattern in NestJS applications using TypeORM. It helps maintain separation of concerns by decoupling the data access logic from the business logic.

Key features:

• Simple decorator-based repository creation
• Support for multiple data sources
• Flexible configuration options
• Seamless integration with NestJS and TypeORM

Packages used:

• @nestjs/common - Core NestJS functionality
• @nestjs/core - Core NestJS functionality
• @nestjs/typeorm - NestJS TypeORM integration
• typeorm - TypeORM ORM

Installation

npm install @toxicoder/nestjs-typeorm-repository

Dependencies

This module requires the following peer dependencies:

npm install @nestjs/common @nestjs/core @nestjs/typeorm typeorm

Make sure you have TypeORM and NestJS properly configured in your application.

Usage

Basic Configuration

1. Create a repository class that extends TypeORM's Repository:

import { TypeormRepository } from '@toxicoder/nestjs-typeorm-repository';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@TypeormRepository(User)
export class UserRepository extends Repository<User> {
  // Custom repository methods
  findByEmail(email: string) {
    return this.findOne({ where: { email } });
  }
}

2. Import the module in your feature module:

import { Module } from '@nestjs/common';
import { TypeormRepositoryModule } from '@toxicoder/nestjs-typeorm-repository';
import { UserRepository } from './user.repository';

@Module({
  imports: [
    TypeormRepositoryModule.forFeature(UserRepository),
  ],
  providers: [UserService],
  exports: [UserService],
})
export class UserModule {}

Multiple Data Sources

You can specify which data source to use for a repository:

@TypeormRepository(User, 'readOnlyConnection')
export class UserReadOnlyRepository extends Repository<User> {
  // Read-only operations
}

Important Notes

⚠️ Warning: Do not add repository classes to the providers array in your module. This will cause errors as the repositories are already provided by the TypeormRepositoryModule.forFeature() method. Simply declare them in the forFeature() method.

❌ Incorrect:

@Module({
  imports: [
    TypeormRepositoryModule.forFeature(UserRepository),
  ],
  providers: [UserService, UserRepository], // Don't add UserRepository here!
  exports: [UserService],
})

✅ Correct:

@Module({
  imports: [
    TypeormRepositoryModule.forFeature(UserRepository),
  ],
  providers: [UserService],
  exports: [UserService],
})

Examples

Basic Example

// user.repository.ts
import { TypeormRepository } from '@toxicoder/nestjs-typeorm-repository';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@TypeormRepository(User)
export class UserRepository extends Repository<User> {
  findByUsername(username: string) {
    return this.findOne({ where: { username } });
  }
}

// user.module.ts
import { Module } from '@nestjs/common';
import { TypeormRepositoryModule } from '@toxicoder/nestjs-typeorm-repository';
import { UserRepository } from './user.repository';
import { UserService } from './user.service';

@Module({
  imports: [
    TypeormRepositoryModule.forFeature(UserRepository),
  ],
  providers: [UserService],
  exports: [UserService],
})
export class UserModule {}

// user.service.ts
import { Injectable } from '@nestjs/common';
import { UserRepository } from './user.repository';

@Injectable()
export class UserService {
  constructor(private userRepository: UserRepository) {}

  findByUsername(username: string) {
    return this.userRepository.findByUsername(username);
  }
}

Multiple Data Sources Example

// app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UserModule } from './user/user.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      name: 'default',
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'postgres',
      password: 'postgres',
      database: 'app',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
    }),
    TypeOrmModule.forRoot({
      name: 'readOnly',
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'readonly_user',
      password: 'readonly_password',
      database: 'app',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      readonly: true,
    }),
    UserModule,
  ],
})
export class AppModule {}

// user.repository.ts
import { TypeormRepository } from '@toxicoder/nestjs-typeorm-repository';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@TypeormRepository(User)
export class UserRepository extends Repository<User> {
  // Regular repository with write access
}

@TypeormRepository(User, 'readOnly')
export class UserReadOnlyRepository extends Repository<User> {
  // Read-only repository
}

// user.module.ts
import { Module } from '@nestjs/common';
import { TypeormRepositoryModule } from '@toxicoder/nestjs-typeorm-repository';
import { UserReadOnlyRepository, UserRepository } from './user.repository';
import { UserService } from './user.service';

@Module({
  imports: [
    TypeormRepositoryModule.forFeature([
      UserRepository,
      UserReadOnlyRepository,
    ]),
  ],
  providers: [UserService],
  exports: [UserService],
})
export class UserModule {}

// user.service.ts
import { Injectable } from '@nestjs/common';
import { UserReadOnlyRepository, UserRepository } from './user.repository';

@Injectable()
export class UserService {
  constructor(
    private userRepository: UserRepository,
    private userReadOnlyRepository: UserReadOnlyRepository,
  ) {}

  // Use userRepository for write operations
  async create(userData: any) {
    return this.userRepository.save(userData);
  }

  // Use userReadOnlyRepository for read operations
  async findAll() {
    return this.userReadOnlyRepository.find();
  }
}

Data Source Priority

When configuring repositories, you can specify the data source at two levels:

1. In the @TypeormRepository decorator
2. In the TypeormRepositoryModule.forFeature() method

The data source specified in the decorator takes precedence over the one specified in the forFeature() method.

// Decorator data source takes precedence
@TypeormRepository(User, 'readOnly')
export class UserReadOnlyRepository extends Repository<User> {}

// Module configuration
@Module({
  imports: [
    // Even though 'default' is specified here, 'readOnly' from the decorator will be used
    TypeormRepositoryModule.forFeature([UserReadOnlyRepository], 'default'),
  ],
})
export class UserModule {}

If no data source is specified in the decorator, the one from forFeature() will be used:

// No data source specified in decorator
@TypeormRepository(User)
export class UserRepository extends Repository<User> {}

// Module configuration
@Module({
  imports: [
    // 'default' will be used since no data source is specified in the decorator
    TypeormRepositoryModule.forFeature([UserRepository], 'default'),
  ],
})
export class UserModule {}

If no data source is specified in either place, the default data source will be used.

License

ISC