@rotorsoft/act-sqlite 1.22.7 → 2.0.0

package/dist/index.js

@@ -4,6 +4,9 @@ import {
 } from "@libsql/client";
 import {
   ConcurrencyError,
+  check_appends,
+  DEFAULT_QUERY_STREAMS_LIMIT,
+  fair_slots,
   is_literal_source,
   StoreError,
   ValidationError
@@ -241,8 +244,9 @@ var SqliteStore = class {
   // while a write transaction is open on it: a second one fails at once
   // (`TRANSACTION_ACTIVE` in memory, `SQLITE_BUSY` on a file) instead of
   // waiting. So every statement and every transaction takes its turn here.
-  // A turn covers only the database work, never a caller's callback, so a
-  // callback that writes to the store can't wait on itself.
+  // A turn covers only the database work, so a `query` callback that writes to
+  // the store can't wait on itself. `restore` is the exception: its driver runs
+  // inside the turn, because the whole restore is one transaction.
   _turn = Promise.resolve();
   _serial(work) {
     const run = this._turn.then(work);
@@ -276,53 +280,63 @@ var SqliteStore = class {
   async dispose() {
     await this._serial(async () => this.client.close());
   }
-  // --- commit: transaction + optimistic concurrency ---
-  async commit(stream, msgs, meta, expectedVersion) {
+  // --- commit: one transaction across every append ---
+  async commit(appends, meta) {
+    check_appends(appends);
+    if (!appends.length) return [];
     return this._serial(async () => {
       const tx = await this._begin("commit");
-      let current_version = -1;
+      let appending = appends[0];
+      let head = -1;
       try {
-        const version_row = await tx.execute({
-          sql: "SELECT COALESCE(MAX(version), -1) as v FROM events WHERE stream = ?",
-          args: [stream]
-        });
-        current_version = Number(version_row.rows[0].v);
-        if (typeof expectedVersion === "number" && current_version !== expectedVersion) {
-          throw new ConcurrencyError(
-            stream,
-            current_version,
-            msgs,
-            expectedVersion
-          );
+        const heads = /* @__PURE__ */ new Map();
+        for (const { stream, msgs, expectedVersion } of appends) {
+          const row = await tx.execute({
+            sql: "SELECT COALESCE(MAX(version), -1) as v FROM events WHERE stream = ?",
+            args: [stream]
+          });
+          const current = Number(row.rows[0].v);
+          if (typeof expectedVersion === "number" && current !== expectedVersion)
+            throw new ConcurrencyError(
+              stream,
+              current,
+              msgs,
+              expectedVersion
+            );
+          heads.set(stream, current);
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const committed = [];
-        let version = current_version + 1;
-        for (const { name, data, pii } of msgs) {
-          const pii_for_write = await this._stringify_pii_for_write(pii);
-          const result = await tx.execute({
-            sql: "INSERT INTO events (stream, version, name, data, meta, created, pii) VALUES (?, ?, ?, ?, ?, ?, ?)",
-            args: [
-              stream,
+        for (const append of appends) {
+          appending = append;
+          head = heads.get(append.stream);
+          let version = head + 1;
+          for (const { name, data, pii } of append.msgs) {
+            const pii_for_write = await this._stringify_pii_for_write(pii);
+            const result = await tx.execute({
+              sql: "INSERT INTO events (stream, version, name, data, meta, created, pii) VALUES (?, ?, ?, ?, ?, ?, ?)",
+              args: [
+                append.stream,
+                version,
+                name,
+                JSON.stringify(data),
+                JSON.stringify(meta),
+                now,
+                pii_for_write
+              ]
+            });
+            committed.push({
+              id: Number(result.lastInsertRowid),
+              stream: append.stream,
               version,
+              created: new Date(now),
               name,
-              JSON.stringify(data),
-              JSON.stringify(meta),
-              now,
-              pii_for_write
-            ]
-          });
-          committed.push({
-            id: Number(result.lastInsertRowid),
-            stream,
-            version,
-            created: new Date(now),
-            name,
-            data,
-            meta,
-            ...pii == null ? {} : { pii }
-          });
-          version++;
+              data,
+              meta,
+              ...pii == null ? {} : { pii }
+            });
+            version++;
+          }
         }
         await tx.commit();
         return committed;
@@ -331,10 +345,10 @@ var SqliteStore = class {
         if (e instanceof ConcurrencyError) throw e;
         if (is_unique_violation(e))
           throw new ConcurrencyError(
-            stream,
-            current_version,
-            msgs,
-            expectedVersion ?? -1
+            appending.stream,
+            head,
+            appending.msgs,
+            appending.expectedVersion ?? -1
           );
         throw new StoreError("commit", { cause: e });
       }
@@ -407,8 +421,8 @@ var SqliteStore = class {
   //     targeting the same stream. Operator overrides go
   //     through `prioritize()` instead.
   async subscribe(streams, correlated_at, correlator) {
-    for (const { source } of streams) {
-      if (source !== void 0 && !is_literal_source(source))
+    for (const { stream, source } of streams) {
+      if (source !== void 0 && !is_literal_source(source, stream))
         streamPatternToGlob(source);
     }
     return this._tx("subscribe", async (tx) => {
@@ -542,7 +556,7 @@ var SqliteStore = class {
         priority: Number(row.priority),
         lane: row.lane
       })).sort((a, b) => b.priority - a.priority || a.at - b.at);
-      const fair = lagging >= 2 ? Math.max(1, Math.floor(lagging / 4)) : 0;
+      const fair = fair_slots(lagging);
       const priority_slice = candidates.slice(0, lagging - fair);
       const picked = new Set(priority_slice.map((c) => c.stream));
       const fair_slice = [...candidates].sort((a, b) => a.at - b.at).filter((c) => !picked.has(c.stream)).slice(0, fair);
@@ -749,7 +763,7 @@ var SqliteStore = class {
   }
   // --- query_streams: read-only introspection with filters ---
   async query_streams(callback, query) {
-    const limit = query?.limit ?? 100;
+    const limit = query?.limit ?? DEFAULT_QUERY_STREAMS_LIMIT;
     const { clause, args } = this._filter_clause(query ?? {});
     let sql = `SELECT stream, source, at, retry, blocked, error, leased_by, leased_until, priority, lane, deferred_at, correlated_at FROM streams WHERE ${clause}`;
     if (query?.after !== void 0) {
@@ -1064,6 +1078,8 @@ var SqliteStore = class {
    * new sequence is dense from 1. `created` is preserved verbatim
    * from the source.
    */
+  // The driver runs inside this store's turn, so it must read from another
+  // store: a call on this one would wait for the restore to end, forever.
   async restore(driver) {
     return this._serial(async () => {
       const tx = await this._begin("restore");