@sproutboat/wire 0.14.3 → 0.14.5

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @sproutboat/wire
 
+## 0.14.5
+
+### Patch Changes
+
+- 9a5363e: D1 matches workerd from compatibility date `2026-10-24`:
+  
+  - `all()`, `run()`, `first()`, `raw()`, `batch()` and `exec()` return Promises, and errors reject them. `bind()` stays synchronous and still throws `D1_TYPE_ERROR` at once.
+  - `meta` has D1's keys: `served_by`, `duration`, `changes`, `last_row_id`, `changed_db`, `size_after` (always 0 here), `rows_read` and `rows_written`.
+  - `raw({ columnNames: true })` puts the column names first, and keeps duplicate names.
+  - `first("name")` throws `D1_COLUMN_NOTFOUND` for a column the result doesn't have.
+  - Empty SQL and an empty `batch([])` throw `D1_ERROR: No SQL statements detected.`
+  - `BEGIN`, `COMMIT`, `ROLLBACK`, `SAVEPOINT` and `RELEASE` are refused, as in D1. A batch is already one transaction.
+  - `exec()` runs line by line, all or nothing, and returns the number of lines. A failing line throws `D1_EXEC_ERROR: Error in line N: ...`.
+  - `withSession()` returns a session with `prepare`, `batch` and `getBookmark()`, which returns `null`. `dump()` rejects; use `backup()` instead.
+  
+  Apps with an earlier `compatibility_date` keep the synchronous API unchanged. To opt in, move the date to `2026-10-24` or later and rebuild. `await` code needs no other change, but code that reads results without `await` does.
+  
+  Not yet like D1: `rows_read` counts the rows returned, not the rows scanned, and pragmas are not limited to D1's allow-list.
+  
+  With LTX capture on (from `2026-10-22`), a capture failure during a D1 call now reports `SQLITE_IOERR` with a message saying the write is not durable in the replication log, instead of SQLite's "not an error". Writes stay refused until restart.
+- Updated dependencies [9a5363e]
+  - @sproutboat/runtime@0.24.0
+
+## 0.14.4
+
+### Patch Changes
+
+- 7a7fd34: D1 correctness fixes, in the standalone (embedded) transport and the broker:
+  
+  - **Bytes are no longer lost.** Binding a `Uint8Array`, another typed array, a `DataView` or an `ArrayBuffer` stored NULL in a standalone sprout, along with every parameter after it. It now stores a BLOB, at every compatibility date. On earlier dates a BLOB still reads back as before: as one character per byte.
+  - **`batch()` is one transaction** in a standalone sprout, as it already was through the broker and is in D1: if a statement fails, the ones before it are rolled back. This applies at every compatibility date.
+  - **From compatibility date `2026-10-24`**, D1 follows workerd's rules:
+    - a parameter must be `null`, a number, a string, a boolean or bytes, or the call throws `D1_TYPE_ERROR` (before, `undefined` and objects became NULL);
+    - the number of parameters must match the statement (`D1_ERROR: Wrong number of parameter bindings for SQL query.`);
+    - foreign keys are enforced (`PRAGMA foreign_keys = ON`);
+    - errors read `D1_ERROR: <message>: SQLITE_<CODE>`;
+    - a BLOB reads back as an array of byte values.
+  
+    Apps with an earlier `compatibility_date` keep the old behaviour. To opt in, move the date to `2026-10-24` or later and rebuild.
+  - `meta.changes` is 0 for a statement that only reads. It used to repeat the previous write's count.
+- Updated dependencies [7a7fd34]
+  - @sproutboat/runtime@0.23.1
+
 ## 0.14.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/wire",
-  "version": "0.14.3",
+  "version": "0.14.5",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,6 +23,6 @@
   },
   "dependencies": {
     "@sproutboat/assets": "^0.3.0",
-    "@sproutboat/runtime": "^0.23.0"
+    "@sproutboat/runtime": "^0.24.0"
   }
 }

package/src/d1.ts

@@ -7,20 +7,126 @@ import { isBoolean, isString, jsonObject, type JsonObject, type JsonValue } from
 import type { Frame } from "./broker";
 
 const isNumber = (value: JsonValue): value is number => Number.isFinite(value);
