nestjs: TypeOrm 0.3.0

custom-repository.util.ts

import { Provider, Type } from '@nestjs/common';
import { getDataSourceToken, getRepositoryToken } from '@nestjs/typeorm';
import { DataSource, DataSourceOptions, Repository } from 'typeorm';

export function provideCustomRepository<T>(
  entity: Type<T>,
  repository: Type<Repository<T>>,
  dataSource?: DataSource | DataSourceOptions | string
): Provider {
  return {
    provide: getRepositoryToken(entity),
    inject: [getDataSourceToken(dataSource)],
    useFactory(dataSource: DataSource) {
      const baseRepository = dataSource.getRepository(entity);
      return new repository(
        baseRepository.target,
        baseRepository.manager,
        baseRepository.queryRunner
      );
    },
  };
}

user.repository.ts

import { FindOneOptions, Raw, Repository } from 'typeorm';
import { User } from '../entities';

// remove @EntityRepository decorator
export class UserRepository extends Repository<User> {
  async findByEmail(options: { email: string }) {
    const searchCriteria = {
      join: { alias: 'user', innerJoin: { emails: 'user.emails' } },
      where: {
        emails: {
          address: Raw((alias) => `LOWER(${alias}) = :email`, {
            email: options.email.toLowerCase(),
          }),
        },
      },
    };

    return await this.findOneOrFail(searchCriteria);
  }
}

users-data.module.ts

import { provideCustomRepository } from './custom-repository.util';
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Email, User } from './entities';
import { UserRepository } from './repositories';
import { UsersService } from './services';

@Module({
  imports: [TypeOrmModule.forFeature([Email, User])],
  providers: [provideCustomRepository(User, UserRepository), UsersService],
  exports: [UsersService],
})
export class UsersDataModule {}

users.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from './entities';
import { UserRepository } from './repositories';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    protected readonly repository: UserRepository
  ) {}
}

@InjectRepository(User)

no need if provide: repository, instead of provide: getRepositoryToken(entity),

import { Provider, Type } from '@nestjs/common';
import { getDataSourceToken } from '@nestjs/typeorm';
import { DataSource, DataSourceOptions, Repository } from 'typeorm';

export function provideCustomRepository<Entity extends Record<string, any>, Repo extends Repository<Entity>>(
    entity: Type<Entity>,
    repository: Type<Repo>,
    dataSource?: DataSource | DataSourceOptions | string
): Provider<Repo> {
    return {
        provide: repository,
        inject: [getDataSourceToken(dataSource)],
        useFactory(dataSource: DataSource) {
            const baseRepository = dataSource.getRepository(entity);
            
            return new repository(
                baseRepository.target,
                baseRepository.manager,
                baseRepository.queryRunner
            );
        },
    };
}

@rhutchison Good job! Have you tried writing tests for this service(with util)? Can you share an example?

great example, could you please provide an example on how to create a dataSource file in typeorm 0.3