perf(table): project only the job field the row count needs

Both job reads selected the whole payload jsonb, but mapJobRow reads exactly
one number out of it, and only for a running delete. The payload also carries
the delete job's filter and an unbounded excludeRowIds array, and the latest
non-export job is read on essentially every table request — a table that once
ran a large delete would ship that id list on every read, forever.

LatestJobRow.payload becomes doomedCount, extracted in SQL. Both readers share
JOB_PROJECTION so one edit reaches the batch DISTINCT ON and the correlated
subquery alike; the compile-time constraint widens to Column | SQL rather than
being dropped.

Behaviour is identical. `->` keeps the value jsonb, which postgres-js decodes
through its built-in JSON.parse handler, so it arrives as a number with no
boundary coercion. A null payload, a payload without the key, a non-object
payload and an explicit JSON null all collapse to the same `?? 0` the previous
optional chain produced.

Sized honestly before claiming a win: payloads are small in practice today, so
this is defensive rather than impactful — it removes an unbounded growth path,
not a measured cost.

Verified against a real Postgres, not just the mocked driver: the
generated correlated subquery returns doomedCount 12 for a delete job, null
for an import job, and a null row for a table with no job.

Also from the review pass: re-homes the strictWrite explanation onto
rowWriteOptions, where six {@link} references now point; records why
replaceProjectedWireRows carries no keying discriminator; notes the one case
the uniqueness-narrowing invariant does not cover; pins the lax id-wire
passthrough with a test; and renames a parameter that misled once only its
keys were read.

Author: waleedlatif1

apps/sim/lib/table/__tests__/update-row.test.ts

