fix(folders): finish the unique-name handling across every write path

Three gaps left by the previous pass, all from the same new constraint.

- restore re-roots a folder whose parent is still archived, but the dedup
  ran against the original parentId, so a root-level clash was missed and
  clearing deletedAt still hit the index — defeating the dedup in exactly
  the case it exists for. It now dedups against the resolved parent
- the folder PUT handler mapped only not_found and validation, so the
  conflict errorCode added for renames fell through to 500. It now shares
  folderMutationStatus with the POST route
- admin workspace import inserted path segments unconditionally, so a
  segment matching an existing folder failed the import. It now reuses the
  existing folder (mkdir -p), which is also the semantics importing into
  a folder path should have — the same path twice lands in one tree

Author: waleedlatif1

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

@@ -13,6 +13,14 @@ import { captureServerEvent } from '@/lib/posthog/server'
 import { performDeleteFolder, performUpdateFolder } from '@/lib/workflows/orchestration'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
+/** Maps an orchestration errorCode to its HTTP status; mirrors the POST /api/folders route. */
+function folderMutationStatus(errorCode: string | undefined): number {
+  if (errorCode === 'validation') return 400
+  if (errorCode === 'conflict') return 409
+  if (errorCode === 'not_found') return 404
+  return 500
+}
+
 const logger = createLogger('FoldersIDAPI')
 
 // PUT - Update a folder
@@ -92,8 +100,7 @@ export const PUT = withRouteHandler(
       })
 
       if (!result.success || !result.folder) {
-        const status =
-          result.errorCode === 'not_found' ? 404 : result.errorCode === 'validation' ? 400 : 500
+        const status = folderMutationStatus(result.errorCode)
         return NextResponse.json({ error: result.error }, { status })
       }
 

apps/sim/app/api/v1/admin/workspaces/[id]/import/route.ts

@@ -28,7 +28,7 @@ import { folder as folderTable, workflow } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
-import { eq } from 'drizzle-orm'
+import { and, eq, isNull } from 'drizzle-orm'
 import { NextResponse } from 'next/server'
 import {
   adminV1ImportWorkspaceContract,
@@ -76,6 +76,51 @@ interface ParsedWorkflow {
   folderPath: string[]
 }
 
+/**
+ * Returns the id of the active workflow folder named `name` under `parentId`, creating it if
+ * absent — `mkdir -p` semantics.
+ *
+ * The generic `folder` table enforces active sibling-name uniqueness, which
+ * `workflow_folder` did not, so blindly inserting an import path segment that already exists
+ * now fails the whole import on a unique violation. Reusing the existing folder is also the
+ * behaviour an import of a folder *path* should have: importing into "Reports/2026" twice
+ * should land in one tree, not two.
+ */
+async function ensureImportFolder(
+  workspaceId: string,
+  userId: string,
+  name: string,
+  parentId: string | null
+): Promise<string> {
+  const [existing] = await db
+    .select({ id: folderTable.id })
+    .from(folderTable)
+    .where(
+      and(
+        eq(folderTable.workspaceId, workspaceId),
+        eq(folderTable.resourceType, 'workflow'),
+        eq(folderTable.name, name),
+        parentId ? eq(folderTable.parentId, parentId) : isNull(folderTable.parentId),
+        isNull(folderTable.deletedAt)
+      )
+    )
+    .limit(1)
+  if (existing) return existing.id
+
+  const folderId = generateId()
+  await db.insert(folderTable).values({
+    id: folderId,
+    resourceType: 'workflow',
+    name,
+    userId,
+    workspaceId,
+    parentId,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  })
+  return folderId
+}
+
 export const POST = withRouteHandler(
   withAdminAuthParams<RouteParams>(async (request, context) => {
     const parsed = await parseRequest(adminV1ImportWorkspaceContract, request, context)
@@ -151,17 +196,12 @@ export const POST = withRouteHandler(
 
       let rootFolderId: string | undefined
       if (rootFolderName && createFolders) {
-        rootFolderId = generateId()
-        await db.insert(folderTable).values({
-          id: rootFolderId,
-          resourceType: 'workflow',
-          name: rootFolderName,
-          userId: workspaceData.ownerId,
+        rootFolderId = await ensureImportFolder(
           workspaceId,
-          parentId: null,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        })
+          workspaceData.ownerId,
+          rootFolderName,
+          null
+        )
       }
 
       const folderMap = new Map<string, string>()
@@ -230,17 +270,12 @@ async function importSingleWorkflow(
         const fullPath = rootFolderId ? `root/${pathSegment}` : pathSegment
 
         if (!folderMap.has(fullPath)) {
-          const folderId = generateId()
-          await db.insert(folderTable).values({
-            id: folderId,
-            resourceType: 'workflow',
-            name: wf.folderPath[i],
-            userId: ownerId,
+          const folderId = await ensureImportFolder(
             workspaceId,
-            parentId,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          })
+            ownerId,
+            wf.folderPath[i],
+            parentId
+          )
           folderMap.set(fullPath, folderId)
           parentId = folderId
         } else {

apps/sim/lib/workflows/orchestration/folder-lifecycle.ts

@@ -543,13 +543,17 @@ export async function performRestoreFolder(
   let restoredStats: { folders: number; workflows: number }
   try {
     restoredStats = await db.transaction(async (tx) => {
+      // A folder whose parent is still archived is re-rooted, so the name it has to be
+      // unique against is its *resolved* parent's sibling set, not its original one.
+      let resolvedParentId = folder.parentId
       if (folder.parentId) {
         const [parentFolder] = await tx
           .select({ archivedAt: folderTable.deletedAt })
           .from(folderTable)
           .where(and(eq(folderTable.id, folder.parentId), eq(folderTable.resourceType, 'workflow')))
 
         if (!parentFolder || parentFolder.archivedAt) {
+          resolvedParentId = null
           await tx
             .update(folderTable)
             .set({ parentId: null })
@@ -566,7 +570,7 @@ export async function performRestoreFolder(
       const restoredName = await deduplicateFolderName(
         tx,
         workspaceId,
-        folder.parentId,
+        resolvedParentId,
         folder.name
       )
       if (restoredName !== folder.name) {