在 NestJS 中链接 MongoDB 有两种方法。一种方法就是使用TypeORM来进行连接，另外一种方法就是使用Mongoose。

此笔记主要是记录使用Mongoose的。所以我们先安装所需的依赖：

npm i @nestjs/mongoose mongoose

安装完成后，需要在AppModule中引入MongooseModule。具体实例如下：

import databaseConfig from "./config/database.config";
import { MongooseModule } from "@nestjs/mongoose";@Module({imports: [MongooseModule.forRoot("mongodb://localhost:27017/managementsytem"),CommodityModule,],
})
export class AppModule {}

MongooseModule.forRoot中的配置对象与mongoose.connect()的配置对象一致。

模型注入

在 Mongoose 中最为核心的是模式，因为每个模式都会转换成一个具体的MongoDB集合，并且模式定义了集合中文档的结构。

在 Mongoose 中模型主要是负责从底层创建数据和读取文档。

在 NestJs 中模式可以使用装饰器来创建，也可以使用 Mongoose 本身手动创建。使用装饰器创建的模式在代码量和代码可读性上都比 Mongoose 本身手动创建的要好。所以建议使用装饰器来创建模式。具体的实例如下：

import { HydratedDocument } from "mongoose";
import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";export type CommodityDocument = HydratedDocument<Commodity>;@Schema()
export class Commodity {@Prop()name: string; // 商品名称@Prop()price: number; // 商品价格@Prop()stock: number; // 商品库存@Prop([String])tag: string; // 商品标签
}export const CommoditySchema = SchemaFactory.createForClass(Commodity);

注意：
您还可以使用 DefinitionsFactory 类生成原始模式定义。这允许您手动修改根据您提供的元数据生成的架构定义。当模型的字段可能会进行扩展和删除的时候，我们就可以使用DefinitionsFactory来维护模式的数据。

@Schema()装饰器的作用主要是定义模式。在上述的例子中会把Commodity类映射到同名的MongoDB集合中，但是需要注意的是在 MongoDB 集合中的名称会添加一个’s’，即Commoditys。此装饰器可以接受一个可选参数，此参数主要是用于设置 MongoDB 的模型相关参数，具体的内容可以进入这里查看。

@Prop() 装饰器定义文档中的属性。例如，在上面的模式定义中，我们定义了三个属性：名称、价格和标签。借助 TypeScript 元数据（和反射）功能，可以自动推断这些属性的架构类型。但是，在无法隐式反映类型的更复杂场景（例如数组或嵌套对象结构）中，必须显式指示类型，如下所示：

@Prop([String])
tags: string[];

或者，@Prop() 装饰器接受选项对象参数（阅读有关可用选项的更多信息）。这样，您可以指示属性是否是必需的、指定默认值或将其标记为不可变。例如：

@Prop({ required: true })
name: string;

如果一个模型中带有另外一个属性的话，可以使用@Prop()装饰器。例如，Commodity 里面包含一个 supply 模型，这样我们需要在 Commodity 里面添加具体的类和引用。具体例子如下：

import * as mongoose from 'mongoose';
import { Supply } from '../owners/schemas/supply.schema';@Prop({ type: mongoose.Schema.Types.ObjectId, ref: 'Supply' })
supply: Supply;

如果有多个提供商，您的属性配置应如下所示：

