12.nest中使用mongoose实现增删改查，以及如何避坑

一、安装mongoose

$ npm install --save @nestjs/mongoose mongoose

二、配置数据库连接地址

@@filename(app.module)
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { AdminModule } from './module/admin/admin.module';
import { ApiModule } from './module/api/api.module';
import { DefaultModule } from './module/default/default.module';
// 1.引入mongoose
import { MongooseModule } from '@nestjs/mongoose';

@Module({
    imports: [
        AdminModule, ApiModule, DefaultModule,
        // 2.连接数据库 
        // 查数据库的连接地址 1.$ mongodb 2.$ show dbs
        MongooseModule.forRoot("mongodb://127.0.0.1:27017/dadi")
    ],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule { }

**重点：**MongooseModule.forRoot

三、配置 Schema

src/schema/article.schema.ts

import * as mongoose from 'mongoose';
export const ArticleSchema = new mongoose.Schema({
    title: String,
    author: String,
    keywords: String,
    content: String,
    status: Number
})

四、在控制器对应的 Module 中配置 Model

src/module/admin/admin.module

import { Module } from '@nestjs/common';
import { UserController } from './controller/user/user.controller';
import { NewsController } from './controller/news/news.controller';
// 配置数据库模型
import { MongooseModule } from '@nestjs/mongoose';
import { ArticleSchema } from '../../schema/article.schema';
// 引入service
import { ArticleService } from '../../service/article/article.service';

@Module({
  imports:[MongooseModule.forFeature([
    {
      name: "Article",
      schema: ArticleSchema,
      collection: 'article'
    }
  ])],
  controllers: [UserController, NewsController],
  providers: [ArticleService]
})
export class AdminModule {}

**总结：**name: "Article"在service中会用到

五、在服务里面使用 InjectModel 获取数据库 Model 实现 操作数据库

在服务中获取服务器数据

创建服务 nest g service service/article

article.service.ts 内容

import { Injectable } from '@nestjs/common';
// 1.引入injectModel 
import { InjectModel } from '@nestjs/mongoose';
@Injectable()
export class ArticleService {
    // 2.引入admin.module中的Article
    constructor(@InjectModel('Article') private articleModel ){}
    async findAll() {
        let result = await this.articleModel.find().exec();
        return result;
    }
}

**重点：**引入admin.module中的Article，constructor(@InjectModel(‘Article’) private articleModel ){}

在controll中使用服务

1.admin.module中引入服务

...
// 引入service
import { ArticleService } from '../../service/article/article.service';

@Module({
  ...
  providers:[ArticleService]
})
export class AdminModule {}

在news.controller中引入

import { Controller, Get } from '@nestjs/common';
import { ArticleService } from '../../../../service/article/article.service';

@Controller('admin/news')
export class NewsController {
    constructor(
        private articleService:ArticleService
    ){}

    @Get()
    async index() {
        let result = await this.articleService.findAll();
        return result;
    }
}

处理报错（此坑必看）

在service中引入module中的schema的名称后，项目会报错

Nest can't resolve dependencies of the RoleService (?). Please make sure that the argument RoleModel at index [0] is available in the AppModule context.

原因

原因是用nest g service创建service后，默认会在app.module中也引入刚创建的service，但是app.module中没有引入schema，所以报错。

解决办法：在app.module中删除刚创建的service。

六、查看结果

1. 启动服务npm run start:dev
2. 浏览期中查看 http://localhost:3000/admin/news

七、进阶：增删改查示例

需求：对user表做增删改查

根据mongoose文档，对user表做增删改查。

注：在上述技术的基础上联系。

user.schema

import * as mongoose from 'mongoose';
export const UserSchema = new mongoose.Schema({
    "username": String,
    "password": String,
    "name": String,
    "age": Number,
    "sex": String,
    "tel": Number,
})

admin.module.ts

import { Module } from '@nestjs/common';
import { UserController } from './controller/user/user.controller';
import { NewsController } from './controller/news/news.controller';
// 配置数据库模型
import { MongooseModule } from '@nestjs/mongoose';
import { ArticleSchema } from '../../schema/article.schema';
import { UserSchema } from '../../schema/user.schema';
// 引入service
import { ArticleService } from '../../service/article/article.service';
import { UserService } from '../../service/user/user.service';

@Module({
  imports:[MongooseModule.forFeature([
    {
      name: "Article",
      schema: ArticleSchema,
      collection: 'article'
    },
    {
      name: "User",
      schema: UserSchema,
      collection: 'users'
    }
  ])],
  controllers: [UserController, NewsController],
  providers: [ArticleService, UserService]
})
export class AdminModule {}

user.service.ts

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { User } from '../../interface/user.interface'
@Injectable()
export class UserService {
    constructor(@InjectModel('User') private userModel) {}
    // 查询
    // 第二个参数的作用是返回的数据中包含哪些字段
    async findAll(json?:User, fields?:String) {
        let result = await this.userModel.find(json, fields).exec();
        return result;
    }

    // 增加
    async create(json:User) {
        let result = await this.userModel.create(json)
        return result;
    }

    // 修改
    async update(json1:User, json2:User) {
        let result = await this.userModel.findOneAndUpdate(json1,json2)
        return result;
    }

    // 删除
    async delete(json) {
        let result = await this.userModel.deleteOne(json)
        return result;
    }
}

user.controller

import { Controller, Get } from '@nestjs/common';
import { UserService } from '../../../../service/user/user.service';

@Controller('admin/user')
export class UserController {
    constructor(private userService: UserService) {}

    @Get()
    async index() {
        let result = await this.userService.findAll({}, 'name tel'); 
        return result;
    }

    @Get('create')
    async create() {
        let params = {
            "username": 'zhangsan3',
            "password": '123455',
            "name": '张三2',
            "age": 20,
            "sex": '男',
            "tel": 101,
        }
        let result = await this.userService.create(params); 
        return result;
    }

    @Get('update')
    async update() {
        let params1 = {
            "username": 'zhangsan2',
        }
        let params2 = {
            "name": '张三2222',
        }
        let result = await this.userService.update(params1, params2); 
        return result;
    }

    @Get('delete')
    async delete() {
        let params = {
            "username": 'zhangsan3',
        }
        let result = await this.userService.delete(params); 
        return result;
    }
}

运行

http://localhost:3000/admin/user/...