fix(folders): row-lock restore reads, map conflict errorCode to 409

Three more review findings this round:

1. statusForOrchestrationError never mapped errorCode: 'conflict' to a
   status, so it silently fell to 500. The folders PUT route (rename
   conflicts) and the restore route (file-folder name conflicts) both used
   this default, turning a legitimate 409 into a misleading 500. Added the
   conflict -> 409 case, matching the sibling workspaceFilesOrchestrationStatus
   mapper that already had it.

2. Switched the folders [id] PUT/DELETE routes and the restore route from
   their bespoke inline errorCode->status ternaries to the shared
   statusForOrchestrationError helper, now that every orchestration failure
   branch they consume sets an explicit errorCode (verified branch by
   branch) -- this was deliberately deferred in an earlier commit until that
   was true. Also closed two errorCode gaps this surfaced: the
   archived-workspace check in performRestoreFolder (workflow) had no
   errorCode, and performRestoreFileFolder's catch-all didn't recognize the
   'Cannot restore folder into an archived workspace' message, so it was
   being mapped to a generic 500 by the previous commit's internal-error
   fallback.

3. Greptile: performRestoreFolder's (workflow) and performRestoreResourceFolder's
   (kb/table) restore-transaction reads of the folder's own locked/deletedAt
   columns were plain SELECTs, not SELECT ... FOR UPDATE -- being inside the
   same transaction as the write closes the round-trip race but not this one,
   since a plain read doesn't block a concurrent UPDATE from another
   transaction. Added FOR UPDATE to both, matching the existing
   restoreKnowledgeBase precedent. The file-folder restore path doesn't need
   this: it already takes a workspace-scoped pg_advisory_xact_lock that the
   lock-toggle path also acquires, so it was already race-free.

Author: waleedlatif1

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

@@ -11,6 +11,7 @@ import { getSession } from '@/lib/auth'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { performRestoreFolder } from '@/lib/folders/orchestration'
 import { captureServerEvent } from '@/lib/posthog/server'
+import { statusForOrchestrationError } from '@/lib/workflows/orchestration/types'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('RestoreFolderAPI')
@@ -52,12 +53,10 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Route
     })
 
     if (!result.success) {
-      // Only 'not_found' gets its own status here -- the other restore-failure
-      // shapes (validation, and file-folder's name-conflict case which omits
-      // errorCode) all read naturally as 400, matching this route's prior
-      // behavior for everything except "not found".
-      const status = result.errorCode === 'not_found' ? 404 : 400
-      return NextResponse.json({ error: result.error }, { status })
+      return NextResponse.json(
+        { error: result.error },
+        { status: statusForOrchestrationError(result.errorCode) }
+      )
     }
 
     logger.info(`Restored folder ${folderId}`, { restoredItems: result.restoredItems })

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

@@ -11,6 +11,7 @@ import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { performDeleteFolder, performUpdateFolder } from '@/lib/folders/orchestration'
 import { FOLDER_RESOURCE_POLICIES } from '@/lib/folders/policy'
 import { captureServerEvent } from '@/lib/posthog/server'
+import { statusForOrchestrationError } from '@/lib/workflows/orchestration/types'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('FoldersIDAPI')
@@ -98,9 +99,10 @@ export const PUT = withRouteHandler(
       })
 
       if (!result.success || !result.folder) {
-        const status =
-          result.errorCode === 'not_found' ? 404 : result.errorCode === 'validation' ? 400 : 500
-        return NextResponse.json({ error: result.error }, { status })
+        return NextResponse.json(
+          { error: result.error },
+          { status: statusForOrchestrationError(result.errorCode) }
+        )
       }
 
       logger.info('Updated folder:', { id, updates: parsed.data.body })
@@ -161,9 +163,10 @@ export const DELETE = withRouteHandler(
       })
 
       if (!result.success) {
-        const status =
-          result.errorCode === 'not_found' ? 404 : result.errorCode === 'validation' ? 400 : 500
-        return NextResponse.json({ error: result.error }, { status })
+        return NextResponse.json(
+          { error: result.error },
+          { status: statusForOrchestrationError(result.errorCode) }
+        )
       }
 
       captureServerEvent(

apps/sim/lib/folders/orchestration.ts

@@ -321,6 +321,9 @@ async function performRestoreFileFolder(
     if (message === 'Folder is not archived') {
       return { success: false, error: message, errorCode: 'validation' }
     }
+    if (message === 'Cannot restore folder into an archived workspace') {
+      return { success: false, error: message, errorCode: 'validation' }
+    }
     logger.error('Failed to restore file folder', { error })
     return { success: false, error: 'Internal server error', errorCode: 'internal' }
   }
@@ -529,6 +532,10 @@ async function performRestoreResourceFolder<TCountKey extends 'knowledgeBases' |
   const { folderId, workspaceId, userId, folderName } = params
 
   const outcome = await db.transaction(async (tx) => {
+    // `FOR UPDATE` row-locks this folder for the rest of the transaction -- a plain
+    // SELECT inside a transaction does not block a concurrent UPDATE, so without this
+    // a lock toggled on this row after this read but before the restore write below
+    // could still be silently bypassed.
     const [raw] = await tx
       .select()
       .from(folderTable)
@@ -539,6 +546,7 @@ async function performRestoreResourceFolder<TCountKey extends 'knowledgeBases' |
           eq(folderTable.resourceType, cascade.resourceType)
         )
       )
+      .for('update')
       .limit(1)
     if (!raw) return { kind: 'not_found' as const }
     if (!raw.deletedAt) return { kind: 'not_archived' as const }

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

@@ -477,14 +477,23 @@ export async function performRestoreFolder(
   const { getWorkspaceWithOwner } = await import('@/lib/workspaces/permissions/utils')
   const ws = await getWorkspaceWithOwner(workspaceId)
   if (!ws || ws.archivedAt) {
-    return { success: false, error: 'Cannot restore folder into an archived workspace' }
+    return {
+      success: false,
+      error: 'Cannot restore folder into an archived workspace',
+      errorCode: 'validation',
+    }
   }
 
   const outcome = await db.transaction(async (tx) => {
+    // `FOR UPDATE` row-locks this folder for the rest of the transaction -- a plain
+    // SELECT inside a transaction does not block a concurrent UPDATE, so without this
+    // a lock toggled on this row after this read but before the restore write below
+    // could still be silently bypassed.
     const [existingFolder] = await tx
       .select()
       .from(folder)
       .where(and(eq(folder.id, folderId), eq(folder.workspaceId, workspaceId), isWorkflowFolder))
+      .for('update')
 
     if (!existingFolder) return { kind: 'not_found' as const }
     if (!existingFolder.deletedAt) return { kind: 'not_archived' as const }

apps/sim/lib/workflows/orchestration/types.ts

@@ -7,5 +7,6 @@ export type OrchestrationErrorCode = 'validation' | 'not_found' | 'conflict' | '
 export function statusForOrchestrationError(code: OrchestrationErrorCode | undefined): number {
   if (code === 'validation') return 400
   if (code === 'not_found') return 404
+  if (code === 'conflict') return 409
   return 500
 }