我想我找到了一个解决方案，它允许调用自定义方法，但也允许调用继承的方法。这个“问题”似乎还不太流行，但在typeorm GitHub线程中肯定有一些关于它的讨论：https://github.com/typeorm/typeorm/issues/9013
下面的解决方案使用MySQL作为底层数据库驱动程序，但我认为它也适用于MongoDB。

team.repository.ts

import {DataSource, Repository} from 'typeorm';
import {Injectable} from '@nestjs/common';
import {Team} from '@Domain/Team/Models/team.entity';

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

    /**
     * Add a basic where clause to the query and return the first result.
     */
    async firstWhere(column: string, value: string | number, operator = '='): Promise<Team | undefined>
    {
        return await this.createQueryBuilder()
                         .where(`Team.${column} ${operator} :value`, {value: value})
                         .getOne();
    }
}

team.service.ts

import {Injectable} from '@nestjs/common';
import {Team} from '@Domain/Team/Models/team.entity';
import {TeamRepository} from '@Domain/Team/Repositories/team.repository';

@Injectable()
export class TeamService
{
    constructor(
        private teamRepository: TeamRepository,
    )
    {
    }

    async create(): Promise<Team>
    {
        const team: Team = await this.teamRepository.firstWhere('id', 1);

        return this.teamRepository.save(team);
    }
}

team.module.ts

import {Module} from '@nestjs/common';
import {TeamService} from '@Domain/Team/Services/team.service';
import {TypeOrmModule} from '@nestjs/typeorm';
import {Team} from '@Domain/Team/Models/team.entity';
import {TeamRepository} from '@Domain/Team/Repositories/team.repository';

@Module({
            imports:   [TypeOrmModule.forFeature([Team])],
            exports:   [TeamService],
            providers: [TeamService, TeamRepository],
        })
export class TeamModule
{
}

在TypeORM中为mongo创建自定义仓库的方法如下：

users.repository.ts

在这里，您将使用@Injectable装饰器而不是@EntityRepository，对于inject，schema将使用MongoRepository

// 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;
  }
  

   //write other helpful 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])], // NOTICE: HERE
  controllers: [TasksController], // NOTICE: HERE
  providers: [TasksService],
})
export class TasksModule {}

@Injectable()
export class TasksService {
  constructor(
    @InjectRepository(Task) // NOTICE: 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;
  }
}

我刚刚开发了一个解决这个问题的软件包，你可以看看。
nestjs-typeorm-custom-repository

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

import { User } from './user.entity';

@EntityRepository(User)
export class UsersRepository extends Repository<User> {}

// 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,
  ) {}
  ...
  }
}

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

import { UsersController } from './users.controller';
import { UsersRepository } from './users.repository';
import { UsersService } from './users.service';

@Module({
  imports: [CustomRepositoryModule.forFeature([UsersRepository])],
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}