@delali/sirannon-db 0.3.4-next.62 → 0.3.4

package/dist/{chunk-M2BEAH5I.mjs → chunk-ZN4HI5FK.mjs}

@@ -1,8 +1,8 @@
-import { tableColumnNames, tablePkColumns, selectMinChangeSeqSql, selectMaxChangeSeq, deleteChangesBeforeUpToSeqSql, deleteChangesBeforeSql, selectTableExists, ensureChangesTable, ensureMetaTable, insertMetaValueIfAbsent, selectMetaValue, selectChangesAfterSeqSql, selectTablesChangesInRangeSql } from './chunk-45MKELYA.mjs';
-import { CHANGES_TABLE, isReservedIdentifier, CDC_TRIGGER_PREFIX, encodeTaggedValues, changedAtToEventTimestamp, decodeTaggedValues, SAFE_INT_BOUND_TEXT } from './chunk-6CMCO7S4.mjs';
-import { synchronousPragmaValue } from './chunk-OUSWVNWT.mjs';
+import { tableColumnNames, tablePkColumns, selectMinChangeSeqSql, selectMaxChangeSeq, deleteChangesBeforeUpToSeqSql, deleteChangesBeforeSql, selectTableExists, ensureChangesTable, ensureMetaTable, insertMetaValueIfAbsent, selectMetaValue, selectChangesAfterSeqSql, selectTablesChangesInRangeSql, deleteExpiredDeviceCursors, selectMinDeviceCursorBoundary } from './chunk-ESTZZPT5.mjs';
+import { CHANGES_TABLE, isReservedIdentifier, CDC_TRIGGER_PREFIX, encodeTaggedValues, changedAtToEventTimestamp, decodeTaggedValues, SAFE_INT_BOUND_TEXT, DEVICE_CURSORS_TABLE } from './chunk-2O3PP4CF.mjs';
+import { synchronousPragmaValue } from './chunk-YCMB6GR4.mjs';
 import { randomHex, invokeCallerCallback, reportCallerFailure, toError } from './chunk-QBBLSQHQ.mjs';
-import { SirannonError, ForbiddenSqlError, CDCError, MigrationError } from './chunk-PBRXXISQ.mjs';
+import { SirannonError, ForbiddenSqlError, CDCError, MigrationError } from './chunk-KINDFBQP.mjs';
 
 // src/core/bulk-load.ts
 var DEFAULT_LOAD_DURABILITY = "off";
@@ -119,6 +119,38 @@ async function readSinceTables(conn, cache, changesTable, tables, afterSeq, upTo
   return rows.map(rowToEvent);
 }
 