@@ -558,6 +558,10 @@ describe('batchUpdateRows — per-row partial merge', () => {
  * The safety argument is that a merge cannot newly violate uniqueness on a
  * column it leaves alone: that value is the one already stored, and it
  * satisfied the constraint when it was written.
+ *
+ * The one case that does not cover is a unique constraint added to a column
+ * that already held duplicates — such a row is no longer blocked from edits
+ * elsewhere in it, which is the intended outcome.
  */
 describe('updateRow — uniqueness probe scoping', () => {
   beforeEach(() => {

apps/sim/lib/table/application/context.test.ts

@@ -47,6 +47,23 @@ async function withUnhandledRejectionWatch(body: () => Promise<void>): Promise<u
   return seen
 }
 
+/**
+ * Holds the table load open so a test can observe what the resolver does before
+ * the table arrives. `release` resolves it with the canonical table.
+ */
+function deferTableLoad(): { release: () => void } {
+  let releaseTable: (table: unknown) => void = () => {}
+  getTableById.mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        releaseTable = resolve
+      })
+  )
+  return {
+    release: () => releaseTable({ id: 'table-1', workspaceId: 'workspace-1', name: 'Contacts' }),
+  }
+}
+
 describe('table application context', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -73,13 +90,7 @@ describe('table application context', () => {
   })
 
   it('starts the workspace load without waiting for the table when a workspace is asserted', async () => {
-    let releaseTable: (table: unknown) => void = () => {}
-    getTableById.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          releaseTable = resolve
-        })
-    )
+    const { release } = deferTableLoad()
 
     const pending = resolveActiveTableContext({
       tableId: 'table-1',
@@ -90,26 +101,20 @@ describe('table application context', () => {
 
     expect(loadWorkspace).toHaveBeenCalledWith('workspace-1')
 
-    releaseTable({ id: 'table-1', workspaceId: 'workspace-1', name: 'Contacts' })
+    release()
     await expect(pending).resolves.toMatchObject({ tableId: 'table-1', workspaceId: 'workspace-1' })
   })
 
   it('waits for the table before loading a workspace when none is asserted', async () => {
-    let releaseTable: (table: unknown) => void = () => {}
-    getTableById.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          releaseTable = resolve
-        })
-    )
+    const { release } = deferTableLoad()
 
     const pending = resolveActiveTableContext({ tableId: 'table-1' })
     await Promise.resolve()
     await Promise.resolve()
 
     expect(loadWorkspace).not.toHaveBeenCalled()
 
-    releaseTable({ id: 'table-1', workspaceId: 'workspace-1', name: 'Contacts' })
+    release()
     await expect(pending).resolves.toMatchObject({ tableId: 'table-1', workspaceId: 'workspace-1' })
     expect(loadWorkspace).toHaveBeenCalledWith('workspace-1')
   })

apps/sim/lib/table/application/rows.test.ts

@@ -172,6 +172,22 @@ const TABLE: TableDefinition = {
 
 const PRINCIPAL = { kind: 'session' as const, userId: 'user-1', sessionId: 'session-1' }
 
+/**
+ * The active-table context every row command resolves before it does any work.
+ * Pass a variant table when a test needs a different schema — the surrounding
+ * workspace scope is the same for every command under test.
+ */
+function contextFor(table: TableDefinition = TABLE) {
+  return {
+    tableId: table.id,
+    table,
+    workspaceId: table.workspaceId,
+    workspaceOrganizationId: 'organization-1',
+    allowPersonalApiKeys: true,
+    billedAccountUserId: 'billing-owner-1',
+  }
+}
+
 describe('table predicate translation', () => {
   it('maps invalid run filters to the shared row validation error', () => {
     expect(() =>
@@ -210,14 +226,7 @@ describe('replaceProjectedWireRows application command', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockResolvePermission.mockResolvedValue('write')
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: TABLE,
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(contextFor())
     mockAssertRowCapacity.mockResolvedValue(10_000)
     mockWithLockedTable.mockImplementation(
       async (_tableId: string, run: (table: TableDefinition, trx: unknown) => unknown) =>
@@ -457,14 +466,7 @@ describe('replaceTableRows application use case', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockResolvePermission.mockResolvedValue('write')
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: TABLE,
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(contextFor())
     mockReplaceRowsPrimitive.mockResolvedValue({ deletedCount: 2, insertedCount: 1 })
   })
 
@@ -570,14 +572,7 @@ describe('row query and upsert application semantics', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockResolvePermission.mockResolvedValue('write')
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: TABLE,
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(contextFor())
   })
 
   it('rejects a malformed POST query cursor before querying storage', async () => {
@@ -831,14 +826,7 @@ describe('table row write secret provenance defaulting', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockResolvePermission.mockResolvedValue('write')
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: TABLE,
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(contextFor())
     mockValidateRowData.mockResolvedValue({ valid: true })
     mockValidateBatchRows.mockResolvedValue({ valid: true })
     mockInsertRow.mockResolvedValue(ROW)
@@ -898,14 +886,7 @@ describe('table row write secret provenance defaulting', () => {
       ...TABLE,
       schema: { columns: [{ id: 'column_name', name: 'name', type: 'string' }] },
     }
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: filterableTable,
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(contextFor(filterableTable))
 
     await updateTableRows.execute({
       principal: PRINCIPAL,
@@ -995,14 +976,7 @@ describe('unknown column names under strictWrite', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockResolvePermission.mockResolvedValue('write')
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: TABLE,
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(contextFor())
     mockValidateRowData.mockResolvedValue({ valid: true })
     mockValidateBatchRows.mockResolvedValue({ valid: true })
     mockInsertRow.mockResolvedValue({ id: 'row-1', data: {} })
@@ -1161,14 +1135,7 @@ describe('row data keying', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockResolvePermission.mockResolvedValue('write')
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: TABLE,
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(contextFor())
     mockAssertRowCapacity.mockResolvedValue(10_000)
     mockCreateSecretProvenance.mockReturnValue({ complete: true, columns: {} })
     mockIsScopeCompatible.mockReturnValue(true)
@@ -1215,6 +1182,31 @@ describe('row data keying', () => {
     )
   })
 
+  it('persists an unrecognised key on the lax id wire, unlike the name wire', async () => {
+    // The asymmetry a non-strict id-keyed caller sees, pinned deliberately: the
+    // name path drops what it cannot resolve, the id path stores what it is
+    // given. This is what the grid does today via the identity `dataIn` in
+    // `row-wire.ts`, so the discriminator preserved it rather than changing it.
+    // Closing it is a behaviour change and belongs with the route migration.
+    await updateTableRow.execute({
+      principal: PRINCIPAL,
+      input: {
+        tableId: TABLE.id,
+        rowId: 'row-1',
+        data: { 'column-name': 'Ada', 'no-such-column': 'x' },
+        strictWrite: false,
+        dataKeying: 'ids',
+      },
+    })
+
+    expect(mockUpdateRow).toHaveBeenCalledWith(
+      expect.objectContaining({ data: { 'column-name': 'Ada', 'no-such-column': 'x' } }),
+      TABLE,
+      expect.any(String),
+      expect.anything()
+    )
+  })
+
   it('translates a name-keyed write to storage ids', async () => {
     await updateTableRow.execute({
       principal: PRINCIPAL,
@@ -1255,14 +1247,9 @@ describe('row data keying', () => {
     // Two production tables still carry pre-backfill columns with no `id`.
     // Their storage key is the name, so a strict id-keyed write naming one must
     // be accepted, not refused as unknown.
-    mockResolveContext.mockResolvedValue({
-      tableId: TABLE.id,
-      table: { ...TABLE, schema: { columns: [{ name: 'legacy', type: 'string' }] } },
-      workspaceId: TABLE.workspaceId,
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-owner-1',
-    })
+    mockResolveContext.mockResolvedValue(
+      contextFor({ ...TABLE, schema: { columns: [{ name: 'legacy', type: 'string' }] } })
+    )
 
     await expect(
       updateTableRow.execute({

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

@@ -83,7 +83,19 @@ interface TableScopedInput {
   requestId?: string
 }
 
-/** The write policy `strictWrite` selects, for the row-service primitives. */
+/**
+ * The write policy `strictWrite` selects, for the row-service primitives.
+ *
+ * `strictWrite` means the calling surface publishes the stricter `/api/v2` write
+ * contract: a row naming a column the table does not have is refused rather than
+ * having that key dropped, and a value the column's type cannot coerce is
+ * answered with a 400 rather than stored as `null`.
+ *
+ * Absent — every first-party surface, and the only behavior any of them has ever
+ * had: the workspace grid, the internal `/api/table` routes, `/api/v1`, the
+ * Copilot table tools, and the executor's Table block all drop the unknown key
+ * and blank the uncoercible cell.
+ */
 function rowWriteOptions(input: { strictWrite: boolean }): RowWriteOptions {
   return input.strictWrite ? { uncoercibleValues: 'reject' } : {}
 }
@@ -729,7 +741,16 @@ function projectedRowsSecretProvenance(
   })
 }
 
-/** Atomically validates name-keyed projected rows against the locked schema and replaces the table. */
+/**
+ * Atomically validates name-keyed projected rows against the locked schema and
+ * replaces the table.
+ *
+ * Deliberately carries no {@link TableRowDataKeying}: unlike the six generic
+ * write use cases this one is not surface-agnostic. Its resolved-secret gate and
+ * its "row matches no column" check both compare by `column.name` (see
+ * {@link projectedRowsForTable}), and its only caller is Copilot's
+ * `Function.execute` output — keys a model can only have written as names.
+ */
 export const replaceProjectedWireRows = defineAuthorizedTableUseCase({
   operation: tableOperations.replaceRows,
   resolveContext: ({ input }: { input: ReplaceProjectedWireRowsInput }) =>

apps/sim/lib/table/column-keys.ts

@@ -207,8 +207,11 @@ export function rowDataNameToId(data: RowData, idByName: Map<string, string>): R
  * row, and letting it through would reinstate the silent drop for exactly the
  * callers most likely to believe they had written something.
  */
-export function unknownColumnNames(data: RowData, idByName: ReadonlyMap<string, string>): string[] {
-  return Object.keys(data).filter((name) => !idByName.has(name))
+export function unknownColumnNames(
+  data: RowData,
+  knownKeys: ReadonlyMap<string, unknown>
+): string[] {
+  return Object.keys(data).filter((key) => !knownKeys.has(key))
 }
 
 /**