Enforce duplicate file name

Author: Theodore Li

apps/sim/app/api/v1/files/route.ts

@@ -4,6 +4,7 @@ import { z } from 'zod'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
 import { generateRequestId } from '@/lib/core/utils/request'
 import {
+  FileConflictError,
   getWorkspaceFile,
   listWorkspaceFiles,
   uploadWorkspaceFile,
@@ -182,7 +183,8 @@ export async function POST(request: NextRequest) {
     })
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Failed to upload file'
-    const isDuplicate = errorMessage.includes('already exists')
+    const isDuplicate =
+      error instanceof FileConflictError || errorMessage.includes('already exists')
 
     if (isDuplicate) {
       return NextResponse.json({ error: errorMessage }, { status: 409 })

apps/sim/app/api/workspaces/[id]/files/[fileId]/restore/route.ts

@@ -2,7 +2,7 @@ import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
 import { generateRequestId } from '@/lib/core/utils/request'
-import { restoreWorkspaceFile } from '@/lib/uploads/contexts/workspace'
+import { FileConflictError, restoreWorkspaceFile } from '@/lib/uploads/contexts/workspace'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('RestoreWorkspaceFileAPI')
@@ -31,6 +31,9 @@ export async function POST(
 
     return NextResponse.json({ success: true })
   } catch (error) {
+    if (error instanceof FileConflictError) {
+      return NextResponse.json({ error: error.message }, { status: 409 })
+    }
     logger.error(`[${requestId}] Error restoring workspace file ${fileId}`, error)
     return NextResponse.json(
       { error: error instanceof Error ? error.message : 'Internal server error' },

apps/sim/app/api/workspaces/[id]/files/route.ts

@@ -4,6 +4,7 @@ import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
 import { getSession } from '@/lib/auth'
 import { generateRequestId } from '@/lib/core/utils/request'
 import {
+  FileConflictError,
   listWorkspaceFiles,
   uploadWorkspaceFile,
   type WorkspaceFileScope,
@@ -135,9 +136,9 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
   } catch (error) {
     logger.error(`[${requestId}] Error uploading workspace file:`, error)
 
-    // Check if it's a duplicate file error
     const errorMessage = error instanceof Error ? error.message : 'Failed to upload file'
-    const isDuplicate = errorMessage.includes('already exists')
+    const isDuplicate =
+      error instanceof FileConflictError || errorMessage.includes('already exists')
 
     return NextResponse.json(
       {

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

@@ -19,6 +19,7 @@ import {
   uploadFile,
 } from '@/lib/uploads/core/storage-service'
 import { getFileMetadataByKey, insertFileMetadata } from '@/lib/uploads/server/metadata'
+import { getPostgresErrorCode } from '@/lib/core/utils/pg-error'
 import { generateRestoreName } from '@/lib/core/utils/restore-name'
 import { isUuid, sanitizeFileName } from '@/executor/constants'
 import type { UserFile } from '@/executor/types'
@@ -110,7 +111,7 @@ export async function uploadWorkspaceFile(
 
   const exists = await fileExistsInWorkspace(workspaceId, fileName)
   if (exists) {
-    throw new Error(`A file named "${fileName}" already exists in this workspace`)
+    throw new FileConflictError(fileName)
   }
 
   const quotaCheck = await checkStorageQuota(userId, fileBuffer.length)
@@ -204,6 +205,12 @@ export async function uploadWorkspaceFile(
       context: 'workspace',
     }
   } catch (error) {
+    if (error instanceof FileConflictError) {
+      throw error
+    }
+    if (getPostgresErrorCode(error) === '23505') {
+      throw new FileConflictError(fileName)
+    }
     logger.error(`Failed to upload workspace file ${fileName}:`, error)
     throw new Error(
       `Failed to upload file: ${error instanceof Error ? error.message : 'Unknown error'}`
@@ -573,17 +580,25 @@ export async function renameWorkspaceFile(
     throw new FileConflictError(trimmedName)
   }
 
-  const updated = await db
-    .update(workspaceFiles)
-    .set({ originalName: trimmedName })
-    .where(
-      and(
-        eq(workspaceFiles.id, fileId),
-        eq(workspaceFiles.workspaceId, workspaceId),
-        eq(workspaceFiles.context, 'workspace')
+  let updated: { id: string }[]
+  try {
+    updated = await db
+      .update(workspaceFiles)
+      .set({ originalName: trimmedName })
+      .where(
+        and(
+          eq(workspaceFiles.id, fileId),
+          eq(workspaceFiles.workspaceId, workspaceId),
+          eq(workspaceFiles.context, 'workspace')
+        )
       )
-    )
-    .returning({ id: workspaceFiles.id })
+      .returning({ id: workspaceFiles.id })
+  } catch (error: unknown) {
+    if (getPostgresErrorCode(error) === '23505') {
+      throw new FileConflictError(trimmedName)
+    }
+    throw error
+  }
 
   if (updated.length === 0) {
     throw new Error('File not found or could not be renamed')
@@ -651,22 +666,43 @@ export async function restoreWorkspaceFile(workspaceId: string, fileId: string):
     throw new Error('Cannot restore file into an archived workspace')
   }
 
-  const newName = await generateRestoreName(
-    fileRecord.name,
-    (candidate) => fileExistsInWorkspace(workspaceId, candidate),
-    { hasExtension: true }
-  )
+  /**
+   * A concurrent upload/rename can claim the chosen name after `generateRestoreName`'s check (MVCC).
+   * Retries pick a new random suffix; 23505 maps to {@link FileConflictError} after exhaustion.
+   */
+  const maxUniqueViolationRetries = 8
+  let attemptedRestoreName = ''
 
-  await db
-    .update(workspaceFiles)
-    .set({ deletedAt: null, originalName: newName })
-    .where(
-      and(
-        eq(workspaceFiles.id, fileId),
-        eq(workspaceFiles.workspaceId, workspaceId),
-        eq(workspaceFiles.context, 'workspace')
+  for (let attempt = 0; attempt < maxUniqueViolationRetries; attempt++) {
+    attemptedRestoreName = ''
+    try {
+      const newName = await generateRestoreName(
+        fileRecord.name,
+        (candidate) => fileExistsInWorkspace(workspaceId, candidate),
+        { hasExtension: true }
       )
-    )
+      attemptedRestoreName = newName
+
+      await db
+        .update(workspaceFiles)
+        .set({ deletedAt: null, originalName: newName })
+        .where(
+          and(
+            eq(workspaceFiles.id, fileId),
+            eq(workspaceFiles.workspaceId, workspaceId),
+            eq(workspaceFiles.context, 'workspace')
+          )
+        )
 
-  logger.info(`Successfully restored workspace file: ${newName}`)
+      logger.info(`Successfully restored workspace file: ${newName}`)
+      return
+    } catch (error: unknown) {
+      if (getPostgresErrorCode(error) !== '23505') {
+        throw error
+      }
+      if (attempt === maxUniqueViolationRetries - 1) {
+        throw new FileConflictError(attemptedRestoreName || fileRecord.name)
+      }
+    }
+  }
 }

packages/db/migrations/0178_chunky_juggernaut.sql

@@ -0,0 +1,41 @@
+-- Dedupe blocks prepended after `bunx drizzle-kit generate` so partial unique indexes can apply.
+--
+-- Knowledge bases: one active name per workspace (see schema `kb_workspace_name_active_unique`).
+-- Keeps the most recently updated row with its original name; older duplicates get " (2)", " (3)", etc.
+WITH kb_duplicates AS (
+  SELECT id, name, workspace_id,
+    ROW_NUMBER() OVER (
+      PARTITION BY workspace_id, name
+      ORDER BY updated_at DESC, created_at DESC
+    ) AS rn
+  FROM knowledge_base
+  WHERE deleted_at IS NULL
+    AND workspace_id IS NOT NULL
+)
+UPDATE knowledge_base
+SET name = knowledge_base.name || ' (' || kb_duplicates.rn || ')'
+FROM kb_duplicates
+WHERE knowledge_base.id = kb_duplicates.id
+  AND kb_duplicates.rn > 1;--> statement-breakpoint
+--
+-- Workspace files: one active display name per workspace for context `workspace`
+-- (`workspace_files_workspace_name_active_unique`). Keeps the most recently uploaded row; others
+-- get " (2)", " (3)", etc.
+WITH file_name_duplicates AS (
+  SELECT id, original_name, workspace_id,
+    ROW_NUMBER() OVER (
+      PARTITION BY workspace_id, original_name
+      ORDER BY uploaded_at DESC
+    ) AS rn
+  FROM workspace_files
+  WHERE deleted_at IS NULL
+    AND context = 'workspace'
+    AND workspace_id IS NOT NULL
+)
+UPDATE workspace_files
+SET original_name = workspace_files.original_name || ' (' || file_name_duplicates.rn || ')'
+FROM file_name_duplicates
+WHERE workspace_files.id = file_name_duplicates.id
+  AND file_name_duplicates.rn > 1;--> statement-breakpoint
+CREATE UNIQUE INDEX "kb_workspace_name_active_unique" ON "knowledge_base" USING btree ("workspace_id","name") WHERE "knowledge_base"."deleted_at" IS NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX "workspace_files_workspace_name_active_unique" ON "workspace_files" USING btree ("workspace_id","original_name") WHERE "workspace_files"."deleted_at" IS NULL AND "workspace_files"."context" = 'workspace' AND "workspace_files"."workspace_id" IS NOT NULL;--> statement-breakpoint