simstudioai · waleedlatif1 · Jun 24, 2025 · Jun 20, 2025 · Jun 20, 2025 · Jun 20, 2025
diff --git a/apps/sim/app/(landing)/components/hero-workflow.tsx b/apps/sim/app/(landing)/components/hero-workflow.tsx
@@ -154,7 +154,7 @@ const mobileEdges: Edge[] = [
 
 const workflowVariants = {
   hidden: { opacity: 0, scale: 0.98 },
-  visible: { opacity: 1, scale: 1, transition: { duration: 0.5, delay: 0.1 } },
+  visible: { opacity: 1, scale: 1 },
 }
 
 export function HeroWorkflow() {
@@ -208,6 +208,7 @@ export function HeroWorkflow() {
       variants={workflowVariants}
       initial='hidden'
       animate='visible'
+      transition={{ duration: 0.5, delay: 0.1, ease: 'easeOut' }}
     >
       <style jsx global>{`
         .react-flow__edge-path {

diff --git a/apps/sim/app/(landing)/components/nav-client.tsx b/apps/sim/app/(landing)/components/nav-client.tsx
@@ -44,13 +44,7 @@ const mobileSheetContainerVariants = {
 
 const mobileNavItemsContainerVariants = {
   hidden: { opacity: 0 },
-  visible: {
-    opacity: 1,
-    transition: {
-      delayChildren: 0.1, // Delay before starting stagger
-      staggerChildren: 0.08, // Stagger delay between items
-    },
-  },
+  visible: { opacity: 1 },
 }
 
 const mobileNavItemVariants = {
@@ -217,6 +211,7 @@ export default function NavClient({
             variants={desktopNavContainerVariants}
             initial='hidden'
             animate='visible'
+            transition={{ delay: 0.2, duration: 0.3, ease: 'easeOut' }}
           >
             <NavLinks currentPath={currentPath} onContactClick={onContactClick} />
           </motion.div>
@@ -265,6 +260,7 @@ export default function NavClient({
                       initial='hidden'
                       animate='visible'
                       exit='exit'
+                      transition={{ duration: 0.3, ease: 'easeInOut' }}
                       className='fixed inset-y-0 right-0 z-50'
                     >
                       <SheetContent
@@ -281,6 +277,10 @@ export default function NavClient({
                           variants={mobileNavItemsContainerVariants}
                           initial='hidden'
                           animate='visible'
+                          transition={{
+                            delayChildren: 0.1,
+                            staggerChildren: 0.08,
+                          }}
                         >
                           <NavLinks
                             mobile

diff --git a/apps/sim/app/api/auth/socket-token/route.ts b/apps/sim/app/api/auth/socket-token/route.ts
@@ -0,0 +1,20 @@
+import { headers } from 'next/headers'
+import { NextResponse } from 'next/server'
+import { auth } from '@/lib/auth'
+
+export async function POST() {
+  try {
+    const response = await auth.api.generateOneTimeToken({
+      headers: await headers(),
+    })
+
+    if (!response) {
+      return NextResponse.json({ error: 'Failed to generate token' }, { status: 500 })
+    }
+
+    return NextResponse.json({ token: response.token })
+  } catch (error) {
+    console.error('Error generating one-time token:', error)
+    return NextResponse.json({ error: 'Failed to generate token' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/workflows/[id]/deploy/route.test.ts b/apps/sim/app/api/workflows/[id]/deploy/route.test.ts
@@ -129,6 +129,33 @@ describe('Workflow Deployment API Route', () => {
               }),
             }),
           })
+          // Mock normalized table queries (blocks, edges, subflows)
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([
+                {
+                  id: 'block-1',
+                  type: 'starter',
+                  name: 'Start',
+                  positionX: '100',
+                  positionY: '100',
+                  enabled: true,
+                  subBlocks: {},
+                  data: {},
+                },
+              ]),
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No edges
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No subflows
+            }),
+          })
           .mockReturnValueOnce({
             from: vi.fn().mockReturnValue({
               where: vi.fn().mockReturnValue({
@@ -189,6 +216,33 @@ describe('Workflow Deployment API Route', () => {
               }),
             }),
           })
+          // Mock normalized table queries (blocks, edges, subflows)
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([
+                {
+                  id: 'block-1',
+                  type: 'starter',
+                  name: 'Start',
+                  positionX: '100',
+                  positionY: '100',
+                  enabled: true,
+                  subBlocks: {},
+                  data: {},
+                },
+              ]),
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No edges
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No subflows
+            }),
+          })
           .mockReturnValueOnce({
             from: vi.fn().mockReturnValue({
               where: vi.fn().mockReturnValue({

diff --git a/apps/sim/app/api/workflows/[id]/deploy/route.ts b/apps/sim/app/api/workflows/[id]/deploy/route.ts
@@ -4,7 +4,7 @@ import { v4 as uuidv4 } from 'uuid'
 import { createLogger } from '@/lib/logs/console-logger'
 import { generateApiKey } from '@/lib/utils'
 import { db } from '@/db'
-import { apiKey, workflow } from '@/db/schema'
+import { apiKey, workflow, workflowBlocks, workflowEdges, workflowSubflows } from '@/db/schema'
 import { validateWorkflowAccess } from '../../middleware'
 import { createErrorResponse, createSuccessResponse } from '../../utils'
 
@@ -126,7 +126,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return createErrorResponse(validation.error.message, validation.error.status)
     }
 
-    // Get the workflow to find the user and current state
+    // Get the workflow to find the user
     const workflowData = await db
       .select({
         userId: workflow.userId,
@@ -142,8 +142,92 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     }
 
     const userId = workflowData[0].userId
-    const currentState = workflowData[0].state
+
+    // Get the current live state from normalized tables instead of stale JSON
+    logger.debug(`[${requestId}] Getting current workflow state for deployment`)
+
+    // Get blocks from normalized table
+    const blocks = await db.select().from(workflowBlocks).where(eq(workflowBlocks.workflowId, id))
+
+    // Get edges from normalized table
+    const edges = await db.select().from(workflowEdges).where(eq(workflowEdges.workflowId, id))
+
+    // Get subflows from normalized table
+    const subflows = await db
+      .select()
+      .from(workflowSubflows)
+      .where(eq(workflowSubflows.workflowId, id))
+
+    // Build current state from normalized data
+    const blocksMap: Record<string, any> = {}
+    const loops: Record<string, any> = {}
+    const parallels: Record<string, any> = {}
+
+    // Process blocks
+    blocks.forEach((block) => {
+      blocksMap[block.id] = {
+        id: block.id,
+        type: block.type,
+        name: block.name,
+        position: { x: Number(block.positionX), y: Number(block.positionY) },
+        data: block.data,
+        enabled: block.enabled,
+        subBlocks: block.subBlocks || {},
+      }
+    })
+
+    // Process subflows (loops and parallels)
+    subflows.forEach((subflow) => {
+      const config = (subflow.config as any) || {}
+      if (subflow.type === 'loop') {
+        loops[subflow.id] = {
+          nodes: config.nodes || [],
+          iterationCount: config.iterationCount || 1,
+          iterationType: config.iterationType || 'fixed',
+          collection: config.collection || '',
+        }
+      } else if (subflow.type === 'parallel') {
+        parallels[subflow.id] = {
+          nodes: config.nodes || [],
+          parallelCount: config.parallelCount || 2,
+          collection: config.collection || '',
+        }
+      }
+    })
+
+    // Convert edges to the expected format
+    const edgesArray = edges.map((edge) => ({
+      id: edge.id,
+      source: edge.sourceBlockId,
+      target: edge.targetBlockId,
+      sourceHandle: edge.sourceHandle,
+      targetHandle: edge.targetHandle,
+      type: 'default',
+      data: {},
+    }))
+
+    const currentState = {
+      blocks: blocksMap,
+      edges: edgesArray,
+      loops,
+      parallels,
+      lastSaved: Date.now(),
+    }
+
+    logger.debug(`[${requestId}] Current state retrieved from normalized tables:`, {
+      blocksCount: Object.keys(blocksMap).length,
+      edgesCount: edgesArray.length,
+      loopsCount: Object.keys(loops).length,
+      parallelsCount: Object.keys(parallels).length,
+    })
+
+    if (!currentState || !currentState.blocks) {
+      logger.error(`[${requestId}] Invalid workflow state retrieved`, { currentState })
+      throw new Error('Invalid workflow state: missing blocks')
+    }
+
     const deployedAt = new Date()
+    logger.debug(`[${requestId}] Proceeding with deployment at ${deployedAt.toISOString()}`)
 
     // Check if the user already has an API key
     const userApiKey = await db
@@ -191,7 +275,13 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     logger.info(`[${requestId}] Workflow deployed successfully: ${id}`)
     return createSuccessResponse({ apiKey: userKey, isDeployed: true, deployedAt })
   } catch (error: any) {
-    logger.error(`[${requestId}] Error deploying workflow: ${id}`, error)
+    logger.error(`[${requestId}] Error deploying workflow: ${id}`, {
+      error: error.message,
+      stack: error.stack,
+      name: error.name,
+      cause: error.cause,
+      fullError: error,
+    })
     return createErrorResponse(error.message || 'Failed to deploy workflow', 500)
   }
 }