fix(workflows): compare deployment states after the snapshot transaction commits

checkNeedsRedeployment ran the full workflow diff inside its REPEATABLE READ
transaction, holding a pooled connection idle in transaction during CPU work.
Reads (active version, normalized draft, variables, credential migrations)
stay in the snapshot; the pure diff now runs after commit.

Author: waleedlatif1

apps/sim/lib/workflows/deployment-status.test.ts

@@ -0,0 +1,77 @@
+/**
+ * @vitest-environment node
+ */
+import { workflowDeploymentVersion } from '@sim/db'
+import { createMinimalWorkflowState } from '@sim/testing/factories/workflow.factory'
+import {
+  dbChainMock,
+  dbChainMockFns,
+  queueTableRows,
+  resetDbChainMock,
+} from '@sim/testing/mocks/database.mock'
+import {
+  workflowsPersistenceUtilsMock,
+  workflowsPersistenceUtilsMockFns,
+} from '@sim/testing/mocks/workflows-persistence-utils.mock'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/workflows/persistence/utils', () => workflowsPersistenceUtilsMock)
+
+import { checkNeedsRedeployment } from '@/lib/workflows/deployment-status'
+
+const WORKFLOW_ID = 'wf-1'
+
+describe('checkNeedsRedeployment', () => {
+  let transactionOpen: boolean
+  let draftReadWhileTransactionOpen: boolean
+
+  beforeEach(() => {
+    resetDbChainMock()
+    transactionOpen = false
+    draftReadWhileTransactionOpen = false
+
+    dbChainMockFns.transaction.mockImplementation(async (cb: (tx: unknown) => unknown) => {
+      transactionOpen = true
+      try {
+        return await cb(dbChainMock.db)
+      } finally {
+        transactionOpen = false
+      }
+    })
+
+    queueTableRows(workflowDeploymentVersion, [
+      { id: 'version-1', state: { blocks: {} }, workspaceId: 'ws-1' },
+    ])
+
+    const deployed = createMinimalWorkflowState()
+    const draft = createMinimalWorkflowState()
+    draft.blocks.agent1.subBlocks.prompt.value = 'Edited after deploy'
+    const draftBlocks = draft.blocks
+
+    workflowsPersistenceUtilsMockFns.mockMaterializeDeploymentState.mockResolvedValue({
+      ...deployed,
+      parallels: {},
+      variables: {},
+    })
+    workflowsPersistenceUtilsMockFns.mockLoadWorkflowDeploymentSnapshot.mockResolvedValue({
+      edges: draft.edges,
+      loops: {},
+      parallels: {},
+      variables: {},
+      get blocks() {
+        if (transactionOpen) draftReadWhileTransactionOpen = true
+        return draftBlocks
+      },
+    })
+  })
+
+  it('diffs the draft against the deployment only after the snapshot transaction commits', async () => {
+    await expect(checkNeedsRedeployment(WORKFLOW_ID)).resolves.toBe(true)
+    expect(draftReadWhileTransactionOpen).toBe(false)
+  })
+
+  it('reports no redeploy when the workflow has no active deployment', async () => {
+    resetDbChainMock()
+    await expect(checkNeedsRedeployment(WORKFLOW_ID)).resolves.toBe(false)
+  })
+})

apps/sim/lib/workflows/deployment-status.ts

@@ -19,9 +19,15 @@ import type { WorkflowState } from '@/stores/workflows/workflow/types'
  * caller is what let this surface compare a raw jsonb blob against a normalized
  * draft, so that the server and the client answered the same question
  * differently for the same workflow.
+ *
+ * Every read — the active version row, the normalized draft, its variables and
+ * the credential rows the block migrations consult — runs in one REPEATABLE READ
+ * transaction so both operands come from the same snapshot. The diff does not:
+ * it is pure CPU over values already read, and running it after commit returns
+ * the pooled connection instead of holding it idle in transaction.
  */
 export async function checkNeedsRedeployment(workflowId: string): Promise<boolean> {
-  return db.transaction(async (tx) => {
+  const snapshot = await db.transaction(async (tx) => {
     await tx.execute(sql`SET TRANSACTION ISOLATION LEVEL REPEATABLE READ`)
     /*
      * `workspaceId` is selected here, in this transaction, rather than left for
@@ -53,10 +59,10 @@ export async function checkNeedsRedeployment(workflowId: string): Promise<boolea
       .limit(1)
 
     /* The inner join guarantees a workspace row; a null id means unusable data. */
-    if (!active?.state || !active.workspaceId) return false
+    if (!active?.state || !active.workspaceId) return null
 
     const currentState = await loadWorkflowDeploymentSnapshot(workflowId, tx)
-    if (!currentState) return false
+    if (!currentState) return null
 
     const deployedState = await materializeDeploymentState(
       workflowId,
@@ -65,6 +71,9 @@ export async function checkNeedsRedeployment(workflowId: string): Promise<boolea
       tx
     )
 
-    return hasWorkflowChanged(currentState, deployedState as WorkflowState)
+    return { currentState, deployedState }
   })
+
+  if (!snapshot) return false
+  return hasWorkflowChanged(snapshot.currentState, snapshot.deployedState as WorkflowState)
 }