fix(table): make name→storage predicate translation one operation

The block's own filter — {"all":[{"field":"Color","op":"contains","value":"Teal"}]}
— returned 0 rows against a table where 15 rows hold Teal.

Translating a name-keyed predicate to storage keys is two steps: column names →
column ids, and select operands → option ids. Both are required, neither is
useful alone, but they were two separate calls each boundary had to remember to
pair. Three did not: the internal query route (the table_v2 block's own path),
the bulk update/delete resolver, and — before this branch — nothing else needed
it, so the gap was invisible until select columns landed.

Replaced with a single `predicateToStorage(predicate, schema)` and migrated
every call site, so the pair cannot be split again. `predicateNamesToIds` now
has no direct callers outside it.

Also fixes four type errors that a failed inference in contracts/tables.ts was
masking — once the leaf schema type-checked, tsc surfaced the rest:
- `ColumnType` was imported from lib/table/types but never exported there (it
  lived as a local alias in sql.ts). Now exported once, next to ColumnDefinition.
- rows/service.ts referenced TableRowsCursor in three signatures without
  importing it.
- export-runner and snapshot-cache still declared their paging cursor's orderKey
  as non-null, after selectExportRowPage was corrected to return the nullable it
  always had.
- the predicate leaf's `z.unknown()` value infers wider than Predicate['value'];
  narrowed with an annotated cast, runtime unchanged.

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

Author: TheodoreSpeaks

apps/sim/app/api/table/[tableId]/query/route.ts

@@ -7,11 +7,12 @@ import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { Sort, TableSchema } from '@/lib/table'
-import { buildIdByName, predicateNamesToIds, sortSpecNamesToIds } from '@/lib/table/column-keys'
+import { buildIdByName, sortSpecNamesToIds } from '@/lib/table/column-keys'
 import { TableQueryValidationError } from '@/lib/table/errors'
 import { validatePredicate, validateSortSpec } from '@/lib/table/query-builder/validate'
 import { decodeCursor } from '@/lib/table/rows/cursor'
 import { queryRows } from '@/lib/table/rows/service'
+import { predicateToStorage } from '@/lib/table/select-values'
 import { rowWireTranslators } from '@/app/api/table/row-wire'
 import { accessError, checkAccess, tablesV2GateError } from '@/app/api/table/utils'
 
@@ -82,7 +83,7 @@ export const POST = withRouteHandler(async (request: NextRequest, context: RowQu
     let predicate = body.predicate
     if (predicate) {
       validatePredicate(predicate, schema.columns)
-      predicate = predicateNamesToIds(predicate, idByName)
+      predicate = predicateToStorage(predicate, schema)
     }
     let sortSpec = body.sort
     if (sortSpec?.length) {

apps/sim/app/api/table/[tableId]/rows/route.ts

@@ -25,11 +25,11 @@ import {
   validateRowData,
   validateRowSize,
 } from '@/lib/table'
-import { buildIdByName, predicateNamesToIds } from '@/lib/table/column-keys'
 import { TableQueryValidationError } from '@/lib/table/errors'
 import { predicateToFilter } from '@/lib/table/query-builder/converters'
 import { validatePredicate } from '@/lib/table/query-builder/validate'
 import { queryRows } from '@/lib/table/rows/service'
+import { predicateToStorage } from '@/lib/table/select-values'
 import type { TablePredicate } from '@/lib/table/types'
 import { type RowWireTranslators, rowWireTranslators } from '@/app/api/table/row-wire'
 import { accessError, checkAccess, rowWriteErrorResponse } from '@/app/api/table/utils'
@@ -54,7 +54,7 @@ function resolveBulkFilter(
 ): Filter {
   if (isTablePredicate(raw)) {
     validatePredicate(raw, schema.columns)
-    return predicateToFilter(predicateNamesToIds(raw, buildIdByName(schema)))
+    return predicateToFilter(predicateToStorage(raw, schema))
   }
   return wire.filterIn(raw)
 }

apps/sim/app/api/table/row-wire.ts

@@ -4,12 +4,11 @@ import { namedRowMapper } from '@/lib/table/cell-format'
 import {
   buildIdByName,
   filterNamesToIds,
-  predicateNamesToIds,
   rowDataNameToId,
   sortNamesToIds,
   sortSpecNamesToIds,
 } from '@/lib/table/column-keys'
-import { resolveFilterSelectValues, resolvePredicateSelectValues } from '@/lib/table/select-values'
+import { predicateToStorage, resolveFilterSelectValues } from '@/lib/table/select-values'
 
 export interface RowWireTranslators {
   /** Inbound row data: wire keys → storage column ids. */
@@ -58,8 +57,7 @@ export function rowWireTranslators(
     filterIn: (filter) =>
       resolveFilterSelectValues(filterNamesToIds(filter, idByName), schema.columns),
     sortIn: (sort) => sortNamesToIds(sort, idByName),
-    predicateIn: (predicate) =>
-      resolvePredicateSelectValues(predicateNamesToIds(predicate, idByName), schema.columns),
+    predicateIn: (predicate) => predicateToStorage(predicate, schema),
     sortSpecIn: (sort) => sortSpecNamesToIds(sort, idByName),
   }
 }

apps/sim/app/api/v2/tables/[tableId]/query/route.ts

@@ -6,13 +6,13 @@ import { parseRequest, validationErrorResponseFromError } from '@/lib/api/server
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { Sort, TablePredicate, TableSchema } from '@/lib/table'
-import { buildIdByName, predicateNamesToIds, sortSpecNamesToIds } from '@/lib/table'
+import { buildIdByName, sortSpecNamesToIds } from '@/lib/table'
 import { namedRowMapper } from '@/lib/table/cell-format'
 import { TableQueryValidationError } from '@/lib/table/errors'
 import { validatePredicate, validateSortSpec } from '@/lib/table/query-builder/validate'
 import { decodeCursor } from '@/lib/table/rows/cursor'
 import { queryRows } from '@/lib/table/rows/service'
-import { resolvePredicateSelectValues } from '@/lib/table/select-values'
+import { predicateToStorage } from '@/lib/table/select-values'
 import { accessError, checkAccess, tablesV2GateError } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -91,10 +91,7 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Query
     let predicate: TablePredicate | undefined = parsed.data.body.predicate
     if (predicate) {
       validatePredicate(predicate, schema.columns)
-      predicate = resolvePredicateSelectValues(
-        predicateNamesToIds(predicate, idByName),
-        schema.columns
-      )
+      predicate = predicateToStorage(predicate, schema)
     }
     let sortSpec = sort
     if (sortSpec?.length) {

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

@@ -6,6 +6,7 @@ import type {
   CsvHeaderMapping,
   EnrichmentRunDetail,
   Filter,
+  Predicate,
   PredicateNode,
   RowData,
   Sort,
@@ -429,11 +430,14 @@ function predicateTreeTooLarge(root: unknown): string | null {
  * before it ran. Strict on BOTH branches is required: strict on the group alone
  * would just fall through to the leaf branch, which is the more dangerous reading.
  */
+// double-cast-allowed: `z.unknown()` keeps the runtime permissive (a leaf value
+// is arbitrary JSON), but infers `unknown`, which is wider than
+// `Predicate['value']`. The narrowing is type-level only — nothing is coerced.
 const predicateLeafSchema = z.strictObject({
   field: z.string().min(1, 'field is required').max(128),
   op: z.enum(FILTER_OPS),
   value: z.unknown().optional(),
-})
+}) as unknown as z.ZodType<Predicate>
 
 const predicateNodeSchema: z.ZodType<PredicateNode> = z.lazy(() =>
   z.union([predicateGroupSchema, predicateLeafSchema])

apps/sim/lib/copilot/tools/server/table/user-table.ts

@@ -30,7 +30,6 @@ import { namedRowMapper } from '@/lib/table/cell-format'
 import {
   buildIdByName,
   columnMatchesRef,
-  predicateNamesToIds,
   rowDataNameToId,
   sortSpecNamesToIds,
 } from '@/lib/table/column-keys'
@@ -64,7 +63,7 @@ import {
   updateRow,
   updateRowsByFilter,
 } from '@/lib/table/rows/service'
-import { resolvePredicateSelectValues } from '@/lib/table/select-values'
+import { predicateToStorage } from '@/lib/table/select-values'
 import { createTable, deleteTable, getTableById, renameTable } from '@/lib/table/service'
 import type {
   ColumnDefinition,
@@ -677,10 +676,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           let predicate: TablePredicate | undefined
           if (args.filter) {
             validatePredicate(args.filter, table.schema.columns)
-            predicate = resolvePredicateSelectValues(
-              predicateNamesToIds(args.filter, idByName),
-              table.schema.columns
-            )
+            predicate = predicateToStorage(args.filter, table.schema)
           }
           let orderSpec = args.order as SortSpec | undefined
           if (orderSpec?.length) {
@@ -859,12 +855,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           // the bulk engine (same fieldPredicate leaf → identical SQL). Select
           // operands arrive as option NAMES and must resolve to stored ids.
           validatePredicate(args.filter, table.schema.columns)
-          const idFilter = predicateToFilter(
-            resolvePredicateSelectValues(
-              predicateNamesToIds(args.filter, idByName),
-              table.schema.columns
-            )
-          )
+          const idFilter = predicateToFilter(predicateToStorage(args.filter, table.schema))
           const idData = rowDataNameToId(args.data, idByName)
 
           // Inline handles up to MAX_BULK_OPERATION_SIZE rows in one request; a larger operation
@@ -966,12 +957,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           // the bulk engine (same fieldPredicate leaf → identical SQL). Select
           // operands arrive as option NAMES and must resolve to stored ids.
           validatePredicate(args.filter, table.schema.columns)
-          const idFilter = predicateToFilter(
-            resolvePredicateSelectValues(
-              predicateNamesToIds(args.filter, idByName),
-              table.schema.columns
-            )
-          )
+          const idFilter = predicateToFilter(predicateToStorage(args.filter, table.schema))
 
           // Inline handles up to MAX_BULK_OPERATION_SIZE rows; a larger delete (an explicit limit
           // above the cap, or unbounded "delete everything matching") hands off to the background

apps/sim/lib/table/export-runner.ts

@@ -80,7 +80,9 @@ export async function runTableExport(payload: TableExportPayload): Promise<void>
 
     let exported = 0
     let firstJsonRow = true
-    let after: { orderKey: string; id: string } | null = null
+    // `order_key` is nullable (rows predating the backfill), and the page query
+    // seeks NULLs explicitly — so the cursor has to carry a null too.
+    let after: { orderKey: string | null; id: string } | null = null
     while (true) {
       // Ownership gate before every page: a canceled job stops within one batch.
       const owns = await updateJobProgress(tableId, exported, jobId)

apps/sim/lib/table/jobs/service.ts

@@ -242,7 +242,9 @@ export async function selectExportRowPage(
     )
     .orderBy(asc(userTableRows.orderKey), asc(userTableRows.id))
     .limit(limit)
-  return rows
+  // drizzle types a jsonb column as `unknown`; every writer goes through the
+  // row-data validators, so narrowing here is a projection, not an assumption.
+  return rows.map((r) => ({ ...r, data: r.data as RowData }))
 }
 
 /** How long a terminal export stays listable (and re-downloadable from the tray). */

apps/sim/lib/table/rows/service.ts

@@ -87,6 +87,7 @@ import type {
   TableDefinition,
   TableDeleteJobPayload,
   TableRow,
+  TableRowsCursor,
   UpdateRowData,
   UpsertResult,
   UpsertRowData,

apps/sim/lib/table/select-values.ts

@@ -9,7 +9,7 @@
  * both the legacy `$` grammar and the v2 predicate tree.
  */
 
-import { getColumnId } from '@/lib/table/column-keys'
+import { buildIdByName, getColumnId, predicateNamesToIds } from '@/lib/table/column-keys'
 import type {
   ColumnDefinition,
   ConditionOperators,
@@ -19,6 +19,7 @@ import type {
   Predicate,
   PredicateNode,
   TablePredicate,
+  TableSchema,
 } from '@/lib/table/types'
 import { resolveSelectOptionId } from '@/lib/table/validation'
 
@@ -153,3 +154,20 @@ export function resolvePredicateSelectValues(
 
   return walk(predicate) as TablePredicate
 }
+
+/**
+ * The complete name-keyed → storage-keyed translation for a v2 predicate:
+ * column names become column ids AND select operands become option ids.
+ *
+ * Both halves are required and neither is useful alone, but they lived as two
+ * separate calls that every boundary had to remember to pair — and three of them
+ * did not, so a filter on a select column compared an option NAME against a
+ * stored option ID and returned zero rows while reporting success. Call this
+ * instead of `predicateNamesToIds` so the pair cannot be split again.
+ */
+export function predicateToStorage(predicate: TablePredicate, schema: TableSchema): TablePredicate {
+  return resolvePredicateSelectValues(
+    predicateNamesToIds(predicate, buildIdByName(schema)),
+    schema.columns
+  )
+}