improvement(folders): suffix the name on restore instead of failing

A 409 is the right answer when the user is choosing a name — create and
rename keep it. Restore is different: the caller cannot rename an archived
folder, so refusing on a name a sibling has since taken leaves them
permanently unable to restore it, with no affordance to resolve the
conflict.

Restore now deduplicates to "<name> (N)" instead, matching the convention
already used by the duplicate route, the client-side create dedup, and the
0272 backfill. The rename happens while the row is still archived, which
cannot collide because the unique index only covers active rows. Only the
restore root can conflict — descendants come back alongside the siblings
they were archived with.

Extracts deduplicateFolderName out of the duplicate route into
lib/folders/naming.ts now that it has a second caller.

Author: waleedlatif1

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

@@ -12,6 +12,7 @@ import { getSession } from '@/lib/auth'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { DbOrTx } from '@/lib/db/types'
+import { deduplicateFolderName } from '@/lib/folders/naming'
 import { toFolderApi } from '@/lib/folders/queries'
 import { duplicateWorkflow } from '@/lib/workflows/persistence/duplicate'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
@@ -265,38 +266,6 @@ async function assertTargetParentFolderMutable(
   }
 }
 
-async function deduplicateFolderName(
-  tx: DbOrTx,
-  workspaceId: string,
-  parentId: string | null,
-  requestedName: string
-): Promise<string> {
-  const parentCondition = parentId
-    ? eq(folderTable.parentId, parentId)
-    : isNull(folderTable.parentId)
-  const siblingRows = await tx
-    .select({ name: folderTable.name })
-    .from(folderTable)
-    .where(
-      and(
-        eq(folderTable.workspaceId, workspaceId),
-        eq(folderTable.resourceType, 'workflow'),
-        parentCondition,
-        isNull(folderTable.deletedAt)
-      )
-    )
-  const siblingNames = new Set(siblingRows.map((row) => row.name))
-  if (!siblingNames.has(requestedName)) return requestedName
-
-  let suffix = 1
-  let candidate = `${requestedName} (${suffix})`
-  while (siblingNames.has(candidate)) {
-    suffix += 1
-    candidate = `${requestedName} (${suffix})`
-  }
-  return candidate
-}
-
 async function duplicateFolderStructure(
   tx: DbOrTx,
   sourceFolderId: string,

apps/sim/lib/folders/naming.ts

@@ -0,0 +1,46 @@
+import { type db, folder as folderTable } from '@sim/db'
+import { and, eq, isNull } from 'drizzle-orm'
+import type { FolderResourceType } from '@/lib/api/contracts/folders'
+
+type DbOrTx = Pick<typeof db, 'select'>
+
+/**
+ * Returns `requestedName`, or the first `"<name> (N)"` variant not already taken by an
+ * active sibling under `parentId`.
+ *
+ * The generic `folder` table has a partial unique index on active
+ * `(workspaceId, resourceType, parentId, name)`, so any path that makes a row active with a
+ * caller-supplied name has to either dedup here or handle a 23505. Use this where the user
+ * has no opportunity to choose a different name (duplicate, restore); return a conflict
+ * instead where they do (create, rename).
+ *
+ * The `" (N)"` shape deliberately matches both the client-side dedup in
+ * `useFolderCreateWithDedup` and the backfill in migration 0272, so a deduped name reads the
+ * same however it was produced.
+ */
+export async function deduplicateFolderName(
+  tx: DbOrTx,
+  workspaceId: string,
+  parentId: string | null,
+  requestedName: string,
+  resourceType: FolderResourceType = 'workflow'
+): Promise<string> {
+  const siblingRows = await tx
+    .select({ name: folderTable.name })
+    .from(folderTable)
+    .where(
+      and(
+        eq(folderTable.workspaceId, workspaceId),
+        eq(folderTable.resourceType, resourceType),
+        parentId ? eq(folderTable.parentId, parentId) : isNull(folderTable.parentId),
+        isNull(folderTable.deletedAt)
+      )
+    )
+
+  const siblingNames = new Set(siblingRows.map((row) => row.name))
+  if (!siblingNames.has(requestedName)) return requestedName
+
+  let suffix = 1
+  while (siblingNames.has(`${requestedName} (${suffix})`)) suffix += 1
+  return `${requestedName} (${suffix})`
+}

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

@@ -12,6 +12,7 @@ import { createLogger } from '@sim/logger'
 import { getPostgresErrorCode } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
 import { and, eq, inArray, isNull, min } from 'drizzle-orm'
+import { deduplicateFolderName } from '@/lib/folders/naming'
 import { archiveWorkflowsByIdsInWorkspace } from '@/lib/workflows/lifecycle'
 import type { OrchestrationErrorCode } from '@/lib/workflows/orchestration/types'
 import { checkForCircularReference } from '@/lib/workflows/utils'
@@ -556,6 +557,27 @@ export async function performRestoreFolder(
         }
       }
 
+      // Restore is a recovery action — the caller cannot rename an archived folder, so a
+      // name already taken by an active sibling would leave them permanently unable to
+      // restore. Dedup instead of failing. Safe to rename while the row is still archived:
+      // the unique index only covers active rows, so this cannot collide before the
+      // recursive restore below clears `deletedAt`. Only the restore root can conflict —
+      // descendants come back alongside the siblings they were archived with.
+      const restoredName = await deduplicateFolderName(
+        tx,
+        workspaceId,
+        folder.parentId,
+        folder.name
+      )
+      if (restoredName !== folder.name) {
+        logger.info('Renamed folder on restore to avoid a sibling name conflict', {
+          folderId,
+          from: folder.name,
+          to: restoredName,
+        })
+        await tx.update(folderTable).set({ name: restoredName }).where(eq(folderTable.id, folderId))
+      }
+
       return restoreFolderRecursively(folderId, workspaceId, folder.deletedAt!, tx)
     })
   } catch (error) {