-type SqlParam = string | number | null;
+type SqlParam = string | number | null | Uint8Array;
 const str = (v: JsonValue | undefined) => (isString(v) ? v : String(v ?? ""));
+// {"$blob":"HEX"} is the shim's encoding of bytes (an ArrayBuffer or a typed array).
+const blobOf = (p: JsonValue): Uint8Array | undefined => {
+  const o = jsonObject(p);
+  return o && isString(o.$blob) ? Uint8Array.from(Buffer.from(o.$blob, "hex")) : undefined;
+};
 const params = (v: JsonValue | undefined): SqlParam[] =>
   Array.isArray(v)
-    ? v.map((p) => (p === null || isNumber(p) || isString(p) ? p : isBoolean(p) ? Number(p) : String(p)))
+    ? v.map((p) => (p === null || isNumber(p) || isString(p) ? p : isBoolean(p) ? Number(p) : (blobOf(p) ?? String(p))))
     : [];
+// A BLOB read back: hex for strict calls (the shim makes it an array of byte values, as
+// workerd does), one char per byte otherwise (what the embedded transport returns).
+// SAFETY: bun:sqlite returns only null, numbers, strings, bigints (off by default) and
+// Uint8Array for BLOBs; the Uint8Array case is converted here, the rest are JSON values.
+type SqliteValue = JsonValue | Uint8Array | bigint;
+// SAFETY: the two non-JSON cases (bytes, bigint) are converted first; what is left is a JSON value.
+const cell = (v: SqliteValue, strict: boolean): JsonValue =>
+  v instanceof Uint8Array
+    ? strict
+      ? { $blob: Buffer.from(v).toString("hex") }
+      : String.fromCharCode(...v)
+    : Object(v) instanceof BigInt
+      ? Number(v)
+      : (v as JsonValue);
+type SqliteFailure = Error & { errno?: number; code?: string; byteOffset?: number };
+const isSqliteFailure = (e: Error): e is SqliteFailure => "errno" in e;
+const SQLITE_CODES = [
+  "",
+  "SQLITE_ERROR",
+  "SQLITE_INTERNAL",
+  "SQLITE_PERM",
+  "SQLITE_ABORT",
+  "SQLITE_BUSY",
+  "SQLITE_LOCKED",
+  "SQLITE_NOMEM",
+  "SQLITE_READONLY",
+  "SQLITE_INTERRUPT",
+  "SQLITE_IOERR",
+  "SQLITE_CORRUPT",
+  "SQLITE_NOTFOUND",
+  "SQLITE_FULL",
+  "SQLITE_CANTOPEN",
+  "SQLITE_PROTOCOL",
+  "SQLITE_EMPTY",
+  "SQLITE_SCHEMA",
+  "SQLITE_TOOBIG",
+  "SQLITE_CONSTRAINT",
+  "SQLITE_MISMATCH",
+  "SQLITE_MISUSE",
+  "SQLITE_NOLFS",
+  "SQLITE_AUTH",
+  "SQLITE_FORMAT",
+  "SQLITE_RANGE",
+  "SQLITE_NOTADB",
+];
+/** D1's wording for a SQLite error, as the embedded transport words it for strict calls. */
+export function d1Error(error: Error): Error {
+  if (!isSqliteFailure(error)) return error;
+  let text = `D1_ERROR: ${error.message}`;
+  if (Number.isInteger(error.byteOffset) && Number(error.byteOffset) >= 0) text += ` at offset ${error.byteOffset}`;
+  const base = SQLITE_CODES[(Number(error.errno) || 0) & 255];
+  if (base) {
+    text += `: ${base}`;
+    if (base === "SQLITE_CONSTRAINT" && error.code && error.code !== base) text += ` (extended: ${error.code})`;
+  }
+  return new Error(text);
+}
 export type D1Request = { owner: string; key: string; path: string; name: string; msg: Frame };
 
 export function createD1Store(executionMs = 0, capability = "") {
   if (executionMs && !/^[a-f0-9]{64}$/.test(capability)) throw new Error("invalid host budget capability");
   const connections = new Map<string, { db: Database; owners: Set<string> }>();
+  // Strict calls (the shim's compatibility date 2026-10-24): the parameter count must match
+  // and rows come back as arrays with their column names.
+  // A read changes nothing: changes() still holds the last write's count, total_changes() does not move.
+  const total = (db: Database) => db.query<{ n: number }, []>("SELECT total_changes() AS n").get()?.n ?? 0;
+  const runStrict = (db: Database, sql: string, values: SqlParam[]) => {
+    const started = performance.now();
+    const before = total(db);
+    let statement;
+    try {
+      statement = db.query<SqliteValue[], SqlParam[]>(sql);
+    } catch (error) {
+      throw d1Error(error instanceof Error ? error : new Error(String(error)));
+    }
+    if (statement.paramsCount !== values.length)
+      throw new Error("D1_ERROR: Wrong number of parameter bindings for SQL query.");
+    let rows: SqliteValue[][];
+    try {
+      rows = statement.values(...values) ?? [];
+    } catch (error) {
+      throw d1Error(error instanceof Error ? error : new Error(String(error)));
+    }
+    const meta = db
+      .query<{ changes: number; last_row_id: number }, []>(
+        "SELECT changes() AS changes, last_insert_rowid() AS last_row_id",
+      )
+      .get();
+    return {
+      columns: statement.columnNames,
+      rows: rows.map((row) => row.map((v) => cell(v, true))),
+      meta: {
+        duration: performance.now() - started,
+        changes: total(db) > before ? (meta?.changes ?? 0) : 0,
+        last_row_id: meta?.last_row_id ?? 0,
+        rows_read: rows.length,
+      },
+    };
+  };
   const run = (db: Database, sql: string, values: SqlParam[]) => {
     const started = performance.now();
-    const results = db.query<JsonObject, SqlParam[]>(sql).all(...values);
+    const before = total(db);
+    const results = db
+      .query<JsonObject, SqlParam[]>(sql)
+      .all(...values)
+      .map((row) => {
+        for (const k in row) row[k] = cell(row[k], false);
+        return row;
+      });
     const meta = db
       .query<{ changes: number; last_row_id: number }, []>(
         "SELECT changes() AS changes, last_insert_rowid() AS last_row_id",
@@ -30,7 +136,7 @@ export function createD1Store(executionMs = 0, capability = "") {
       results,
       meta: {
         duration: performance.now() - started,
-        changes: meta?.changes ?? 0,
+        changes: total(db) > before ? (meta?.changes ?? 0) : 0,
         last_row_id: meta?.last_row_id ?? 0,
         rows_read: results.length,
       },
@@ -74,12 +180,32 @@ export function createD1Store(executionMs = 0, capability = "") {
         }
       };
       try {
+        const strict = msg.strict === true;
+        // Foreign keys are enforced from compatibility date 2026-10-24, as in D1. The
+        // pragma is per connection and a no-op inside a transaction, so set it per call.
+        if (msg.op !== "d1.backup") db.exec(strict ? "PRAGMA foreign_keys = ON" : "PRAGMA foreign_keys = OFF");
+        const exec1 = strict ? runStrict : run;
         switch (msg.op) {
           case "d1.query":
-            return { ok: true, ...run(db, str(msg.sql), params(msg.params)) };
-          case "d1.exec":
-            db.exec(str(msg.sql));
+            return { ok: true, ...exec1(db, str(msg.sql), params(msg.params)) };
+          case "d1.exec": {
+            const lines = Array.isArray(msg.lines) ? msg.lines.map(str) : null;
+            if (!strict || !lines) {
+              db.exec(str(msg.sql));
+              return { ok: true };
+            }
+            // From 2026-10-24: line by line as workerd runs it, all or nothing.
+            db.transaction(() =>
+              lines.forEach((line, i) => {
+                try {
+                  db.exec(line);
+                } catch (error) {
+                  throw new Error(`D1_EXEC_ERROR: Error in line ${i + 1}: ${line}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+              }),
+            )();
             return { ok: true };
+          }
           case "d1.batch": {
             const statements = Array.isArray(msg.statements) ? msg.statements.map((s) => jsonObject(s) ?? {}) : [];
             return {
@@ -88,7 +214,7 @@ export function createD1Store(executionMs = 0, capability = "") {
                 statements.map((s) => {
                   if (executionMs && performance.now() >= deadline)
                     throw new Error("D1 execution deadline exceeded; batch rolled back");
-                  return run(db, str(s.sql), params(s.params));
+                  return exec1(db, str(s.sql), params(s.params));
                 }),
               )(),
             };