fix(workflows): allow operations on blockless drafts

Author: TheodoreSpeaks

apps/sim/lib/workflows/application/apply-workflow-operations.test.ts

@@ -188,6 +188,36 @@ describe('applyWorkflowOperations', () => {
     expect(result.needsRedeployment).toBe(true)
   })
 
+  /**
+   * Replacing a draft with `{ blocks: {}, edges: [] }` legitimately deletes
+   * every normalized block row. The workflow row still exists, so the next add
+   * must initialize that empty canvas rather than treating it as missing state.
+   */
+  it('adds the first block to a blockless workflow', async () => {
+    const emptyGraph = graph({})
+    const graphWithAddedBlock = graph({
+      'block-2': { ...BLOCK, id: 'block-2', type: 'agent', name: 'Triage' },
+    })
+    mocks.loadNormalized.mockResolvedValue(emptyGraph)
+    mocks.normalizeState.mockImplementation((state) => ({ state, warnings: [] }))
+    mocks.applyOperations.mockReturnValue({
+      state: graphWithAddedBlock,
+      validationErrors: [],
+      skippedItems: [],
+      mintedBlockIds: {},
+    })
+
+    const result = await applyWorkflowOperations.execute({
+      principal: sessionPrincipal,
+      input: { workflowId: 'workflow-1', operations, atomic: true },
+    })
+
+    expect(mocks.normalizeState).toHaveBeenCalledWith(emptyGraph)
+    expect(mocks.applyOperations).toHaveBeenCalledWith(emptyGraph, operations, null)
+    expect(mocks.replace).toHaveBeenCalledTimes(1)
+    expect(result.graph.blocks).toEqual(graphWithAddedBlock.blocks)
+  })
+
   describe('dry run', () => {
     it('runs the whole engine and stops at the write', async () => {
       const result = await applyWorkflowOperations.execute({

apps/sim/lib/workflows/application/apply-workflow-operations.ts

@@ -120,6 +120,13 @@ function asGraph(value: Record<string, unknown>): Pick<WorkflowState, 'blocks' |
   return value as unknown as Pick<WorkflowState, 'blocks' | 'edges'>
 }
 
+/**
+ * Loads the editable graph after the workflow row has already been resolved.
+ *
+ * The normalized loader projects a legitimate blockless draft as an empty
+ * graph. A null result therefore remains a hard failure rather than becoming a
+ * fallback graph that a write could persist after a failed read.
+ */
 async function loadStoredGraph(workflowId: string): Promise<Record<string, unknown>> {
   const normalized = await loadWorkflowFromNormalizedTables(workflowId)
   if (!normalized) {

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

@@ -413,12 +413,26 @@ describe('Database Helpers', () => {
       )
     })
 
-    it('should return null when no blocks are found', async () => {
+    it('should return null when the workflow row is not found', async () => {
       const result = await dbHelpers.loadWorkflowFromNormalizedTables(mockWorkflowId)
 
       expect(result).toBeNull()
     })
 
+    it('should load an existing blockless workflow as an empty graph', async () => {
+      queueLoadFixtures({ blocks: [] })
+
+      const result = await dbHelpers.loadWorkflowFromNormalizedTables(mockWorkflowId)
+
+      expect(result).toMatchObject({
+        blocks: {},
+        edges: [],
+        loops: {},
+        parallels: {},
+        isFromNormalizedTables: true,
+      })
+    })
+
     it('should return null when database query fails', async () => {
       dbChainMockFns.where.mockImplementationOnce(() =>
         Promise.reject(new Error('Database connection failed'))

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

@@ -507,8 +507,8 @@ async function migrateCredentialIds(
  * Load workflow from normalized tables and apply all block migrations
  * (credential ID rewrites, agent message migration, subblock ID migrations,
  * WhatsApp interactive-type backfill, canonical-mode backfill, tool
- * sanitization). Returns null if the workflow has not been migrated to
- * normalized tables yet.
+ * sanitization). An existing blockless workflow returns an explicit empty
+ * graph; null is reserved for a missing workflow or a failed load.
  */
 export async function loadWorkflowFromNormalizedTables(
   workflowId: string,

packages/workflow-persistence/src/load.test.ts

@@ -95,11 +95,34 @@ async function loadRetry(retry: unknown) {
   return loaded?.blocks['block-1'].retry
 }
 
-describe('loadWorkflowFromNormalizedTablesRaw retry normalization', () => {
+describe('loadWorkflowFromNormalizedTablesRaw', () => {
   beforeEach(() => {
     vi.clearAllMocks()
   })
 
+  it('loads an existing blockless workflow as an empty normalized graph', async () => {
+    const tx = createTx({
+      workflowBlocks: [],
+      workflowEdges: [],
+      workflowSubflows: [],
+      workflow: [{ workspaceId: 'workspace-1' }],
+    })
+
+    await expect(
+      loadWorkflowFromNormalizedTablesRaw(
+        'workflow-1',
+        tx as unknown as Parameters<typeof loadWorkflowFromNormalizedTablesRaw>[1]
+      )
+    ).resolves.toMatchObject({
+      blocks: {},
+      edges: [],
+      loops: {},
+      parallels: {},
+      isFromNormalizedTables: true,
+      workspaceId: 'workspace-1',
+    })
+  })
+
   /**
    * The `retry` column is jsonb written verbatim by writers that never bound it
    * (realtime batch-add and replace-state, the admin/superuser import routes),

packages/workflow-persistence/src/load.ts

@@ -125,11 +125,8 @@ export async function loadWorkflowFromNormalizedTablesRaw(
         .limit(1),
     ])
 
-    if (blocks.length === 0) {
-      return null
-    }
-
-    if (!workflowRow?.workspaceId) {
+    if (!workflowRow) return null
+    if (!workflowRow.workspaceId) {
       throw new Error(`Workflow ${workflowId} has no workspace`)
     }