Function saveWorkflowToNormalizedTables

packages/workflow-persistence/src/save.ts:15–108

(
  workflowId: string,
  state: WorkflowState,
  externalTx?: DbOrTx
)

type SubflowInsert = InferInsertModel<typeof workflowSubflows>

export async function saveWorkflowToNormalizedTables(
  workflowId: string,
  state: WorkflowState,
  externalTx?: DbOrTx
): Promise<{ success: boolean; error?: string }> {
  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)),
    ])

    if (Object.keys(state.blocks).length > 0) {
      const blockInserts = Object.values(state.blocks).map((block) => ({
        id: block.id,
        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)
    }

    if (state.edges.length > 0) {
      const edgeInserts = state.edges.map((edge) => ({
        id: edge.id,
        workflowId,
        sourceBlockId: edge.source,
        targetBlockId: edge.target,
        sourceHandle: edge.sourceHandle || null,
        targetHandle: edge.targetHandle || null,
      }))

      await tx.insert(workflowEdges).values(edgeInserts)
    }

    const subflowInserts: SubflowInsert[] = []

    Object.values(canonicalLoops).forEach((loop) => {
      subflowInserts.push({
        id: loop.id,