rocicorp · arv · Oct 8, 2025 · Oct 8, 2025
diff --git a/packages/zero-cache/src/auth/write-authorizer.ts b/packages/zero-cache/src/auth/write-authorizer.ts
@@ -32,6 +32,10 @@ import {
 import {simplifyCondition} from '../../../zql/src/query/expression.ts';
 import type {Query} from '../../../zql/src/query/query.ts';
 import {StaticQuery, staticQuery} from '../../../zql/src/query/static-query.ts';
+import {
+  DatabaseStorage,
+  type ClientGroupStorage,
+} from '../../../zqlite/src/database-storage.ts';
 import {Database} from '../../../zqlite/src/db.ts';
 import {compile, sql} from '../../../zqlite/src/internal/sql.ts';
 import {
@@ -42,10 +46,6 @@ import type {LogConfig, ZeroConfig} from '../config/zero-config.ts';
 import {computeZqlSpecs} from '../db/lite-tables.ts';
 import type {LiteAndZqlSpec} from '../db/specs.ts';
 import {StatementRunner} from '../db/statements.ts';
-import {
-  DatabaseStorage,
-  type ClientGroupStorage,
-} from '../../../zqlite/src/database-storage.ts';
 import {mapLiteDataTypeToZqlSchemaValue} from '../types/lite.ts';
 import {
   getSchema,
@@ -433,7 +433,7 @@ export class WriteAuthorizerImpl implements WriteAuthorizer {
     if (ret === undefined) {
       return ret;
     }
-    return fromSQLiteTypes(spec.zqlSpec, ret);
+    return fromSQLiteTypes(spec.zqlSpec, ret, op.tableName);
   }
 
   #requirePreMutationRow(op: UpdateOp | DeleteOp) {

diff --git a/packages/zero-cache/src/services/view-syncer/snapshotter.ts b/packages/zero-cache/src/services/view-syncer/snapshotter.ts
@@ -1,12 +1,12 @@
 import {LogContext} from '@rocicorp/logger';
 import {assert} from '../../../../shared/src/asserts.ts';
+import {stringify, type JSONValue} from '../../../../shared/src/bigint-json.ts';
 import {must} from '../../../../shared/src/must.ts';
 import * as v from '../../../../shared/src/valita.ts';
 import {Database} from '../../../../zqlite/src/db.ts';
 import {fromSQLiteTypes} from '../../../../zqlite/src/table-source.ts';
 import type {LiteAndZqlSpec, LiteTableSpecWithKeys} from '../../db/specs.ts';
 import {StatementRunner} from '../../db/statements.ts';
-import {stringify, type JSONValue} from '../../../../shared/src/bigint-json.ts';
 import {
   normalizedKeyOrder,
   type RowKey,
@@ -419,10 +419,10 @@ class Diff implements SnapshotDiff {
             // Modify the values in place when converting to ZQL rows
             // This is safe since we're the first node in the iterator chain.
             if (prevValue) {
-              prevValue = fromSQLiteTypes(zqlSpec, prevValue);
+              prevValue = fromSQLiteTypes(zqlSpec, prevValue, table);
             }
             if (nextValue) {
-              nextValue = fromSQLiteTypes(zqlSpec, nextValue);
+              nextValue = fromSQLiteTypes(zqlSpec, nextValue, table);
             }
             return {
               value: {table, prevValue, nextValue, rowKey} satisfies Change,

diff --git a/packages/zqlite/src/table-source.test.ts b/packages/zqlite/src/table-source.test.ts
@@ -1,4 +1,5 @@
 import {describe, expect, test} from 'vitest';
+import {testLogConfig} from '../../otel/src/test-log-config.ts';
 import type {JSONValue} from '../../shared/src/json.ts';
 import {createSilentLogContext} from '../../shared/src/logging-test-utils.ts';
 import type {Ordering} from '../../zero-protocol/src/ast.ts';
@@ -11,10 +12,10 @@ import {Database} from './db.ts';
 import {format} from './internal/sql.ts';
 import {
   filtersToSQL,
+  fromSQLiteTypes,
   TableSource,
   UnsupportedValueError,
 } from './table-source.ts';
-import {testLogConfig} from '../../otel/src/test-log-config.ts';
 
 const columns = {
   id: {type: 'string'},
@@ -939,3 +940,118 @@ describe('optional filters to sql', () => {
 });
 
 // TODO: Add constraint test with compound keys
+
+describe('fromSQLiteTypes error messages', () => {
+  test('invalid column error includes table name', () => {
+    const valueTypes = {
+      id: {type: 'string'},
+      name: {type: 'string'},
+    } as const;
+
+    const row = {
+      id: '123',
+      name: 'test',
+      invalidColumn: 'oops',
+    };
+
+    expect(() => fromSQLiteTypes(valueTypes, row, 'users')).toThrow(
+      'Invalid column "invalidColumn" for table "users". Synced columns include id, name',
+    );
+  });
+
+  test('bigint out of range error includes table name and column', () => {
+    const db = new Database(createSilentLogContext(), ':memory:');
+    db.exec(
+      /* sql */ `CREATE TABLE test_table (id TEXT PRIMARY KEY, big_value INTEGER);`,
+    );
+    db.exec(
+      /* sql */ `INSERT INTO test_table (id, big_value) VALUES ('1', ${
+        BigInt(Number.MAX_SAFE_INTEGER) + 1n
+      });`,
+    );
+
+    const source = new TableSource(
+      lc,
+      testLogConfig,
+      db,
+      'test_table',
+      {
+        id: {type: 'string'},
+        big_value: {type: 'number'},
+      },
+      ['id'],
+    );
+    const input = source.connect([['id', 'asc']]);
+
+    expect(() => [...input.fetch({})]).toThrow(
+      /value .* \(in test_table\.big_value\) is outside of supported bounds/,
+    );
+  });
+
+  test('invalid JSON error includes table name and column', () => {
+    const db = new Database(createSilentLogContext(), ':memory:');
+    db.exec(
+      /* sql */ `CREATE TABLE test_table (id TEXT PRIMARY KEY, json_data TEXT);`,
+    );
+    db.exec(
+      /* sql */ `INSERT INTO test_table (id, json_data) VALUES ('1', 'invalid json {');`,
+    );
+
+    const source = new TableSource(
+      lc,
+      testLogConfig,
+      db,
+      'test_table',
+      {
+        id: {type: 'string'},
+        json_data: {type: 'json'},
+      },
+      ['id'],
+    );
+    const input = source.connect([['id', 'asc']]);
+
+    expect(() => [...input.fetch({})]).toThrow(
+      /Failed to parse JSON for test_table\.json_data/,
+    );
+  });
+
+  test('error cause is preserved for JSON parse errors', () => {
+    const db = new Database(createSilentLogContext(), ':memory:');
+    db.exec(
+      /* sql */ `CREATE TABLE test_table (id TEXT PRIMARY KEY, json_data TEXT);`,
+    );
+    db.exec(
+      /* sql */ `INSERT INTO test_table (id, json_data) VALUES ('1', 'not valid json');`,
+    );
+
+    const source = new TableSource(
+      lc,
+      testLogConfig,
+      db,
+      'test_table',
+      {
+        id: {type: 'string'},
+        json_data: {type: 'json'},
+      },
+      ['id'],
+    );
+    const input = source.connect([['id', 'asc']]);
+
+    let caughtError: unknown;
+    try {
+      for (const _ of input.fetch({})) {
+        // Consume the iterator to trigger the error
+      }
+    } catch (error) {
+      caughtError = error;
+    }
+
+    expect(caughtError).toBeInstanceOf(UnsupportedValueError);
+    expect((caughtError as Error).message).toMatchInlineSnapshot(
+      `"Failed to parse JSON for test_table.json_data: Unexpected token 'o', "not valid json" is not valid JSON"`,
+    );
+    expect((caughtError as Error).cause).toMatchInlineSnapshot(
+      `[SyntaxError: Unexpected token 'o', "not valid json" is not valid JSON]`,
+    );
+  });
+});
diff --git a/packages/zqlite/src/table-source.ts b/packages/zqlite/src/table-source.ts
@@ -18,6 +18,7 @@ import type {
   SchemaValue,
   ValueType,
 } from '../../zero-schema/src/table-schema.ts';
+import type {DebugDelegate} from '../../zql/src/builder/debug-delegate.ts';
 import {
   createPredicate,
   transformFilters,
@@ -43,7 +44,6 @@ import type {Stream} from '../../zql/src/ivm/stream.ts';
 import {Database, Statement} from './db.ts';
 import {compile, format, sql} from './internal/sql.ts';
 import {StatementCache} from './internal/statement-cache.ts';
-import type {DebugDelegate} from '../../zql/src/builder/debug-delegate.ts';
 
 type Statements = {
   readonly cache: StatementCache;
@@ -785,17 +785,15 @@ export function toSQLiteTypeName(type: ValueType) {
 export function fromSQLiteTypes(
   valueTypes: Record<string, SchemaValue>,
   row: Row,
-  tableName?: string,
+  tableName: string,
 ): Row {
   const newRow: Writable<Row> = {};
   for (const key of Object.keys(row)) {
     const valueType = valueTypes[key];
     if (valueType === undefined) {
       const columnList = Object.keys(valueTypes).sort().join(', ');
       throw new Error(
-        tableName
-          ? `Invalid column "${key}" for table "${tableName}". Synced columns include ${columnList}`
-          : `Invalid column "${key}". Synced columns include ${columnList}`,
+        `Invalid column "${key}" for table "${tableName}". Synced columns include ${columnList}`,
       );
     }
     newRow[key] = fromSQLiteType(valueType.type, row[key], key, tableName);
@@ -807,7 +805,7 @@ function fromSQLiteType(
   valueType: ValueType,
   v: Value,
   column: string,
-  tableName: string | undefined,
+  tableName: string,
 ): Value {
   if (v === null) {
     return null;
@@ -821,9 +819,7 @@ function fromSQLiteType(
       if (typeof v === 'bigint') {
         if (v > Number.MAX_SAFE_INTEGER || v < Number.MIN_SAFE_INTEGER) {
           throw new UnsupportedValueError(
-            tableName
-              ? `value ${v} (in ${tableName}.${column}) is outside of supported bounds`
-              : `value ${v} (in column ${column}) is outside of supported bounds`,
+            `value ${v} (in ${tableName}.${column}) is outside of supported bounds`,
           );
         }
         return Number(v);
@@ -836,9 +832,8 @@ function fromSQLiteType(
         const errorMessage =
           error instanceof Error ? error.message : String(error);
         throw new UnsupportedValueError(
-          tableName
-            ? `Failed to parse JSON for ${tableName}.${column}: ${errorMessage}`
-            : `Failed to parse JSON for column "${column}": ${errorMessage}`,
+          `Failed to parse JSON for ${tableName}.${column}: ${errorMessage}`,
+          {cause: error},
         );
       }
   }