@Prop({ type: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Supply' }] })
supply: Supply[];

最后，原始模式定义也可以传递给装饰器。例如，当属性表示未定义为类的嵌套对象时，这很有用。为此，请使用 @nestjs/mongoose 包中的 raw() 函数，如下所示：

@Prop(raw({firstName: { type: String },lastName: { type: String }
}))
details: Record<string, any>;

或者，如果您不想使用装饰器，则可以手动定义架构。例如:

export const CommoditySchema = new mongoose.Schema({name: String,price: Number,stock: Number,tags: [String],
});

当我们定义好模式后，就可以在对应的Module中进行定义，具体实例如下：

@Module({imports: [ConfigModule,MongooseModule.forFeature([{ name: Commodity.name, schema: CommoditySchema },]),],controllers: [CommodityController],providers: [CommodityService],
})
export class CommodityModule {}

MongooseModule 提供了 forFeature() 方法来配置模块，包括定义应在当前范围内注册哪些模型。如果您还想在另一个模块中使用模型的话，你只要在 CommodityModule 中添加 MongooseModule 作为导出部分，并在另一个模块中导入 CommodityModule 就可以。

注册模式后，您可以使用 @InjectModel() 装饰器将 Commodity 模型注入到 CommodityService 中：

import { Injectable } from "@nestjs/common";
import { InjectModel } from "@nestjs/mongoose";
import { Model } from "mongoose";
import { Commodity } from "src/schemas/commodity.schemas";@Injectable()
export class CommodityService {constructor(@InjectModel(Commodity.name) private commodityModel: Model<Commodity>) {}create(commodity: Commodity) {const createdCommdity = new this.commodityModel(commodity);return createdCommdity.save();}
}

获取 Mongoose Connection 对象

有时您可能需要访问本机 Mongoose Connection 对象。例如，您可能希望对连接对象进行本机 API 调用。您可以使用 @InjectConnection() 装饰器注入 Mongoose Connection，如下所示：

import { Injectable } from "@nestjs/common";
import { InjectConnection } from "@nestjs/mongoose";
import { Connection } from "mongoose";@Injectable()
export class CatsService {constructor(@InjectConnection() private connection: Connection) {}
}

多个数据库使用

有些项目需要多个数据库连接。这也可以通过该模块来实现。要使用多个连接，请首先创建连接。在这种情况下，连接命名就成为强制性的。具体实例如下：

import { Module } from "@nestjs/common";
import { CommodityModule } from "./module/commodity.module";
import { AccountModule } from "./module/account.module";
import { ConfigModule } from "@nestjs/config";
import configuration from "./config/configuration";
import databaseConfig from "./config/database.config";
import { MongooseModule } from "@nestjs/mongoose";@Module({imports: [ConfigModule.forRoot({load: [configuration, databaseConfig],cache: true,}),MongooseModule.forRoot("mongodb://localhost:27017/managementsytem", {connectionName: "commodity",}),MongooseModule.forRoot("mongodb://localhost:27018/user", {connectionName: "user",}),CommodityModule,AccountModule,],
})
export class AppModule {}

**注意：**您不应有多个没有名称或名称相同的连接，否则它们将被覆盖。

假如你设置了多个数据链接后，你必须在对应的模块中使用MongooseModule.forFeature()函数来声明链接哪个数据库。具体的例子如下：

@Module({imports: [ConfigModule,MongooseModule.forFeature([{ name: Commodity.name, schema: CommoditySchema }],"commodity"),],controllers: [CommodityController],providers: [CommodityService],exports: [CommodityService],
})
export class CommodityModule {}

如果您在 AppModule 中声明了多个数据库，并在对应的模块中声明了链接的数据库名称，那么我们的提供者就需要在装饰器中添加第二个参数。具体实例如下：

@Injectable()
export class CatsService {constructor(@InjectModel(Commodity.name, "commodities")private commodityModel: Model<Commodity>) {}async create(commodity: Commodity) {const createdCommdity = new this.commodityModel(commodity);const _res = await createdCommdity.save();return _res;}
}

您还可以为给定连接注入连接：

import { Injectable } from "@nestjs/common";
import { InjectConnection } from "@nestjs/mongoose";
import { Connection } from "mongoose";@Injectable()
export class CommodityService {constructor(@InjectConnection("commodity") private connection: Connection) {}
}

要将给定连接注入到自定义提供程序（例如工厂提供程序），请使用 getConnectionToken() 函数，将连接名称作为参数传递。

{provide: CommodityService,useFactory: (commodityConnection: Connection) => {return new CommodityService(commodityConnection);},inject: [getConnectionToken('commodity')],
}

Mongo 钩子（中间件）

Mongo 钩子的使用场景一般都是在编写自己的插件时才会使用。

Mongo 的中间件是在模式级别指定的，对于编写插件很有用。编译模型后调用 pre() 或 post() 在 Mongoose 中不起作用。要在模型注册之前注册钩子，请使用 MongooseModule 的 forFeatureAsync() 方法以及工厂提供程序（即 useFactory）。通过这种技术，您可以访问模式对象，然后使用 pre() 或 post() 方法在该模式上注册挂钩。具体实例如下：

@Module({imports: [MongooseModule.forFeatureAsync([{name: Commodity.name,useFactory: () => {const schema = CommoditySchema;schema.pre("save", function () {console.log("Hello from pre save");});return schema;},},]),],
})
export class AppModule {}

与其他工厂提供者一样，我们的工厂函数可以是异步的，并且可以通过注入注入依赖项。

@Module({imports: [MongooseModule.forFeatureAsync([{name: Commodity.name,imports: [ConfigModule],useFactory: (configService: ConfigService) => {const schema = CommoditySchema;schema.pre('save', function() {console.log(`${configService.get('APP_NAME')}: Hello from pre save`,),});return schema;},inject: [ConfigService],},]),],
})
export class AppModule {}

中间件中使用插件

要为给定架构注册插件，请使用 forFeatureAsync() 方法。

@Module({imports: [MongooseModule.forFeatureAsync([{name: Commodity.name,useFactory: () => {const schema = CommoditySchema;schema.plugin(require("mongoose-autopopulate"));return schema;},},]),],
})
export class AppModule {}

要一次为所有模式注册插件，请调用 Connection 对象的 .plugin() 方法。您应该在创建模型之前访问连接；为此，请使用连接工厂：

import { Module } from "@nestjs/common";
import { MongooseModule } from "@nestjs/mongoose";@Module({imports: [MongooseModule.forRoot("mongodb://localhost/test", {connectionFactory: (connection) => {connection.plugin(require("mongoose-autopopulate"));return connection;},}),],
})
export class AppModule {}

鉴别器

鉴别器是一种模式继承机制。它们使您能够在同一底层 MongoDB 集合之上拥有具有重叠架构的多个模型。这个功能相当于模型形成继承关系。

假设您想在单个集合中跟踪不同类型的事件。每个事件都会有一个时间戳。

@Schema({ discriminatorKey: "kind" })
export class Event {@Prop({type: String,required: true,enum: [ClickedLinkEvent.name, SignUpEvent.name],})kind: string;@Prop({ type: Date, required: true })time: Date;
}export const EventSchema = SchemaFactory.createForClass(Event);

SignedUpEvent 和 ClickedLinkEvent 实例将与通用事件存储在同一集合中。

现在，让我们定义 ClickedLinkEvent 类，如下所示：

@Schema()
export class ClickedLinkEvent {kind: string;time: Date;@Prop({ type: String, required: true })url: string;
}export const ClickedLinkEventSchema =SchemaFactory.createForClass(ClickedLinkEvent);

和 SignUpEvent 类：

@Schema()
export class SignUpEvent {kind: string;time: Date;@Prop({ type: String, required: true })user: string;
}export const SignUpEventSchema = SchemaFactory.createForClass(SignUpEvent);

完成此操作后，使用鉴别器选项为给定模式注册鉴别器。它适用于 MongooseModule.forFeature 和 MongooseModule.forFeatureAsync：

import { Module } from "@nestjs/common";
import { MongooseModule } from "@nestjs/mongoose";@Module({imports: [MongooseModule.forFeature([{name: Event.name,schema: EventSchema,discriminators: [{ name: ClickedLinkEvent.name, schema: ClickedLinkEventSchema },{ name: SignUpEvent.name, schema: SignUpEventSchema },],},]),],
})
export class EventsModule {}

完成上述的代码后，其实模型之间的关系如下：

异步配置

当您需要异步而不是静态地传递模块选项时，请使用 forRootAsync() 方法。与大多数动态模块一样，Nest 提供了多种处理异步配置的技术。

一种技术是使用工厂函数：

MongooseModule.forRootAsync({useFactory: () => ({uri: "mongodb://localhost/nest",}),
});

与其他工厂提供者一样，我们的工厂函数可以是异步的，并且可以通过注入注入依赖项。

MongooseModule.forRootAsync({imports: [ConfigModule],useFactory: async (configService: ConfigService) => ({uri: configService.get<string>("MONGODB_URI"),}),inject: [ConfigService],
});

或者，您可以使用类而不是工厂来配置 MongooseModule，如下所示：

MongooseModule.forRootAsync({useClass: MongooseConfigService,
});

上面的构造在 MongooseModule 中实例化 MongooseConfigService，使用它来创建所需的选项对象。请注意，在此示例中，MongooseConfigService 必须实现 MongooseOptionsFactory 接口，如下所示。MongooseModule 将在所提供的类的实例化对象上调用 createMongooseOptions() 方法。

@Injectable()
export class MongooseConfigService implements MongooseOptionsFactory {createMongooseOptions(): MongooseModuleOptions {return {uri: "mongodb://localhost/nest",};}
}

如果您想重用现有的选项提供程序而不是在 MongooseModule 内创建私有副本，请使用 useExisting 语法。

MongooseModule.forRootAsync({imports: [ConfigModule],useExisting: ConfigService,
});