@delali/sirannon-db 0.3.5-next.69 → 0.3.5-next.72

package/README.md

@@ -131,6 +131,8 @@ const subscription = db
 
 With a filter, you receive each change in a row's membership of the set that the filter matches. When an order's `status` changes from `pending` to `shipped`, the handler receives an insert, because the row joins the set. When an order's `status` changes away from `shipped`, the handler receives a delete with the previous row in `oldRow`. Read `event.type` as the row joining or leaving the set, because the handler receives the same event for a real insert and for a row that joins the set.
 
+When a `REPLACE` deletes a stored row because the new row has the same primary key or the same value in a unique column, Sirannon calls the handler with a delete for that row before it calls the handler with the write. If your own `BEFORE` trigger on the table inserts or updates a row in the same statement and the `REPLACE` then deletes that row, Sirannon may report no delete for it.
+
 A live query holds the current result of a query and updates its rows from those same events:
 
 ```ts

package/dist/backup/index.d.ts

@@ -1,8 +1,8 @@
-import { B as BackupDestination, f as BackupRunReport } from '../types-Dc8oWlxj.js';
-export { g as BackupChain, h as BackupChainBase, i as BackupChainChange, j as BackupChainPosition, k as BackupChainRecord, l as BackupCycle, m as BackupCycleError, n as BackupCycleOptions, o as BackupCycleStatus, p as BackupFileReport, q as BackupGroupMembership, r as BackupGroupSource, s as BackupLogPosition, t as BackupNodePreference, u as BackupPiece, v as BackupProgress, w as BackupSkip, x as BackupSkipReason, y as BackupToDestinationOptions, z as BackupVerifyResult, C as DEFAULT_CHAIN_NAME, E as chainLogName, F as readBackupChains, G as verifyBackupRecord } from '../types-Dc8oWlxj.js';
-export { B as BackupCapabilities, a as BackupChainLocation, b as BackupRestorePlan, c as BackupSafeToDeleteOptions, d as backupPiecesSafeToDelete, p as planBackupRestore } from '../database-backup-DcLhxoa1.js';
-import { B as BackupRestoreOptions, a as BackupRestoreReport } from '../restore-options-CH8mE-Tb.js';
-export { b as BackupRestoreProgress } from '../restore-options-CH8mE-Tb.js';
+import { B as BackupDestination, g as BackupRunReport } from '../types-DTmi7pXp.js';
+export { h as BackupChain, i as BackupChainBase, j as BackupChainChange, k as BackupChainPosition, l as BackupChainRecord, m as BackupCycle, n as BackupCycleError, o as BackupCycleOptions, p as BackupCycleStatus, q as BackupFileReport, r as BackupGroupMembership, s as BackupGroupSource, t as BackupLogPosition, u as BackupNodePreference, v as BackupPiece, w as BackupProgress, x as BackupSkip, y as BackupSkipReason, z as BackupToDestinationOptions, C as BackupVerifyResult, E as DEFAULT_CHAIN_NAME, F as chainLogName, G as readBackupChains, H as verifyBackupRecord } from '../types-DTmi7pXp.js';
+export { B as BackupCapabilities, a as BackupChainLocation, b as BackupRestorePlan, c as BackupSafeToDeleteOptions, d as backupPiecesSafeToDelete, p as planBackupRestore } from '../database-backup-BwTNiBm2.js';
+import { B as BackupRestoreOptions, a as BackupRestoreReport } from '../restore-options-CcMukOLO.js';
+export { b as BackupRestoreProgress } from '../restore-options-CcMukOLO.js';
 import '../query-types-5B02ixH0.js';
 
 /** The byte and piece counts for one file that Sirannon assembles from a destination.

package/dist/backup/index.mjs

@@ -1,8 +1,9 @@
-export { assembleFromDestination, restoreBackup } from '../chunk-3BZLZ47R.mjs';
+export { assembleFromDestination, restoreBackup } from '../chunk-L6EX6K27.mjs';
 export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-YW7IKQ7T.mjs';
 export { verifyBackupRecord } from '../chunk-DX4WGJL7.mjs';
 import '../chunk-QGVRRKB2.mjs';
-import '../chunk-R7GBXNTO.mjs';
+import '../chunk-BUWJH3D3.mjs';
 export { DEFAULT_CHAIN_NAME, chainLogName, readBackupChains } from '../chunk-CZL4D3BM.mjs';
-import '../chunk-QBBLSQHQ.mjs';
+import '../chunk-BGJ5JVYL.mjs';
+import '../chunk-HO2XTXVX.mjs';
 import '../chunk-KINDFBQP.mjs';

package/dist/backup-scheduler/index.d.ts

@@ -1,5 +1,5 @@
-import { I as SQLiteConnection, J as BackupFileCopy, K as BackupRunRequest, f as BackupRunReport, L as BackupScheduleRequest } from '../types-Dc8oWlxj.js';
-export { p as BackupFileReport, O as BackupScheduleOptions, R as RunExclusive } from '../types-Dc8oWlxj.js';
+import { J as SQLiteConnection, K as BackupFileCopy, L as BackupRunRequest, g as BackupRunReport, O as BackupScheduleRequest } from '../types-DTmi7pXp.js';
+export { q as BackupFileReport, P as BackupScheduleOptions, R as RunExclusive } from '../types-DTmi7pXp.js';
 import '../query-types-5B02ixH0.js';
 
 /** What a runtime supplies so that Sirannon can send a copy to a destination without writing a local file.

package/dist/backup-scheduler/index.mjs

@@ -1,6 +1,7 @@
-export { BackupScheduler } from '../chunk-NVSQ2T5Q.mjs';
+export { BackupScheduler } from '../chunk-BTUD6XQO.mjs';
 import '../chunk-W67A4H2E.mjs';
-import '../chunk-KJLNYOOL.mjs';
-import '../chunk-R7GBXNTO.mjs';
-import '../chunk-QBBLSQHQ.mjs';
+import '../chunk-AHCMO4YL.mjs';
+import '../chunk-BUWJH3D3.mjs';
+import '../chunk-BGJ5JVYL.mjs';
+import '../chunk-HO2XTXVX.mjs';
 import '../chunk-KINDFBQP.mjs';

package/dist/{change-tracker-DqCdeEyx.d.ts → change-tracker-Dpo99EI-.d.ts}

@@ -1,7 +1,7 @@
-import { I as SQLiteConnection } from './types-Dc8oWlxj.js';
+import { J as SQLiteConnection } from './types-DTmi7pXp.js';
 import { C as ChangeEvent } from './query-types-5B02ixH0.js';
 
-type PruneBoundarySource = 'device-sync' | 'replication' | 'device-cursors';
+type PruneBoundarySource = 'device-sync' | 'device-push-cursor' | 'replication' | 'device-cursors';
 
 /**
  * Configures a change tracker's retention period, change log table, and poll size.
@@ -32,6 +32,7 @@ interface ChangeTrackerOptions {
  */
 declare class ChangeTracker {
     private readonly watched;
+    private readonly watchedByFoldedName;
     private lastSeq;
     private readonly retentionMs;
     private readonly changesTable;
@@ -42,24 +43,36 @@ declare class ChangeTracker {
     private readonly stmtCache;
     private readonly pruneBoundaries;
     private lastPollAtTxBoundary;
+    private watchQueue;
     constructor(options?: ChangeTrackerOptions);
     /**
      * Installs change-capture triggers on a table, so that every later write to it adds a row to the change log.
      *
+     * The tracker matches the name to an ordinary table as SQLite does, ignoring the case of ASCII letters, and records every change under the name that the schema stores. A name that matches no ordinary table, such as the name of a view or a virtual table, fails with `CDC_ERROR`. The tracker queues each call behind the one before it, so concurrent calls on one connection never open overlapping transactions.
+     *
      * @param conn - The writer connection on which the tracker creates the triggers.
      * @param table - The name of the table to watch.
      */
     watch(conn: SQLiteConnection, table: string): Promise<void>;
+    private watchNow;
     /**
      * Drops a table's change-capture triggers and removes the table from the watched set.
      *
      * @param conn - The writer connection on which the tracker drops the triggers.
-     * @param table - The name of the table to stop watching.
+     * @param table - The name of the table to stop watching, in any letter case.
      */
     unwatch(conn: SQLiteConnection, table: string): Promise<void>;
+    /**
+     * Returns the stored name of the watched table that a name refers to, ignoring the case of ASCII letters as SQLite does.
+     *
+     * @param table - The name to look up.
+     * @returns The stored name, or `undefined` when the tracker watches no such table.
+     * @internal
+     */
+    watchedTableNamed(table: string): string | undefined;
     /**
      * Rebuilds the change-capture triggers on `conn` for every watched table
-     * whose column list has changed, without opening a nested transaction.
+     * whose columns or unique keys have changed, without opening a nested transaction.
      *
      * 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
@@ -70,9 +83,11 @@ declare class ChangeTracker {
      * driver error or an invalid column name propagates to the caller, so that
      * the caller can roll back its transaction.
      *
+     * @param conn - The writer connection, which can hold an open transaction.
+     * @param rebuilt - The watched tables whose triggers the caller dropped, which the method installs again whether or not their shape changed.
      * @internal
      */
-    refreshAllTriggersUsingConnection(conn: SQLiteConnection): Promise<void>;
+    refreshAllTriggersUsingConnection(conn: SQLiteConnection, rebuilt?: ReadonlySet<string>): Promise<void>;
     /**
      * Drops the change-capture triggers of each named table that the tracker
      * watches, and removes that table from the watched set.
@@ -122,7 +137,9 @@ declare class ChangeTracker {
     private assertIdentifier;
     private detectChangesTable;
     private ensureChangesTable;
-    private installTriggers;
+    private readShape;
+    private markWatched;
+    private markUnwatched;
 }
 
-export { ChangeTracker as C, type ChangeTrackerOptions as a };
+export { ChangeTracker as C, type PruneBoundarySource as P, type ChangeTrackerOptions as a };

package/dist/{chunk-ADNWEHGZ.mjs → chunk-3VTT3VU6.mjs}

@@ -13,7 +13,7 @@ function toColumnValue(value) {
     return { intValue: value };
   }
   if (typeof value === "number") {
-    if (Number.isInteger(value)) {
+    if (Number.isSafeInteger(value)) {
       return { intValue: BigInt(value) };
     }
     return { floatValue: value };
@@ -91,7 +91,8 @@ function toBatchPayload(batch) {
     changes: batch.changes.map(toProtoChange),
     checksum: batch.checksum,
     groupId: batch.groupId ?? "",
-    primaryTerm: batch.primaryTerm ?? 0n
+    primaryTerm: batch.primaryTerm ?? 0n,
+    afterSeq: batch.afterSeq ?? 0n
   };
 }
 function fromBatchPayload(payload) {
@@ -107,7 +108,8 @@ function fromBatchPayload(payload) {
     changes: payload.changes.map(fromProtoChange),
     checksum: payload.checksum,
     groupId: payload.groupId || void 0,
-    primaryTerm: payload.primaryTerm === 0n ? void 0 : payload.primaryTerm
+    primaryTerm: payload.primaryTerm === 0n ? void 0 : payload.primaryTerm,
+    afterSeq: payload.afterSeq === 0n ? void 0 : payload.afterSeq
   };
 }
 function toAckPayload(ack) {
@@ -135,7 +137,8 @@ function toSyncRequestPayload(req) {
     completedTables: req.completedTables,
     groupId: req.groupId ?? "",
     primaryTerm: req.primaryTerm ?? 0n,
-    supportsStreamVerification: req.supportsStreamVerification === true
+    supportsStreamVerification: req.supportsStreamVerification === true,
+    historyTail: req.historyTail ? { hlc: req.historyTail.hlc, txId: req.historyTail.txId } : void 0
   };
 }
 function fromSyncRequestPayload(p) {
@@ -145,7 +148,8 @@ function fromSyncRequestPayload(p) {
     completedTables: p.completedTables,
     supportsStreamVerification: p.supportsStreamVerification === true ? true : void 0,
     groupId: p.groupId || void 0,
-    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm
+    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm,
+    historyTail: p.historyTail ? { hlc: p.historyTail.hlc, txId: p.historyTail.txId } : void 0
   };
 }
 function toSyncBatchPayload(batch) {
@@ -187,7 +191,9 @@ function toSyncCompletePayload(complete) {
       batchDigest: m.batchDigest ?? ""
     })),
     groupId: complete.groupId ?? "",
-    primaryTerm: complete.primaryTerm ?? 0n
+    primaryTerm: complete.primaryTerm ?? 0n,
+    historyPoint: complete.historyPoint ? { hlc: complete.historyPoint.hlc, txId: complete.historyPoint.txId } : void 0,
+    resumed: complete.resumed === true
   };
 }
 function fromSyncCompletePayload(p) {
@@ -203,7 +209,9 @@ function fromSyncCompletePayload(p) {
       })
     ),
     groupId: p.groupId || void 0,
-    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm
+    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm,
+    historyPoint: p.historyPoint ? { hlc: p.historyPoint.hlc, txId: p.historyPoint.txId } : void 0,
+    resumed: p.resumed === true ? true : void 0
   };
 }
 function toSyncAckPayload(ack) {

package/dist/chunk-75IBRE73.mjs

@@ -0,0 +1,55 @@
+import { withRowCounts, rowCountsOf } from './chunk-E2GRX4ZD.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
+
+// src/core/worker/protocol.ts
+function toWorkerGroupStatement(statement) {
+  return {
+    sql: statement.sql,
+    params: statement.params ? [...statement.params] : [],
+    ...statement.trusted === true ? { trusted: true } : {}
+  };
+}
+var WORKER_CANCELLED_CODE = "WRITER_WORKER_CANCELLED";
+var WORKER_BEGIN_FAILED_CODE = "WRITER_WORKER_BEGIN_FAILED";
+var KINDS_THAT_CARRY_BEGIN = /* @__PURE__ */ new Set([
+  "exec",
+  "run",
+  "get",
+  "all",
+  "allRaw",
+  "allCounted",
+  "getCounted",
+  "allRawCounted",
+  "runBatch",
+  "runBatchSummary"
+]);
+function canCarryBegin(kind) {
+  return KINDS_THAT_CARRY_BEGIN.has(kind);
+}
+function leftTransactionUnbegun(error) {
+  return error.code === WORKER_BEGIN_FAILED_CODE || error.code === WORKER_CANCELLED_CODE;
+}
+var WORKER_COPY_STOPPED_CODE = "WRITER_WORKER_COPY_STOPPED";
+function serializeError(err) {
+  if (err instanceof Error) {
+    const { code, sql } = err;
+    return withRowCounts(
+      {
+        message: err.message,
+        name: err.name,
+        ...typeof code === "string" ? { code } : {},
+        ...typeof sql === "string" ? { sql } : {},
+        ...err instanceof SirannonError ? { sirannonError: true } : {}
+      },
+      rowCountsOf(err)
+    );
+  }
+  return { message: String(err) };
+}
+function deserializeError(error) {
+  const err = error.sirannonError === true && error.code !== void 0 ? new SirannonError(error.message, error.code) : Object.assign(new Error(error.message), error.code === void 0 ? {} : { code: error.code });
+  if (error.name) err.name = error.name;
+  return withRowCounts(err, rowCountsOf(error));
+}
+
+export { WORKER_BEGIN_FAILED_CODE, WORKER_CANCELLED_CODE, WORKER_COPY_STOPPED_CODE, canCarryBegin, deserializeError, leftTransactionUnbegun, serializeError, toWorkerGroupStatement };

package/dist/{chunk-KJLNYOOL.mjs → chunk-AHCMO4YL.mjs}

@@ -1,8 +1,9 @@
-import { LOG_HEADER_BYTES, readLogHeader, logFrameOffset, readValidLogFrame } from './chunk-R7GBXNTO.mjs';
+import { LOG_HEADER_BYTES, readLogHeader, logFrameOffset, readValidLogFrame } from './chunk-BUWJH3D3.mjs';
 import { SirannonError } from './chunk-KINDFBQP.mjs';
 import { open } from 'fs/promises';
 
 var READ_CHUNK_BYTES = 4 * 1024 * 1024;
+var LOG_POSITION_READ_ATTEMPTS = 5;
 async function openForReading(path) {
   try {
     return await open(path, "r");
@@ -120,19 +121,27 @@ function logPathFor(sourcePath) {
 async function readLogPosition(sourcePath) {
   const logPath = logPathFor(sourcePath);
   try {
-    const header = await readLogFileHeader(logPath);
-    if (!header) return void 0;
-    const scan = await scanLogFrames(logPath, header, { frame: 0, checksum: header.checksum });
-    return {
-      logSequence: header.logSequence,
-      salt1: header.salt1,
-      salt2: header.salt2,
-      lastFrame: scan.lastCommitFrame
-    };
+    for (let attempt = 0; attempt < LOG_POSITION_READ_ATTEMPTS; attempt++) {
+      const header = await readLogFileHeader(logPath);
+      if (!header) return void 0;
+      const scan = await scanLogFrames(logPath, header, { frame: 0, checksum: header.checksum });
+      const headerAfterScan = await readLogFileHeader(logPath);
+      if (headerAfterScan === void 0 || !sameGeneration(header, headerAfterScan)) continue;
+      return {
+        logSequence: header.logSequence,
+        salt1: header.salt1,
+        salt2: header.salt2,
+        lastFrame: scan.lastCommitFrame
+      };
+    }
+    return void 0;
   } catch {
     return void 0;
   }
 }
+function sameGeneration(first, second) {
+  return first.logSequence === second.logSequence && first.salt1 === second.salt1 && first.salt2 === second.salt2;
+}
 function cursorChecksum(cursor) {
   return { first: cursor.checksum1, second: cursor.checksum2 };
 }