Function rollbackFork

apps/sim/lib/workspaces/fork/promote/rollback.ts:63–292

(params: RollbackForkParams)

 * deployed version is the source of truth.
 */
export async function rollbackFork(params: RollbackForkParams): Promise<RollbackForkResult> {
  const { targetWorkspaceId, otherWorkspaceId, userId } = params
  const requestId = params.requestId ?? 'unknown'

  const edge = await resolveForkEdge(targetWorkspaceId, otherWorkspaceId)
  if (!edge) {
    throw new ForkError('These workspaces are not a direct fork edge', 400)
  }

  // Only the most recent sync into the target is undoable. Undoing an older sibling's
  // sync while a newer one stands would partially revert the target and strand the
  // newer sync's changes.
  const run = await getLatestPromoteRunForTarget(db, targetWorkspaceId)
  if (!run) {
    throw new ForkError('There is no promote to undo for this workspace', 404)
  }
  if (run.childWorkspaceId !== edge.childWorkspaceId) {
    throw new ForkError(
      'A newer sync into this workspace exists; reopen and undo the most recent sync.',
      409
    )
  }

  const { updated, created, archived } = run.snapshot

  // Build the restore ops: reactivate a prior version, or undeploy (created targets +
  // updated targets that had no prior deployment). Sort by workflow id so the locked
  // transaction acquires workflow row locks in a deterministic order, avoiding
  // deadlocks with the (unlocked) promote deploy loop, which locks the same rows.
  const undeployIds = [
    ...created,
    ...updated.filter((i) => i.priorVersion == null).map((i) => i.workflowId),
  ]
  const toReactivateOps = (
    list: Array<{ workflowId: string; priorVersion: number | null }>
  ): RollbackOp[] =>
    list
      .filter((item) => item.priorVersion != null)
      .map((item) => ({
        workflowId: item.workflowId,
        kind: 'reactivate' as const,
        version: item.priorVersion as number,
      }))
  const ops: RollbackOp[] = [
    ...toReactivateOps(updated),
    ...toReactivateOps(archived),
    ...undeployIds.map((workflowId) => ({ workflowId, kind: 'undeploy' as const })),
  ].sort((a, b) => a.workflowId.localeCompare(b.workflowId))

  const skipped = new Set<string>()
  const outboxEventIds: string[] = []

  await db.transaction(async (tx) => {
    await setForkLockTimeout(tx)
    await acquireForkTargetLock(tx, targetWorkspaceId)
    await acquireForkEdgeLock(tx, edge.childWorkspaceId)

    // Re-confirm our run is still the newest sync, now under the lock. If a promote