fix(tables): bound predicate validation

Author: TheodoreSpeaks

apps/sim/lib/api/contracts/tables.ts

@@ -33,7 +33,11 @@ import {
   TABLE_LIMITS,
 } from '@/lib/table/constants'
 import { CSV_MAX_FILE_SIZE_BYTES } from '@/lib/table/import'
-import { normalizeTablePredicate } from '@/lib/table/query-builder/predicate'
+import {
+  getTablePredicateTreeSizeError,
+  MAX_PREDICATE_GROUP_SIZE,
+  normalizeTablePredicate,
+} from '@/lib/table/query-builder/predicate'
 
 export const domainObjectSchema = <T>() => z.custom<T>(isRecordLike)
 
@@ -422,45 +426,8 @@ const filterSchema = domainObjectSchema<Filter>()
  */
 export const TABLE_QUERY_MAX_BODY_BYTES = 1024 * 1024
 
-/** Max members in one `all`/`any` group — a generous bound against pathological trees. */
-const MAX_PREDICATE_GROUP_SIZE = 100
 /** Max sort keys — more than a few is already a smell. */
 const MAX_SORT_KEYS = 16
-/** Max nesting levels of `all`/`any` groups. Ten is already unreadable. */
-const MAX_PREDICATE_DEPTH = 10
-/** Max nodes in the whole tree, so a wide-but-shallow tree can't amplify either. */
-const MAX_PREDICATE_NODES = 500
-
-/**
- * Iterative depth/size walk over an unvalidated predicate tree. Runs BEFORE the
- * recursive Zod schema: a few thousand nested `{all:[...]}` levels overflow the
- * stack inside `safeParse`, and a `RangeError` from a parser is a 500, not a 400.
- * The walk itself must stay iterative for the same reason.
- */
-function predicateTreeTooLarge(root: unknown): string | null {
-  const stack: Array<{ node: unknown; depth: number }> = [{ node: root, depth: 1 }]
-  let nodes = 0
-
-  while (stack.length > 0) {
-    const { node, depth } = stack.pop()!
-    if (++nodes > MAX_PREDICATE_NODES) {
-      return `Filter has too many conditions (max ${MAX_PREDICATE_NODES})`
-    }
-    if (depth > MAX_PREDICATE_DEPTH) {
-      return `Filter nesting is too deep (max ${MAX_PREDICATE_DEPTH} levels)`
-    }
-    if (typeof node !== 'object' || node === null) continue
-    const group = node as { all?: unknown; any?: unknown }
-    const members = Array.isArray(group.all)
-      ? group.all
-      : Array.isArray(group.any)
-        ? group.any
-        : null
-    if (!members) continue
-    for (const member of members) stack.push({ node: member, depth: depth + 1 })
-  }
-  return null
-}
 
 /**
  * v2 filter wire format: the typed `{ all | any: [...] }` predicate tree (same
@@ -512,7 +479,7 @@ const predicateTreeSchema: z.ZodType<TablePredicate> = z.lazy(() =>
 const predicateGroupSchema = predicateTreeSchema
 
 const predicateBoundarySchema = z.unknown().superRefine((value, ctx) => {
-  const problem = predicateTreeTooLarge(value)
+  const problem = getTablePredicateTreeSizeError(value)
   if (problem) ctx.addIssue({ code: 'custom', message: problem })
 })
 

apps/sim/lib/table/query-builder/__tests__/validate.test.ts

@@ -213,3 +213,22 @@ describe('empty groups are rejected at every layer', () => {
     expect(() => validatePredicate({ all: [] }, COLS)).toThrow(/at least one condition/)
   })
 })
+
+describe('predicate complexity limits', () => {
+  it('rejects deeply nested untrusted input before recursive validation', () => {
+    let predicate: unknown = { field: 'status', op: 'eq', value: 'active' }
+    for (let depth = 0; depth < 20_000; depth++) predicate = { all: [predicate] }
+
+    expect(() => validatePredicateShape(predicate as never)).toThrow(/Filter nesting is too deep/)
+  })
+
+  it('rejects oversized groups at the shared runtime boundary', () => {
+    const conditions = Array.from({ length: 101 }, () => ({
+      field: 'status',
+      op: 'eq' as const,
+      value: 'active',
+    }))
+
+    expect(() => validatePredicateShape({ all: conditions })).toThrow(/at most 100 conditions/)
+  })
+})

apps/sim/lib/table/query-builder/predicate.ts

@@ -1,5 +1,46 @@
 import type { TablePredicate, TablePredicateInput } from '@/lib/table/types'
 
+/** Max members in one `all`/`any` group. */
+export const MAX_PREDICATE_GROUP_SIZE = 100
+
+const MAX_PREDICATE_DEPTH = 10
+const MAX_PREDICATE_NODES = 500
+
+/**
+ * Returns the predicate size-limit violation for an untrusted tree, if any.
+ * The walk stays iterative so pathological input cannot overflow the call stack
+ * before the caller turns the result into its boundary-specific validation error.
+ */
+export function getTablePredicateTreeSizeError(root: unknown): string | null {
+  const stack: Array<{ node: unknown; depth: number }> = [{ node: root, depth: 1 }]
+  let nodes = 0
+
+  while (stack.length > 0) {
+    const { node, depth } = stack.pop()!
+    if (++nodes > MAX_PREDICATE_NODES) {
+      return `Filter has too many conditions (max ${MAX_PREDICATE_NODES})`
+    }
+    if (depth > MAX_PREDICATE_DEPTH) {
+      return `Filter nesting is too deep (max ${MAX_PREDICATE_DEPTH} levels)`
+    }
+    if (typeof node !== 'object' || node === null) continue
+
+    const group = node as { all?: unknown; any?: unknown }
+    const members = Array.isArray(group.all)
+      ? group.all
+      : Array.isArray(group.any)
+        ? group.any
+        : null
+    if (!members) continue
+    if (members.length > MAX_PREDICATE_GROUP_SIZE) {
+      return `A filter group can contain at most ${MAX_PREDICATE_GROUP_SIZE} conditions`
+    }
+    for (const member of members) stack.push({ node: member, depth: depth + 1 })
+  }
+
+  return null
+}
+
 /**
  * Converts the readable single-condition v2 input into the grouped shape every
  * downstream table path stores and executes. Callers validate untrusted input

apps/sim/lib/table/query-builder/validate.ts

@@ -2,6 +2,7 @@ import { isRecordLike } from '@sim/utils/object'
 import { getColumnId } from '@/lib/table/column-keys'
 import { NAME_PATTERN } from '@/lib/table/constants'
 import { TableQueryValidationError } from '@/lib/table/errors'
+import { getTablePredicateTreeSizeError } from '@/lib/table/query-builder/predicate'
 import type {
   ColumnDefinition,
   ColumnType,
@@ -119,6 +120,15 @@ export function validatePredicateShape(predicate: TablePredicateInput): void {
 }
 
 function validateNode(node: PredicateNode, typeByName: Map<string, ColumnType> | null): void {
+  const sizeError = getTablePredicateTreeSizeError(node)
+  if (sizeError) throw new TableQueryValidationError(sizeError, 'INVALID_FILTER')
+  validateNodeStructure(node, typeByName)
+}
+
+function validateNodeStructure(
+  node: PredicateNode,
+  typeByName: Map<string, ColumnType> | null
+): void {
   // Guard before the `in` checks below: an untrusted caller (copilot args, a raw
   // block value) can hand us a string/number/null, where `'all' in node` throws
   // a raw TypeError. Fail with a clean, actionable message instead.
@@ -166,7 +176,7 @@ function validateNode(node: PredicateNode, typeByName: Map<string, ColumnType> |
         'INVALID_FILTER'
       )
     }
-    for (const child of members) validateNode(child, typeByName)
+    for (const child of members) validateNodeStructure(child, typeByName)
     return
   }
   // Neither a group nor a leaf. Overwhelmingly this is the legacy `$`-grammar