This is an improvement to allow @nestjs/[email protected] to handle CustomRepository. I won't explain it specifically, but it will help in some way. https://github.com/nestjs/typeorm/pull/1233

README.md

You need to provide some classes and decorators yourself to maintain the same style as [email protected].

1. EntityRepository -> CustomRepository

@EntityRepository(UserEntity)
export class UserRepository extends Repository<UserEntity> {}

↓

@CustomRepository(UserEntity)
export class UserRepository extends Repository<UserEntity> {}

2. forFeature -> forCustomRepository

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

↓

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

database.options.ts

@Injectable()
export class DatabaseOptions implements TypeOrmOptionsFactory {

  public createTypeOrmOptions(): TypeOrmModuleOptions {
    return {
      ...
      entities: [UserEntity],
    };
  }
}

typeorm-ex.decorator.ts

import { SetMetadata } from "@nestjs/common";

export const TYPEORM_EX_CUSTOM_REPOSITORY = "TYPEORM_EX_CUSTOM_REPOSITORY";

export function CustomRepository(entity: Function): ClassDecorator {
  return SetMetadata(TYPEORM_EX_CUSTOM_REPOSITORY, entity);
}

typeorm-ex.module.ts

import { DynamicModule, Provider } from "@nestjs/common";
import { getDataSourceToken } from "@nestjs/typeorm";
import { DataSource } from "typeorm";
import { TYPEORM_EX_CUSTOM_REPOSITORY } from "./typeorm-ex.decorator";

export class TypeOrmExModule {
  public static forCustomRepository<T extends new (...args: any[]) => any>(repositories: T[]): DynamicModule {
    const providers: Provider[] = [];

    for (const repository of repositories) {
      const entity = Reflect.getMetadata(TYPEORM_EX_CUSTOM_REPOSITORY, repository);

      if (!entity) {
        continue;
      }

      providers.push({
        inject: [getDataSourceToken()],
        provide: repository,
        useFactory: (dataSource: DataSource): typeof repository => {
          const baseRepository = dataSource.getRepository<any>(entity);
          return new repository(baseRepository.target, baseRepository.manager, baseRepository.queryRunner);
        },
      });
    }

    return {
      exports: providers,
      module: TypeOrmExModule,
      providers,
    };
  }
}

user.module.ts

import { Module } from "@nestjs/common";
import { TypeOrmExModule } from "../database/typeorm-ex.module";
import { UserRepository } from "./user.repository";
import { UserService } from "./user.service";

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

user.repository.ts

import { Repository } from "typeorm";
import { CustomRepository } from "../database/typeorm-ex.decorator";
import { UserEntity } from "./user.entity";

@CustomRepository(UserEntity)
export class UserRepository extends Repository<UserEntity> {}

user.service.ts

import { Injectable } from "@nestjs/common";
import { UserRepository } from "./user.repository";

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

Hey everyone. If you want to use transactions in a simpler way, there's a pretty cool lib that uses cls-hooked for that:

• https://github.com/Aliheym/typeorm-transactional

But we have to modify how custom repositories are provided in typeorm-ex.module.ts as suggested by the author of the lib:

• Aliheym/typeorm-transactional#8 (comment)

Hope this can be helpful to someone. It worked great for me!

I created a utility method to provide custom repositories. Open to feedback: https://gist.github.com/rhutchison/a530d89c37f1978a48dcee4bf2418cb7

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

@Injectable()
export class UserRepository extends Repository<User> {
  constructor(private readonly dataSource: DataSource) {
    super(User, dataSource.manager);
  }
}

Should do the trick. Don't forget to add UserRepository as a provider of the module.

Hello, thanks for your solution, works great to bridge from nestjs v8.x / typeorm 0.2.x to nestjs 9.x / typeorm 0.3.x, however, how do you deal with custom repositories imports / mocks within Unit tests / e2e ?

Thanks in advance fo any insight

Thank you for this solution for managing custom repos.

I have custom repositories and entities in a library, that I install using npm.

Datasources are defined in the client project, so from the client I name the DataSource, and use the name as parameter of TypeOrmExModule.forCustomRepository.

But I get an error saying Nest can't resolve dependencies of the MyEntityRepository (?). Please make sure that the argument DataSource at index [0] is available in the TypeOrmExModule context.

This MyEntityRepository does not exist, but MyEntity and MyRepository do.

Is there a way to fix this?

I tried to add DataSource to list of providers, but then I get:

