To set up a custom repository for MongoDB in TypeORM, follow these steps:

users.repository.ts

Instead of using @EntityRepository, utilize the @Injectable decorator and the MongoRepository for injecting the schema.

// users.repository.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { MongoRepository } from 'typeorm';
import { User } from './user.entity';
@Injectable()
export class UsersRepository {
  constructor(
    @InjectRepository(User)
    private readonly usersRepository: MongoRepository<User>,
  ) {}

  async createUser(firstName: string, lastName: string): Promise<User> {
    const user = new User({
      firstName,
      lastName,
    });

    await this.usersRepository.save(user);

    return user;
  }
  

   //include other useful methods here (find, delete, etc...)


}

users.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from './user.entity';
import { UsersRepository } from './users.repository';

@Injectable()
export class UsersService {
  constructor(private readonly usersRepository: UsersRepository) {}

  async createUser(firstName: string, lastName: string): Promise<User> {
    return this.usersRepository.createUser(firstName, lastName);
  }
}

users.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UsersController } from './users.controller';
import { UsersRepository } from './users.repository';
import { UsersService } from './users.service';
import { User } from './user.entity';
import { UsersRepository } from './database/repository/UsersRepository';
@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [UsersController],
  providers: [UsersRepository, UsersService],
  exports: [UsersService],
})
export class UsersModule {}

// task.entity.ts
import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Task {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column()
  title: string;

  @Column()
  description: string;
}

// tasks.repository.ts
import { Injectable } from '@nestjs/common';
import { DataSource, Repository } from 'typeorm';
import { Task } from './tast.entity';

@Injectable()
export class TasksRepository extends Repository<Task> {
  constructor(dataSource: DataSource) {
    super(Task, dataSource.createEntityManager());
  }
}

//tasks.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TasksController } from './tasks.controller';
import { TasksService } from './tasks.service';
import { Task } from './tast.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Task])], // IMPORTANT: ATTENTION HERE
  controllers: [TasksController], // IMPORTANT: ATTENTION HERE
  providers: [TasksService],
})
export class TasksModule {}

@Injectable()
export class TasksService {
  constructor(
    @InjectRepository(Task) // IMPORTANT: ATTENTION HERE
    private readonly tasksRepository: TasksRepository,
  ) {}

  async getTaskById(id: string): Promise<Task> {
    const task = this.tasksRepository.findOne({
      where: {
        id,
      },
    });

    if (!task) {
      throw new NotFoundException(`Task with id ${id} not found`);
    }

    return task;
  }
}

I recently created a solution to address this issue, feel free to take a look.

nestjs-typeorm-custom-repository

// custom-repository.ts
import { Repository } from 'typeorm';
import { EntityRepository } from 'nestjs-typeorm-custom-repository';

import { CustomEntity } from './custom.entity';

@EntityRepository(CustomEntity)
export class CustomRepository extends Repository<CustomEntity> {}

// custom-service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { CustomEntity } from './custom.entity';
import { CustomRepository } from './custom.repository';

@Injectable()
export class CustomService {
  constructor(
    private readonly customRepository: CustomRepository,
  ) {}
  ...
  }
}

// custom-module.ts
import { Module } from '@nestjs/common';
import { CustomRepositoryModule } from 'nestjs-typeorm-custom-repository';

import { CustomController } from './custom.controller';
import { CustomRepository } from './custom.repository';
import { CustomService } from './custom.service';

@Module({
  imports: [CustomRepositoryModule.forFeature([CustomRepository])],
  controllers: [CustomController],
  providers: [CustomService],
  exports: [CustomService],
})
export class CustomModule {}

The Repository.extend function should be used instead of @deprecated for creating a custom repository

It is recommended to follow this structure:

export const UserRepository = dataSource.getRepository(User).extend({
    findByName(firstName: string, lastName: string) {
        return this.createQueryBuilder("user")
            .where("user.firstName = :firstName", { firstName })
            .andWhere("user.lastName = :lastName", { lastName })
            .getMany()
    },
})

This particular problem was tackled using the following method, and it seems to be working smoothly.

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { PlaygroundEntity } from 'src/entities/playground.entity';
import { Repository } from 'typeorm';

@Injectable()
export class PlaygroundRepository {
  constructor(
    @InjectRepository(PlaygroundEntity)
    private readonly _repository: Repository<PlaygroundEntity>,
  ) {}

  public get _() {
    return this._repository;
  }

  async findWithCriteria() {
    return this._.find({ where: { datecolumn: new Date() } });
  }
}

To utilize it, simply inject it as a regular provider.

import { Inject, Injectable } from '@nestjs/common';
import { PlaygroundRepository } from './repositories/pg.repository';

@Injectable()
export class AppService {
  constructor(
    @Inject(PlaygroundRepository)
    private pgRepository: PlaygroundRepository,
  ) {}

  async start() {
    const customMethod = await this.pgRepository.findWithCriteria();

    const defaultMethod = await this.pgRepository._.find();
  }
}

The implementation appears to be neat and easy to understand.