feat(folders): folders to manage workflows (#490)

* feat(subworkflows) workflows in workflows

* revert sync changes

* working output vars

* fix greptile comments

* add cycle detection

* add tests

* working tests

* works

* fix formatting

* fix input var handling

* fix(tab-sync): sync between tabs on change

* feat(folders): folders to organize workflows

* address comments

* change schema types

* fix lint error

* fix typing error

* fix race cond

* delete unused files

* improved UI

* updated naming conventions

* revert unrelated changes to db schema

* fixed collapsed sidebar subfolders

* add logs filters for folders

---------

Co-authored-by: Vikhyath Mondreti <vikhyathmondreti@Vikhyaths-MacBook-Air.local>
Co-authored-by: Vikhyath Mondreti <vikhyathmondreti@Vikhyaths-Air.attlocal.net>
Co-authored-by: Waleed Latif <walif6@gmail.com>

Author: 4 people

apps/sim/app/api/folders/[id]/route.ts

@@ -0,0 +1,182 @@
+import { and, eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { createLogger } from '@/lib/logs/console-logger'
+import { db } from '@/db'
+import { workflow, workflowFolder } from '@/db/schema'
+
+const logger = createLogger('FoldersIDAPI')
+
+// PUT - Update a folder
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { id } = await params
+    const body = await request.json()
+    const { name, color, isExpanded, parentId } = body
+
+    // Verify the folder exists and belongs to the user
+    const existingFolder = await db
+      .select()
+      .from(workflowFolder)
+      .where(and(eq(workflowFolder.id, id), eq(workflowFolder.userId, session.user.id)))
+      .then((rows) => rows[0])
+
+    if (!existingFolder) {
+      return NextResponse.json({ error: 'Folder not found' }, { status: 404 })
+    }
+
+    // Prevent setting a folder as its own parent or creating circular references
+    if (parentId && parentId === id) {
+      return NextResponse.json({ error: 'Folder cannot be its own parent' }, { status: 400 })
+    }
+
+    // Check for circular references if parentId is provided
+    if (parentId) {
+      const wouldCreateCycle = await checkForCircularReference(id, parentId)
+      if (wouldCreateCycle) {
+        return NextResponse.json(
+          { error: 'Cannot create circular folder reference' },
+          { status: 400 }
+        )
+      }
+    }
+
+    // Update the folder
+    const updates: any = { updatedAt: new Date() }
+    if (name !== undefined) updates.name = name.trim()
+    if (color !== undefined) updates.color = color
+    if (isExpanded !== undefined) updates.isExpanded = isExpanded
+    if (parentId !== undefined) updates.parentId = parentId || null
+
+    const [updatedFolder] = await db
+      .update(workflowFolder)
+      .set(updates)
+      .where(eq(workflowFolder.id, id))
+      .returning()
+
+    logger.info('Updated folder:', { id, updates })
+
+    return NextResponse.json({ folder: updatedFolder })
+  } catch (error) {
+    logger.error('Error updating folder:', { error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
+
+// DELETE - Delete a folder
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { id } = await params
+    const { searchParams } = new URL(request.url)
+    const moveWorkflowsTo = searchParams.get('moveWorkflowsTo') // Optional: move workflows to another folder
+
+    // Verify the folder exists and belongs to the user
+    const existingFolder = await db
+      .select()
+      .from(workflowFolder)
+      .where(and(eq(workflowFolder.id, id), eq(workflowFolder.userId, session.user.id)))
+      .then((rows) => rows[0])
+
+    if (!existingFolder) {
+      return NextResponse.json({ error: 'Folder not found' }, { status: 404 })
+    }
+
+    // Check if folder has child folders
+    const childFolders = await db
+      .select({ id: workflowFolder.id })
+      .from(workflowFolder)
+      .where(eq(workflowFolder.parentId, id))
+
+    // Check if folder has workflows
+    const workflowsInFolder = await db
+      .select({ id: workflow.id })
+      .from(workflow)
+      .where(eq(workflow.folderId, id))
+
+    // Handle child folders - move them to parent or root
+    if (childFolders.length > 0) {
+      await db
+        .update(workflowFolder)
+        .set({
+          parentId: existingFolder.parentId, // Move to the parent of the deleted folder
+          updatedAt: new Date(),
+        })
+        .where(eq(workflowFolder.parentId, id))
+    }
+
+    // Handle workflows in the folder
+    if (workflowsInFolder.length > 0) {
+      const newFolderId = moveWorkflowsTo || null // Move to specified folder or root
+      await db
+        .update(workflow)
+        .set({
+          folderId: newFolderId,
+          updatedAt: new Date(),
+        })
+        .where(eq(workflow.folderId, id))
+    }
+
+    // Delete the folder
+    await db.delete(workflowFolder).where(eq(workflowFolder.id, id))
+
+    logger.info('Deleted folder:', {
+      id,
+      childFoldersCount: childFolders.length,
+      workflowsCount: workflowsInFolder.length,
+      movedWorkflowsTo: moveWorkflowsTo,
+    })
+
+    return NextResponse.json({
+      success: true,
+      movedItems: {
+        childFolders: childFolders.length,
+        workflows: workflowsInFolder.length,
+      },
+    })
+  } catch (error) {
+    logger.error('Error deleting folder:', { error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
+
+// Helper function to check for circular references
+async function checkForCircularReference(folderId: string, parentId: string): Promise<boolean> {
+  let currentParentId: string | null = parentId
+  const visited = new Set<string>()
+
+  while (currentParentId) {
+    if (visited.has(currentParentId)) {
+      return true // Circular reference detected
+    }
+
+    if (currentParentId === folderId) {
+      return true // Would create a cycle
+    }
+
+    visited.add(currentParentId)
+
+    // Get the parent of the current parent
+    const parent: { parentId: string | null } | undefined = await db
+      .select({ parentId: workflowFolder.parentId })
+      .from(workflowFolder)
+      .where(eq(workflowFolder.id, currentParentId))
+      .then((rows) => rows[0])
+
+    currentParentId = parent?.parentId || null
+  }
+
+  return false
+}

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

@@ -0,0 +1,101 @@
+import { and, asc, desc, eq, isNull } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { createLogger } from '@/lib/logs/console-logger'
+import { db } from '@/db'
+import { workflowFolder } from '@/db/schema'
+
+const logger = createLogger('FoldersAPI')
+
+// GET - Fetch folders for a workspace
+export async function GET(request: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { searchParams } = new URL(request.url)
+    const workspaceId = searchParams.get('workspaceId')
+
+    if (!workspaceId) {
+      return NextResponse.json({ error: 'Workspace ID is required' }, { status: 400 })
+    }
+
+    // Fetch all folders for the workspace, ordered by sortOrder and createdAt
+    const folders = await db
+      .select()
+      .from(workflowFolder)
+      .where(
+        and(eq(workflowFolder.workspaceId, workspaceId), eq(workflowFolder.userId, session.user.id))
+      )
+      .orderBy(asc(workflowFolder.sortOrder), asc(workflowFolder.createdAt))
+
+    return NextResponse.json({ folders })
+  } catch (error) {
+    logger.error('Error fetching folders:', { error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
+
+// POST - Create a new folder
+export async function POST(request: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const { name, workspaceId, parentId, color } = body
+
+    if (!name || !workspaceId) {
+      return NextResponse.json({ error: 'Name and workspace ID are required' }, { status: 400 })
+    }
+
+    // Generate a new ID
+    const id = crypto.randomUUID()
+
+    // Use transaction to ensure sortOrder consistency
+    const newFolder = await db.transaction(async (tx) => {
+      // Get the next sort order for the parent (or root level)
+      const existingFolders = await tx
+        .select({ sortOrder: workflowFolder.sortOrder })
+        .from(workflowFolder)
+        .where(
+          and(
+            eq(workflowFolder.workspaceId, workspaceId),
+            eq(workflowFolder.userId, session.user.id),
+            parentId ? eq(workflowFolder.parentId, parentId) : isNull(workflowFolder.parentId)
+          )
+        )
+        .orderBy(desc(workflowFolder.sortOrder))
+        .limit(1)
+
+      const nextSortOrder = existingFolders.length > 0 ? existingFolders[0].sortOrder + 1 : 0
+
+      // Insert the new folder within the same transaction
+      const [folder] = await tx
+        .insert(workflowFolder)
+        .values({
+          id,
+          name: name.trim(),
+          userId: session.user.id,
+          workspaceId,
+          parentId: parentId || null,
+          color: color || '#6B7280',
+          sortOrder: nextSortOrder,
+        })
+        .returning()
+
+      return folder
+    })
+
+    logger.info('Created new folder:', { id, name, workspaceId, parentId })
+
+    return NextResponse.json({ folder: newFolder })
+  } catch (error) {
+    logger.error('Error creating folder:', { error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}