fix(deploy): stop the redeploy check checking out a second connection

`checkNeedsRedeployment` opens a REPEATABLE READ transaction and then called
`materializeDeploymentState` without a workspaceId, which resolves one through
`getActiveWorkflowContext` — on the global pool. A transaction holding one
connection while awaiting a second checkout starves the pool under any
concurrency, and this endpoint is polled and refetches on window focus. The
nested read then failed and surfaced as a 500 on `/api/workflows/[id]/deploy`,
with the failing statement being the authz context lookup rather than anything
the caller wrote. Introduced by the operand fix earlier on this branch.

`materializeDeploymentState` now REQUIRES a workspaceId, so it cannot check out
a connection at all and is safe inside any transaction by construction; the two
non-transactional entry points resolve theirs through a named helper that says
so. The type change surfaced both remaining callers rather than leaving the
hazard to be avoided by convention.

The UI half: an absent answer was rendered as a positive one, three times over.
`isDeployed` is `deploymentInfo?.isDeployed ?? false`, so a pending OR FAILED
request was indistinguishable from a genuinely undeployed workflow — the modal
told the user to deploy a workflow whose version list showed v4 live. The status
now reports `unknown` until deployment info actually answers, the chip is
disabled there (a click is interpreted against that same flag: deployed opens
the modal, undeployed deploys), and the General tab renders a skeleton rather
than claiming undeployed whenever the live workflow cannot yet be shown.

No retry or fallback: the earlier draft of this commit polled the snapshot query
while it held no data, which papered over the pool starvation instead of fixing
it. That is removed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/deploy.tsx