TypeError: Cannot read properties of undefined (reading 'name') at new DataSource (D:\xxx\src\data-source\DataSource.ts:133:29) at Injector.instantiateClass (D:\xxx\node_modules\@nestjs\core\injector\injector.js:340:19) at callback (D:\xxx\node_modules\@nestjs\core\injector\injector.js:53:45) at Injector.resolveConstructorParams (D:\xxx\node_modules\@nestjs\core\injector\injector.js:132:24) at Injector.loadInstance (D:\xxx\node_modules\@nestjs\core\injector\injector.js:57:13) at Injector.loadProvider (D:\xxx\node_modules\@nestjs\core\injector\injector.js:84:9) at async Promise.all (index 3) at InstanceLoader.createInstancesOfProviders (D:\xxx\node_modules\@nestjs\core\injector\instance-loader.js:47:9) at D:\xxx\node_modules\@nestjs\core\injector\instance-loader.js:32:13 at async Promise.all (index 6)

Thanks a lot.

@GaryHebert What do you mean??? You mean that you import like this???:

TypeOrmExModule.forCustomRepository([DataSource])

@anchan828 Hey, Thanks for your answer. I use it and works perfect.

@GaryHebert What do you mean??? You mean that you import like this???:

TypeOrmExModule.forCustomRepository([DataSource])

I modified the TypeOrmExModule like @anchan828 suggestion on june 10th, adding the dataSourceName parameter.

Firstly, thanks for the gist @anchan828

I don't know nothing about nest js yet and I need to make this update. I did everything but in my service I was injecting the repository with this decorator @InjectRepository as below:

@Injectable()
export class ABCService {

  constructor(
    @InjectRepository(ABCRepository, 'FDM')
    private readonly abcRepository: ABCRepository
  ) {}
.
.
.
}

And after the modifications I'm getting this error:
Nest can't resolve dependencies of the ABCService (?). Please make sure that the argument ABC_ABCRepository at index [0] is available in the ABCModule context.

How can i fix this?
I've tried to manually construct the repository inside the service constructor, but, I don't have any of the necessary arguments there, as EntityManager and QueryRunner.

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

@Injectable()
export class UserRepository extends Repository<User> {
  constructor(private readonly dataSource: DataSource) {
    super(User, dataSource.manager);
  }
}

Should do the trick. Don't forget to add UserRepository as a provider of the module.

This will work for some use cases. But it wont work if you're using transactions, because the repository constructor is called directly inside withRepository().

Unfortunately, the simpler solution (as recommended by @kamilmysliwiec here nestjs/typeorm#1422) does not work with transactions.

Any idea for multiple database connection with custom repositories?

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

@Injectable()
export class UserRepository extends Repository<User> {
  constructor(private readonly dataSource: DataSource) {
    super(User, dataSource.manager);
  }
}

Should do the trick. Don't forget to add UserRepository as a provider of the module.

It works for me, thanks!

Firstly, thanks for the gist @anchan828

I don't know nothing about nest js yet and I need to make this update. I did everything but in my service I was injecting the repository with this decorator @InjectRepository as below:

@Injectable()
export class ABCService {

  constructor(
    @InjectRepository(ABCRepository, 'FDM')
    private readonly abcRepository: ABCRepository
  ) {}
.
.
.
}

And after the modifications I'm getting this error: Nest can't resolve dependencies of the ABCService (?). Please make sure that the argument ABC_ABCRepository at index [0] is available in the ABCModule context.

How can i fix this? I've tried to manually construct the repository inside the service constructor, but, I don't have any of the necessary arguments there, as EntityManager and QueryRunner.

Hi mate, I hit my head into the same issue as yours.
What was your solution for it?
thanks

And after the modifications I'm getting this error: Nest can't resolve dependencies of the ABCService (?). Please make sure that the argument ABC_ABCRepository at index [0] is available in the ABCModule context.
How can i fix this? I've tried to manually construct the repository inside the service constructor, but, I don't have any of the necessary arguments there, as EntityManager and QueryRunner.

Hi mate, I hit my head into the same issue as yours. What was your solution for it? thanks

Add the Repository to the module providers as you would with the service.
e.g

providers: [UserService, UserRepository],

Here is my setup.

user.respository.ts

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

@Injectable()
export class UserRepository extends Repository<User> {
  constructor(private dataSource: DataSource) {
    super(User, dataSource.createEntityManager());
  }
  async findByEmail(email: string) {
    return this.findOne({ where: { email: email } });
  }
}

user.module.ts

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserController } from './user.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './entities/user.entity';
import { UserRepository } from './repositories/user.repository';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [UserController],
  providers: [UserService, UserRepository],
})
export class UserModule {}

Now, I need it in my auth module.
auth.module.ts

@Module({
  imports: [
    TypeOrmModule.forFeature([User]),
  ],
  controllers: [AuthController],
  providers: [AuthService, TokenService, UserService, UserRepository],
})
export class AuthModule {}

Using it in my auth service.
auth.service.ts

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

use this :
@Injectable() export class AuthService { constructor( @InjectRepository(User) private userRepository: UserRepository, private userService: UserService, ) {}

user.repository.ts

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

@Injectable()
export class UserRepository extends Repository {
async findByEmail(email: string) {
return this.findOne({ where: { email: email } });
}
}`