fix: preserve committed write results and bound retention reads

Author: mzxchandra

apps/sim/lib/file-retention/folders.ts

@@ -53,17 +53,6 @@ export async function cleanupExpiredFileFolderInTx(
         .where(and(folderScope, eq(folder.id, child.id)))
     }
   }
-  const rootFiles = await tx
-    .select({ name: workspaceFiles.originalName })
-    .from(workspaceFiles)
-    .where(
-      and(
-        fileOwnerCondition(owner),
-        workspaceFileNameFolderCondition(null),
-        isNull(workspaceFiles.deletedAt)
-      )
-    )
-  const rootNames = new Set(rootFiles.map(({ name }) => name))
   for (;;) {
     const children = await tx
       .select({ id: workspaceFiles.id, name: workspaceFiles.originalName })
@@ -79,11 +68,40 @@ export async function cleanupExpiredFileFolderInTx(
       .limit(FILES_PER_QUERY)
       .for('update')
     if (!children.length) break
+    const candidateNames = new Set(children.map(({ name }) => name))
+    const rootFiles = await tx
+      .select({ name: workspaceFiles.originalName })
+      .from(workspaceFiles)
+      .where(
+        and(
+          fileOwnerCondition(owner),
+          workspaceFileNameFolderCondition(null),
+          isNull(workspaceFiles.deletedAt),
+          inArray(workspaceFiles.originalName, [...candidateNames])
+        )
+      )
+    const rootNames = new Set(rootFiles.map(({ name }) => name))
     const renamed: { id: string; name: string }[] = []
     for (const child of children) {
       const name = await generateRestoreName(
         child.name,
-        async (candidate) => rootNames.has(candidate),
+        async (candidate) => {
+          if (rootNames.has(candidate)) return true
+          if (candidateNames.has(candidate)) return false
+          const [existing] = await tx
+            .select({ id: workspaceFiles.id })
+            .from(workspaceFiles)
+            .where(
+              and(
+                fileOwnerCondition(owner),
+                workspaceFileNameFolderCondition(null),
+                isNull(workspaceFiles.deletedAt),
+                eq(workspaceFiles.originalName, candidate)
+              )
+            )
+            .limit(1)
+          return Boolean(existing)
+        },
         { hasExtension: true }
       )
       rootNames.add(name)

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

@@ -2705,8 +2705,7 @@ export async function updateWorkspaceFileContent(
     }
     await finishFileContentEffects(
       { cleanupIds: finalized.storageCleanupEventIds, liveDocEventId: finalized.liveDocEventId },
-      { workspaceId, fileId, reason: 'released version' },
-      'defer'
+      { workspaceId, fileId, reason: 'released version' }
     )
 
     const currentFolderPath =

apps/sim/lib/uploads/server/content-effects.test.ts

@@ -1,3 +1,4 @@
+import { createLogger } from '@sim/logger'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mocks = vi.hoisted(() => ({ cleanup: vi.fn(), reconcile: vi.fn() }))
@@ -22,12 +23,23 @@ describe('committed file reconciliation policy', () => {
       await expect(finishFileContentEffects(effects, {})).resolves.toBeUndefined()
     }
   )
-  it.each(['dead_letter', 'not_found'])('propagates a terminal %s result', async (status) => {
-    mocks.reconcile.mockResolvedValue(status)
-    await expect(finishFileContentEffects(effects, {})).rejects.toThrow(status)
-  })
-  it('retains the explicit defer policy for a terminal result', async () => {
-    mocks.reconcile.mockResolvedValue('dead_letter')
-    await expect(finishFileContentEffects(effects, {}, 'defer')).resolves.toBeUndefined()
+  it.each(['dead_letter', 'not_found'])(
+    'reports a terminal %s result without failing the committed write',
+    async (status) => {
+      mocks.reconcile.mockResolvedValue(status)
+      await expect(finishFileContentEffects(effects, {})).resolves.toBeUndefined()
+      expect(createLogger('FileContentEffects').error).toHaveBeenCalledWith(
+        'Committed file live-document reconciliation requires intervention',
+        expect.objectContaining({ eventId: 'event-1', result: status })
+      )
+    }
+  )
+  it('reports an inline processing exception without failing the committed write', async () => {
+    mocks.reconcile.mockRejectedValue(new Error('database unavailable'))
+    await expect(finishFileContentEffects(effects, {})).resolves.toBeUndefined()
+    expect(createLogger('FileContentEffects').error).toHaveBeenCalledWith(
+      'Committed file live-document reconciliation failed inline',
+      expect.objectContaining({ eventId: 'event-1' })
+    )
   })
 })

apps/sim/lib/uploads/server/content-effects.ts

@@ -5,36 +5,26 @@ import { processFileLiveDocReconciliationNow } from '@/lib/uploads/server/live-d
 
 const logger = createLogger('FileContentEffects')
 
-/** Processes durable content effects after commit, retaining the caller's inline failure policy. */
+/** Reports durable effect failures without changing the outcome of an already committed write. */
 export async function finishFileContentEffects(
   effects: { cleanupIds: readonly string[]; liveDocEventId?: string },
-  logContext: Record<string, unknown>,
-  reconciliationFailure: 'propagate' | 'defer' = 'propagate'
+  logContext: Record<string, unknown>
 ): Promise<void> {
   await processWorkspaceFileStorageCleanupsNow(effects.cleanupIds, logContext)
   if (!effects.liveDocEventId) return
-  if (reconciliationFailure === 'propagate') {
+  const context = { ...logContext, eventId: effects.liveDocEventId }
+  try {
     const result = await processFileLiveDocReconciliationNow(effects.liveDocEventId)
     if (result === 'dead_letter' || result === 'not_found') {
-      throw new Error(`Live document reconciliation could not complete: ${result}`)
-    }
-    if (result !== 'completed') {
-      logger.warn('Live document reconciliation remains pending', {
-        ...logContext,
-        eventId: effects.liveDocEventId,
+      logger.error('Committed file live-document reconciliation requires intervention', {
+        ...context,
         result,
       })
-    }
-    return
-  }
-  const context = { ...logContext, eventId: effects.liveDocEventId }
-  try {
-    const result = await processFileLiveDocReconciliationNow(effects.liveDocEventId)
-    if (result !== 'completed') {
-      logger.warn('Live document reconciliation deferred to outbox retry', { ...context, result })
+    } else if (result !== 'completed') {
+      logger.warn('Live document reconciliation remains pending', { ...context, result })
     }
   } catch (error) {
-    logger.warn('Live document reconciliation deferred after inline processing error', {
+    logger.error('Committed file live-document reconciliation failed inline', {
       ...context,
       error: describeError(error),
     })