MongoDB 自增序列在 NestJs/Mongoose 中的应用

在本文中，我们将介绍如何在 NestJs 框架中使用 Mongoose 库实现 MongoDB 的自增序列。自增序列是指在每次插入新文档时自动为其分配一个递增的数值标识符。这在许多应用程序中非常有用，例如订单号、用户ID等需要唯一自增的场景。

阅读更多：MongoDB 教程

什么是自增序列？

自增序列是数据库中用于唯一标识每个文档的序列。它通常是一个整数值，每次插入新文档时自动递增。这种方式可以确保每个文档都有一个独特的标识符，并且可以方便地进行排序和查询。

使用 Mongoose 实现自增序列

在 NestJs 中使用 Mongoose 库可以轻松地实现自增序列。首先，我们需要定义一个模式（Schema）并添加一个自增字段。我们可以使用 Mongoose 的中间件来实现自增逻辑。以下是一个示例：

import * as mongoose from 'mongoose';

export const CounterSchema = new mongoose.Schema({
  fieldName: { type: String, required: true },
  count: { type: Number, default: 0 },
});

export interface Counter {
  _id: string;
  fieldName: string;
  count: number;
}

export interface DocumentWithAutoIncrementID extends mongoose.Document {
  _id: number;
  id: number;
}

export const counterModelName = 'Counter';

export const CounterModel = mongoose.model<Counter>(
  counterModelName,
  CounterSchema,
);

export function generateAutoIncrementID(fieldName: string) {
  return async function (this: mongoose.Document) {
    const counter = await CounterModel.findOneAndUpdate(
      { fieldName },
      { $inc: { count: 1 } },
      { new: true, upsert: true },
    ).exec();

    return counter.count;
  };
}

export function AutoIncrementID(fieldName: string) {
  return function (
    target: mongoose.Model<any> & any,
    propertyKey: string,
    descriptor: PropertyDescriptor,
  ) {
    const generateID = generateAutoIncrementID(fieldName);

    target.schema.pre('save', async function (this: DocumentWithAutoIncrementID) {
      if (!this.id) {
        this.id = await generateID.call(this);
      }
    });
  };
}

上述代码中，我们定义了一个名为 Counter 的模式，用于保存自增序列的计数器信息。generateAutoIncrementID 函数用于生成自增序列，并使用 Mongoose 的 findOneAndUpdate 方法进行原子计数器更新。

AutoIncrementID 函数是应用于 Document 的装饰器，可以在保存文档之前生成自增序列。我们只需要在需要自增序列的字段上添加该装饰器即可。例如：

import { Model } from 'mongoose';
import { AutoIncrementID } from './counter.schema';

export interface User extends mongoose.Document {
  id: number;
  name: string;
}

export const UserSchema = new mongoose.Schema({
  id: { type: Number },
  name: { type: String, required: true },
});

UserSchema.index({ id: 1 }, { unique: true });

@AutoIncrementID('user')
export const UserModel: Model<User> = mongoose.model<User>('User', UserSchema);

上述代码中，我们在 UserSchema 中的 id 字段上添加了 @AutoIncrementID(‘user’) 装饰器。这样在保存用户数据时，id 字段会自动递增并分配一个唯一的值。

示例应用：生成订单号

让我们来看一个使用自增序列的实际应用示例：生成订单号。假设我们有一个订单模型：

import { Model } from 'mongoose';
import { AutoIncrementID } from './counter.schema';

export interface Order extends mongoose.Document {
  id: number;
  orderNumber: string;
  amount: number;
  // ...其他字段
}

export const OrderSchema = new mongoose.Schema({
  id: { type: Number },
  orderNumber: { type: String, required: true },
  amount: { type: Number, required: true },
  // ...其他字段
});

OrderSchema.index({ id: 1 }, { unique: true });

@AutoIncrementID('order')
export const OrderModel: Model<Order> = mongoose.model<Order>('Order', OrderSchema);

在上述代码中，我们在 OrderSchema 中的 id 字段上添加了 @AutoIncrementID(‘order’) 装饰器，用于生成订单号。现在，我们可以通过以下方式创建订单：

const order = new OrderModel({
  orderNumber: 'ORD-',
  amount: 100,
  // ...其他订单信息
});

await order.save();
console.log(order.orderNumber); // 输出类似于 "ORD-1" 的订单号

每次创建订单时，id 字段都会自动递增并分配一个唯一的值。