+// src/core/cdc/prune-boundaries.ts
+var PruneBoundaries = class {
+  bySource = /* @__PURE__ */ new Map();
+  set(source, seq) {
+    this.bySource.set(source, seq);
+  }
+  clear(source) {
+    this.bySource.delete(source);
+  }
+  lowest() {
+    let lowest = null;
+    for (const boundary of this.bySource.values()) {
+      if (lowest === null || boundary < lowest) {
+        lowest = boundary;
+      }
+    }
+    return lowest;
+  }
+};
+function seqBoundFor(lowest, lastSeq) {
+  if (lastSeq > 0n && lowest !== null) {
+    return lastSeq < lowest ? lastSeq : lowest;
+  }
+  if (lowest !== null) {
+    return lowest;
+  }
+  if (lastSeq > 0n) {
+    return lastSeq;
+  }
+  return null;
+}
+
 // src/core/cdc/statement-cache.ts
 var StatementCache = class {
   cache = /* @__PURE__ */ new WeakMap();
@@ -216,7 +248,7 @@ var ChangeTracker = class {
   changesTableEnsured = false;
   watchedTablesCache = null;
   stmtCache = new StatementCache();
-  pruneBoundary = null;
+  pruneBoundaries = new PruneBoundaries();
   lastPollAtTxBoundary = true;
   constructor(options) {
     this.retentionMs = options?.retention ?? DEFAULT_RETENTION_MS;
@@ -225,10 +257,10 @@ var ChangeTracker = class {
     this.assertIdentifier(this.changesTable, "changes table name");
   }
   /**
-   * Starts recording changes to a table by installing its change-capture triggers.
+   * Installs change-capture triggers on a table, so that every later write to it adds a row to the change log.
    *
-   * @param conn - Writer connection the triggers are created on.
-   * @param table - Name of the table to watch.
+   * @param conn - The writer connection on which the tracker creates the triggers.
+   * @param table - The name of the table to watch.
    */
   async watch(conn, table) {
     this.assertIdentifier(table, "table name");
@@ -261,10 +293,10 @@ var ChangeTracker = class {
     this.watchedTablesCache = null;
   }
   /**
-   * Stops recording changes to a table and drops its triggers.
+   * Drops a table's change-capture triggers and removes the table from the watched set.
    *
-   * @param conn - Writer connection the triggers are dropped from.
-   * @param table - Name of the table to stop watching.
+   * @param conn - The writer connection on which the tracker drops the triggers.
+   * @param table - The name of the table to stop watching.
    */
   async unwatch(conn, table) {
     if (!this.watched.has(table)) {
@@ -275,29 +307,17 @@ var ChangeTracker = class {
     this.watchedTablesCache = null;
   }
   /**
-   * Rebuilds CDC triggers for every watched table directly on the supplied
-   * connection, without opening a nested transaction.
-   *
-   * Required when a caller has already issued `BEGIN` on `conn` and runs a
-   * DDL statement that changes a watched table's column list: the next DML
-   * inside the same transaction must see triggers compiled against the new
-   * columns, otherwise CDC `new_data` silently omits them. Callers that are
-   * not inside an active transaction may also use this method; CREATE
-   * TRIGGER and DROP TRIGGER statements are committed individually by the
-   * driver in that case.
+   * Rebuilds the change-capture triggers on `conn` for every watched table
+   * whose column list has changed, without opening a nested transaction.
    *
-   * Failure semantics:
-   * - If a watched table no longer exists (e.g. it was just dropped by the
-   *   DDL), it is skipped. The watched-map entry is left alone so a separate
-   *   cleanup path can handle it; throwing here would roll back the user's
-   *   transaction over a benign condition.
-   * - If reading column metadata succeeds but the column list is unchanged,
-   *   no triggers are touched.
-   * - If reading column metadata succeeds and the column list differs from
-   *   the cached one, the existing triggers are dropped and reinstalled on
-   *   `conn`. The cached column list is updated on success.
-   * - Any other error (driver failure, identifier validation failure) is
-   *   rethrown so the caller's transaction can roll back deterministically.
+   * Call it after a DDL statement inside an open transaction, so that the next
+   * write in that transaction records the new columns in `new_data`. You can
+   * also call it outside a transaction, in which case SQLite commits each
+   * `CREATE TRIGGER` and `DROP TRIGGER` statement on its own. The method skips
+   * a watched table that no longer exists, and it leaves that table's entry for
+   * `pruneDroppedTables` to remove after the commit. A
+   * driver error or an invalid column name propagates to the caller, so that
+   * the caller can roll back its transaction.
    *
    * @internal
    */
@@ -329,24 +349,16 @@ var ChangeTracker = class {
     }
   }
   /**
-   * Removes the supplied tables from the watched map and drops any leftover
-   * CDC triggers carrying their identifier on the supplied connection.
+   * Drops the change-capture triggers of each named table that the tracker
+   * watches, and removes that table from the watched set.
    *
-   * Intended to be called after a DDL transaction that dropped one or more
-   * watched tables has committed. On rollback the caller must not invoke
-   * this method; the rollback semantics rely on the caller discarding its
-   * captured drop list before reaching this call.
-   *
-   * Idempotent: tables not currently in the watched map are silently
-   * skipped. `dropCdcTriggers` issues `DROP TRIGGER IF EXISTS` so calling
-   * twice in succession produces the same state.
-   *
-   * Defence in depth: even after a `DROP TABLE`, the in-transaction trigger
-   * refresh path may have observed a freshly-created table of the same name
-   * (the DROP and CREATE happened inside the same transaction) and
-   * re-installed triggers compiled against the new schema. Those triggers
-   * are dropped here so the recreated table starts with a clean slate and
-   * the caller must explicitly `watch` it again.
+   * Call it once a transaction that drops watched tables commits, and skip the
+   * call when that transaction rolls back. The method skips each table outside
+   * the watched set and issues `DROP TRIGGER IF EXISTS`, so a second call leaves
+   * the same state. When one transaction drops a table and creates another with
+   * the same name, `refreshAllTriggersUsingConnection` can
+   * install triggers on the new table. This method drops those triggers too, so
+   * you have to call `watch` again for the new table.
    *
    * @internal
    */
@@ -386,7 +398,7 @@ var ChangeTracker = class {
     return this.lastPollAtTxBoundary;
   }
   /**
-   * The highest seq already polled; live subscribers receive events beyond it.
+   * Returns the sequence number of the last change that the tracker polled or skipped with `advanceToLatest`, so live subscribers receive only later changes.
    *
    * @internal
    */
@@ -405,7 +417,7 @@ var ChangeTracker = class {
     return readSinceTables(conn, this.stmtCache, this.changesTable, tables, afterSeq, upToSeq, limit);
   }
   /**
-   * The lowest retained seq, or `null` when the change log is empty.
+   * Returns the lowest sequence number in the change log, or `null` when the log is empty or missing.
    *
    * @internal
    */
@@ -461,12 +473,16 @@ var ChangeTracker = class {
     return result.changes;
   }
   /** @internal */
-  setPruneBoundary(seq) {
-    this.pruneBoundary = seq;
+  setPruneBoundary(source, seq) {
+    this.pruneBoundaries.set(source, seq);
+  }
+  /** @internal */
+  clearPruneBoundary(source) {
+    this.pruneBoundaries.clear(source);
   }
   /** @internal */
-  clearPruneBoundary() {
-    this.pruneBoundary = null;
+  get changeLogTable() {
+    return this.changesTable;
   }
   /** @internal */
   get watchedTables() {
@@ -476,17 +492,7 @@ var ChangeTracker = class {
     return this.watchedTablesCache;
   }
   computeSeqBound() {
-    const boundary = this.pruneBoundary;
-    if (this.lastSeq > 0n && boundary !== null) {
-      return this.lastSeq < boundary ? this.lastSeq : boundary;
-    }
-    if (boundary !== null) {
-      return boundary;
-    }
-    if (this.lastSeq > 0n) {
-      return this.lastSeq;
-    }
-    return null;
+    return seqBoundFor(this.pruneBoundaries.lowest(), this.lastSeq);
   }
   assertIdentifier(name, label) {
     if (!IDENTIFIER_RE.test(name)) {
@@ -550,6 +556,42 @@ function reconcileMigrationChecksums(migrations, applied) {
   return backfills;
 }
 
+// src/core/cdc/device-retention.ts
+var DEFAULT_DEVICE_CURSOR_RETENTION_MS = 30 * 24 * 36e5;
+function resolveDeviceRetentionPolicy(options, fallback) {
+  return {
+    cursorRetentionMs: options?.deviceCursorRetention ?? fallback?.deviceCursorRetention ?? DEFAULT_DEVICE_CURSOR_RETENTION_MS,
+    maxChangesHeldForDevice: options?.maxChangesHeldForDevice ?? fallback?.maxChangesHeldForDevice ?? 0
+  };
+}
+async function bothTablesExist(conn, changesTable) {
+  if (!await selectTableExists(conn, DEVICE_CURSORS_TABLE)) return false;
+  return selectTableExists(conn, changesTable);
+}
+async function dropExpiredDeviceCursors(conn, policy, changesTable = CHANGES_TABLE) {
+  if (!await bothTablesExist(conn, changesTable)) return 0;
+  const cutoff = Date.now() / 1e3 - policy.cursorRetentionMs / 1e3;
+  return deleteExpiredDeviceCursors(conn, changesTable, {
+    idleCutoff: cutoff,
+    changeAgeCutoff: cutoff,
+    maxChangesHeldForDevice: policy.maxChangesHeldForDevice
+  });
+}
+async function resolveMinDeviceCursorBoundary(conn, changesTable = CHANGES_TABLE) {
+  if (!await bothTablesExist(conn, changesTable)) return null;
+  return selectMinDeviceCursorBoundary(conn, changesTable);
+}
+async function applyDeviceCursorBoundary(conn, tracker, policy) {
+  const changesTable = tracker.changeLogTable;
+  await dropExpiredDeviceCursors(conn, policy, changesTable);
+  const boundary = await resolveMinDeviceCursorBoundary(conn, changesTable);
+  if (boundary === null) {
+    tracker.clearPruneBoundary("device-cursors");
+    return;
+  }
+  tracker.setPruneBoundary("device-cursors", boundary);
+}
+
 // src/core/cdc/epoch.ts
 var EPOCH_KEY = "cdc_epoch";
 async function ensureCdcEpoch(conn) {
@@ -563,7 +605,11 @@ async function ensureCdcEpoch(conn) {
 }
 
 // src/core/cdc/subscription.ts
+var NO_SUBSCRIBERS = /* @__PURE__ */ new Set();
 var SubscriptionManager = class {
+  constructor(onDispatched) {
+    this.onDispatched = onDispatched;
+  }
   nextId = 1;
   subscriptions = /* @__PURE__ */ new Map();
   byTable = /* @__PURE__ */ new Map();
@@ -592,15 +638,17 @@ var SubscriptionManager = class {
   }
   dispatch(events) {
     for (const event of events) {
-      const ids = this.byTable.get(event.table);
-      if (!ids) continue;
+      const ids = this.byTable.get(event.table) ?? NO_SUBSCRIBERS;
+      let deliveredTo = 0;
       for (const id of ids) {
         const sub = this.subscriptions.get(id);
         if (!sub) continue;
         const delivered = sub.filter === void 0 ? event : filteredChange(event, sub.filter);
         if (delivered === null) continue;
+        deliveredTo++;
         invokeCallerCallback(() => sub.callback(delivered), sub.onError);
       }
+      this.onDispatched?.(event, deliveredTo);
     }
   }
   reportError(error) {
@@ -640,7 +688,10 @@ var SubscriptionBuilderImpl = class {
     return this.manager.subscribe(this.table, this.conditions, callback, options);
   }
 };
-function startPolling(conn, tracker, manager, intervalMs, onError, runExclusive) {
+function startPolling(conn, tracker, manager, intervalMs, onError, runExclusive, deviceRetention = {
+  cursorRetentionMs: DEFAULT_DEVICE_CURSOR_RETENTION_MS,
+  maxChangesHeldForDevice: 0
+}) {
   let consecutiveErrors = 0;
   let tickCount = 0;
   let polling = false;
@@ -661,7 +712,10 @@ function startPolling(conn, tracker, manager, intervalMs, onError, runExclusive)
       tickCount++;
       if (tickCount >= CLEANUP_INTERVAL_TICKS) {
         tickCount = 0;
-        await exclusive(() => tracker.cleanup(conn));
+        await exclusive(async () => {
+          await applyDeviceCursorBoundary(conn, tracker, deviceRetention);
+          await tracker.cleanup(conn);
+        });
       }
     } catch (err) {
       consecutiveErrors++;
@@ -850,4 +904,4 @@ var TransactionGrouper = class {
   }
 };
 
-export { ChangeTracker, PrimedSubscription, SubscriptionBuilderImpl, SubscriptionManager, TransactionGrouper, ensureCdcEpoch, filteredChange, isBulkLoadDurability, migrationChecksum, migrationContentChecksum, needsResync, reconcileMigrationChecksums, runBulkLoad, startPolling };
+export { ChangeTracker, PrimedSubscription, SubscriptionBuilderImpl, SubscriptionManager, TransactionGrouper, applyDeviceCursorBoundary, ensureCdcEpoch, filteredChange, isBulkLoadDurability, migrationChecksum, migrationContentChecksum, needsResync, reconcileMigrationChecksums, resolveDeviceRetentionPolicy, runBulkLoad, startPolling };

package/dist/{chunk-SBL6GN43.mjs → chunk-ZYWI45EN.mjs}

@@ -1,4 +1,4 @@
-import { CDCError } from './chunk-PBRXXISQ.mjs';
+import { CDCError } from './chunk-KINDFBQP.mjs';
 
 // src/core/live/sql-tokens.ts
 var WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", "\f", "\v"]);