@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/change-tracker-CFTQ9TSn.d.ts

@@ -0,0 +1,89 @@
+import { a as SQLiteConnection } from './types-BFSsG77t.js';
+import { C as ChangeEvent } from './types-D-74JiXb.js';
+
+interface ChangeTrackerOptions {
+    retention?: number;
+    changesTable?: string;
+    pollBatchSize?: number;
+    replication?: boolean;
+}
+
+declare class ChangeTracker {
+    private readonly watched;
+    private lastSeq;
+    private readonly retentionMs;
+    private readonly changesTable;
+    private readonly pollBatchSize;
+    private readonly replication;
+    private changesTableReady;
+    private watchedTablesCache;
+    private readonly stmtCache;
+    private pruneBoundary;
+    constructor(options?: ChangeTrackerOptions);
+    watch(conn: SQLiteConnection, table: string): Promise<void>;
+    unwatch(conn: SQLiteConnection, table: string): Promise<void>;
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    refreshAllTriggersUsingConnection(conn: SQLiteConnection): Promise<void>;
+    /**
+     * Removes the supplied tables from the watched map and drops any leftover
+     * CDC triggers carrying their identifier on the supplied connection.
+     *
+     * 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.
+     */
+    pruneDroppedTables(conn: SQLiteConnection, tables: readonly string[]): Promise<void>;
+    poll(conn: SQLiteConnection): Promise<ChangeEvent[]>;
+    advanceToLatest(conn: SQLiteConnection): Promise<void>;
+    cleanup(conn: SQLiteConnection): Promise<number>;
+    setPruneBoundary(seq: bigint): void;
+    clearPruneBoundary(): void;
+    get watchedTables(): ReadonlySet<string>;
+    private computeSeqBound;
+    private assertIdentifier;
+    private detectChangesTable;
+    private ensureChangesTable;
+    private getColumns;
+    private getPkColumns;
+    private dropTriggers;
+    private getStmt;
+    private installTriggers;
+}
+
+export { ChangeTracker as C, type ChangeTrackerOptions as a };

package/dist/chunk-3MCMONVP.mjs

@@ -0,0 +1,115 @@
+import { QueryError } from './chunk-O7BHI3CF.mjs';
+
+// src/core/query-executor.ts
+var STATEMENT_CACHE_CAPACITY = 128;
+var statementCaches = /* @__PURE__ */ new WeakMap();
+async function getStatement(conn, sql) {
+  let cache = statementCaches.get(conn);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    statementCaches.set(conn, cache);
+  }
+  const cached = cache.get(sql);
+  if (cached) {
+    cache.delete(sql);
+    cache.set(sql, cached);
+    return cached;
+  }
+  const pending = conn.prepare(sql);
+  cache.set(sql, pending);
+  if (cache.size > STATEMENT_CACHE_CAPACITY) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) {
+      cache.delete(oldest);
+    }
+  }
+  try {
+    return await pending;
+  } catch (err) {
+    cache.delete(sql);
+    throw err;
+  }
+}
+function bindParams(params) {
+  if (params === void 0) return [];
+  if (Array.isArray(params)) return params;
+  return [params];
+}
+async function query(conn, sql, params) {
+  try {
+    const stmt = await getStatement(conn, sql);
+    return await stmt.all(...bindParams(params));
+  } catch (err) {
+    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
+  }
+}
+async function queryOne(conn, sql, params) {
+  try {
+    const stmt = await getStatement(conn, sql);
+    return await stmt.get(...bindParams(params));
+  } catch (err) {
+    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
+  }
+}
+async function execute(conn, sql, params) {
+  try {
+    const stmt = await getStatement(conn, sql);
+    const result = await stmt.run(...bindParams(params));
+    return {
+      changes: result.changes,
+      lastInsertRowId: result.lastInsertRowId
+    };
+  } catch (err) {
+    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
+  }
+}
+async function executeBatch(conn, sql, paramsBatch) {
+  try {
+    const stmt = await getStatement(conn, sql);
+    const results = [];
+    for (const params of paramsBatch) {
+      const result = await stmt.run(...bindParams(params));
+      results.push({
+        changes: result.changes,
+        lastInsertRowId: result.lastInsertRowId
+      });
+    }
+    return results;
+  } catch (err) {
+    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
+  }
+}
+
+// src/core/transaction.ts
+var Transaction = class _Transaction {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  _lastInsertRowId = 0;
+  async query(sql, params) {
+    return query(this.conn, sql, params);
+  }
+  async execute(sql, params) {
+    const result = await execute(this.conn, sql, params);
+    this._lastInsertRowId = result.lastInsertRowId;
+    return result;
+  }
+  async executeBatch(sql, paramsBatch) {
+    const results = await executeBatch(this.conn, sql, paramsBatch);
+    if (results.length > 0) {
+      this._lastInsertRowId = results[results.length - 1].lastInsertRowId;
+    }
+    return results;
+  }
+  get lastInsertRowId() {
+    return this._lastInsertRowId;
+  }
+  static async run(conn, fn) {
+    return conn.transaction(async (txConn) => {
+      const tx = new _Transaction(txConn);
+      return fn(tx);
+    });
+  }
+};
+
+export { Transaction, execute, executeBatch, query, queryOne };

