Merge branch 'fix/w8-neutral' of https://github.com/simstudioai/sim into integrate/v2-w5

Author: waleedlatif1

apps/sim/app/api/v2/tables/[tableId]/rows/[rowId]/route.test.ts

@@ -131,6 +131,7 @@ describe('/api/v2/tables/[tableId]/rows/[rowId]', () => {
         rowId: 'row-1',
         assertedWorkspaceId: WORKSPACE_ID,
         data: { name: 'Ada' },
+        strictWrite: true,
       },
       request: req,
     })

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

@@ -41,6 +41,7 @@ export const PATCH = defineV2JsonRoute({
     rowId: params.rowId,
     assertedWorkspaceId: body.workspaceId,
     data: body.data,
+    strictWrite: true,
   }),
   useCase: updateTableRow,
   present: ({ table, row }) => ({

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

@@ -154,6 +154,10 @@ describe('/api/v2/tables/[tableId]/rows', () => {
         tableId: 'table-1',
         assertedWorkspaceId: WORKSPACE_ID,
         data: { name: 'Ada' },
+        // v2 alone opts into the strict write contract: an unknown column name
+        // or a value the column cannot hold is a 400, not a dropped key or a
+        // nulled cell. Every first-party surface leaves this unset.
+        strictWrite: true,
       },
       request: single,
     })
@@ -170,6 +174,7 @@ describe('/api/v2/tables/[tableId]/rows', () => {
         tableId: 'table-1',
         assertedWorkspaceId: WORKSPACE_ID,
         rows: [{ name: 'Ada' }],
+        strictWrite: true,
       },
       request: batch,
     })

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

