@delali/sirannon-db 0.1.1 → 0.1.4

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

@@ -1,91 +1,4 @@
-// src/core/errors.ts
-var SirannonError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "SirannonError";
-  }
-};
-var DatabaseNotFoundError = class extends SirannonError {
-  constructor(id) {
-    super(`Database '${id}' not found`, "DATABASE_NOT_FOUND");
-    this.name = "DatabaseNotFoundError";
-  }
-};
-var DatabaseAlreadyExistsError = class extends SirannonError {
-  constructor(id) {
-    super(`Database '${id}' already exists`, "DATABASE_ALREADY_EXISTS");
-    this.name = "DatabaseAlreadyExistsError";
-  }
-};
-var ReadOnlyError = class extends SirannonError {
-  constructor(id) {
-    super(`Database '${id}' is read-only`, "READ_ONLY");
-    this.name = "ReadOnlyError";
-  }
-};
-var QueryError = class extends SirannonError {
-  constructor(message, sql) {
-    super(message, "QUERY_ERROR");
-    this.sql = sql;
-    this.name = "QueryError";
-  }
-};
-var TransactionError = class extends SirannonError {
-  constructor(message) {
-    super(message, "TRANSACTION_ERROR");
-    this.name = "TransactionError";
-  }
-};
-var MigrationError = class extends SirannonError {
-  constructor(message, version, code = "MIGRATION_ERROR") {
-    super(message, code);
-    this.version = version;
-    this.name = "MigrationError";
-  }
-};
-var HookDeniedError = class extends SirannonError {
-  constructor(hookName, reason) {
-    super(
-      reason ? `Hook '${hookName}' denied the operation: ${reason}` : `Hook '${hookName}' denied the operation`,
-      "HOOK_DENIED"
-    );
-    this.name = "HookDeniedError";
-  }
-};
-var CDCError = class extends SirannonError {
-  constructor(message) {
-    super(message, "CDC_ERROR");
-    this.name = "CDCError";
-  }
-};
-var BackupError = class extends SirannonError {
-  constructor(message) {
-    super(message, "BACKUP_ERROR");
-    this.name = "BackupError";
-  }
-};
-var ConnectionPoolError = class extends SirannonError {
-  constructor(message) {
-    super(message, "CONNECTION_POOL_ERROR");
-    this.name = "ConnectionPoolError";
-  }
-};
-var MaxDatabasesError = class extends SirannonError {
-  constructor(max) {
-    super(`Maximum number of open databases (${max}) reached`, "MAX_DATABASES");
-    this.name = "MaxDatabasesError";
-  }
-};
-var ExtensionError = class extends SirannonError {
-  constructor(path, cause) {
-    super(
-      cause ? `Failed to load extension '${path}': ${cause}` : `Failed to load extension '${path}'`,
-      "EXTENSION_ERROR"
-    );
-    this.name = "ExtensionError";
-  }
-};
+import { CDCError } from './chunk-O7BHI3CF.mjs';
 
 // src/core/cdc/change-tracker.ts
 var DEFAULT_RETENTION_MS = 36e5;
@@ -107,46 +20,50 @@ var ChangeTracker = class {
     this.pollBatchSize = options?.pollBatchSize ?? DEFAULT_POLL_BATCH_SIZE;
     this.assertIdentifier(this.changesTable, "changes table name");
   }
