如何架构跨Firestore、Auth、Realtime的多函数批量写入方案？

首先明确：Firebase官方没有提供跨Firestore、Realtime Database(RTDB)、Auth三个服务的原生原子事务能力，要实现全链路要么全成功要么全回滚的逻辑原子性，可通过两阶段执行+补偿回滚+状态兜底的方案实现，具体架构如下：

核心实现步骤 #

• 第一步：为每一个操作封装执行+回滚逻辑
  把你现有分散在update1/update2/update3中的所有操作，拆分为独立的执行方法和对应的回滚方法：

  • Firestore操作的回滚：记录变更前的文档快照，回滚时恢复原始值/删除新增的文档
  • RTDB操作的回滚：记录变更前的节点数据，回滚时恢复原始值
  • Auth操作的回滚：记录变更前的用户属性，回滚时恢复用户原始配置/删除新增的用户
    所有回滚方法必须做幂等处理，避免重复调用导致数据异常。

• 第二步：新增操作状态追踪
  在Firestore中创建operation_tracks集合，每个批量操作生成唯一的operationId，对应一条状态记录，存储：操作整体状态（待执行/执行中/已成功/已回滚/回滚失败）、已执行步骤的回滚参数、操作创建时间。该文档的单操作原子性可作为整个流程的可信状态源。

• 第三步：按规则执行主流程
  执行顺序建议按「回滚成本从低到高」排序，优先执行Firestore批量操作，再执行RTDB操作，最后执行Auth操作：

  1. 初始化operationId，写入初始状态为「执行中」
  2. 按顺序执行每个操作，每成功执行一个操作，就把对应的回滚参数写入状态记录
  3. 所有操作全部执行成功，更新状态为「已成功」，流程结束
  4. 任意步骤执行失败，立刻按执行顺序的逆序调用所有已完成操作的回滚方法，全部回滚完成后更新状态为「已回滚」，返回失败

• 第四步：添加兜底定时补偿任务
  部署一个定时触发的Cloud Function，每分钟扫描operation_tracks中超过5分钟仍处于「执行中」的记录（对应执行到一半函数意外中断的场景），根据已记录的回滚参数主动触发回滚，避免出现半更新的中间状态。

简化实现示例 #

const { FieldValue } = require('firebase-admin/firestore')
const admin = require('firebase-admin')
const db = admin.firestore()
const rtdb = admin.database()
const auth = admin.auth()

// 封装所有要执行的原子操作，每个操作包含run执行方法和rollback回滚方法
const atomicOperations = [
  // 所有Firestore批量操作放在第一位
  {
    run: async (data) => {
      const batch = db.batch()
      // 把update1、update2、update3中所有Firestore写入逻辑批量加入batch
      // 示例：batch.update(db.doc(`users/${data.uid}`), {name: data.name})
      await batch.commit()
      // 返回回滚需要的所有参数，这里示例记录修改过的文档和原始值
      return { rollbackParams: { modifiedDocs: [], originalValues: [] } }
    },
    rollback: async (params) => {
      const rollbackBatch = db.batch()
      params.modifiedDocs.forEach((docPath, idx) => {
        rollbackBatch.update(db.doc(docPath), params.originalValues[idx])
      })
      await rollbackBatch.commit()
    }
  },
  // RTDB操作放在第二位
  {
    run: async (data) => {
      const rtdbRef = rtdb.ref(`user_status/${data.uid}`)
      const originalVal = (await rtdbRef.get()).val()
      await rtdbRef.update({ online: data.onlineStatus })
      return { rollbackParams: { rtdbPath: `user_status/${data.uid}`, originalVal } }
    },
    rollback: async (params) => {
      await rtdb.ref(params.rtdbPath).set(params.originalVal)
    }
  },
  // Auth操作放在最后
  {
    run: async (data) => {
      const originalUser = await auth.getUser(data.uid)
      await auth.updateUser(data.uid, { emailVerified: data.verifyStatus })
      return { rollbackParams: { uid: data.uid, originalProps: { emailVerified: originalUser.emailVerified } } }
    },
    rollback: async (params) => {
      await auth.updateUser(params.uid, params.originalProps)
    }
  }
]

// 主执行函数
async function runFullAtomicOperation(operationData) {
  // 初始化操作记录
  const opRef = db.collection('operation_tracks').doc()
  await opRef.set({
    status: 'running',
    executedRollbackParams: [],
    createdAt: Date.now()
  })
  const executedSteps = []

  try {
    for (const op of atomicOperations) {
      const { rollbackParams } = await op.run(operationData)
      executedSteps.push({ rollback: op.rollback, rollbackParams })
      // 记录已执行步骤的回滚参数
      await opRef.update({
        executedRollbackParams: FieldValue.arrayUnion(rollbackParams)
      })
    }
    // 全部执行成功
    await opRef.update({ status: 'success' })
    return { success: true }
  } catch (error) {
    // 触发逆序回滚
    for (let i = executedSteps.length - 1; i >= 0; i--) {
      const step = executedSteps[i]
      try {
        await step.rollback(step.rollbackParams)
      } catch (rollbackError) {
        // 回滚失败则标记状态，留待定时任务兜底
        await opRef.update({
          status: 'rollback_failed',
          error: error.message,
          rollbackError: rollbackError.message
        })
        throw new Error('Operation failed, rollback exception will be retried later')
      }
    }
    await opRef.update({ status: 'rolled_back', error: error.message })
    throw new Error('Operation failed, all changes have been rolled back')
  }
}

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