如何在Mongoose中定义类似OCaml的变体类型？

嘿，我刚好也处理过类似的需求——把OCaml那种优雅的变体类型搬到Mongoose里。其实MongoDB本身是无Schema的，但Mongoose的Schema系统可以通过几种方式来模拟这种代数数据类型的效果，下面给你几个实用的方案：

方案一：判别式字段 + 自定义验证 #

这是最直接的实现方式，核心思路是用一个显式的type字段标记变体类型，再通过自定义验证确保对应类型的结构合法性，完美对应OCaml里的Int of int、Pair of int * string结构。

const PostSchema = new mongoose.Schema({
  num: { type: Number },
  name: { type: String },
  variant: {
    // 用type字段区分变体，枚举值对应OCaml的构造器
    type: {
      type: String,
      required: true,
      enum: ['Int', 'Pair']
    },
    // 存储变体对应的值，根据type动态约束结构
    value: mongoose.Schema.Types.Mixed,
    // 自定义验证逻辑，确保类型与值匹配
    validate: {
      validator: function(v) {
        switch(v.type) {
          case 'Int':
            return typeof v.value === 'number';
          case 'Pair':
            // 也可以把Pair做成对象{first: number, second: string}，这里用数组示例
            return Array.isArray(v.value) && 
                   v.value.length === 2 && 
                   typeof v.value[0] === 'number' && 
                   typeof v.value[1] === 'string';
          default:
            return false;
        }
      },
      message: props => `${props.value}不符合变体类型的结构要求！`
    }
  }
});

这种方式的优势是轻量、灵活，不需要额外的模型定义，适合简单的变体场景。

方案二：使用Mongoose鉴别器（Discriminators） #

如果你的变体结构差异较大，甚至需要给不同变体绑定专属方法，Mongoose的鉴别器会是更好的选择。它允许你基于基础Schema创建不同的子模型，自动处理类型标识和字段约束。

// 定义基础变体Schema，指定discriminatorKey作为类型标识字段
const VariantSchema = new mongoose.Schema({}, { discriminatorKey: 'type' });

// 创建Int变体模型，对应OCaml的Int of int
const IntVariant = VariantSchema.discriminator('Int', new mongoose.Schema({
  value: { type: Number, required: true }
}));

// 创建Pair变体模型，对应OCaml的Pair of int * string
const PairVariant = VariantSchema.discriminator('Pair', new mongoose.Schema({
  first: { type: Number, required: true },
  second: { type: String, required: true }
}));

// 在PostSchema中引用基础变体Schema
const PostSchema = new mongoose.Schema({
  num: { type: Number },
  name: { type: String },
  variant: VariantSchema
});

使用鉴别器时，Mongoose会自动在存入数据时添加type字段，查询时也会自动实例化对应的子模型，适合复杂的变体场景。

方案三：自定义Schema类型 #

如果需要在多个Schema中复用这个变体类型，可以封装一个自定义的Mongoose Schema类型，把验证、序列化逻辑全部封装进去，让代码更简洁。

// 自定义变体类型
class VariantType extends mongoose.SchemaType {
  constructor(key, options) {
    super(key, options, 'Variant');
    // 接收允许的变体配置
    this.variants = options.variants || {};
  }

  // 验证输入是否符合变体规则
  validate(val, fn) {
    if (!val || !val.type || !this.variants[val.type]) {
      return fn(new Error(`无效的变体类型: ${val.type}`));
    }
    const variantRule = this.variants[val.type];
    if (!variantRule.validate(val.value)) {
      return fn(new Error(`变体${val.type}的value不符合要求`));
    }
    fn(null);
  }

  // 转换为MongoDB存储格式
  cast(val) {
    if (typeof val !== 'object' || !val.type) {
      throw new Error('变体必须是包含type字段的对象');
    }
    return val;
  }
}

// 注册自定义类型到Mongoose
mongoose.Schema.Types.Variant = VariantType;

// 使用自定义变体类型
const PostSchema = new mongoose.Schema({
  num: { type: Number },
  name: { type: String },
  variant: {
    type: VariantType,
    variants: {
      Int: {
        validate: v => typeof v === 'number'
      },
      Pair: {
        validate: v => Array.isArray(v) && v.length === 2 && typeof v[0] === 'number' && typeof v[1] === 'string'
      }
    }
  }
});

这种方式的优势是高度封装，复用性强，适合需要在多个地方使用相同变体规则的场景。

内容的提问来源于stack exchange，提问作者SoftTimur