package/dist/chunk-ER7ODTDA.mjs

@@ -0,0 +1,23 @@
+// src/replication/coordinator/compatibility.ts
+function compatibilityAllowsPromotion(groupCompatibility, sessionCompatibility) {
+  if (!groupCompatibility) return true;
+  return compatibleMajorVersion(groupCompatibility.packageVersion, sessionCompatibility?.packageVersion) && compatibleMajorVersion(groupCompatibility.protocolVersion, sessionCompatibility?.protocolVersion) && compatibleMajorVersion(groupCompatibility.specVersion, sessionCompatibility?.specVersion);
+}
+function compatibleMajorVersion(required, candidate) {
+  if (!required) return true;
+  if (!candidate) return false;
+  const requiredMajor = parseMajorVersion(required);
+  const candidateMajor = parseMajorVersion(candidate);
+  if (requiredMajor === null || candidateMajor === null) {
+    return required === candidate;
+  }
+  return requiredMajor === candidateMajor;
+}
+function parseMajorVersion(version) {
+  const match = /^v?(\d+)/.exec(version);
+  if (!match) return null;
+  const major = match[1];
+  return major === void 0 ? null : Number(major);
+}
+
+export { compatibilityAllowsPromotion };

package/dist/chunk-GS7T5YMI.mjs

