fix(db): dedupe every re-root path in the folder contract migration

The migration re-roots rows in three places and each lands them in a namespace
covered by a partial unique index keyed on a coalesced nullable column, so a
name that is free in the source scope can already be taken in the destination.

- step 1's free-suffix probe only consulted the folder table, so a stranded row
  keeping the name 'X (1)' was invisible to the probe run for a stranded 'X' and
  both were assigned the same name
- step 2 re-rooted dangling folder_ids to NULL with no dedupe at all, colliding
  on the workflow and workspace_files active-unique indexes
- a stranded folder whose parent lives in another workspace passed the parent
  resolver but fails the folder_parent_resource_type_match trigger

Also re-roots active children before the retention sweep hard-deletes a folder:
the new ON DELETE SET NULL would otherwise collide on those same indexes, and
the batch delete turns that into a permanent stall.

Author: waleedlatif1

apps/sim/background/cleanup-soft-deletes.ts

@@ -32,7 +32,9 @@ import { prepareChatCleanup } from '@/lib/cleanup/chat-cleanup'
 import { hardDeleteDocuments } from '@/lib/knowledge/documents/service'
 import type { StorageContext } from '@/lib/uploads'
 import { isUsingCloudStorage, StorageService } from '@/lib/uploads'
+import { allocateUniqueWorkspaceFileName } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 import { deleteFileMetadata } from '@/lib/uploads/server/metadata'
+import { deduplicateWorkflowName } from '@/lib/workflows/utils'
 
 const logger = createLogger('CleanupSoftDeletes')
 
@@ -424,6 +426,75 @@ async function cleanupExpiredKnowledgeBases(
  * workspace files → S3 storage) are handled explicitly so the SELECT that drives
  * the external cleanup and the SELECT that drives the DB delete see the same rows.
  */
+/**
+ * Re-roots any still-active workflow or workspace file filed under a folder that is about to be
+ * hard-deleted, giving it a collision-free name first.
+ *
+ * The `folder_id` FKs are `ON DELETE SET NULL`, so Postgres already re-roots these rows on its
+ * own. The problem is the name: both tables carry a partial unique index keyed on
+ * `coalesce(folder_id, '')`, so an implicit SET NULL can land a row on a name the workspace root
+ * already holds and abort the whole DELETE with a 23505. `chunkedBatchDelete` counts that as a
+ * failed batch and stops, and the same poison row re-fails on every later run — folder retention
+ * would stall permanently for that workspace chunk. Renaming here leaves the SET NULL a no-op.
+ *
+ * An active child inside a soft-deleted folder is already an anomaly — the delete cascade
+ * archives children — so this normally selects nothing, which is why the per-row loop is fine.
+ */
+async function reRootActiveFolderChildren(folderIds: string[], label: string): Promise<void> {
+  if (folderIds.length === 0) return
+
+  const workflows = await cleanupDb
+    .select({ id: workflow.id, name: workflow.name, workspaceId: workflow.workspaceId })
+    .from(workflow)
+    .where(and(inArray(workflow.folderId, folderIds), isNull(workflow.archivedAt)))
+
+  for (const row of workflows) {
+    if (!row.workspaceId) continue
+    const name = await deduplicateWorkflowName(row.name, row.workspaceId, null, cleanupDb)
+    await cleanupDb.update(workflow).set({ folderId: null, name }).where(eq(workflow.id, row.id))
+  }
+
+  const files = await cleanupDb
+    .select({
+      id: workspaceFiles.id,
+      originalName: workspaceFiles.originalName,
+      workspaceId: workspaceFiles.workspaceId,
+    })
+    .from(workspaceFiles)
+    .where(
+      and(
+        inArray(workspaceFiles.folderId, folderIds),
+        isNull(workspaceFiles.deletedAt),
+        eq(workspaceFiles.context, 'workspace')
+      )
+    )
+
+  for (const row of files) {
+    if (!row.workspaceId) continue
+    /**
+     * `allocateUniqueWorkspaceFileName` throws once the copy-suffix range is exhausted. Falling
+     * back to the row id keeps the sweep running on a name that cannot collide — the opposite
+     * failure (letting it throw) is the stall this function exists to prevent.
+     */
+    let originalName: string
+    try {
+      originalName = await allocateUniqueWorkspaceFileName(row.workspaceId, row.originalName, null)
+    } catch {
+      originalName = `${row.originalName} (${row.id})`
+    }
+    await cleanupDb
+      .update(workspaceFiles)
+      .set({ folderId: null, originalName })
+      .where(eq(workspaceFiles.id, row.id))
+  }
+
+  if (workflows.length > 0 || files.length > 0) {
+    logger.warn(
+      `[${label}] Re-rooted ${workflows.length} workflow(s) and ${files.length} file(s) out of folders being purged`
+    )
+  }
+}
+
 const CLEANUP_TARGETS = [
   {
     table: folderTable,
@@ -442,6 +513,11 @@ const CLEANUP_TARGETS = [
       'knowledge_base',
       'table',
     ]),
+    onBatch: (rows: { id: string }[]) =>
+      reRootActiveFolderChildren(
+        rows.map(({ id }) => id),
+        'cleanup'
+      ),
     name: 'folder',
   },
   {
@@ -702,6 +778,7 @@ export async function runCleanupSoftDeletes(payload: CleanupJobPayload): Promise
       tableName: `${label}/${target.name}`,
       requireTimestampNotNull: true,
       additionalPredicate: 'additionalPredicate' in target ? target.additionalPredicate : undefined,
+      onBatch: 'onBatch' in target ? target.onBatch : undefined,
       dbClient: cleanupDb,
     })
     totalDeleted += result.deleted

apps/sim/lib/cleanup/batch-delete.ts

@@ -214,6 +214,12 @@ export interface BatchDeleteOptions {
    * so a cleanup pass only ever removes the kind it owns.
    */
   additionalPredicate?: SQL
+  /**
+   * Runs on each selected batch before its DELETE, for side effects that must observe exactly
+   * the rows about to be removed. Forwarded to `chunkedBatchDelete`; see `deleteFilter` there
+   * for the restore-race window this opens.
+   */
+  onBatch?: (rows: { id: string }[]) => Promise<void>
   batchSize?: number
   maxBatches?: number
   workspaceChunkSize?: number

apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts

@@ -267,7 +267,7 @@ function withCopySuffix(fileName: string, n: number): string {
 /**
  * Picks a display name that does not collide with an active workspace file (`original_name`).
  */
-async function allocateUniqueWorkspaceFileName(
+export async function allocateUniqueWorkspaceFileName(
   workspaceId: string,
   baseName: string,
   folderId?: string | null