@@ -54,6 +54,7 @@ export const POST = defineV2JsonRoute({
           tableId: params.tableId,
           assertedWorkspaceId: body.workspaceId,
           rows: body.rows,
+          strictWrite: true,
         }
       : {
           kind: 'single' as const,
@@ -62,6 +63,7 @@ export const POST = defineV2JsonRoute({
           data: body.data,
           afterRowId: body.afterRowId,
           beforeRowId: body.beforeRowId,
+          strictWrite: true,
         },
   useCase: createTableRows,
   present: (result) => {
@@ -89,6 +91,7 @@ export const PATCH = defineV2JsonRoute({
     filter: body.filter,
     data: body.data,
     limit: body.limit,
+    strictWrite: true,
   }),
   useCase: updateTableRows,
   present: ({ affectedCount, affectedRowIds }) => ({

apps/sim/app/api/v2/tables/[tableId]/rows/upsert/route.test.ts

@@ -102,6 +102,7 @@ describe('POST /api/v2/tables/[tableId]/rows/upsert', () => {
         assertedWorkspaceId: WORKSPACE_ID,
         data: { email: 'ada@example.com' },
         conflictTarget: 'email',
+        strictWrite: true,
       },
       request,
     })

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

@@ -20,6 +20,7 @@ export const POST = defineV2JsonRoute({
     assertedWorkspaceId: body.workspaceId,
     data: body.data,
     conflictTarget: body.conflictTarget,
+    strictWrite: true,
   }),
   useCase: upsertTableRow,
   present: ({ table, row, operation }) => ({

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.test.ts

@@ -156,21 +156,17 @@ describe('cleanCellValue', () => {
     expect(cleanCellValue('Bug, Docs', column)).toEqual(['opt_a', 'opt_b'])
     expect(cleanCellValue(['opt_b'], column)).toEqual(['opt_b'])
     expect(cleanCellValue('Bug, Bug', column)).toEqual(['opt_a'])
-    // A part matching no option is refused rather than silently dropped: this helper
-    // runs the same registry coercion the server does, and the server now rejects it.
-    expect(cleanCellValue('Nope', column)).toBeNull()
-    expect(cleanCellValue('Bug, Nope', column)).toBeNull()
+    expect(cleanCellValue('Nope', column)).toEqual([])
   })
 
   /**
-   * The refusal above is `coerce`'s, not the last word the registry has on the
-   * value: `salvage` reads the same paste as the one option that resolved. That
-   * reading is reserved for writes with no caller to answer — a CSV row, a block
-   * output — and a typed cell has one, so this helper must not reach for it. The
-   * pairing is asserted rather than described so a future helper that "improves"
-   * the paste by salvaging it fails here.
+   * The grid writes through a first-party route, which runs the `null` policy —
+   * a member the paste names that resolves to no option is dropped, and the ones
+   * that do resolve are kept. Erasing the cell instead would lose two live
+   * options over one deleted one. The registry pairing is asserted rather than
+   * described so a helper that stops consulting `salvage` fails here.
    */
-  it('refuses a partial multiselect paste the registry could still salvage', () => {
+  it('keeps the members of a partial multiselect paste that still resolve', () => {
     const column = {
       name: 'tags',
       type: 'select',
@@ -181,11 +177,12 @@ describe('cleanCellValue', () => {
       ],
     } as const
 
+    expect(columnTypeOf(column).coerce('Bug, Nope', column)).toEqual({ ok: false })
     expect(columnTypeOf(column).salvage?.('Bug, Nope', column)).toEqual({
       ok: true,
       value: ['opt_a'],
     })
-    expect(cleanCellValue('Bug, Nope', column)).toBeNull()
+    expect(cleanCellValue('Bug, Nope', column)).toEqual(['opt_a'])
   })
 })
 

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.ts

@@ -21,16 +21,14 @@ export function generateColumnName(columns: ReadonlyArray<{ name: string }>): st
 /**
  * Coerce a value a person typed or pasted into a cell to that column's type.
  * Throws on invalid JSON, and answers `null` for everything else the column
- * type refuses.
+ * type can read nothing from.
  *
- * `null` is what the server would store for the same value, which is the point:
- * the optimistic cache and the row that comes back agree. It deliberately does
- * not consult `ColumnTypeDefinition.salvage`, which reads a refused value
- * lossily — a multiselect paste naming one option that no longer exists blanks
- * the cell here rather than storing the members that did resolve. Salvage is
- * reserved for writes with no caller to answer, and this one has one: a person
- * watching the cell, who is better served seeing the paste refused than seeing
- * part of it silently kept.
+ * The result is what the server would store for the same value, which is the
+ * point: the optimistic cache and the row that comes back agree. The grid
+ * writes through a first-party route, which runs the `null` policy — so a
+ * refused value falls back to `ColumnTypeDefinition.salvage` here exactly as it
+ * does there, and a multiselect paste naming one live option and one deleted
+ * one keeps the live one instead of erasing the cell.
  */
 export function cleanCellValue(
   value: unknown,
@@ -56,8 +54,11 @@ export function cleanCellValue(
 
   // Everything else runs the SAME coercion the server will run, so the
   // optimistic cache holds exactly the value that gets persisted.
-  const coerced = columnTypeOf(column).coerce(value as JsonValue, column)
-  return coerced.ok ? coerced.value : null
+  const columnType = columnTypeOf(column)
+  const coerced = columnType.coerce(value as JsonValue, column)
+  if (coerced.ok) return coerced.value
+  const salvaged = columnType.salvage?.(value as JsonValue, column)
+  return salvaged?.ok ? salvaged.value : null
 }
 
 /**

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

@@ -138,14 +138,31 @@ describe('updateRow — partial merge', () => {
     expect(data?.values).not.toContain(JSON.stringify({ name: 'Alice', age: 31 }))
   })
 
-  it('holds only the patched keys to the strict policy when validating the merge', async () => {
+  it('blanks an uncoercible cell for a first-party caller, as it always has', async () => {
+    const { coerceRowToSchema } = await import('@/lib/table/validation')
+    await updateRow(
+      { tableId: 'tbl-1', rowId: 'row-1', data: { age: 31 }, workspaceId: 'ws-1' },
+      TABLE,
+      'req-1'
+    )
+
+    expect(coerceRowToSchema).toHaveBeenCalledWith(
+      { name: 'Alice', age: 31 },
+      TABLE.schema,
+      undefined,
+      ['age']
+    )
+  })
+
+  it('holds only the patched keys to the strict policy a v2 caller opts into', async () => {
     // The merged row carries cells this request never sent. A legacy value in one
     // of them belongs to an earlier write and must not decide this one.
     const { coerceRowToSchema } = await import('@/lib/table/validation')
     await updateRow(
       { tableId: 'tbl-1', rowId: 'row-1', data: { age: 31 }, workspaceId: 'ws-1' },
       TABLE,
-      'req-1'
+      'req-1',
+      { uncoercibleValues: 'reject' }
     )
 
     expect(coerceRowToSchema).toHaveBeenCalledWith(

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

@@ -358,15 +358,15 @@ describe('Validation', () => {
       expect(data.founded).toBe(1999)
     })
 
-    it('rejects an un-coercible value for an optional number column', () => {
+    it('rejects an un-coercible value for an optional number column under `reject`', () => {
       const data = { name: 'Acme', founded: 2000, age: 'unknown' }
-      const result = coerceRowToSchema(data, schema)
+      const result = coerceRowToSchema(data, schema, 'reject')
       expect(result.valid).toBe(false)
     })
 
-    it('nulls an un-coercible optional value under the `null` policy', () => {
+    it('nulls an un-coercible optional value by default', () => {
       const data = { name: 'Acme', founded: 2000, age: 'unknown' }
-      const result = coerceRowToSchema(data, schema, 'null')
+      const result = coerceRowToSchema(data, schema)
       expect(result.valid).toBe(true)
       expect(data.age).toBeNull()
     })
@@ -393,12 +393,20 @@ describe('Validation', () => {
       expect(data.active).toBe(false)
     })
 
-    it('refuses a bare epoch number, whose unit the value cannot state', () => {
+    it('refuses a bare epoch number under `reject`, whose unit the value cannot state', () => {
       const data = { name: 'Acme', founded: 2000, created: Date.parse('2024-01-15T00:00:00Z') }
-      const result = coerceRowToSchema(data, schema)
+      const result = coerceRowToSchema(data, schema, 'reject')
       expect(result.valid).toBe(false)
     })
 
+    it('coerces an epoch number to an ISO date string by default', () => {
+      const epoch = Date.parse('2024-01-15T00:00:00Z')
+      const data = { name: 'Acme', founded: 2000, created: epoch }
+      const result = coerceRowToSchema(data, schema)
+      expect(result.valid).toBe(true)
+      expect(data.created).toBe(new Date(epoch).toISOString())
+    })
+
     it('coerces a Date instance to an ISO date string', () => {
       const date = new Date('2024-01-15T00:00:00Z')
       const data = { name: 'Acme', founded: 2000, created: date }
@@ -407,16 +415,16 @@ describe('Validation', () => {
       expect(data.created).toBe(date.toISOString())
     })
 
-    it('nulls an out-of-range epoch number under the `null` policy without throwing', () => {
+    it('nulls an out-of-range epoch number without throwing', () => {
       const data = { name: 'Acme', founded: 2000, created: 1e20 }
-      const result = coerceRowToSchema(data, schema, 'null')
+      const result = coerceRowToSchema(data, schema)
       expect(result.valid).toBe(true)
       expect(data.created).toBeNull()
     })
 
-    it('nulls an invalid Date instance under the `null` policy without throwing', () => {
+    it('nulls an invalid Date instance without throwing', () => {
       const data = { name: 'Acme', founded: 2000, created: new Date('not-a-date') }
-      const result = coerceRowToSchema(data, schema, 'null')
+      const result = coerceRowToSchema(data, schema)
       expect(result.valid).toBe(true)
       expect(data.created).toBeNull()
     })
@@ -451,15 +459,15 @@ describe('Validation', () => {
       expect(patch.age).toBe(42)
     })
 
-    it('leaves an un-coercible optional patch value in place for downstream validation', () => {
+    it('leaves an un-coercible optional patch value in place under `reject`', () => {
       const patch: { age: unknown } = { age: 'nope' }
-      coerceRowValues(patch as never, schema)
+      coerceRowValues(patch as never, schema, 'reject')
       expect(patch.age).toBe('nope')
     })
 
-    it('nulls an un-coercible optional patch value under the `null` policy', () => {
+    it('nulls an un-coercible optional patch value by default', () => {
       const patch: { age: unknown } = { age: 'nope' }
-      coerceRowValues(patch as never, schema, 'null')
+      coerceRowValues(patch as never, schema)
       expect(patch.age).toBeNull()
     })
 
@@ -533,15 +541,15 @@ describe('Validation', () => {
         expect(patch.price).toBe(42)
       })
 
-      it('leaves an unreadable amount in place on an optional column so validation reports it', () => {
+      it('leaves an unreadable amount in place on an optional column under `reject`', () => {
         const patch: Record<string, unknown> = { price: 'ask sales' }
-        coerceRowValues(patch as never, currencySchema)
+        coerceRowValues(patch as never, currencySchema, 'reject')
         expect(patch.price).toBe('ask sales')
       })
 
-      it('nulls an unreadable amount on an optional column under the `null` policy', () => {
+      it('nulls an unreadable amount on an optional column by default', () => {
         const patch: Record<string, unknown> = { price: 'ask sales' }
-        coerceRowValues(patch as never, currencySchema, 'null')
+        coerceRowValues(patch as never, currencySchema)
         expect(patch.price).toBeNull()
       })