@@ -0,0 +1,51 @@
+// src/core/cdc/encoding.ts
+var BLOB_TAG = "__sirannon_blob";
+var INT_TAG = "__sirannon_int";
+var SAFE_INT_BOUND_TEXT = "9007199254740991";
+var HEX_BYTES_RE = /^[0-9a-fA-F]*$/;
+function decodeTaggedValues(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (isBinaryValue(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map(decodeTaggedValues);
+  }
+  const obj = value;
+  const keys = Object.keys(obj);
+  if (keys.length === 1) {
+    const tag = keys[0];
+    const tagValue = obj[tag];
+    if (tag === BLOB_TAG && typeof tagValue === "string") {
+      return decodeHexBytes(tagValue);
+    }
+    if (tag === INT_TAG && typeof tagValue === "string") {
+      return BigInt(tagValue);
+    }
+  }
+  const out = {};
+  for (const k of keys) {
+    out[k] = decodeTaggedValues(obj[k]);
+  }
+  return out;
+}
+function isBinaryValue(value) {
+  return value instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(value);
+}
+function decodeHexBytes(hex) {
+  if (hex.length % 2 !== 0 || !HEX_BYTES_RE.test(hex)) {
+    throw new Error("Invalid CDC BLOB hex payload");
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(hex, "hex");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = Number.parseInt(hex.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Invalid CDC BLOB hex payload");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+
+export { SAFE_INT_BOUND_TEXT, decodeTaggedValues };

package/dist/{chunk-AX66KWBR.mjs → chunk-UTO3ZAFS.mjs}

@@ -1,5 +1,67 @@
+import { decodeTaggedValues, SAFE_INT_BOUND_TEXT } from './chunk-GS7T5YMI.mjs';
 import { CDCError } from './chunk-O7BHI3CF.mjs';
 
+// src/core/cdc/trigger-sql.ts
+async function dropCdcTriggers(conn, table) {
+  await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_insert"`);
+  await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_update"`);
+  await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_delete"`);
+}
+async function installCdcTriggers(conn, changesTable, table, columns, pkColumns, replication) {
+  const newJson = buildJsonObject(columns, "NEW");
+  const oldJson = buildJsonObject(columns, "OLD");
+  const newPk = buildPkRef(pkColumns, "NEW");
+  const oldPk = buildPkRef(pkColumns, "OLD");
+  const replCols = replication ? ", node_id, tx_id, hlc" : "";
+  const replVals = replication ? ", '', '', ''" : "";
+  await conn.exec(`
+			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_insert"
+			AFTER INSERT ON "${table}"
+			BEGIN
+				INSERT INTO "${changesTable}" (table_name, operation, row_id, new_data${replCols})
+				VALUES ('${table}', 'INSERT', ${newPk}, ${newJson}${replVals});
+			END
+		`);
+  await conn.exec(`
+			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_update"
+			AFTER UPDATE ON "${table}"
+			BEGIN
+				INSERT INTO "${changesTable}" (table_name, operation, row_id, old_data, new_data${replCols})
+				VALUES ('${table}', 'UPDATE', ${newPk}, ${oldJson}, ${newJson}${replVals});
+			END
+		`);
+  await conn.exec(`
+			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_delete"
+			AFTER DELETE ON "${table}"
+			BEGIN
+				INSERT INTO "${changesTable}" (table_name, operation, row_id, old_data${replCols})
+				VALUES ('${table}', 'DELETE', ${oldPk}, ${oldJson}${replVals});
+			END
+		`);
+}
+function buildPkRef(pkColumns, ref) {
+  if (pkColumns.length === 0) {
+    return `${ref}.rowid`;
+  }
+  if (pkColumns.length === 1) {
+    return `${ref}."${escId(pkColumns[0])}"`;
+  }
+  return pkColumns.map((col) => `${ref}."${escId(col)}"`).join(" || '-' || ");
+}
+function buildJsonObject(columns, ref) {
+  const pairs = columns.map((col) => {
+    const ident = `${ref}."${escId(col)}"`;
+    return `'${escStr(col)}', CASE typeof(${ident}) WHEN 'blob' THEN json(json_object('__sirannon_blob', hex(${ident}))) WHEN 'integer' THEN CASE WHEN ${ident} > ${SAFE_INT_BOUND_TEXT} OR ${ident} < -${SAFE_INT_BOUND_TEXT} THEN json(json_object('__sirannon_int', printf('%d', ${ident}))) ELSE ${ident} END ELSE ${ident} END`;
+  }).join(", ");
+  return `json_object(${pairs})`;
+}
+function escId(name) {
+  return name.replace(/"/g, '""');
+}
+function escStr(name) {
+  return name.replace(/'/g, "''");
+}
+
 // src/core/cdc/change-tracker.ts
 var DEFAULT_RETENTION_MS = 36e5;
 var DEFAULT_CHANGES_TABLE = "_sirannon_changes";
@@ -7,17 +69,20 @@ var DEFAULT_POLL_BATCH_SIZE = 1e3;
 var IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var ChangeTracker = class {
   watched = /* @__PURE__ */ new Map();
-  lastSeq = 0;
+  lastSeq = 0n;
   retentionMs;
   changesTable;
   pollBatchSize;
+  replication;
   changesTableReady = false;
   watchedTablesCache = null;
   stmtCache = /* @__PURE__ */ new WeakMap();
+  pruneBoundary = null;
   constructor(options) {
     this.retentionMs = options?.retention ?? DEFAULT_RETENTION_MS;
     this.changesTable = options?.changesTable ?? DEFAULT_CHANGES_TABLE;
     this.pollBatchSize = options?.pollBatchSize ?? DEFAULT_POLL_BATCH_SIZE;
+    this.replication = options?.replication ?? false;
     this.assertIdentifier(this.changesTable, "changes table name");
   }
   async watch(conn, table) {
@@ -55,6 +120,92 @@ var ChangeTracker = class {
     this.watched.delete(table);
     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.
+   *
+   * 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.
+   */
+  async refreshAllTriggersUsingConnection(conn) {
+    const tables = Array.from(this.watched.keys());
+    let anyMutated = false;
+    for (const table of tables) {
+      const existing = this.watched.get(table);
+      if (!existing) continue;
+      const columns = await this.getColumns(conn, table);
+      if (columns.length === 0) {
+        continue;
+      }
+      for (const col of columns) {
+        this.assertIdentifier(col, `column name in table '${table}'`);
+      }
+      const same = existing.columns.length === columns.length && existing.columns.every((col, i) => col === columns[i]);
+      if (same) {
+        continue;
+      }
+      const pkColumns = await this.getPkColumns(conn, table);
+      await this.dropTriggers(conn, table);
+      await this.installTriggers(conn, table, columns, pkColumns);
+      this.watched.set(table, { table, columns, pkColumns });
+      anyMutated = true;
+    }
+    if (anyMutated) {
+      this.watchedTablesCache = null;
+    }
+  }
+  /**
+   * Removes the supplied tables from the watched map and drops any leftover
+   * CDC triggers carrying their identifier on the supplied connection.
+   *
+   * 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.
+   */
+  async pruneDroppedTables(conn, tables) {
+    let mutated = false;
+    for (const table of tables) {
+      if (!this.watched.has(table)) {
+        continue;
+      }
+      await this.dropTriggers(conn, table);
+      this.watched.delete(table);
+      mutated = true;
+    }
+    if (mutated) {
+      this.watchedTablesCache = null;
+    }
+  }
   async poll(conn) {
     if (!this.changesTableReady) {
       await this.detectChangesTable(conn);
@@ -71,7 +222,7 @@ var ChangeTracker = class {
 			 ORDER BY seq ASC
 			 LIMIT ?`
     );
-    const rows = await stmt.all(this.lastSeq, this.pollBatchSize);
+    const rows = await stmt.all(this.lastSeq.toString(), this.pollBatchSize);
     if (rows.length === 0) {
       return [];
     }
@@ -80,15 +231,33 @@ var ChangeTracker = class {
       events.push({
         type: row.operation.toLowerCase(),
         table: row.table_name,
-        row: row.new_data ? JSON.parse(row.new_data) : {},
-        oldRow: row.old_data ? JSON.parse(row.old_data) : void 0,
+        row: row.new_data ? decodeTaggedValues(JSON.parse(row.new_data)) : {},
+        oldRow: row.old_data ? decodeTaggedValues(JSON.parse(row.old_data)) : void 0,
         seq: BigInt(row.seq),
         timestamp: row.changed_at
       });
     }
-    this.lastSeq = rows[rows.length - 1].seq;
+    this.lastSeq = BigInt(rows[rows.length - 1].seq);
     return events;
   }
+  async advanceToLatest(conn) {
+    if (!this.changesTableReady) {
+      await this.detectChangesTable(conn);
+      if (!this.changesTableReady) {
+        return;
+      }
+    }
+    const stmt = await this.getStmt(conn, "latest_seq", `SELECT MAX(seq) AS seq FROM "${this.changesTable}"`);
+    const row = await stmt.get();
+    const seq = row?.seq;
+    if (seq === void 0 || seq === null) {
+      return;
+    }
+    const latestSeq = typeof seq === "bigint" ? seq : BigInt(String(seq));
+    if (latestSeq > this.lastSeq) {
+      this.lastSeq = latestSeq;
+    }
+  }
   async cleanup(conn) {
     if (!this.changesTableReady) {
       await this.detectChangesTable(conn);
@@ -97,25 +266,45 @@ var ChangeTracker = class {
       }
     }
     const cutoff = Date.now() / 1e3 - this.retentionMs / 1e3;
-    if (this.lastSeq > 0) {
+    const seqBound = this.computeSeqBound();
+    if (seqBound !== null) {
       const stmt2 = await this.getStmt(
         conn,
         "cleanup_coordinated",
         `DELETE FROM "${this.changesTable}" WHERE changed_at < ? AND seq <= ?`
       );
-      const result2 = await stmt2.run(cutoff, this.lastSeq);
+      const result2 = await stmt2.run(cutoff, seqBound.toString());
       return result2.changes;
     }
     const stmt = await this.getStmt(conn, "cleanup", `DELETE FROM "${this.changesTable}" WHERE changed_at < ?`);
     const result = await stmt.run(cutoff);
     return result.changes;
   }
+  setPruneBoundary(seq) {
+    this.pruneBoundary = seq;
+  }
+  clearPruneBoundary() {
+    this.pruneBoundary = null;
+  }
   get watchedTables() {
     if (!this.watchedTablesCache) {
       this.watchedTablesCache = new Set(this.watched.keys());
     }
     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;
+  }
   assertIdentifier(name, label) {
     if (!IDENTIFIER_RE.test(name)) {
       throw new CDCError(
@@ -134,7 +323,29 @@ var ChangeTracker = class {
     if (this.changesTableReady) {
       return;
     }
-    await conn.exec(`
+    if (this.replication) {
+      await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
+  seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  table_name TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  row_id TEXT NOT NULL,
+  changed_at REAL NOT NULL DEFAULT (unixepoch('subsec')),
+  old_data TEXT,
+  new_data TEXT,
+  node_id TEXT NOT NULL DEFAULT '',
+  tx_id TEXT NOT NULL DEFAULT '',
+  hlc TEXT NOT NULL DEFAULT ''
+)`);
+      await conn.exec(
+        `CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_changed_at" ON "${this.changesTable}" (changed_at)`
+      );
+      await conn.exec(
+        `CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_node_id" ON "${this.changesTable}" (node_id)`
+      );
+      await conn.exec(`CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_hlc" ON "${this.changesTable}" (hlc)`);
+    } else {
+      await conn.exec(`
 CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
   seq INTEGER PRIMARY KEY AUTOINCREMENT,
   table_name TEXT NOT NULL,
@@ -144,9 +355,10 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
   old_data TEXT,
   new_data TEXT
 )`);
-    await conn.exec(
-      `CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_changed_at" ON "${this.changesTable}" (changed_at)`
-    );
+      await conn.exec(
+        `CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_changed_at" ON "${this.changesTable}" (changed_at)`
+      );
+    }
     this.changesTableReady = true;
   }
   async getColumns(conn, table) {
@@ -160,9 +372,7 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
     return info.filter((col) => col.pk > 0).sort((a, b) => a.pk - b.pk).map((col) => col.name);
   }
   async dropTriggers(conn, table) {
-    await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_insert"`);
-    await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_update"`);
-    await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_delete"`);
+    await dropCdcTriggers(conn, table);
   }
   async getStmt(conn, key, sql) {
     let stmts = this.stmtCache.get(conn);
@@ -181,54 +391,8 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
       throw err;
     }
   }
-  buildPkRef(pkColumns, ref) {
-    if (pkColumns.length === 0) {
-      return `${ref}.rowid`;
-    }
-    if (pkColumns.length === 1) {
-      return `${ref}."${this.escId(pkColumns[0])}"`;
-    }
-    return pkColumns.map((col) => `${ref}."${this.escId(col)}"`).join(" || '-' || ");
-  }
   async installTriggers(conn, table, columns, pkColumns) {
-    const newJson = this.buildJsonObject(columns, "NEW");
-    const oldJson = this.buildJsonObject(columns, "OLD");
-    const newPk = this.buildPkRef(pkColumns, "NEW");
-    const oldPk = this.buildPkRef(pkColumns, "OLD");
-    await conn.exec(`
-			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_insert"
-			AFTER INSERT ON "${table}"
-			BEGIN
-				INSERT INTO "${this.changesTable}" (table_name, operation, row_id, new_data)
-				VALUES ('${table}', 'INSERT', ${newPk}, ${newJson});
-			END
-		`);
-    await conn.exec(`
-			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_update"
-			AFTER UPDATE ON "${table}"
-			BEGIN
-				INSERT INTO "${this.changesTable}" (table_name, operation, row_id, old_data, new_data)
-				VALUES ('${table}', 'UPDATE', ${newPk}, ${oldJson}, ${newJson});
-			END
-		`);
-    await conn.exec(`
-			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_delete"
-			AFTER DELETE ON "${table}"
-			BEGIN
-				INSERT INTO "${this.changesTable}" (table_name, operation, row_id, old_data)
-				VALUES ('${table}', 'DELETE', ${oldPk}, ${oldJson});
-			END
-		`);
-  }
-  buildJsonObject(columns, ref) {
-    const pairs = columns.map((col) => `'${this.escStr(col)}', ${ref}."${this.escId(col)}"`).join(", ");
-    return `json_object(${pairs})`;
-  }
-  escId(name) {
-    return name.replace(/"/g, '""');
-  }
-  escStr(name) {
-    return name.replace(/'/g, "''");
+    await installCdcTriggers(conn, this.changesTable, table, columns, pkColumns, this.replication);
   }
 };
 
@@ -331,9 +495,7 @@ function startPolling(conn, tracker, manager, intervalMs, onError) {
     }
   };
   const interval = setInterval(tick, intervalMs);
-  if (typeof interval === "object" && "unref" in interval) {
-    interval.unref();
-  }
+  interval.unref?.();
   const stop = () => {
     clearInterval(interval);
   };