address error handling at correct level

Author: icecrasher321

apps/sim/app/api/workflows/route.ts

@@ -269,10 +269,7 @@ export async function POST(req: NextRequest) {
         variables: {},
       })
 
-      const saveResult = await saveWorkflowToNormalizedTables(workflowId, workflowState, tx)
-      if (!saveResult.success) {
-        throw new Error(saveResult.error || 'Failed to persist default workflow blocks')
-      }
+      await saveWorkflowToNormalizedTables(workflowId, workflowState, tx)
     })
 
     logger.info(`[${requestId}] Successfully created workflow ${workflowId} with default blocks`)

apps/sim/app/api/workspaces/route.ts

@@ -175,10 +175,7 @@ async function createWorkspace(
         })
 
         const { workflowState } = buildDefaultWorkflowArtifacts()
-        const seedResult = await saveWorkflowToNormalizedTables(workflowId, workflowState, tx)
-        if (!seedResult.success) {
-          throw new Error(seedResult.error || 'Failed to seed default workflow state')
-        }
+        await saveWorkflowToNormalizedTables(workflowId, workflowState, tx)
       }
 
       logger.info(

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

@@ -534,91 +534,86 @@ export async function saveWorkflowToNormalizedTables(
   state: WorkflowState,
   externalTx?: DbOrTx
 ): Promise<{ success: boolean; error?: string }> {
-  try {
-    const blockRecords = state.blocks as Record<string, BlockState>
-    const canonicalLoops = generateLoopBlocks(blockRecords)
-    const canonicalParallels = generateParallelBlocks(blockRecords)
-
-    const execute = async (tx: DbOrTx) => {
-      await Promise.all([
-        tx.delete(workflowBlocks).where(eq(workflowBlocks.workflowId, workflowId)),
-        tx.delete(workflowEdges).where(eq(workflowEdges.workflowId, workflowId)),
-        tx.delete(workflowSubflows).where(eq(workflowSubflows.workflowId, workflowId)),
-      ])
-
-      // Insert blocks
-      if (Object.keys(state.blocks).length > 0) {
-        const blockInserts = Object.values(state.blocks).map((block) => ({
-          id: block.id,
-          workflowId: workflowId,
-          type: block.type,
-          name: block.name || '',
-          positionX: String(block.position?.x || 0),
-          positionY: String(block.position?.y || 0),
-          enabled: block.enabled ?? true,
-          horizontalHandles: block.horizontalHandles ?? true,
-          advancedMode: block.advancedMode ?? false,
-          triggerMode: block.triggerMode ?? false,
-          height: String(block.height || 0),
-          subBlocks: block.subBlocks || {},
-          outputs: block.outputs || {},
-          data: block.data || {},
-          parentId: block.data?.parentId || null,
-          extent: block.data?.extent || null,
-          locked: block.locked ?? false,
-        }))
-
-        await tx.insert(workflowBlocks).values(blockInserts)
-      }
+  const blockRecords = state.blocks as Record<string, BlockState>
+  const canonicalLoops = generateLoopBlocks(blockRecords)
+  const canonicalParallels = generateParallelBlocks(blockRecords)
+
+  const execute = async (tx: DbOrTx) => {
+    await Promise.all([
+      tx.delete(workflowBlocks).where(eq(workflowBlocks.workflowId, workflowId)),
+      tx.delete(workflowEdges).where(eq(workflowEdges.workflowId, workflowId)),
+      tx.delete(workflowSubflows).where(eq(workflowSubflows.workflowId, workflowId)),
+    ])
 
-      // Insert edges
-      if (state.edges.length > 0) {
-        const edgeInserts = state.edges.map((edge) => ({
-          id: edge.id,
-          workflowId: workflowId,
-          sourceBlockId: edge.source,
-          targetBlockId: edge.target,
-          sourceHandle: edge.sourceHandle || null,
-          targetHandle: edge.targetHandle || null,
-        }))
-
-        await tx.insert(workflowEdges).values(edgeInserts)
-      }
+    if (Object.keys(state.blocks).length > 0) {
+      const blockInserts = Object.values(state.blocks).map((block) => ({
+        id: block.id,
+        workflowId: workflowId,
+        type: block.type,
+        name: block.name || '',
+        positionX: String(block.position?.x || 0),
+        positionY: String(block.position?.y || 0),
+        enabled: block.enabled ?? true,
+        horizontalHandles: block.horizontalHandles ?? true,
+        advancedMode: block.advancedMode ?? false,
+        triggerMode: block.triggerMode ?? false,
+        height: String(block.height || 0),
+        subBlocks: block.subBlocks || {},
+        outputs: block.outputs || {},
+        data: block.data || {},
+        parentId: block.data?.parentId || null,
+        extent: block.data?.extent || null,
+        locked: block.locked ?? false,
+      }))
+
+      await tx.insert(workflowBlocks).values(blockInserts)
+    }
 
-      // Insert subflows (loops and parallels)
-      const subflowInserts: SubflowInsert[] = []
+    if (state.edges.length > 0) {
+      const edgeInserts = state.edges.map((edge) => ({
+        id: edge.id,
+        workflowId: workflowId,
+        sourceBlockId: edge.source,
+        targetBlockId: edge.target,
+        sourceHandle: edge.sourceHandle || null,
+        targetHandle: edge.targetHandle || null,
+      }))
+
+      await tx.insert(workflowEdges).values(edgeInserts)
+    }
 
-      // Add loops
-      Object.values(canonicalLoops).forEach((loop) => {
-        subflowInserts.push({
-          id: loop.id,
-          workflowId: workflowId,
-          type: SUBFLOW_TYPES.LOOP,
-          config: loop,
-        })
+    const subflowInserts: SubflowInsert[] = []
+
+    Object.values(canonicalLoops).forEach((loop) => {
+      subflowInserts.push({
+        id: loop.id,
+        workflowId: workflowId,
+        type: SUBFLOW_TYPES.LOOP,
+        config: loop,
       })
+    })
 
-      // Add parallels
-      Object.values(canonicalParallels).forEach((parallel) => {
-        subflowInserts.push({
-          id: parallel.id,
-          workflowId: workflowId,
-          type: SUBFLOW_TYPES.PARALLEL,
-          config: parallel,
-        })
+    Object.values(canonicalParallels).forEach((parallel) => {
+      subflowInserts.push({
+        id: parallel.id,
+        workflowId: workflowId,
+        type: SUBFLOW_TYPES.PARALLEL,
+        config: parallel,
       })
+    })
 
-      if (subflowInserts.length > 0) {
-        await tx.insert(workflowSubflows).values(subflowInserts)
-      }
+    if (subflowInserts.length > 0) {
+      await tx.insert(workflowSubflows).values(subflowInserts)
     }
+  }
 
-    if (externalTx) {
-      await execute(externalTx)
-    } else {
-      await db.transaction(execute)
-    }
+  if (externalTx) {
+    await execute(externalTx)
+    return { success: true }
+  }
 
+  try {
+    await db.transaction(execute)
     return { success: true }
   } catch (error) {
     logger.error(`Error saving workflow ${workflowId} to normalized tables:`, error)