如何在nestJs中使用estimatedDocumentCount的猫鼬？

Question

我有一个问题，我正在尝试使用 nestJs 重构我的 nodeJs 服务器。

这里的想法是在启动服务器时检查“角色”集合是否已经存在并包含条目，如果不存在，我们在 mongoDB 集合中生成角色。

我有这个文件夹结构：“模型”文件夹中的猫鼬模式和导入它们的 index.js：

./models/role.model.js

const mongoose = require("mongoose");
const Role = mongoose.model(
  "Role",
  new mongoose.Schema({
    name: String
  })
);
module.exports = Role;

./models/index.js

const mongoose = require('mongoose');
mongoose.Promise = global.Promise;
const db = {};
db.mongoose = mongoose;
db.user = require("./user.model");
db.role = require("./role.model");
db.ROLES = ["user", "admin", "moderator"];
module.exports = db;

然后，在 server.js 中，我将 index.js 导入为 db，然后我将 Role 定义为 db.role，并使用带有“Role.estimatedDocumentCount”的 init 函数来计算文档数量并执行一些逻辑：

./server.js

const db = require("./models");
const Role = db.role;
[...]
function init() {
  Role.estimatedDocumentCount((err, count) => {
    if (!err && count === 0) {
      new Role({
        name: "user"
      }).save(err => {
        if (err) {
          console.log("error", err);
        }
        console.log("added 'user' to roles collection");
      });
    }
  });
}

它在我的 nodeJs 服务器 上运行得非常好，但是新的 nestJs 服务器 出现了问题，基本上，我认为这是一个类型问题 ，并且我不确定我的方法在nestjs环境中是否合法，假设我是其中的绝对初学者......这就是我尝试过的：

./schemas/role.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type RoleDocument = Role & Document;

@Schema()
export class Role {
  @Prop()
  name: string;
}

export const RoleSchema = SchemaFactory.createForClass(Role);

./schemas/index.ts

import mongoose from 'mongoose';
import { User } from './user.schema'
import { Role } from './role.schema'

mongoose.Promise = global.Promise;
export const db = {
  mongoose: mongoose,
  user: User,
  role: Role,
  ROLES: ["user", "admin", "moderator"]
};

./main.ts

[...]
import { db } from './auth/schemas';
const Role = db.role;
[...]
function init() {
  Role.estimatedDocumentCount((err, count) => {
    if (!err && count === 0) {
      new Role({
        name: "user"
      }).save(err => {
        if (err) {
          console.log("error", err);
        }
        console.log("added 'user' to roles collection");
      });

    }
  });
}

但它不起作用，我收到此错误：

当我检查 nodeJs 服务器 上的类型时，我有这个：

但是在 nestJs 服务器 上我得到了另一种类型，这就是为什么我认为我的问题来自类型，或者由于某种原因该方法与 nodeJs 上的工作方式不同......

编辑：我也尝试在我的 main.ts 文件中直接获取 roleSchema，我得到了一个更有趣的类型，但它也不起作用：

import { RoleSchema } from './auth/schemas/role.schema';
function init() {
  RoleSchema.estimatedDocumentCount((err, count) => {
    if (!err && count === 0) {
      new Role({
        name: "user"
      }).save(err => {
        if (err) {
          console.log("error", err);
        }
        console.log("added 'user' to roles collection");
      });

    }
  });
}

EDIT2：回复 gianfranco

auth.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { JwtModule } from '@nestjs/jwt';
import { MongooseModule } from '@nestjs/mongoose';
import { PassportModule } from '@nestjs/passport';
import { JwtStrategy } from './strategies/jwt.strategy';
import { LocalStrategy } from './strategies/local.strategy';

import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UserSchema } from './schemas/user.schema';
import { RoleSchema } from './schemas/role.schema';

@Module({
  imports: [
    ConfigModule.forRoot(),
    MongooseModule.forFeature([{ name: 'User', schema: UserSchema },{ name: 'Role', schema: RoleSchema}]),
    PassportModule,
    JwtModule.register({
      secret: process.env.JWT_SECRET,
      signOptions: { expiresIn: '60s' },
    }),
  ],
  providers: [AuthService, LocalStrategy, JwtStrategy],
  controllers: [AuthController],
  exports: [AuthService],
})
export class AuthModule {}

auth.controller.ts

import {
  Body,
  Controller,
  Post,
  Get,
  Res,
  Request,
  UseGuards,
  ValidationPipe,
} from '@nestjs/common';
import express, { Response } from 'express';

import { AuthService } from './auth.service';
import { AuthCredentialsDto } from './dto/auth-credentials.dto';
import { LocalAuthGuard } from './guards/auth.guard';
import { JwtAuthGuard } from './guards/jwt-auth.guard';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  @Post('signup')
  async signUp(
    @Body(ValidationPipe) authCredentialsDto: AuthCredentialsDto,
  ): Promise<void> {
    return await this.authService.signUp(authCredentialsDto);
  }

  @UseGuards(LocalAuthGuard)
  @Post('signin')
  async signIn(@Request() req) {
    return this.authService.signIn(req.user);
  }

  @UseGuards(JwtAuthGuard)
  @Get('me')
  getMe(@Request() req) {
    return req.user;
  }
}

非常感谢您的帮助！

Answer 1

关键是在auth.service.ts中实现逻辑，而不是在main.ts中设置。感谢您的帮助！