-  watch(db, table) {
+  async watch(conn, table) {
     this.assertIdentifier(table, "table name");
-    this.ensureChangesTable(db);
-    const columns = this.getColumns(db, table);
+    await this.ensureChangesTable(conn);
+    const columns = await this.getColumns(conn, table);
     if (columns.length === 0) {
       throw new CDCError(`Table '${table}' does not exist or has no columns`);
     }
     for (const col of columns) {
       this.assertIdentifier(col, `column name in table '${table}'`);
     }
-    const pkColumns = this.getPkColumns(db, table);
+    const pkColumns = await this.getPkColumns(conn, table);
     const existing = this.watched.get(table);
     if (existing) {
       const same = existing.columns.length === columns.length && existing.columns.every((col, i) => col === columns[i]);
       if (same) {
         return;
       }
-      this.dropTriggers(db, table);
+      await conn.transaction(async (txConn) => {
+        await this.dropTriggers(txConn, table);
+        await this.installTriggers(txConn, table, columns, pkColumns);
+      });
+    } else {
+      await this.installTriggers(conn, table, columns, pkColumns);
     }
-    this.installTriggers(db, table, columns, pkColumns);
     this.watched.set(table, { table, columns, pkColumns });
     this.watchedTablesCache = null;
   }
-  unwatch(db, table) {
+  async unwatch(conn, table) {
     if (!this.watched.has(table)) {
       return;
     }
-    this.dropTriggers(db, table);
+    await this.dropTriggers(conn, table);
     this.watched.delete(table);
     this.watchedTablesCache = null;
   }
-  poll(db) {
+  async poll(conn) {
     if (!this.changesTableReady) {
-      this.detectChangesTable(db);
+      await this.detectChangesTable(conn);
       if (!this.changesTableReady) {
         return [];
       }
     }
-    const stmt = this.getStmt(
-      db,
+    const stmt = await this.getStmt(
+      conn,
       "poll",
       `SELECT seq, table_name, operation, row_id, changed_at, old_data, new_data
 			 FROM "${this.changesTable}"
@@ -154,7 +71,7 @@ var ChangeTracker = class {
 			 ORDER BY seq ASC
 			 LIMIT ?`
     );
-    const rows = stmt.all(this.lastSeq, this.pollBatchSize);
+    const rows = await stmt.all(this.lastSeq, this.pollBatchSize);
     if (rows.length === 0) {
       return [];
     }
@@ -172,24 +89,26 @@ var ChangeTracker = class {
     this.lastSeq = rows[rows.length - 1].seq;
     return events;
   }
-  cleanup(db) {
+  async cleanup(conn) {
     if (!this.changesTableReady) {
-      this.detectChangesTable(db);
+      await this.detectChangesTable(conn);
       if (!this.changesTableReady) {
         return 0;
       }
     }
     const cutoff = Date.now() / 1e3 - this.retentionMs / 1e3;
     if (this.lastSeq > 0) {
-      const stmt2 = this.getStmt(
-        db,
+      const stmt2 = await this.getStmt(
+        conn,
         "cleanup_coordinated",
         `DELETE FROM "${this.changesTable}" WHERE changed_at < ? AND seq <= ?`
       );
-      return stmt2.run(cutoff, this.lastSeq).changes;
+      const result2 = await stmt2.run(cutoff, this.lastSeq);
+      return result2.changes;
     }
-    const stmt = this.getStmt(db, "cleanup", `DELETE FROM "${this.changesTable}" WHERE changed_at < ?`);
-    return stmt.run(cutoff).changes;
+    const stmt = await this.getStmt(conn, "cleanup", `DELETE FROM "${this.changesTable}" WHERE changed_at < ?`);
+    const result = await stmt.run(cutoff);
+    return result.changes;
   }
   get watchedTables() {
     if (!this.watchedTablesCache) {
@@ -204,17 +123,18 @@ var ChangeTracker = class {
       );
     }
   }
-  detectChangesTable(db) {
-    const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(this.changesTable);
+  async detectChangesTable(conn) {
+    const stmt = await conn.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?");
+    const row = await stmt.get(this.changesTable);
     if (row) {
       this.changesTableReady = true;
     }
   }
-  ensureChangesTable(db) {
+  async ensureChangesTable(conn) {
     if (this.changesTableReady) {
       return;
     }
-    db.exec(`
+    await conn.exec(`
 CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
   seq INTEGER PRIMARY KEY AUTOINCREMENT,
   table_name TEXT NOT NULL,
@@ -224,34 +144,42 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
   old_data TEXT,
   new_data TEXT
 )`);
-    db.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;
   }
-  getColumns(db, table) {
-    const info = db.prepare(`PRAGMA table_info("${table}")`).all();
+  async getColumns(conn, table) {
+    const stmt = await conn.prepare(`PRAGMA table_info("${table}")`);
+    const info = await stmt.all();
     return info.map((col) => col.name);
   }
-  getPkColumns(db, table) {
-    const info = db.prepare(`PRAGMA table_info("${table}")`).all();
+  async getPkColumns(conn, table) {
+    const stmt = await conn.prepare(`PRAGMA table_info("${table}")`);
+    const info = await stmt.all();
     return info.filter((col) => col.pk > 0).sort((a, b) => a.pk - b.pk).map((col) => col.name);
   }
-  dropTriggers(db, table) {
-    db.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_insert"`);
-    db.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_update"`);
-    db.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_delete"`);
+  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"`);
   }
-  getStmt(db, key, sql) {
-    let stmts = this.stmtCache.get(db);
+  async getStmt(conn, key, sql) {
+    let stmts = this.stmtCache.get(conn);
     if (!stmts) {
       stmts = /* @__PURE__ */ new Map();
-      this.stmtCache.set(db, stmts);
+      this.stmtCache.set(conn, stmts);
     }
-    let stmt = stmts.get(key);
-    if (!stmt) {
-      stmt = db.prepare(sql);
-      stmts.set(key, stmt);
+    const existing = stmts.get(key);
+    if (existing) return existing;
+    const pending = conn.prepare(sql);
+    stmts.set(key, pending);
+    try {
+      return await pending;
+    } catch (err) {
+      stmts.delete(key);
+      throw err;
     }
-    return stmt;
   }
   buildPkRef(pkColumns, ref) {
     if (pkColumns.length === 0) {
@@ -262,12 +190,12 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
     }
     return pkColumns.map((col) => `${ref}."${this.escId(col)}"`).join(" || '-' || ");
   }
-  installTriggers(db, table, columns, pkColumns) {
+  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");
-    db.exec(`
+    await conn.exec(`
 			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_insert"
 			AFTER INSERT ON "${table}"
 			BEGIN
@@ -275,7 +203,7 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
 				VALUES ('${table}', 'INSERT', ${newPk}, ${newJson});
 			END
 		`);
-    db.exec(`
+    await conn.exec(`
 			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_update"
 			AFTER UPDATE ON "${table}"
 			BEGIN
@@ -283,7 +211,7 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
 				VALUES ('${table}', 'UPDATE', ${newPk}, ${oldJson}, ${newJson});
 			END
 		`);
-    db.exec(`
+    await conn.exec(`
 			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_delete"
 			AFTER DELETE ON "${table}"
 			BEGIN
@@ -369,15 +297,18 @@ var SubscriptionBuilderImpl = class {
     return this.manager.subscribe(this.table, this.conditions, callback);
   }
 };
-function startPolling(db, tracker, manager, intervalMs, onError) {
+function startPolling(conn, tracker, manager, intervalMs, onError) {
   let consecutiveErrors = 0;
   let tickCount = 0;
+  let polling = false;
   const MAX_CONSECUTIVE_ERRORS = 10;
   const CLEANUP_INTERVAL_TICKS = 100;
-  const tick = () => {
+  const tick = async () => {
     if (manager.size === 0) return;
+    if (polling) return;
+    polling = true;
     try {
-      const events = tracker.poll(db);
+      const events = await tracker.poll(conn);
       if (events.length > 0) {
         manager.dispatch(events);
       }
@@ -385,7 +316,7 @@ function startPolling(db, tracker, manager, intervalMs, onError) {
       tickCount++;
       if (tickCount >= CLEANUP_INTERVAL_TICKS) {
         tickCount = 0;
-        tracker.cleanup(db);
+        await tracker.cleanup(conn);
       }
     } catch (err) {
       consecutiveErrors++;
@@ -395,10 +326,14 @@ function startPolling(db, tracker, manager, intervalMs, onError) {
       if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
         stop();
       }
+    } finally {
+      polling = false;
     }
   };
   const interval = setInterval(tick, intervalMs);
-  interval.unref();
+  if (typeof interval === "object" && "unref" in interval) {
+    interval.unref();
+  }
   const stop = () => {
     clearInterval(interval);
   };
@@ -414,4 +349,4 @@ function matchesFilter(event, filter) {
   return true;
 }
 
-export { BackupError, CDCError, ChangeTracker, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, SubscriptionBuilderImpl, SubscriptionManager, TransactionError, startPolling };
+export { ChangeTracker, SubscriptionBuilderImpl, SubscriptionManager, startPolling };

package/dist/chunk-FB2U2Q3Y.mjs

@@ -0,0 +1,21 @@
+// src/core/errors.ts
+var SirannonError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SirannonError";
+  }
+};
+
+// src/core/driver/define.ts
+function defineDriver(config) {
+  if (!config.capabilities || typeof config.open !== "function") {
+    throw new SirannonError("Driver must define capabilities and open()", "INVALID_DRIVER");
+  }
+  return Object.freeze({
+    capabilities: Object.freeze({ ...config.capabilities }),
+    open: config.open
+  });
+}
+
+export { defineDriver };

package/dist/chunk-O7BHI3CF.mjs

@@ -0,0 +1,90 @@
+// src/core/errors.ts
+var SirannonError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SirannonError";
+  }
+};
+var DatabaseNotFoundError = class extends SirannonError {
+  constructor(id) {
+    super(`Database '${id}' not found`, "DATABASE_NOT_FOUND");
+    this.name = "DatabaseNotFoundError";
+  }
+};
+var DatabaseAlreadyExistsError = class extends SirannonError {
+  constructor(id) {
+    super(`Database '${id}' already exists`, "DATABASE_ALREADY_EXISTS");
+    this.name = "DatabaseAlreadyExistsError";
+  }
+};
+var ReadOnlyError = class extends SirannonError {
+  constructor(id) {
+    super(`Database '${id}' is read-only`, "READ_ONLY");
+    this.name = "ReadOnlyError";
+  }
+};
+var QueryError = class extends SirannonError {
+  constructor(message, sql) {
+    super(message, "QUERY_ERROR");
+    this.sql = sql;
+    this.name = "QueryError";
+  }
+};
+var TransactionError = class extends SirannonError {
+  constructor(message) {
+    super(message, "TRANSACTION_ERROR");
+    this.name = "TransactionError";
+  }
+};
+var MigrationError = class extends SirannonError {
+  constructor(message, version, code = "MIGRATION_ERROR") {
+    super(message, code);
+    this.version = version;
+    this.name = "MigrationError";
+  }
+};
+var HookDeniedError = class extends SirannonError {
+  constructor(hookName, reason) {
+    super(
+      reason ? `Hook '${hookName}' denied the operation: ${reason}` : `Hook '${hookName}' denied the operation`,
+      "HOOK_DENIED"
+    );
+    this.name = "HookDeniedError";
+  }
+};
+var CDCError = class extends SirannonError {
+  constructor(message) {
+    super(message, "CDC_ERROR");
+    this.name = "CDCError";
+  }
+};
+var BackupError = class extends SirannonError {
+  constructor(message) {
+    super(message, "BACKUP_ERROR");
+    this.name = "BackupError";
+  }
+};
+var ConnectionPoolError = class extends SirannonError {
+  constructor(message) {
+    super(message, "CONNECTION_POOL_ERROR");
+    this.name = "ConnectionPoolError";
+  }
+};
+var MaxDatabasesError = class extends SirannonError {
+  constructor(max) {
+    super(`Maximum number of open databases (${max}) reached`, "MAX_DATABASES");
+    this.name = "MaxDatabasesError";
+  }
+};
+var ExtensionError = class extends SirannonError {
+  constructor(path, cause) {
+    super(
+      cause ? `Failed to load extension '${path}': ${cause}` : `Failed to load extension '${path}'`,
+      "EXTENSION_ERROR"
+    );
+    this.name = "ExtensionError";
+  }
+};
+
+export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError };

package/dist/chunk-PXKAKK2V.mjs

@@ -0,0 +1,124 @@
+import { BackupError } from './chunk-O7BHI3CF.mjs';
+import { existsSync, mkdirSync, rmSync, readdirSync, lstatSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { Cron } from 'croner';
+
+var BACKUP_FILE_PREFIX = "backup";
+function hasControlCharacters(s) {
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code <= 31) return true;
+  }
+  return false;
+}
+var BackupManager = class {
+  async backup(conn, destPath) {
+    if (hasControlCharacters(destPath)) {
+      throw new BackupError("Backup path contains invalid characters");
+    }
+    const segments = destPath.split(/[/\\]/);
+    if (segments.includes("..")) {
+      throw new BackupError("Backup path must not contain directory traversal segments");
+    }
+    const resolved = resolve(destPath);
+    const dir = dirname(resolved);
+    if (!existsSync(dir)) {
+      try {
+        mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        throw new BackupError(
+          `Failed to create backup directory '${dir}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    if (existsSync(resolved)) {
+      throw new BackupError(`Backup destination '${destPath}' already exists`);
+    }
+    const escaped = resolved.replace(/'/g, "''");
+    try {
+      await conn.exec(`VACUUM INTO '${escaped}'`);
+    } catch (err) {
+      try {
+        rmSync(resolved, { force: true });
+      } catch {
+      }
+      throw new BackupError(`Backup to '${destPath}' failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  generateFilename() {
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    return `${BACKUP_FILE_PREFIX}-${ts}.db`;
+  }
+  rotate(dir, maxFiles) {
+    if (maxFiles <= 0) return;
+    const resolved = resolve(dir);
+    if (!existsSync(resolved)) return;
+    let entries;
+    try {
+      entries = readdirSync(resolved).filter((f) => f.startsWith(`${BACKUP_FILE_PREFIX}-`) && f.endsWith(".db")).map((f) => {
+        const filePath = join(resolved, f);
+        return { path: filePath, mtimeMs: lstatSync(filePath).mtimeMs };
+      }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+    } catch (err) {
+      throw new BackupError(
+        `Failed to list backup files in '${dir}': ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    for (const entry of entries.slice(maxFiles)) {
+      try {
+        rmSync(entry.path, { force: true });
+      } catch {
+      }
+    }
+  }
+};
+var DEFAULT_MAX_FILES = 5;
+var BackupScheduler = class {
+  manager;
+  constructor(manager) {
+    this.manager = manager ?? new BackupManager();
+  }
+  schedule(conn, options) {
+    const { cron: cronExpr, destDir, maxFiles = DEFAULT_MAX_FILES, onError } = options;
+    const resolvedDir = resolve(destDir);
+    if (!existsSync(resolvedDir)) {
+      try {
+        mkdirSync(resolvedDir, { recursive: true });
+      } catch (err) {
+        throw new BackupError(
+          `Failed to create backup directory '${destDir}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    let job;
+    try {
+      job = new Cron(
+        cronExpr,
+        {
+          unref: true,
+          catch: (err) => {
+            if (onError) {
+              const error = err instanceof Error ? err : new BackupError(typeof err === "string" ? err : "Scheduled backup failed");
+              onError(error);
+            }
+          }
+        },
+        async () => {
+          const filename = this.manager.generateFilename();
+          const destPath = join(resolvedDir, filename);
+          await this.manager.backup(conn, destPath);
+          this.manager.rotate(resolvedDir, maxFiles);
+        }
+      );
+    } catch (err) {
+      throw new BackupError(
+        `Invalid cron expression '${cronExpr}': ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return () => {
+      job.stop();
+    };
+  }
+};
+
+export { BackupManager, BackupScheduler };

package/dist/client/index.d.ts

@@ -1,5 +1,41 @@
-import { P as Params, d as ChangeEvent, f as ClientOptions } from '../types-DArCObcu.js';
-import { c as QueryResponse, b as ExecuteResponse, d as TransactionResponse } from '../protocol-BX1H-_Mz.js';
+/** Query parameter types: named (object) or positional (array). */
+type Params = Record<string, unknown> | unknown[];
+/** CDC operation type. */
+type ChangeOperation = 'insert' | 'update' | 'delete';
+/** Event emitted when a watched table row changes. */
+interface ChangeEvent<T = Record<string, unknown>> {
+    type: ChangeOperation;
+    table: string;
+    row: T;
+    oldRow?: T;
+    seq: bigint;
+    timestamp: number;
+}
+/** Options for the client SDK. */
+interface ClientOptions {
+    /** Transport to use. Default: 'websocket'. */
+    transport?: 'websocket' | 'http';
+    /** Custom headers for HTTP requests. */
+    headers?: Record<string, string>;
+    /** Reconnect on WebSocket disconnect. Default: true. */
+    autoReconnect?: boolean;
+    /** Reconnect interval in ms. Default: 1000. */
+    reconnectInterval?: number;
+}
+
+/** Response for a successful query. */
+interface QueryResponse {
+    rows: Record<string, unknown>[];
+}
+/** Response for a successful execute. */
+interface ExecuteResponse {
+    changes: number;
+    lastInsertRowId: number | string;
+}
+/** Response for a successful transaction. */
+interface TransactionResponse {
+    results: ExecuteResponse[];
+}
 
 /**
  * Transport layer for communicating with a sirannon-db server.