@sproutboat/wire 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @sproutboat/wire
 
+## 0.19.0
+
+### Minor Changes
+
+- 140f0f7: Durable Objects `ctx.storage.sql` from compatibility date `2026-10-29`, on every
+  transport. Each object gets its own SQLite database.
+  
+  - `exec(query, ...bindings)` runs one statement and returns a cursor with `toArray()`,
+    `one()`, `raw()`, `next()`, iteration, `columnNames`, `rowsRead` and `rowsWritten`.
+  - BLOBs come back as ArrayBuffers.
+  - Foreign keys are enforced.
+  - `BEGIN`, `SAVEPOINT` and the other transaction statements throw workerd's error. Use
+    `storage.transactionSync(fn)`, which rolls back if `fn` throws.
+  - `sql.databaseSize` gives the database's size in bytes.
+  - Errors read as in workerd, for example `near "SELEKT": syntax error at offset 0:
+    SQLITE_ERROR`.
+  
+  Every Durable Object class gets `sql`, since `sproutboat.jsonc` has no
+  `new_sqlite_classes`. The key-value API keeps its own store.
+  
+  Where the databases live:
+  - **Standalone executables and sproutd:** in `<data>/do-sql/CLASS/ID.sqlite`. At most 8
+    stay open, and the one used longest ago closes for the next one.
+  - **Broker (wire):** new op `do.sql`. With `doDb`, the databases sit in
+    `<doDb without .sqlite>.do-sql/` next to it, so they survive a redeploy and stay
+    separate per project. Without a SQL pool, the broker keeps at most 64 open
+    (`createD1Store`'s new `maxOpen`).
+
+### Patch Changes
+
+- Updated dependencies [9167b44]
+- Updated dependencies [140f0f7]
+  - @sproutboat/runtime@0.30.0
+
 ## 0.18.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/wire",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,6 +23,6 @@
   },
   "dependencies": {
     "@sproutboat/assets": "^0.3.0",
-    "@sproutboat/runtime": "^0.29.0"
+    "@sproutboat/runtime": "^0.30.0"
   }
 }

package/src/broker.test.ts

