问如何解决这个TypeORM错误，“不推荐使用EntityRepository，而是使用Repository.extend函数”？

EN

npm install @nestjs/typeorm@next

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

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mssql',
      ...
      entities: [Photo],
    }),
    TypeOrmExModule.forCustomRepository([PhotoRepository]),
    ...
  ],
  controllers: [AppController],
  providers: [
    AppService
  ],
})
export class AppModule { }

@CustomRepository(Photo)
export class PhotoRepository extends Repository<Photo> {
    public async getAllPhoto() {
        const query = this.createQueryBuilder('photo')
            .where('photo.isPublished = :isPublished', { isPublished: true })
        const photos = await query.getMany()
        return photos
    }
}

  @EntityRepository(Person)
  export class PersonRepository extends Repository<Person> {...}

  @Injectable()
  export class PersonRepository {
    constructor(private dataSource: DataSource) { }

    exampleQueryBuilder() {
      return this.dataSource
          .getRepository(Person)
          .createQueryBuilder() ...
    }

  @Injectable()
  export class PersonService {
    constructor(
      @Inject(PersonRepository)
      private readonly personRepository: PersonRepository,
    ) {}

import { DataSource } from 'typeorm';
require('dotenv').config();

export const AppDataSource = new DataSource({
  type: 'mongodb',
  url: process.env.MONGO_URI,
  useNewUrlParser: true,
  synchronize: true,
  logging: true,
  database: process.env.DB_DATABASE,
  entities: ['dist/entities/*.js'],
  useUnifiedTopology: true,
});

AppDataSource.initialize()
  .then(() => {
    console.log('Data Source has been initialized!');
  })
  .catch((err) => {
    console.error('Error during Data Source initialization', err);
  });

import { AppDataSource } from '@CustomDataSource';
import { Product } from '@Entities';
import { CreateProductDto, UpdateProductDto } from '@Products';

const dataSource = AppDataSource;
export const ProductRepository = 
dataSource.getMongoRepository(Product).extend({
async findOneById(id: number): Promise<Product> {
    const product = await ProductRepository.findOne({ where: { id }});
    return product;
  },
async findMany(): Promise<Product[]> {
    const products = await ProductRepository.find();
    return products;
  },
});