fix(folders): bound every active folder path index read

`loadActiveFolderPathIndex` only applied a LIMIT when a caller passed
`maxRows`, so 15 call sites issued an unbounded SELECT over a workspace's
folder rows. `updateWorkflow` did both in one function: the folderId branch
read unbounded, then the fallback thirty lines later passed the cap.

Defaults `maxRows` to `MAX_FOLDERS_PER_WORKSPACE` — the same ceiling folder
creation refuses to cross — so no workspace can legitimately hold more rows
than a default call accepts. Exceeding it still throws
`FolderCollectionLimitExceededError`; the index is never silently truncated,
because a partial path index resolves real paths to undefined and re-roots
resources at the workspace root.

Author: waleedlatif1

apps/sim/lib/folders/queries.test.ts

@@ -9,6 +9,7 @@ import {
   schemaMock,
 } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { MAX_FOLDERS_PER_WORKSPACE } from '@/lib/folders/constants'
 import { FolderCollectionLimitExceededError } from '@/lib/folders/errors'
 import {
   findActiveFolder,
@@ -202,6 +203,35 @@ describe('folder queries', () => {
       expect(dbChainMockFns.limit).toHaveBeenCalledWith(3)
     })
 
+    /**
+     * Callers that omit `maxRows` — `createWorkflow`/`updateWorkflow` on their
+     * folderId branch among them — must still get a bounded query rather than an
+     * unbounded `SELECT` over every folder row in the workspace.
+     */
+    it('bounds the path index at the workspace cap when no maxRows is given', async () => {
+      queueTableRows(schemaMock.folder, [ROW])
+
+      await loadActiveFolderPathIndex('ws-1', 'workflow')
+
+      expect(dbChainMockFns.limit).toHaveBeenCalledWith(MAX_FOLDERS_PER_WORKSPACE + 1)
+    })
+
+    it('throws rather than truncating when the default cap is exceeded', async () => {
+      queueTableRows(
+        schemaMock.folder,
+        Array.from({ length: MAX_FOLDERS_PER_WORKSPACE + 1 }, (_, i) => ({
+          ...ROW,
+          id: `f-${i}`,
+          name: `Reports ${i}`,
+        }))
+      )
+
+      await expect(loadActiveFolderPathIndex('ws-1', 'workflow')).rejects.toMatchObject({
+        code: 'payload_too_large',
+        message: `Folder path index exceeds the ${MAX_FOLDERS_PER_WORKSPACE} row limit`,
+      })
+    })
+
     it('fails before returning an oversized folder list', async () => {
       queueTableRows(schemaMock.folder, [ROW, { ...ROW, id: 'f-2' }, { ...ROW, id: 'f-3' }])
 

apps/sim/lib/folders/queries.ts

@@ -4,6 +4,7 @@ import { and, type Column, eq, isNotNull, isNull } from 'drizzle-orm'
 import type { FolderApi, FolderResourceType } from '@/lib/api/contracts/folders'
 import { type ListSortOrder, listOrderBy, searchFilter } from '@/lib/api/list-query'
 import type { DbOrTx } from '@/lib/db/types'
+import { MAX_FOLDERS_PER_WORKSPACE } from '@/lib/folders/constants'
 import { FolderCollectionLimitExceededError } from '@/lib/folders/errors'
 import { buildFolderPathIndex, type FolderPathIndex, ROOT_FOLDER_PATH } from '@/lib/folders/paths'
 import type { FolderQueryScope } from '@/hooks/queries/utils/folder-keys'
@@ -169,13 +170,24 @@ interface ListActiveFolderRowsOptions {
   maxRows?: number
 }
 
+/**
+ * Materializes the workspace's active folder tree for one resource type.
+ *
+ * The read is always bounded: `maxRows` defaults to `MAX_FOLDERS_PER_WORKSPACE`,
+ * the same ceiling folder creation refuses to cross, so a workspace can never
+ * legitimately hold more rows than a default call will accept. Exceeding the
+ * bound THROWS `FolderCollectionLimitExceededError` — the index is never
+ * silently truncated, because a partial path index resolves real folder paths
+ * to `undefined` and re-roots resources at the workspace root.
+ */
 export async function loadActiveFolderPathIndex(
   workspaceId: string,
   resourceType: FolderResourceType,
   tx: DbOrTx = db,
   options?: { maxRows?: number }
 ): Promise<FolderPathIndex<typeof folder.$inferSelect>> {
-  const query = tx
+  const maxRows = options?.maxRows ?? MAX_FOLDERS_PER_WORKSPACE
+  const rows = await tx
     .select()
     .from(folder)
     .where(
@@ -185,9 +197,9 @@ export async function loadActiveFolderPathIndex(
         isNull(folder.deletedAt)
       )
     )
-  const rows = options?.maxRows === undefined ? await query : await query.limit(options.maxRows + 1)
-  if (options?.maxRows !== undefined && rows.length > options.maxRows) {
-    throw new FolderCollectionLimitExceededError('path index', options.maxRows)
+    .limit(maxRows + 1)
+  if (rows.length > maxRows) {
+    throw new FolderCollectionLimitExceededError('path index', maxRows)
   }
 
   return buildFolderPathIndex(rows)