fix(table): reject a v2 predicate at the legacy filter compiler

Cross-version safety net. If a client speaking the predicate grammar reaches a
server that predates it, the predicate arrives at the legacy `$`-compiler as
`{ all: [...] }`. That was skipped as "an array on a regular field", so the
filter compiled to NO WHERE CLAUSE — which on a bulk delete means every row
rather than none. `update-runner` has always had an `if (!filterClause) throw`;
`delete-runner` does not, so the background delete path (tables over 1000 rows)
was the one that could actually wipe a table.

`buildFilterClause` is the single choke point every filter path shares —
`queryRows`, `update-runner`, `delete-runner`, inline and background — so one
guard there covers all of them, and it names the mismatch instead of failing
with a generic "filter required".

Scoped to the `all`/`any` discriminators specifically: an ordinary column that
happens to hold an array stays a silent skip, so no working legacy filter
changes behaviour.

This matters for deploy ordering. The copilot and sim deploy independently, and
if the copilot ships the new grammar first it starts sending predicates to a sim
that cannot parse them. With this guard that is a loud 400 on every path instead
of a silent table wipe on one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011M563cbFy2S74GvSDf2C3R

Author: TheodoreSpeaks

apps/sim/lib/table/__tests__/sql.test.ts

@@ -774,3 +774,50 @@ describe('buildPredicateClause (v2 grammar)', () => {
     expect(() => buildPredicateClause(p, TABLE, [])).toThrow('Invalid field name')
   })
 })
+
+/**
+ * Cross-version safety. If a client speaking the v2 predicate grammar reaches a
+ * server that predates it, the predicate arrives at the LEGACY `$`-compiler as
+ * `{ all: [...] }`. That used to be skipped as "an array on a regular field",
+ * compiling to no WHERE clause — which on a bulk delete means every row rather
+ * than none. The guard turns that into a loud, self-describing failure, and it
+ * sits at the one choke point every filter path shares (`queryRows`,
+ * `update-runner`, `delete-runner`, inline and background).
+ */
+describe('legacy compiler rejects a v2 predicate (version-mismatch fail-fast)', () => {
+  it('throws on a top-level all/any group instead of emitting no clause', () => {
+    for (const group of ['all', 'any'] as const) {
+      expect(() =>
+        buildFilterClause(
+          { [group]: [{ field: 'tenant_id', op: 'eq', value: 'acme' }] } as unknown as Filter,
+          TABLE,
+          NO_COLUMNS
+        )
+      ).toThrow(/v2 predicate tree/)
+    }
+  })
+
+  it('catches one nested inside a legacy $or', () => {
+    expect(() =>
+      buildFilterClause(
+        {
+          $or: [{ status: 'a' }, { all: [{ field: 'tenant_id', op: 'eq', value: 'acme' }] }],
+        } as unknown as Filter,
+        TABLE,
+        NO_COLUMNS
+      )
+    ).toThrow(/v2 predicate tree/)
+  })
+
+  it('leaves legitimate legacy filters alone', () => {
+    expect(buildFilterClause({ status: 'archived' }, TABLE, NO_COLUMNS)).toBeDefined()
+    expect(
+      buildFilterClause({ $or: [{ status: 'a' }, { status: 'b' }] }, TABLE, NO_COLUMNS)
+    ).toBeDefined()
+    // An ordinary column holding an array stays a silent skip — only the
+    // predicate discriminators `all`/`any` are treated as a version mismatch.
+    expect(() =>
+      buildFilterClause({ status: ['a', 'b'] } as unknown as Filter, TABLE, NO_COLUMNS)
+    ).not.toThrow()
+  })
+})

apps/sim/lib/table/sql.ts

@@ -157,6 +157,18 @@ function buildFilterClauseInternal(
     }
 
     // Skip arrays for regular fields - arrays are only valid for $or and $and.
+    // A v2 predicate tree (`{ all | any: [...] }`) that reaches this legacy
+    // compiler is a VERSION MISMATCH — a caller speaking the newer grammar
+    // against an older server. Skipping it as "an array on a regular field"
+    // compiles to no WHERE clause at all, which on a bulk delete means every
+    // row rather than none. Fail fast and name the mismatch instead.
+    if ((field === 'all' || field === 'any') && Array.isArray(condition)) {
+      throw new TableQueryValidationError(
+        `Filter looks like a v2 predicate tree ("${field}" group) but reached the legacy filter compiler. ` +
+          'This usually means a client is sending the predicate grammar to a server that predates it.'
+      )
+    }
+
     // If we encounter an array here, it's likely malformed input (e.g., { name: [filter1, filter2] })
     // which doesn't have a clear semantic meaning, so we skip it.
     if (Array.isArray(condition)) {