@@ -1079,6 +1079,49 @@ test("cronMatches: fields, steps, ranges, lists (UTC)", () => {
 // #74 — a binding wired to an account-level resource stores in its own file
 // under resourceDir, keyed by id, so the data outlives a "redeploy" (a new
 // broker with a fresh per-deployment db but the same resourceDir).
+test("Durable Object SQL: one database per object, beside its project's doDb, D1-strict replies", async () => {
+  const root = mkdtempSync(join(tmpdir(), "sb-broker-do-sql-"));
+  try {
+    for (const dep of ["dep", "dep2", "dep3"]) mkdirSync(join(root, dep));
+    const bindings = { do: [{ binding: "SQL", className: "SqlObject" }] };
+    const a = "a".repeat(64);
+    const b2 = "b".repeat(64);
+    const sql = (b: ReturnType<typeof createBroker>, file: string, text: string, params: JsonValue[] = []) =>
+      b.dispatch({ op: "do.sql", cls: "SqlObject", file, sql: text, params });
+    const one = createBroker({ db: join(root, "dep", "state.sqlite"), doDb: join(root, "do_p1.sqlite"), bindings });
+    await sql(one, a, "CREATE TABLE t (v, b BLOB)");
+    expect(await sql(one, a, "INSERT INTO t VALUES (?, ?), (?, ?)", [1, { $blob: "0102" }, 2, null])).toMatchObject({
+      meta: { changes: 2 },
+    });
+    expect(await sql(one, a, "SELECT v, b FROM t ORDER BY v")).toMatchObject({
+      columns: ["v", "b"],
+      rows: [
+        [1, { $blob: "0102" }],
+        [2, null],
+      ],
+    });
+    // Another object has its own database.
+    await expect(sql(one, b2, "SELECT v FROM t")).rejects.toThrow("D1_ERROR: no such table: t");
+    await expect(sql(one, a, "SELEKT 1")).rejects.toThrow('near "SELEKT": syntax error');
+    await expect(sql(one, "../x", "SELECT 1")).rejects.toThrow("invalid Durable Object SQL database");
+    await expect(one.dispatch({ op: "do.sql", cls: "Nope", file: a, sql: "SELECT 1", params: [] })).rejects.toThrow(
+      "not bound",
+    );
+    one.close();
+    expect(existsSync(join(root, "do_p1.do-sql", "SqlObject", `${a}.sqlite`))).toBe(true);
+
+    // A redeploy keeps it; another project with the same class and id does not see it.
+    const again = createBroker({ db: join(root, "dep2", "state.sqlite"), doDb: join(root, "do_p1.sqlite"), bindings });
+    expect((await sql(again, a, "SELECT count(*) AS n FROM t")).rows).toEqual([[2]]);
+    again.close();
+    const other = createBroker({ db: join(root, "dep3", "state.sqlite"), doDb: join(root, "do_p2.sqlite"), bindings });
+    await expect(sql(other, a, "SELECT v FROM t")).rejects.toThrow("no such table: t");
+    other.close();
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("#207: Durable Object storage and alarms in doDb outlive a redeploy", async () => {
   const root = mkdtempSync(join(tmpdir(), "sb-broker-do-"));
   try {

package/src/broker.ts

@@ -675,6 +675,27 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     return d1Session ? d1Session.execute(request) : d1Store.execute({ ...request, owner: "dedicated" });
   };
 
+  // Durable Objects storage.sql (the shim's compatibility date 2026-10-29): one SQLite file per
+  // object, `<do-sql>/CLASS/FILE.sqlite`, run as a strict D1 query. The directory is named
+  // after the DO store file: several projects keep their doDb side by side.
+  // FILE is the object's 64-hex id (or a hash of an older id); the class must be bound.
+  // Without a SQL pool, at most 64 stay open; the one used longest ago closes first.
+  const doSqlDir = opts.doDb
+    ? `${resolve(opts.doDb).replace(/\.sqlite$/, "")}.do-sql`
+    : inMemory
+      ? null
+      : join(dirname(resolve(dbPath)), "do-sql");
+  const doSqlStore = createD1Store(0, "", 64);
+  const doSql = (msg: Frame): Frame | Promise<Frame> => {
+    const cls = requireDoClass(msg.cls);
+    const file = str(msg.file);
+    if (!/^[0-9a-f]{64}$/.test(file)) throw new Error("invalid Durable Object SQL database");
+    const path = doSqlDir ? resolve(doSqlDir, cls, `${file}.sqlite`) : ":memory:";
+    const key = path === ":memory:" ? `${token}:${dbPath}:do-sql:${cls}:${file}` : path;
+    const request = { key, path, name: `do-sql:${cls}`, msg: { ...msg, op: "d1.query", strict: true } };
+    return d1Session ? d1Session.execute(request) : doSqlStore.execute({ ...request, owner: "dedicated" });
+  };
+
   /**
    * #56 — an object's bytes never enter SQLite; they live in their own file,
    * named by a hash of bucket+key (so unicode keys and directory traversal
@@ -1548,6 +1569,8 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
       case "d1.exec":
       case "d1.backup":
         return await d1(requireD1(msg.db), msg);
+      case "do.sql":
+        return await doSql(msg);
 
       case "ratelimit.check": {
         // #69 — fixed window; limit/period arrive in the message. Same upsert as
@@ -2058,6 +2081,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     "d1.exec",
     "d1.batch",
     "d1.backup",
+    "do.sql",
     "ratelimit.check",
     "r2.put",
     "r2.multipart.create",
@@ -2340,6 +2364,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
       for (const t of timers) clearInterval(t);
       d1Session?.close();
       d1Store.close();
+      doSqlStore.close();
       for (const conn of resourceDbs.values()) conn.close();
       if (doDb !== db) doDb.close();
       db.close();

package/src/d1.ts

@@ -77,7 +77,10 @@ export function d1Error(error: Error): Error {
 }
 export type D1Request = { owner: string; key: string; path: string; name: string; msg: Frame };
 
-export function createD1Store(executionMs = 0, capability = "") {
+/** maxOpen > 0 (Durable Object SQL, one file per object): at most that many connections stay
+ * open, and the one used longest ago is closed for a new one. A closed database reopens on
+ * its next call. */
+export function createD1Store(executionMs = 0, capability = "", maxOpen = 0) {
   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
@@ -145,6 +148,18 @@ export function createD1Store(executionMs = 0, capability = "") {
   return {
     execute({ owner, key, path, name, msg }: D1Request): Frame {
       let entry = connections.get(key);
+      if (entry && maxOpen) {
+        // Most recently used last: Map iteration follows insertion order.
+        connections.delete(key);
+        connections.set(key, entry);
+      }
+      if (!entry && maxOpen && connections.size >= maxOpen) {
+        const [oldest, old] = connections.entries().next().value ?? [];
+        if (oldest !== undefined && old) {
+          connections.delete(oldest);
+          old.db.close();
+        }
+      }
       if (!entry) {
         if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
         const db = new Database(path, { create: true });
@@ -200,7 +215,9 @@ export function createD1Store(executionMs = 0, capability = "") {
                 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)}`);
+                  throw new Error(
+                    `D1_EXEC_ERROR: Error in line ${i + 1}: ${line}: ${error instanceof Error ? error.message : String(error)}`,
+                  );
                 }
               }),
             )();