test(cleanup): cover re-rooting active children out of purged folders

Covers the one path this PR added that production exercises on zero rows: the
onBatch that renames active children before the folder hard-delete, so the new
ON DELETE SET NULL cannot collide on the workflow / workspace_files
active-unique indexes and stall retention permanently.

Each assertion was mutation-checked — dropping the dedup, the id-suffixed
fallback, or the onBatch wiring each fails the corresponding test.

Author: waleedlatif1

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

@@ -2,7 +2,13 @@
  * @vitest-environment node
  */
 
-import { dbChainMock, dbChainMockFns, resetDbChainMock, schemaMock } from '@sim/testing'
+import {
+  dbChainMock,
+  dbChainMockFns,
+  queueTableRows,
+  resetDbChainMock,
+  schemaMock,
+} from '@sim/testing'
 import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const {
@@ -18,7 +24,11 @@ const {
   mockPrepareChatCleanup,
   mockResolveStorageBillingContext,
   mockSelectRowsByIdChunks,
+  mockDeduplicateWorkflowName,
+  mockAllocateUniqueWorkspaceFileName,
 } = vi.hoisted(() => ({
+  mockDeduplicateWorkflowName: vi.fn(async (name: string) => name),
+  mockAllocateUniqueWorkspaceFileName: vi.fn(async (_ws: string, name: string) => name),
   mockBatchDeleteByWorkspaceAndTimestamp: vi.fn(async () => ({ deleted: 0, failed: 0 })),
   mockChunkedBatchDelete: vi.fn(async () => ({ deleted: 0, failed: 0 })),
   mockDecrementStorageUsageForBillingContextInTx: vi.fn(async () => undefined),
@@ -66,6 +76,14 @@ vi.mock('@/lib/uploads', () => ({
 
 vi.mock('@/lib/uploads/server/metadata', () => ({ deleteFileMetadata: mockDeleteFileMetadata }))
 
+vi.mock('@/lib/workflows/utils', () => ({
+  deduplicateWorkflowName: mockDeduplicateWorkflowName,
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  allocateUniqueWorkspaceFileName: mockAllocateUniqueWorkspaceFileName,
+}))
+
 import { runCleanupSoftDeletes } from '@/background/cleanup-soft-deletes'
 
 const basePayload = {
@@ -269,6 +287,7 @@ interface BatchDeleteOptions {
   tableName: string
   requireTimestampNotNull?: boolean
   additionalPredicate?: { type: string; column: unknown; values: unknown[] }
+  onBatch?: (rows: { id: string }[]) => Promise<void>
 }
 
 /**
@@ -331,4 +350,95 @@ describe('folder cleanup target', () => {
       .map(([options]) => options.tableName)
     expect(filtered).toEqual(['free/1/folder'])
   })
+
+  /**
+   * `folder_id` is `ON DELETE SET NULL`, so Postgres re-roots surviving children on its own —
+   * but `workflow` and `workspace_files` each carry a partial unique index keyed on
+   * `coalesce(folder_id, '')`, so an implicit SET NULL can land a child on a name the workspace
+   * root already holds. That aborts the whole DELETE with a 23505, which `chunkedBatchDelete`
+   * turns into `hasMore = false` — folder retention then stalls permanently for that chunk,
+   * re-failing on every later run. `onBatch` renames first so the SET NULL is a no-op.
+   */
+  describe('re-rooting active children before the delete', () => {
+    async function getFolderOnBatch() {
+      const target = await runAndFindFolderTarget()
+      expect(target?.onBatch).toBeTypeOf('function')
+      return target!.onBatch!
+    }
+
+    it('is the only cleanup target that re-roots children', async () => {
+      await runCleanupSoftDeletes(basePayload)
+      const calls = mockBatchDeleteByWorkspaceAndTimestamp.mock.calls as unknown as Array<
+        [BatchDeleteOptions]
+      >
+
+      const withOnBatch = calls
+        .filter(([options]) => options.onBatch !== undefined)
+        .map(([options]) => options.tableName)
+      expect(withOnBatch).toEqual(['free/1/folder'])
+    })
+
+    it('re-roots an active workflow under a deduplicated name', async () => {
+      const onBatch = await getFolderOnBatch()
+      queueTableRows(schemaMock.workflow, [{ id: 'w1', name: 'Report', workspaceId: 'ws-1' }])
+      queueTableRows(schemaMock.workspaceFiles, [])
+      mockDeduplicateWorkflowName.mockResolvedValueOnce('Report (2)')
+
+      await onBatch([{ id: 'folder-1' }])
+
+      // Deduped against the workspace ROOT (folderId null), which is where SET NULL would put it.
+      expect(mockDeduplicateWorkflowName).toHaveBeenCalledWith(
+        'Report',
+        'ws-1',
+        null,
+        expect.anything()
+      )
+      expect(dbChainMockFns.set).toHaveBeenCalledWith({ folderId: null, name: 'Report (2)' })
+    })
+
+    it('re-roots an active workspace file under a deduplicated name', async () => {
+      const onBatch = await getFolderOnBatch()
+      queueTableRows(schemaMock.workflow, [])
+      queueTableRows(schemaMock.workspaceFiles, [
+        { id: 'f1', originalName: 'report.pdf', workspaceId: 'ws-1' },
+      ])
+      mockAllocateUniqueWorkspaceFileName.mockResolvedValueOnce('report (2).pdf')
+
+      await onBatch([{ id: 'folder-1' }])
+
+      expect(mockAllocateUniqueWorkspaceFileName).toHaveBeenCalledWith('ws-1', 'report.pdf', null)
+      expect(dbChainMockFns.set).toHaveBeenCalledWith({
+        folderId: null,
+        originalName: 'report (2).pdf',
+      })
+    })
+
+    it('falls back to an id-suffixed name when the copy-suffix range is exhausted', async () => {
+      // Letting the allocator throw would abort the sweep — the exact stall this guards against.
+      const onBatch = await getFolderOnBatch()
+      queueTableRows(schemaMock.workflow, [])
+      queueTableRows(schemaMock.workspaceFiles, [
+        { id: 'f1', originalName: 'report.pdf', workspaceId: 'ws-1' },
+      ])
+      mockAllocateUniqueWorkspaceFileName.mockRejectedValueOnce(new Error('conflict'))
+
+      await expect(onBatch([{ id: 'folder-1' }])).resolves.toBeUndefined()
+
+      expect(dbChainMockFns.set).toHaveBeenCalledWith({
+        folderId: null,
+        originalName: 'report.pdf (f1)',
+      })
+    })
+
+    it('touches nothing when the batch is empty', async () => {
+      const onBatch = await getFolderOnBatch()
+      dbChainMockFns.select.mockClear()
+      dbChainMockFns.update.mockClear()
+
+      await onBatch([])
+
+      expect(dbChainMockFns.select).not.toHaveBeenCalled()
+      expect(dbChainMockFns.update).not.toHaveBeenCalled()
+    })
+  })
 })