@@ -54,6 +54,13 @@ export function Deploy({ activeWorkflowId, userPermissions, disabled = false }:
     isDeploying ||
     !canDeploy ||
     isEmpty ||
+    /*
+     * A click is interpreted against `isDeployed`: deployed opens the modal,
+     * undeployed deploys. While that is unknown the click has no defined
+     * meaning, and guessing "undeployed" would turn a failed info read into an
+     * unintended new version.
+     */
+    buttonStatus === 'unknown' ||
     (!isDeployed && deployReadiness.isBlocked && !deployReadiness.isSyncing)
 
   const onDeployClick = async () => {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deploy-button-status.test.ts

@@ -11,6 +11,7 @@ type Input = Parameters<typeof resolveDeployButtonStatus>[0]
 
 const base: Input = {
   workflowId: 'wf-1',
+  isDeploymentInfoResolved: false,
   isDeployed: false,
   isAwaitingFirstDeployedState: false,
   clientChangeDetected: false,
@@ -39,28 +40,44 @@ describe('resolveDeployButtonStatus', () => {
       // 1. Nothing loaded.
       {},
       // 2. deploymentInfo lands — isDeployed and needsRedeployment arrive together.
-      { isDeployed: true, serverNeedsRedeployment: true, isAwaitingFirstDeployedState: true },
+      {
+        isDeploymentInfoResolved: true,
+        isDeployed: true,
+        serverNeedsRedeployment: true,
+        isAwaitingFirstDeployedState: true,
+      },
       // 3. The deployed snapshot lands; the client diff agrees.
       {
+        isDeploymentInfoResolved: true,
         isDeployed: true,
         serverNeedsRedeployment: true,
         hasDeployedState: true,
         clientChangeDetected: true,
       },
     ])
 
-    expect(statuses).toEqual(['undeployed', 'changed'])
+    expect(statuses).toEqual(['unknown', 'changed'])
     expect(statuses).not.toContain('live')
   })
 
   it('settles straight to live for a deployed workflow with no changes', () => {
     const statuses = committed([
       {},
-      { isDeployed: true, serverNeedsRedeployment: false, isAwaitingFirstDeployedState: true },
-      { isDeployed: true, serverNeedsRedeployment: false, hasDeployedState: true },
+      {
+        isDeploymentInfoResolved: true,
+        isDeployed: true,
+        serverNeedsRedeployment: false,
+        isAwaitingFirstDeployedState: true,
+      },
+      {
+        isDeploymentInfoResolved: true,
+        isDeployed: true,
+        serverNeedsRedeployment: false,
+        hasDeployedState: true,
+      },
     ])
 
-    expect(statuses).toEqual(['undeployed', 'live'])
+    expect(statuses).toEqual(['unknown', 'live'])
     expect(statuses).not.toContain('changed')
   })
 
@@ -70,6 +87,7 @@ describe('resolveDeployButtonStatus', () => {
    */
   it('holds its answer across a background refetch', () => {
     const settled: Partial<Input> = {
+      isDeploymentInfoResolved: true,
       isDeployed: true,
       serverNeedsRedeployment: true,
       hasDeployedState: true,
@@ -90,6 +108,7 @@ describe('resolveDeployButtonStatus', () => {
     // Unsaved edits: the server still describes the persisted draft.
     const status = resolveDeployButtonStatus({
       ...base,
+      isDeploymentInfoResolved: true,
       isDeployed: true,
       serverNeedsRedeployment: false,
       hasDeployedState: true,
@@ -103,9 +122,40 @@ describe('resolveDeployButtonStatus', () => {
     expect(resolveDeployButtonStatus({ ...base, workflowId: null })).toBe('undeployed')
   })
 
+  /**
+   * `GET /api/workflows/[id]/deploy` returning 500 made `isDeployed` default to
+   * false, which rendered a live workflow as "Deploy" beside a version list
+   * showing v4 live — an absence of information presented as a fact.
+   *
+   * The click is also interpreted against the same flag (deployed opens the
+   * modal, undeployed deploys), so guessing here decides an action, not just a
+   * label. Both reasons say the same thing: do not answer until asked.
+   */
+  it('does not claim undeployed when deployment info has not answered', () => {
+    const status = resolveDeployButtonStatus({
+      ...base,
+      isDeploymentInfoResolved: false,
+      isDeployed: false,
+    })
+
+    expect(status).toBe('unknown')
+    expect(status).not.toBe('undeployed')
+  })
+
+  it('reports undeployed only once info has actually said so', () => {
+    const status = resolveDeployButtonStatus({
+      ...base,
+      isDeploymentInfoResolved: true,
+      isDeployed: false,
+    })
+
+    expect(status).toBe('undeployed')
+  })
+
   it('falls back to unknown only when deployed with no verdict from either side', () => {
     const status = resolveDeployButtonStatus({
       ...base,
+      isDeploymentInfoResolved: true,
       isDeployed: true,
       isAwaitingFirstDeployedState: true,
       serverNeedsRedeployment: undefined,

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deploy-button-status.ts

@@ -10,6 +10,12 @@ export type DeployButtonStatus = 'unknown' | 'undeployed' | 'live' | 'changed'
 
 interface ResolveDeployButtonStatusInput {
   workflowId: string | null
+  /**
+   * Whether deployment info has actually answered. `isDeployed` defaults to
+   * `false` while the request is pending OR failed, so without this the two are
+   * indistinguishable and a 500 reads as "not deployed".
+   */
+  isDeploymentInfoResolved: boolean
   isDeployed: boolean
   /** True only before the FIRST deployed snapshot lands — never on a refetch. */
   isAwaitingFirstDeployedState: boolean
@@ -49,13 +55,27 @@ interface ResolveDeployButtonStatusInput {
  */
 export function resolveDeployButtonStatus({
   workflowId,
+  isDeploymentInfoResolved,
   isDeployed,
   isAwaitingFirstDeployedState,
   clientChangeDetected,
   hasDeployedState,
   serverNeedsRedeployment,
 }: ResolveDeployButtonStatusInput): DeployButtonStatus {
-  if (!workflowId || !isDeployed) return 'undeployed'
+  if (!workflowId) return 'undeployed'
+
+  /*
+   * Not knowing is its own answer. `isDeployed` is `deploymentInfo?.isDeployed
+   * ?? false`, so a pending or FAILED info request is indistinguishable from a
+   * genuinely undeployed workflow — and a transient 500 on that endpoint
+   * rendered a live workflow as "Deploy", next to a version list showing v4
+   * live. Worse, the chip acts on that: with `isDeployed` false a click runs a
+   * fresh deploy instead of opening the modal, so a failed read could be
+   * converted into an unintended new version.
+   */
+  if (!isDeploymentInfoResolved) return 'unknown'
+
+  if (!isDeployed) return 'undeployed'
 
   if (hasDeployedState && !isAwaitingFirstDeployedState) {
     return clientChangeDetected ? 'changed' : 'live'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deployment-view-state.ts

@@ -52,6 +52,8 @@ export function useDeploymentViewState({
   deployReadiness,
 }: UseDeploymentViewStateProps): DeploymentViewState {
   const { data: deploymentInfo } = useDeploymentInfo(workflowId, { enabled })
+  /* Undefined covers both "still loading" and "the request failed". */
+  const isDeploymentInfoResolved = deploymentInfo !== undefined
   const isDeployed = deploymentInfo?.isDeployed ?? false
 
   const snapshotEnabled = Boolean(workflowId) && isDeployed && enabled
@@ -77,6 +79,7 @@ export function useDeploymentViewState({
 
   const status = resolveDeployButtonStatus({
     workflowId,
+    isDeploymentInfoResolved,
     isDeployed,
     isAwaitingFirstDeployedState: isLoadingDeployedState,
     clientChangeDetected: changeDetected,
@@ -99,7 +102,12 @@ export function useDeploymentViewState({
     status,
     isDeployed,
     deployedState,
-    isAwaitingSnapshot: snapshotEnabled && deployedState === null,
+    /*
+     * "We cannot show you the live workflow yet" covers both a snapshot in
+     * flight and not knowing whether one exists. Neither is evidence the
+     * workflow is undeployed, so neither may render as that claim.
+     */
+    isAwaitingSnapshot: status === 'unknown' || (snapshotEnabled && deployedState === null),
     isSettling,
     changeDetected,
     changedFields,

apps/sim/hooks/queries/deployments.ts

@@ -34,8 +34,6 @@ export type { ChatDetail, DeploymentVersionsResponse }
 export const DEPLOYMENT_INFO_STALE_TIME = 30 * 1000
 export const DEPLOYMENT_STATUS_REFETCH_INTERVAL = 5 * 1000
 export const DEPLOYED_WORKFLOW_STATE_STALE_TIME = 30 * 1000
-/** Retry cadence while the deployed snapshot is expected but not yet readable. */
-export const DEPLOYED_STATE_RECOVERY_INTERVAL = 3 * 1000
 export const DEPLOYMENT_VERSIONS_STALE_TIME = 30 * 1000
 export const CHAT_DEPLOYMENT_STATUS_STALE_TIME = 30 * 1000
 export const CHAT_DETAIL_STALE_TIME = 30 * 1000
@@ -160,19 +158,6 @@ export function useDeployedWorkflowState(
     queryFn: ({ signal }) => fetchDeployedWorkflowState(workflowId!, signal),
     enabled: Boolean(workflowId) && (options?.enabled ?? true),
     staleTime: DEPLOYED_WORKFLOW_STATE_STALE_TIME,
-    /*
-     * Callers enable this only once deployment info reports the workflow as
-     * deployed, so a null snapshot is a contradiction rather than an answer:
-     * the version exists but is not readable yet.
-     *
-     * Nothing re-invalidates this key when activation cuts over —
-     * `refetchDeploymentBoundary` fires while the query is still disabled, and a
-     * disabled query cannot be refetched — so the null was cached for the whole
-     * stale window. That is what put an empty preview next to a live version
-     * row. Retrying resolves the contradiction and stops the instant it does.
-     */
-    refetchInterval: (query) =>
-      query.state.data == null ? DEPLOYED_STATE_RECOVERY_INTERVAL : false,
   })
 }
 

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

@@ -1,4 +1,5 @@
 import { db, workflowDeploymentVersion } from '@sim/db'
+import { workflow as workflowTable } from '@sim/db/schema'
 import { and, desc, eq, sql } from 'drizzle-orm'
 import { hasWorkflowChanged } from '@/lib/workflows/comparison'
 import {
@@ -22,12 +23,23 @@ import type { WorkflowState } from '@/stores/workflows/workflow/types'
 export async function checkNeedsRedeployment(workflowId: string): Promise<boolean> {
   return 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
+     * `materializeDeploymentState` to look up. It resolves an absent one through
+     * `getActiveWorkflowContext`, which runs on the global pool — a second
+     * connection checkout while this transaction already holds one. Under any
+     * concurrency (this endpoint is polled, and refetches on window focus) that
+     * starves the pool and fails the nested read, surfacing as a 500 on
+     * `/api/workflows/[id]/deploy`. A transaction must not await a checkout.
+     */
     const [active] = await tx
       .select({
         id: workflowDeploymentVersion.id,
         state: workflowDeploymentVersion.state,
+        workspaceId: workflowTable.workspaceId,
       })
       .from(workflowDeploymentVersion)
+      .innerJoin(workflowTable, eq(workflowTable.id, workflowDeploymentVersion.workflowId))
       .where(
         and(
           eq(workflowDeploymentVersion.workflowId, workflowId),
@@ -37,7 +49,8 @@ export async function checkNeedsRedeployment(workflowId: string): Promise<boolea
       .orderBy(desc(workflowDeploymentVersion.createdAt))
       .limit(1)
 
-    if (!active?.state) return false
+    /* The inner join guarantees a workspace row; a null id means unusable data. */
+    if (!active?.state || !active.workspaceId) return false
 
     /*
      * Sequential, not `Promise.all`: both reads share the transaction's single
@@ -46,7 +59,12 @@ export async function checkNeedsRedeployment(workflowId: string): Promise<boolea
     const currentState = await loadWorkflowDeploymentSnapshot(workflowId, tx)
     if (!currentState) return false
 
-    const deployedState = await materializeDeploymentState(workflowId, active, undefined, tx)
+    const deployedState = await materializeDeploymentState(
+      workflowId,
+      active,
+      active.workspaceId,
+      tx
+    )
 
     return hasWorkflowChanged(currentState, deployedState as WorkflowState)
   })

apps/sim/lib/workflows/persistence/utils.ts

@@ -145,7 +145,20 @@ export function invalidateDeployedStateCache(deploymentVersionId?: string): void
   deployedStateCache.clear()
 }
 
-export interface DeploymentStateRow {
+export /**
+ * Only for entry points that are NOT inside a transaction — it checks out a
+ * connection of its own.
+ */
+async function resolveWorkspaceId(workflowId: string, provided?: string): Promise<string> {
+  if (provided) return provided
+  const workflowContext = await getActiveWorkflowContext(workflowId)
+  if (!workflowContext?.workspaceId) {
+    throw new Error(`Workflow ${workflowId} has no workspace`)
+  }
+  return workflowContext.workspaceId
+}
+
+interface DeploymentStateRow {
   id: string
   state: unknown
 }
@@ -160,10 +173,18 @@ export interface DeploymentStateRow {
  * the handle canonicalization and the `errorEnabled` backfill below, the two
  * surfaces answered the same question differently for the same workflow.
  */
+/**
+ * `workspaceId` is required rather than resolved here on purpose. Resolving it
+ * means `getActiveWorkflowContext`, which runs on the global pool — and this
+ * function is called from inside a REPEATABLE READ transaction by
+ * `checkNeedsRedeployment`, where a second connection checkout while holding one
+ * starves the pool under concurrency and fails the nested read. Taking it as an
+ * argument makes that impossible instead of merely avoided.
+ */
 export async function materializeDeploymentState(
   workflowId: string,
   version: DeploymentStateRow,
-  providedWorkspaceId?: string,
+  workspaceId: string,
   executor?: DbOrTx
 ): Promise<DeployedWorkflowData> {
   const cached = deployedStateCache.get(version.id)
@@ -172,19 +193,10 @@ export async function materializeDeploymentState(
   }
 
   const state = version.state as WorkflowState & { variables?: Record<string, unknown> }
-  let resolvedWorkspaceId = providedWorkspaceId
-  if (!resolvedWorkspaceId) {
-    const workflowContext = await getActiveWorkflowContext(workflowId)
-    resolvedWorkspaceId = workflowContext?.workspaceId
-  }
-
-  if (!resolvedWorkspaceId) {
-    throw new Error(`Workflow ${workflowId} has no workspace`)
-  }
 
   const { blocks: migratedBlocks } = await applyBlockMigrations(
     state.blocks || {},
-    resolvedWorkspaceId,
+    workspaceId,
     executor
   )
   /*
@@ -255,7 +267,11 @@ export async function loadDeployedWorkflowState(
       throw new NoActiveDeploymentError(workflowId)
     }
 
-    return materializeDeploymentState(workflowId, active, providedWorkspaceId)
+    return materializeDeploymentState(
+      workflowId,
+      active,
+      await resolveWorkspaceId(workflowId, providedWorkspaceId)
+    )
   } catch (error) {
     logger.error(`Error loading deployed workflow state ${workflowId}:`, error)
     throw error
@@ -288,7 +304,11 @@ export async function loadWorkflowDeploymentVersionState(
     throw new Error(`Deployment ${deploymentVersionId} was not found for workflow ${workflowId}`)
   }
 
-  return materializeDeploymentState(workflowId, version, providedWorkspaceId)
+  return materializeDeploymentState(
+    workflowId,
+    version,
+    await resolveWorkspaceId(workflowId, providedWorkspaceId)
+  )
 }
 
 interface MigrationContext {

apps/sim/scripts/dump-change-detection-states.ts

@@ -186,13 +186,14 @@ async function main(): Promise<void> {
       const webhooks = webhooksByWorkflow.get(row.workflowId)
       if (webhooksOnly && !webhooks) continue
 
+      if (!row.workspaceId) continue
       const current = await loadWorkflowDeploymentSnapshot(row.workflowId)
       if (!current) continue
 
       const deployed = await materializeDeploymentState(
         row.workflowId,
         { id: row.versionId, state: row.state },
-        row.workspaceId ?? undefined
+        row.workspaceId
       )
 
       const currentBlocks =