chore: import upstream snapshot with attribution

apps/sim/app/api/workflows/[id]/autolayout/route.ts

@@ -0,0 +1,167 @@
+import { createLogger } from '@sim/logger'
+import {
+  assertWorkflowMutable,
+  authorizeWorkflowByWorkspacePermission,
+  WorkflowLockedError,
+} from '@sim/platform-authz/workflow'
+import { getErrorMessage } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import { workflowAutoLayoutContract } from '@/lib/api/contracts/workflows'
+import { parseRequest } from '@/lib/api/server'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { applyAutoLayout } from '@/lib/workflows/autolayout'
+import {
+  DEFAULT_HORIZONTAL_SPACING,
+  DEFAULT_LAYOUT_PADDING,
+  DEFAULT_VERTICAL_SPACING,
+} from '@/lib/workflows/autolayout/constants'
+import {
+  loadWorkflowFromNormalizedTables,
+  type NormalizedWorkflowData,
+} from '@/lib/workflows/persistence/utils'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('AutoLayoutAPI')
+
+/**
+ * POST /api/workflows/[id]/autolayout
+ * Apply autolayout to an existing workflow
+ */
+export const POST = withRouteHandler(
+  async (request: NextRequest, context: { params: Promise<{ id: string }> }) => {
+    const requestId = generateRequestId()
+    const startTime = Date.now()
+    const { id: workflowId } = await context.params
+
+    try {
+      const auth = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
+      if (!auth.success || !auth.userId) {
+        logger.warn(`[${requestId}] Unauthorized autolayout attempt for workflow ${workflowId}`)
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+      }
+
+      const userId = auth.userId
+
+      const parsed = await parseRequest(workflowAutoLayoutContract, request, context)
+      if (!parsed.success) return parsed.response
+      const layoutOptions = parsed.data.body
+
+      logger.info(`[${requestId}] Processing autolayout request for workflow ${workflowId}`, {
+        userId,
+      })
+
+      const authorization = await authorizeWorkflowByWorkspacePermission({
+        workflowId,
+        userId,
+        action: 'write',
+      })
+      const workflowData = authorization.workflow
+
+      if (!workflowData) {
+        logger.warn(`[${requestId}] Workflow ${workflowId} not found for autolayout`)
+        return NextResponse.json({ error: 'Workflow not found' }, { status: 404 })
+      }
+
+      const canUpdate = authorization.allowed
+
+      if (!canUpdate) {
+        logger.warn(
+          `[${requestId}] User ${userId} denied permission to autolayout workflow ${workflowId}`
+        )
+        return NextResponse.json(
+          { error: authorization.message || 'Access denied' },
+          { status: authorization.status || 403 }
+        )
+      }
+
+      await assertWorkflowMutable(workflowId)
+
+      let currentWorkflowData: NormalizedWorkflowData | null
+
+      if (layoutOptions.blocks && layoutOptions.edges) {
+        logger.info(`[${requestId}] Using provided blocks with live measurements`)
+        currentWorkflowData = {
+          blocks: layoutOptions.blocks,
+          edges: layoutOptions.edges,
+          loops: layoutOptions.loops || {},
+          parallels: layoutOptions.parallels || {},
+          isFromNormalizedTables: false,
+        }
+      } else {
+        logger.info(`[${requestId}] Loading blocks from database`)
+        currentWorkflowData = await loadWorkflowFromNormalizedTables(workflowId)
+      }
+
+      if (!currentWorkflowData) {
+        logger.error(`[${requestId}] Could not load workflow ${workflowId} for autolayout`)
+        return NextResponse.json({ error: 'Could not load workflow data' }, { status: 500 })
+      }
+
+      const autoLayoutOptions = {
+        horizontalSpacing: layoutOptions.spacing?.horizontal ?? DEFAULT_HORIZONTAL_SPACING,
+        verticalSpacing: layoutOptions.spacing?.vertical ?? DEFAULT_VERTICAL_SPACING,
+        padding: {
+          x: layoutOptions.padding?.x ?? DEFAULT_LAYOUT_PADDING.x,
+          y: layoutOptions.padding?.y ?? DEFAULT_LAYOUT_PADDING.y,
+        },
+        alignment: layoutOptions.alignment,
+        gridSize: layoutOptions.gridSize,
+      }
+
+      const layoutResult = applyAutoLayout(
+        currentWorkflowData.blocks,
+        currentWorkflowData.edges,
+        autoLayoutOptions
+      )
+
+      if (!layoutResult.success || !layoutResult.blocks) {
+        logger.error(`[${requestId}] Auto layout failed:`, {
+          error: layoutResult.error,
+        })
+        return NextResponse.json(
+          {
+            error: 'Auto layout failed',
+            details: layoutResult.error || 'Unknown error',
+          },
+          { status: 500 }
+        )
+      }
+
+      const elapsed = Date.now() - startTime
+      const blockCount = Object.keys(layoutResult.blocks).length
+
+      logger.info(`[${requestId}] Autolayout completed successfully in ${elapsed}ms`, {
+        blockCount,
+        workflowId,
+      })
+
+      return NextResponse.json({
+        success: true,
+        message: `Autolayout applied successfully to ${blockCount} blocks`,
+        data: {
+          blockCount,
+          elapsed: `${elapsed}ms`,
+          layoutedBlocks: layoutResult.blocks,
+        },
+      })
+    } catch (error) {
+      if (error instanceof WorkflowLockedError) {
+        return NextResponse.json({ error: error.message }, { status: error.status })
+      }
+
+      const elapsed = Date.now() - startTime
+
+      logger.error(`[${requestId}] Autolayout failed after ${elapsed}ms:`, error)
+      return NextResponse.json(
+        {
+          error: 'Autolayout failed',
+          details: getErrorMessage(error, 'Unknown error'),
+        },
+        { status: 500 }
+      )
+    }
+  }
+)