如何为Firebase Realtime Database创建类Mongoose的结构化Schema？

嘿，这个需求太贴合实际了——毕竟Firebase本身不像Mongoose那样自带Schema校验机制，但我们完全可以手动实现一套类似的结构，来确保写入Firebase的数据严格符合规范。下面我分Firestore和Realtime Database两种最常用的场景，给你一步步讲具体实现方式：

Firestore是文档型数据库，和MongoDB结构更接近，模拟Mongoose的Schema会更顺手。我们可以用类+校验函数的方式封装：

1. 先定义Schema规则 #

像Mongoose那样，先声明每个字段的类型、必填性、默认值、自定义校验逻辑：

// 示例：用户数据的Schema
const UserSchema = {
  userId: {
    type: String,
    required: true,
    validate: (value) => value.startsWith('user_') // 自定义规则：必须以user_开头
  },
  username: {
    type: String,
    required: true,
    maxLength: 20,
    minLength: 3
  },
  email: {
    type: String,
    required: true,
    validate: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
  },
  age: {
    type: Number,
    min: 18,
    max: 100,
    default: 18
  },
  createdAt: {
    type: Date,
    default: () => new Date()
  }
};

2. 编写通用校验函数 #

写一个工具函数，接收待写入数据和Schema，返回校验结果和处理后的数据（填充默认值）：

function validateData(data, schema) {
  const errors = [];
  const processedData = { ...data };

  // 遍历Schema规则
  for (const field in schema) {
    const rules = schema[field];
    const value = processedData[field];

    // 校验必填字段
    if (rules.required && (value === undefined || value === null)) {
      errors.push(`字段「${field}」为必填项`);
      continue;
    }

    // 字段有值时的校验逻辑
    if (value !== undefined && value !== null) {
      // 类型校验
      if (typeof value !== rules.type.toLowerCase()) {
        errors.push(`字段「${field}」类型错误，预期为${rules.type}`);
      }

      // 自定义校验函数
      if (rules.validate && !rules.validate(value)) {
        errors.push(`字段「${field}」不符合格式要求`);
      }

      // 长度/数值范围校验
      if (rules.maxLength && value.length > rules.maxLength) {
        errors.push(`字段「${field}」长度不能超过${rules.maxLength}`);
      }
      if (rules.minLength && value.length < rules.minLength) {
        errors.push(`字段「${field}」长度不能少于${rules.minLength}`);
      }
      if (rules.max && value > rules.max) {
        errors.push(`字段「${field}」不能大于${rules.max}`);
      }
      if (rules.min && value < rules.min) {
        errors.push(`字段「${field}」不能小于${rules.min}`);
      }
    } else {
      // 字段无值时填充默认值
      if (rules.default !== undefined) {
        processedData[field] = typeof rules.default === 'function' 
          ? rules.default() 
          : rules.default;
      }
    }
  }

  // 校验未知字段（可选：禁止Schema外的字段写入）
  const unknownFields = Object.keys(processedData).filter(field => !(field in schema));
  if (unknownFields.length > 0) {
    errors.push(`存在未定义字段：${unknownFields.join(', ')}`);
  }

  return {
    isValid: errors.length === 0,
    errors,
    processedData
  };
}

3. 封装成可复用的Model类 #

把Schema、校验和Firestore操作封装成Model，像Mongoose那样调用：

class FirestoreModel {
  constructor(collectionName, schema) {
    this.collection = firebase.firestore().collection(collectionName);
    this.schema = schema;
  }

  // 创建文档
  async create(data) {
    const { isValid, errors, processedData } = validateData(data, this.schema);
    if (!isValid) {
      throw new Error(`数据校验失败：${errors.join('; ')}`);
    }

    const docRef = await this.collection.add(processedData);
    return { id: docRef.id, ...processedData };
  }

  // 根据ID更新文档
  async update(docId, data) {
    const { isValid, errors, processedData } = validateData(data, this.schema);
    if (!isValid) {
      throw new Error(`数据校验失败：${errors.join('; ')}`);
    }

    await this.collection.doc(docId).update(processedData);
    return { id: docId, ...processedData };
  }

  // 按需添加get、delete等其他操作
}

// 实例化用户Model
const UserModel = new FirestoreModel('users', UserSchema);

4. 使用示例 #

// 创建用户
try {
  const newUser = await UserModel.create({
    userId: 'user_123456',
    username: 'john_doe',
    email: 'john@example.com'
  });
  console.log('用户创建成功：', newUser);
} catch (err) {
  console.error('创建失败：', err.message);
}

Realtime Database是树形JSON结构，校验思路类似，可结合路径做细粒度控制：

1. 定义路径对应的Schema和校验函数 #

// 按数据路径定义Schema
const RTDBSchema = {
  '/users/{userId}': {
    userId: { type: String, required: true },
    username: { type: String, required: true },
    email: { type: String, required: true, validate: (val) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val) }
  }
};

function validateRTDBData(data, path) {
  const schema = RTDBSchema[path];
  if (!schema) return { isValid: true }; // 无对应Schema时跳过校验（可按需修改）

  const errors = [];
  for (const field in schema) {
    const rules = schema[field];
    const value = data[field];

    if (rules.required && (value === undefined || value === null)) {
      errors.push(`字段「${field}」必填`);
      continue;
    }

    if (value !== undefined) {
      if (typeof value !== rules.type.toLowerCase()) {
        errors.push(`字段「${field}」类型错误`);
      }
      if (rules.validate && !rules.validate(value)) {
        errors.push(`字段「${field}」格式错误`);
      }
    }
  }

  return { isValid: errors.length === 0, errors };
}

2. 封装写入函数 #

async function writeToRTDB(path, data) {
  const { isValid, errors } = validateRTDBData(data, path);
  if (!isValid) {
    throw new Error(`数据校验失败：${errors.join('; ')}`);
  }

  await firebase.database().ref(path).set(data);
  return data;
}

前端的Schema校验只是第一道防线，恶意用户可以绕过前端直接请求Firebase API，所以一定要在Firebase控制台的安全规则里再做一层校验。比如Firestore的规则：

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId} {
      allow create: if request.resource.data.userId is string 
                    && request.resource.data.userId.startsWith('user_')
                    && request.resource.data.username.size() >=3 && request.resource.data.username.size() <=20
                    && request.resource.data.email.matches('^[^\s@]+@[^\s@]+\.[^\s@]+$');
    }
  }
}

前端校验提升用户体验，安全规则保障数据安全，双重校验才能真正规范数据。

我平时做项目时，还会把校验函数抽成独立工具文件，方便多个Model复用，也会根据业务扩展枚举值、数组类型等校验规则，你可以按需调整~

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