typescript mongoose错误是什么原因-schema._preCompile(); ^ TypeError：无法读取未定义的属性（读取“_preCompile”）？

Question

在运行我的 Nest.js 应用程序时进行类型检查后，我收到以下错误 schema._preCompile(); ^ TypeError：无法读取未定义的属性（读取“_preCompile”）？

我怀疑 LanguageDocument.ts 中的这一行代码基于下面错误屏幕截图中提供的堆栈跟踪，我在其中从工厂类创建了一个模式。但我不明白为什么这会突然抛出异常，因为它实际上在一天前工作。😩

export const LanguageSchema = SchemaFactory.createForClass(LanguageDocument)

我在下面提供了完整的代码。非常感谢您的帮助。

DatabaseModule.ts

import { Module } from '@nestjs/common'
import { ConfigService } from '@nestjs/config'
import { MongooseModule } from '@nestjs/mongoose'
import { RedisModule } from 'nestjs-redis'

@Module({
  imports: [
    MongooseModule.forRootAsync({
      useFactory: (configService: ConfigService) => ({
        uri: configService.get<string>('MONGODB_URI'),
      }),
      inject: [ConfigService],
    }),
  ],
})
export class DocumentDatabaseModule {}

BaseDocument.ts

import { Prop } from '@nestjs/mongoose'
import { SchemaTypes } from 'mongoose'
import { v4 as uuid } from 'uuid'

export abstract class BaseDocument {
  @Prop({ type: SchemaTypes.UUID, default: () => uuid() })
  public _id: string

  @Prop({ type: SchemaTypes.String, default: '' })
  public code: string

  @Prop({ type: SchemaTypes.Boolean, default: true })
  public draft: boolean

  @Prop({ type: SchemaTypes.Boolean, default: true })
  public active: boolean

  constructor(draft: boolean, active: boolean, _id?: string, code?: string) {
    this._id = _id
    this.code = code
    this.draft = draft
    this.active = active
  }
}

LanguageDocument.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
import { BaseDocument } from './base.document'
import { SchemaTypes } from 'mongoose'

@Schema({ versionKey: false, collection: 'languages' })
export class LanguageDocument extends BaseDocument {
  @Prop({ type: SchemaTypes.String })
  public name: string

  @Prop({ type: SchemaTypes.String, default: '' })
  public nativeName: string

  @Prop({ type: SchemaTypes.String, default: '' })
  public symbol: string

  constructor(name: string, nativeName: string, symbol: string, draft: boolean,
    active: boolean, _id?: string, code?: string,
  ) {
    super(draft, active, _id, code)
    this.name = name
    this.nativeName = nativeName
    this.symbol = symbol
    this.draft = draft
    this.active = active
    this._id = _id
    this.code = code
  }
}

export const LanguageSchema = SchemaFactory.createForClass(LanguageDocument)

DocumentRepository.ts

import { Injectable } from '@nestjs/common'
import { InjectModel } from '@nestjs/mongoose'
import { Model} from 'mongoose'
import { BaseDocument } from '@mio/document'

@Injectable()
export abstract class DocumentRepository<TDocument extends BaseDocument> {
  constructor(
    @InjectModel('TDocument') private readonly model: Model<TDocument>,
  ) {}

  public async create(document: Omit<TDocument, '_id'>): Promise<TDocument> {
    console.log('called')
    return await new this.model({
      ...document,
      _id: undefined,
    }).save()
  }
}

LanguageRepository.ts

import { DocumentRepository } from '@mio/database'
import { LanguageDocument } from '@mio/document'
import { Injectable, Logger } from '@nestjs/common'
import { InjectModel } from '@nestjs/mongoose'
import { Model } from 'mongoose'

@Injectable()
export class LanguageRepository extends DocumentRepository<LanguageDocument> {
  protected readonly logger = new Logger(LanguageRepository.name)

  constructor(
    @InjectModel(LanguageDocument.name)
    LanguageModel: Model<LanguageDocument>,
  ) {
    super(LanguageModel)
  }
}

SeederModule.ts

import { Module } from '@nestjs/common'
import { SeederService } from './seeder.service'
import { ConfigModule } from '@nestjs/config'
import * as Joi from 'joi'
import { DocumentDatabaseModule } from '@mio/database'
import { LanguageRepository } from 'apps/language/src/infrasctructure/language.repository'
import { MongooseModule } from '@nestjs/mongoose'
import { LanguageDocument, LanguageSchema } from '@mio/document'

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: Joi.object({
        MONGODB_URI: Joi.string().required(),
      }),
      envFilePath: './apps/seeder/.env',
    }),
    DocumentDatabaseModule,
    MongooseModule.forFeature([
      { name: LanguageDocument.name, schema: LanguageSchema },
    ]),
  ],
  providers: [SeederService, LanguageRepository],
})
export class SeederModule {}

SeederService.ts

import { Injectable } from '@nestjs/common'
import { LanguageRepository } from 'apps/language/src/infrasctructure/language.repository'
import { languages } from 'data/configuration.data'

@Injectable()
export class SeederService {
  constructor(
    private readonly _languageRepository: LanguageRepository,
  ) {}

  public async seedlanguages(): Promise<boolean> {
    return (
      (await this._languageRepository.create(languages[0]))._id !==
      null
    )
  }
}