fix(scripts): skip undeployable table workflows

Author: TheodoreSpeaks

apps/sim/scripts/backfill-table-workflow-deployments.test.ts

@@ -179,6 +179,7 @@ describe('backfillTableWorkflowDeployments', () => {
       deployed: 3,
       alreadyDeployed: 0,
       skippedLocked: 0,
+      skippedUndeployable: 0,
     })
     expect(listCandidates.mock.calls).toEqual([
       ['', 2],
@@ -215,6 +216,7 @@ describe('backfillTableWorkflowDeployments', () => {
       deployed: 0,
       alreadyDeployed: 1,
       skippedLocked: 0,
+      skippedUndeployable: 0,
     })
     expect(deploy).not.toHaveBeenCalled()
   })
@@ -256,6 +258,56 @@ describe('backfillTableWorkflowDeployments', () => {
       deployed: 1,
       alreadyDeployed: 0,
       skippedLocked: 1,
+      skippedUndeployable: 0,
+    })
+    expect(deploy.mock.calls.map(([workflow]) => workflow.workflowId)).toEqual([
+      'workflow-a',
+      'workflow-b',
+    ])
+    expect(listCandidates.mock.calls.slice(-2)).toEqual([
+      ['', 1],
+      ['workflow-a', 1],
+    ])
+  })
+
+  it('reports and skips undeployable workflows while continuing the backfill', async () => {
+    const listCandidates = vi
+      .fn<TableWorkflowDeploymentStore['listCandidates']>()
+      .mockResolvedValueOnce([candidate('workflow-a'), candidate('workflow-b')])
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([candidate('workflow-a')])
+      .mockResolvedValueOnce([])
+    const deploymentState = new Map<string, boolean>()
+    const isDeployed = vi
+      .fn<TableWorkflowDeploymentStore['isDeployed']>()
+      .mockImplementation(async (workflowId) => deploymentState.get(workflowId) ?? false)
+    const deploy = vi.fn(async (workflow: TableWorkflowDeploymentCandidate) => {
+      if (workflow.workflowId === 'workflow-a') {
+        return {
+          success: false,
+          error: 'Missing required fields for WhatsApp Webhook: Verification Token, App Secret',
+          errorCode: 'validation' as const,
+        }
+      }
+      deploymentState.set(workflow.workflowId, true)
+      return {
+        success: true,
+        activeDeployment: {
+          deploymentVersionId: `version-${workflow.workflowId}`,
+          version: 1,
+          deployedAt: new Date().toISOString(),
+        },
+      }
+    })
+
+    await expect(
+      backfillTableWorkflowDeployments(store({ listCandidates, isDeployed }), deploy)
+    ).resolves.toEqual({
+      scanned: 2,
+      deployed: 1,
+      alreadyDeployed: 0,
+      skippedLocked: 0,
+      skippedUndeployable: 1,
     })
     expect(deploy.mock.calls.map(([workflow]) => workflow.workflowId)).toEqual([
       'workflow-a',

apps/sim/scripts/backfill-table-workflow-deployments.ts

@@ -59,6 +59,7 @@ export interface TableWorkflowDeploymentSummary {
   deployed: number
   alreadyDeployed: number
   skippedLocked: number
+  skippedUndeployable: number
 }
 
 interface TableWorkflowDeploymentBackfillOptions {
@@ -194,9 +195,9 @@ function validateCandidatePage(
   return lastWorkflowId
 }
 
-async function assertOnlyLockedCandidatesRemain(
+async function assertOnlySkippedCandidatesRemain(
   store: TableWorkflowDeploymentStore,
-  lockedWorkflowIds: ReadonlySet<string>
+  skippedWorkflowIds: ReadonlySet<string>
 ): Promise<void> {
   let afterWorkflowId = ''
   for (;;) {
@@ -205,7 +206,7 @@ async function assertOnlyLockedCandidatesRemain(
     if (!lastWorkflowId) return
 
     const unexpectedCandidate = candidates.find(
-      (candidate) => !lockedWorkflowIds.has(candidate.workflowId)
+      (candidate) => !skippedWorkflowIds.has(candidate.workflowId)
     )
     if (unexpectedCandidate) {
       throw new Error(
@@ -420,8 +421,9 @@ export async function backfillTableWorkflowDeployments(
     deployed: 0,
     alreadyDeployed: 0,
     skippedLocked: 0,
+    skippedUndeployable: 0,
   }
-  const lockedWorkflowIds = new Set<string>()
+  const skippedWorkflowIds = new Set<string>()
   let afterWorkflowId = ''
 
   for (;;) {
@@ -441,7 +443,7 @@ export async function backfillTableWorkflowDeployments(
         const result = await deploy(candidate)
         if (!result.success) {
           if (result.errorCode === 'locked') {
-            lockedWorkflowIds.add(candidate.workflowId)
+            skippedWorkflowIds.add(candidate.workflowId)
             summary.skippedLocked += 1
             logger.warn('Skipping locked workflow referenced by a table workflow group', {
               workflowId: candidate.workflowId,
@@ -450,6 +452,16 @@ export async function backfillTableWorkflowDeployments(
             })
             continue
           }
+          if (result.errorCode === 'validation') {
+            skippedWorkflowIds.add(candidate.workflowId)
+            summary.skippedUndeployable += 1
+            logger.warn('Skipping undeployable workflow referenced by a table workflow group', {
+              workflowId: candidate.workflowId,
+              workspaceId: candidate.workspaceId,
+              reason: result.error ?? 'Workflow deployment validation failed',
+            })
+            continue
+          }
           throw new Error(
             `Failed to deploy table workflow ${candidate.workflowId}: ${result.error ?? 'deployment returned no error'}`
           )
@@ -472,7 +484,7 @@ export async function backfillTableWorkflowDeployments(
   }
 
   await store.assertIntegrity()
-  await assertOnlyLockedCandidatesRemain(store, lockedWorkflowIds)
+  await assertOnlySkippedCandidatesRemain(store, skippedWorkflowIds)
 
   return summary
 }