perf(files): parallelize buffer fetches, fix N+1 folder queries, stabilize drag useMemo

- download route: fan out all fetchWorkspaceFileBuffer calls with Promise.all
  before zip assembly so 100 files resolve in one round-trip instead of sequentially
- getWorkspaceFileFolder: replace per-ancestor SELECTs with a single workspace-wide
  folder load + buildWorkspaceFileFolderPathMap, making depth irrelevant to query count
- ensureWorkspaceFileFolderPath: pre-load all workspace folders in one SELECT before
  the segment loop; resolve existing segments from an in-memory map; only hit the DB
  to CREATE missing segments; conflict retry path preserved and also updates the map
- files.tsx rowDragDropConfig: move activeDropTargetId into a ref so the useMemo
  does not recompute on every drag-over event

Author: waleedlatif1

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

@@ -111,10 +111,15 @@ export const GET = withRouteHandler(
         )
       }
 
+      // Phase 1: fetch all buffers in parallel
+      const buffers = await Promise.all(filesToZip.map((file) => fetchWorkspaceFileBuffer(file)))
+
+      // Phase 2: assemble zip synchronously so path deduplication is deterministic
       const zip = new JSZip()
       const usedPaths = new Set<string>()
-      for (const file of filesToZip) {
-        const buffer = await fetchWorkspaceFileBuffer(file)
+      for (let i = 0; i < filesToZip.length; i++) {
+        const file = filesToZip[i]
+        const buffer = buffers[i]
         const folderPath = file.folderId ? folderPaths.get(file.folderId) : null
         const basePath =
           safeZipPath(folderPath ? `${folderPath}/${file.name}` : file.name) ||

apps/sim/app/workspace/[workspaceId]/files/files.tsx

@@ -243,6 +243,10 @@ export function Files() {
   const [saveStatus, setSaveStatus] = useState<SaveStatus>('idle')
   const [selectedRowIds, setSelectedRowIds] = useState<Set<string>>(() => new Set())
   const [activeDropTargetId, setActiveDropTargetId] = useState<string | null>(null)
+  const activeDropTargetIdRef = useRef(activeDropTargetId)
+  useEffect(() => {
+    activeDropTargetIdRef.current = activeDropTargetId
+  }, [activeDropTargetId])
   const [draggedRowIds, setDraggedRowIds] = useState<Set<string>>(() => new Set())
   const [previewMode, setPreviewMode] = useState<PreviewMode>(() => {
     if (isNewFile) return 'editor'
@@ -679,7 +683,7 @@ export function Files() {
 
   const rowDragDropConfig = useMemo<RowDragDropConfig>(
     () => ({
-      activeDropTargetId,
+      activeDropTargetId: activeDropTargetIdRef.current,
       draggedRowIds,
       isAnyDragActive: draggedRowIds.size > 0,
       isRowDraggable: (rowId) => canEdit && listRename.editingId !== rowId,
@@ -813,7 +817,6 @@ export function Files() {
       },
     }),
     [
-      activeDropTargetId,
       draggedRowIds,
       canEdit,
       listRename.editingId,

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

@@ -282,7 +282,24 @@ export async function getWorkspaceFileFolder(
 ): Promise<WorkspaceFileFolderRecord | null> {
   const { includeDeleted = false } = options ?? {}
   const folder = await getRawWorkspaceFileFolder(workspaceId, folderId, { includeDeleted })
-  return folder ? mapFolderWithPath(workspaceId, folder, { includeDeleted }) : null
+  if (!folder) return null
+
+  // Load all folders in one query to build the path map instead of chaining
+  // per-ancestor SELECTs inside buildWorkspaceFileFolderPath.
+  const allFolders = await db
+    .select()
+    .from(workspaceFileFolder)
+    .where(
+      includeDeleted
+        ? eq(workspaceFileFolder.workspaceId, workspaceId)
+        : and(
+            eq(workspaceFileFolder.workspaceId, workspaceId),
+            isNull(workspaceFileFolder.deletedAt)
+          )
+    )
+
+  const paths = buildWorkspaceFileFolderPathMap(allFolders)
+  return mapFolder(folder, paths)
 }
 
 export async function assertWorkspaceFileFolderTarget(
@@ -391,36 +408,76 @@ export async function ensureWorkspaceFileFolderPath(params: {
   userId: string
   pathSegments: string[]
 }): Promise<string | null> {
+  if (params.pathSegments.length === 0) return null
+
+  // Load all active folders once and build a lookup keyed by "name|parentId"
+  // so we can resolve existing segments without a per-segment SELECT.
+  const existingFolders = await db
+    .select()
+    .from(workspaceFileFolder)
+    .where(
+      and(
+        eq(workspaceFileFolder.workspaceId, params.workspaceId),
+        isNull(workspaceFileFolder.deletedAt)
+      )
+    )
+
+  /** Key format: `${name}|${parentId ?? ''}` */
+  const folderByNameParent = new Map<string, RawWorkspaceFileFolder>()
+  for (const folder of existingFolders) {
+    folderByNameParent.set(`${folder.name}|${folder.parentId ?? ''}`, folder)
+  }
+
   let parentId: string | null = null
+
   for (const rawSegment of params.pathSegments) {
     const name = normalizeWorkspaceFileItemName(rawSegment, 'Folder')
+    const lookupKey = `${name}|${parentId ?? ''}`
 
-    const existing = await findRawWorkspaceFileFolderByName(params.workspaceId, name, parentId)
-    if (existing) {
-      parentId = existing.id
+    const cached = folderByNameParent.get(lookupKey)
+    if (cached) {
+      parentId = cached.id
       continue
     }
 
     try {
-      parentId = (
-        await createWorkspaceFileFolder({
-          workspaceId: params.workspaceId,
-          userId: params.userId,
-          name,
-          parentId,
-        })
-      ).id
+      const created = await createWorkspaceFileFolder({
+        workspaceId: params.workspaceId,
+        userId: params.userId,
+        name,
+        parentId,
+      })
+      // Insert the newly created folder into the in-memory map so subsequent
+      // segments in this path can find their parent without extra DB round trips.
+      folderByNameParent.set(`${created.name}|${created.parentId ?? ''}`, {
+        id: created.id,
+        workspaceId: created.workspaceId,
+        userId: created.userId,
+        name: created.name,
+        parentId: created.parentId,
+        sortOrder: created.sortOrder,
+        deletedAt: created.deletedAt,
+        createdAt: created.createdAt,
+        updatedAt: created.updatedAt,
+      })
+      parentId = created.id
     } catch (error) {
       if (
         error instanceof WorkspaceFileFolderConflictError ||
         getPostgresErrorCode(error) === '23505'
       ) {
+        // A concurrent request created this folder between our initial load and
+        // the INSERT — fall back to a targeted SELECT to get its id.
         const concurrentExisting = await findRawWorkspaceFileFolderByName(
           params.workspaceId,
           name,
           parentId
         )
         if (concurrentExisting) {
+          folderByNameParent.set(
+            `${concurrentExisting.name}|${concurrentExisting.parentId ?? ''}`,
+            concurrentExisting
+          )
           parentId = concurrentExisting.id
           continue
         }