orez-sync-cf-host 0.16.7 → 0.16.8

package/dist/host.js

@@ -531,7 +531,13 @@ export function createSyncDurableObject(config) {
             const recordRowsRead = (rows) => {
                 this.#sqlBilling.rowsRead += rows;
             };
-            this.#engineDb = new SqlStorageSyncDb(ctx.storage.sql, recordRowsWritten, recordRowsRead);
+            this.#engineDb = new SqlStorageSyncDb(ctx.storage.sql, recordRowsWritten, recordRowsRead, (failure) => {
+                console.error(JSON.stringify({
+                    event: 'sync_sql_failure',
+                    hostVersion: config.hostVersion,
+                    ...failure,
+                }));
+            });
             this.#directSql = new SqlStorageDirect(ctx.storage.sql, recordRowsWritten, recordRowsRead);
             this.#mutatorSql = new SqlStorageMutatorTransaction(this.#directSql, (ast, format) => this.#wasm(() => compileQuery(ast, format)), config.transactionQueryBudget);
             const database = {

package/dist/sql-storage-adapter.d.ts

@@ -17,6 +17,22 @@ export type AdapterStats = {
     queryCalls: number;
     sqlMs: number;
 };
+export type SqlStorageFailureBinding = {
+    index: number;
+    kind: WireValue['kind'];
+    value?: string | number | null;
+    bytes?: number;
+    truncated?: true;
+};
+export type SqlStorageFailure = {
+    operation: 'exec' | 'query';
+    error: string;
+    sql: string;
+    sqlBytes: number;
+    sqlTruncated?: true;
+    paramCount: number;
+    params: SqlStorageFailureBinding[];
+};
 export declare function assertHostSql(sql: string): void;
 export declare function decodeSqlParams(value: unknown): unknown[];
 /**
@@ -28,8 +44,9 @@ export declare class SqlStorageSyncDb implements JsSyncDb {
     private readonly sql;
     private readonly recordRowsWritten;
     private readonly recordRowsRead;
+    private readonly recordFailure;
     readonly stats: AdapterStats;
-    constructor(sql: SqlStorage, recordRowsWritten?: (rows: number) => void, recordRowsRead?: (rows: number) => void);
+    constructor(sql: SqlStorage, recordRowsWritten?: (rows: number) => void, recordRowsRead?: (rows: number) => void, recordFailure?: (failure: SqlStorageFailure) => void);
     resetStats(): void;
     exec(sql: string, params: WireValue[]): void;
     query(sql: string, params: WireValue[]): WireRow[];

package/dist/sql-storage-adapter.js

@@ -90,6 +90,45 @@ export function decodeSqlParams(value) {
 function encodeResult(value) {
     return encodeSqlValue(value);
 }
+const MAX_FAILURE_TEXT_BYTES = 256;
+const MAX_FAILURE_SQL_BYTES = 64 * 1024;
+const MAX_FAILURE_BINDINGS = 512;
+const failureTextEncoder = new TextEncoder();
+function describeFailureBinding(value, index) {
+    if (value.kind === 'null')
+        return { index, kind: value.kind, value: null };
+    if (value.kind === 'blob')
+        return { index, kind: value.kind, bytes: value.value.length };
+    if (value.kind !== 'text')
+        return { index, kind: value.kind, value: value.value };
+    const bytes = failureTextEncoder.encode(value.value).byteLength;
+    if (bytes <= MAX_FAILURE_TEXT_BYTES) {
+        return { index, kind: value.kind, value: value.value, bytes };
+    }
+    return {
+        index,
+        kind: value.kind,
+        value: `${value.value.slice(0, MAX_FAILURE_TEXT_BYTES / 2)}…${value.value.slice(-MAX_FAILURE_TEXT_BYTES / 2)}`,
+        bytes,
+        truncated: true,
+    };
+}
+function describeSqlFailure(operation, error, sql, params) {
+    const sqlBytes = failureTextEncoder.encode(sql).byteLength;
+    const failure = {
+        operation,
+        error: String(error),
+        sql: sqlBytes <= MAX_FAILURE_SQL_BYTES
+            ? sql
+            : `${sql.slice(0, MAX_FAILURE_SQL_BYTES / 2)}…${sql.slice(-MAX_FAILURE_SQL_BYTES / 2)}`,
+        sqlBytes,
+        paramCount: params.length,
+        params: params.slice(0, MAX_FAILURE_BINDINGS).map(describeFailureBinding),
+    };
+    if (sqlBytes > MAX_FAILURE_SQL_BYTES)
+        failure.sqlTruncated = true;
+    return failure;
+}
 /**
  * The sole JS SQL adapter used by wasm. It is synchronous, consumes every
  * cursor before returning, accepts positional `?` only, and never starts or
@@ -99,11 +138,13 @@ export class SqlStorageSyncDb {
     sql;
     recordRowsWritten;
     recordRowsRead;
+    recordFailure;
     stats = { execCalls: 0, queryCalls: 0, sqlMs: 0 };
-    constructor(sql, recordRowsWritten = () => { }, recordRowsRead = () => { }) {
+    constructor(sql, recordRowsWritten = () => { }, recordRowsRead = () => { }, recordFailure = () => { }) {
         this.sql = sql;
         this.recordRowsWritten = recordRowsWritten;
         this.recordRowsRead = recordRowsRead;
+        this.recordFailure = recordFailure;
     }
     resetStats() {
         this.stats.execCalls = 0;
@@ -113,21 +154,34 @@ export class SqlStorageSyncDb {
     exec(sql, params) {
         assertHostSql(sql);
         const start = performance.now();
-        trackBillableCursorRows(this.sql.exec(sql, ...params.map((value) => decodeBinding(value))), this.recordRowsWritten, this.recordRowsRead);
+        try {
+            trackBillableCursorRows(this.sql.exec(sql, ...params.map((value) => decodeBinding(value))), this.recordRowsWritten, this.recordRowsRead);
+        }
+        catch (error) {
+            this.recordFailure(describeSqlFailure('exec', error, sql, params));
+            throw error;
+        }
         this.stats.execCalls++;
         this.stats.sqlMs += performance.now() - start;
     }
     query(sql, params) {
         assertHostSql(sql);
         const start = performance.now();
-        const cursor = trackBillableCursorRows(this.sql.exec(sql, ...params.map((value) => decodeBinding(value))), this.recordRowsWritten, this.recordRowsRead);
-        const columns = [...cursor.columnNames];
-        // A SqlStorage cursor must be fully consumed before any await. Returning a
-        // materialized array here makes that property structural.
-        const rows = Array.from(cursor.raw()).map((values) => ({
-            columns,
-            values: values.map(encodeResult),
-        }));
+        let rows;
+        try {
+            const cursor = trackBillableCursorRows(this.sql.exec(sql, ...params.map((value) => decodeBinding(value))), this.recordRowsWritten, this.recordRowsRead);
+            const columns = [...cursor.columnNames];
+            // A SqlStorage cursor must be fully consumed before any await. Returning a
+            // materialized array here makes that property structural.
+            rows = Array.from(cursor.raw()).map((values) => ({
+                columns,
+                values: values.map(encodeResult),
+            }));
+        }
+        catch (error) {
+            this.recordFailure(describeSqlFailure('query', error, sql, params));
+            throw error;
+        }
         this.stats.queryCalls++;
         this.stats.sqlMs += performance.now() - start;
         return rows;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orez-sync-cf-host",
-  "version": "0.16.7",
+  "version": "0.16.8",
   "description": "Internal orez Cloudflare sync host. Do not import directly: consumers use orez-lite/cloudflare/sync.",
   "type": "module",
   "exports": {
@@ -60,7 +60,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "orez-sync-executor": "0.16.7"
+    "orez-sync-executor": "0.16.8"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "4.20260617.1",