@delali/sirannon-db 0.1.3 → 0.1.4

package/dist/driver/better-sqlite3.d.ts

@@ -0,0 +1,8 @@
+import { S as SQLiteDriver } from '../types-BFSsG77t.js';
+
+interface BetterSqlite3Options {
+    busyTimeout?: number;
+}
+declare function betterSqlite3(driverOptions?: BetterSqlite3Options): SQLiteDriver;
+
+export { type BetterSqlite3Options, betterSqlite3 };

package/dist/driver/better-sqlite3.mjs

@@ -0,0 +1,63 @@
+import { defineDriver } from '../chunk-74UN4DIE.mjs';
+import '../chunk-O7BHI3CF.mjs';
+
+// src/drivers/better-sqlite3/index.ts
+function createConnection(db) {
+  const conn = {
+    async exec(sql) {
+      db.exec(sql);
+    },
+    async prepare(sql) {
+      const stmt = db.prepare(sql);
+      return {
+        async all(...params) {
+          return stmt.all(...params);
+        },
+        async get(...params) {
+          return stmt.get(...params);
+        },
+        async run(...params) {
+          const result = stmt.run(...params);
+          return {
+            changes: result.changes,
+            lastInsertRowId: result.lastInsertRowid
+          };
+        }
+      };
+    },
+    async transaction(fn) {
+      await conn.exec("BEGIN");
+      try {
+        const result = await fn(conn);
+        await conn.exec("COMMIT");
+        return result;
+      } catch (err) {
+        try {
+          await conn.exec("ROLLBACK");
+        } catch {
+        }
+        throw err;
+      }
+    },
+    async close() {
+      db.close();
+    }
+  };
+  return conn;
+}
+function betterSqlite3(driverOptions) {
+  return defineDriver({
+    capabilities: { multipleConnections: true, extensions: true },
+    async open(path, options) {
+      const Database = (await import('better-sqlite3')).default;
+      const db = new Database(path, { readonly: options?.readonly ?? false });
+      if (options?.walMode !== false) db.pragma("journal_mode = WAL");
+      db.pragma("synchronous = NORMAL");
+      db.pragma("foreign_keys = ON");
+      db.pragma(`busy_timeout = ${driverOptions?.busyTimeout ?? 5e3}`);
+      return createConnection(db);
+    }
+  });
+}
+
+export { betterSqlite3 };

package/dist/driver/bun.mjs

@@ -0,0 +1,61 @@
+import { defineDriver } from '../chunk-FB2U2Q3Y.mjs';
+
+// src/drivers/bun/index.ts
+function bunSqlite(driverOptions) {
+  return defineDriver({
+    capabilities: { multipleConnections: true, extensions: true },
+    async open(path, options) {
+      const { Database } = await import('bun:sqlite');
+      const db = new Database(path, { readonly: options?.readonly ?? false });
+      if (options?.walMode !== false) db.run("PRAGMA journal_mode = WAL");
+      db.run("PRAGMA synchronous = NORMAL");
+      db.run("PRAGMA foreign_keys = ON");
+      db.run(`PRAGMA busy_timeout = ${driverOptions?.busyTimeout ?? 5e3}`);
+      const conn = {
+        async exec(sql) {
+          db.run(sql);
+        },
+        async prepare(sql) {
+          const stmt = db.query(sql);
+          return {
+            async all(...params) {
+              return stmt.all(...params);
+            },
+            async get(...params) {
+              return stmt.get(...params) ?? void 0;
+            },
+            async run(...params) {
+              stmt.run(...params);
+              const changesStmt = db.query("SELECT changes() AS changes, last_insert_rowid() AS lastId");
+              const info = changesStmt.get();
+              return {
+                changes: info.changes,
+                lastInsertRowId: info.lastId
+              };
+            }
+          };
+        },
+        async transaction(fn) {
+          await conn.exec("BEGIN");
+          try {
+            const result = await fn(conn);
+            await conn.exec("COMMIT");
+            return result;
+          } catch (err) {
+            try {
+              await conn.exec("ROLLBACK");
+            } catch {
+            }
+            throw err;
+          }
+        },
+        async close() {
+          db.close();
+        }
+      };
+      return conn;
+    }
+  });
+}
+
+export { bunSqlite };

package/dist/driver/expo.mjs

@@ -0,0 +1,55 @@
+import { defineDriver } from '../chunk-FB2U2Q3Y.mjs';
+
+// src/drivers/expo/index.ts
+function expoSqlite() {
+  return defineDriver({
+    capabilities: { multipleConnections: false, extensions: false },
+    async open(path, options) {
+      const SQLite = await import('expo-sqlite');
+      const db = await SQLite.openDatabaseAsync(path, {
+        readOnly: options?.readonly
+      });
+      if (options?.walMode !== false) await db.execAsync("PRAGMA journal_mode = WAL");
+      await db.execAsync("PRAGMA synchronous = NORMAL");
+      await db.execAsync("PRAGMA foreign_keys = ON");
+      const buildConnectionFromHandle = (dbHandle) => ({
+        async exec(sql) {
+          await dbHandle.execAsync(sql);
+        },
+        async prepare(sql) {
+          return {
+            async all(...params) {
+              return dbHandle.getAllAsync(sql, params);
+            },
+            async get(...params) {
+              const row = await dbHandle.getFirstAsync(sql, params);
+              return row ?? void 0;
+            },
+            async run(...params) {
+              const result = await dbHandle.runAsync(sql, params);
+              return {
+                changes: result.changes,
+                lastInsertRowId: result.lastInsertRowId
+              };
+            }
+          };
+        },
+        async transaction(fn) {
+          let result;
+          await dbHandle.withExclusiveTransactionAsync(async (txDb) => {
+            const txConn = buildConnectionFromHandle(txDb);
+            result = await fn(txConn);
+          });
+          return result;
+        },
+        async close() {
+          await dbHandle.closeAsync();
+        }
+      });
+      const conn = buildConnectionFromHandle(db);
+      return conn;
+    }
+  });
+}
+
+export { expoSqlite };

package/dist/driver/node.d.ts

@@ -0,0 +1,8 @@
+import { S as SQLiteDriver } from '../types-BFSsG77t.js';
+
+interface NodeSqliteOptions {
+    busyTimeout?: number;
+}
+declare function nodeSqlite(driverOptions?: NodeSqliteOptions): SQLiteDriver;
+
+export { type NodeSqliteOptions, nodeSqlite };

package/dist/driver/node.mjs

@@ -0,0 +1,60 @@
+import { defineDriver } from '../chunk-74UN4DIE.mjs';
+import '../chunk-O7BHI3CF.mjs';
+
+// src/drivers/node/index.ts
+function nodeSqlite(driverOptions) {
+  return defineDriver({
+    capabilities: { multipleConnections: true, extensions: true },
+    async open(path, options) {
+      const { DatabaseSync } = await import('node:sqlite');
+      const db = new DatabaseSync(path, { readOnly: options?.readonly ?? false });
+      if (options?.walMode !== false) db.exec("PRAGMA journal_mode = WAL");
+      db.exec("PRAGMA synchronous = NORMAL");
+      db.exec("PRAGMA foreign_keys = ON");
+      db.exec(`PRAGMA busy_timeout = ${driverOptions?.busyTimeout ?? 5e3}`);
+      const conn = {
+        async exec(sql) {
+          db.exec(sql);
+        },
+        async prepare(sql) {
+          const stmt = db.prepare(sql);
+          return {
+            async all(...params) {
+              return stmt.all(...params);
+            },
+            async get(...params) {
+              return stmt.get(...params);
+            },
+            async run(...params) {
+              const result = stmt.run(...params);
+              return {
+                changes: Number(result.changes),
+                lastInsertRowId: result.lastInsertRowid
+              };
+            }
+          };
+        },
+        async transaction(fn) {
+          await conn.exec("BEGIN");
+          try {
+            const result = await fn(conn);
+            await conn.exec("COMMIT");
+            return result;
+          } catch (err) {
+            try {
+              await conn.exec("ROLLBACK");
+            } catch {
+            }
+            throw err;
+          }
+        },
+        async close() {
+          db.close();
+        }
+      };
+      return conn;
+    }
+  });
+}
+
+export { nodeSqlite };

package/dist/driver/wa-sqlite.d.ts

@@ -0,0 +1,34 @@
+interface RunResult {
+    changes: number;
+    lastInsertRowId: number | bigint;
+}
+interface SQLiteStatement {
+    all<T = unknown>(...params: unknown[]): Promise<T[]>;
+    get<T = unknown>(...params: unknown[]): Promise<T | undefined>;
+    run(...params: unknown[]): Promise<RunResult>;
+}
+interface SQLiteConnection {
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): Promise<SQLiteStatement>;
+    transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+interface OpenOptions {
+    readonly?: boolean;
+    walMode?: boolean;
+}
+interface DriverCapabilities {
+    multipleConnections: boolean;
+    extensions: boolean;
+}
+interface SQLiteDriver {
+    readonly capabilities: DriverCapabilities;
+    open(path: string, options?: OpenOptions): Promise<SQLiteConnection>;
+}
+
+interface WaSqliteOptions {
+    vfs?: 'IDBBatchAtomicVFS' | 'AccessHandlePoolVFS';
+}
+declare function waSqlite(driverOptions?: WaSqliteOptions): SQLiteDriver;
+
+export { type WaSqliteOptions, waSqlite };

package/dist/driver/wa-sqlite.mjs

@@ -0,0 +1,141 @@
+// 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
+  });
+}
+
+// src/drivers/wa-sqlite/index.ts
+function waSqlite(driverOptions) {
+  return defineDriver({
+    capabilities: { multipleConnections: false, extensions: false },
+    async open(path, options) {
+      const { default: SQLiteESMFactory } = await import('wa-sqlite/dist/wa-sqlite-async.mjs');
+      const { Factory } = await import('wa-sqlite');
+      const module = await SQLiteESMFactory();
+      const sqlite3 = Factory(module);
+      const vfsName = driverOptions?.vfs ?? "IDBBatchAtomicVFS";
+      if (vfsName === "AccessHandlePoolVFS") {
+        const { AccessHandlePoolVFS } = await import('../vfs-INWQ5DTE.mjs');
+        const vfs = new AccessHandlePoolVFS(path);
+        await vfs.isReady;
+        sqlite3.vfs_register(vfs, true);
+      } else {
+        const { IDBBatchAtomicVFS } = await import('../vfs-INWQ5DTE.mjs');
+        const vfs = new IDBBatchAtomicVFS(path);
+        await vfs.isReady;
+        sqlite3.vfs_register(vfs, true);
+      }
+      const db = await sqlite3.open_v2(path);
+      if (options?.walMode !== false) {
+        try {
+          await sqlite3.exec(db, "PRAGMA journal_mode = WAL");
+        } catch {
+        }
+      }
+      await sqlite3.exec(db, "PRAGMA synchronous = NORMAL");
+      await sqlite3.exec(db, "PRAGMA foreign_keys = ON");
+      async function execStatements(sql, params) {
+        const columns = [];
+        const rows = [];
+        let changes = 0;
+        let lastRowId = 0;
+        for await (const stmt of sqlite3.statements(db, sql)) {
+          if (params && params.length > 0) {
+            for (let i = 0; i < params.length; i++) {
+              sqlite3.bind(stmt, i + 1, params[i]);
+            }
+          }
+          const cols = sqlite3.column_names(stmt);
+          if (cols.length > 0 && columns.length === 0) {
+            columns.push(...cols);
+          }
+          while (await sqlite3.step(stmt) === 100) {
+            const row = [];
+            for (let i = 0; i < cols.length; i++) {
+              row.push(sqlite3.column(stmt, i));
+            }
+            rows.push(row);
+          }
+        }
+        changes = sqlite3.changes(db);
+        let rowIdCaptured = false;
+        await sqlite3.exec(db, "SELECT last_insert_rowid()", (row) => {
+          if (!rowIdCaptured && row[0] !== void 0) {
+            lastRowId = row[0];
+            rowIdCaptured = true;
+          }
+        });
+        return { columns, rows, changes, lastRowId };
+      }
+      const conn = {
+        async exec(sql) {
+          await sqlite3.exec(db, sql);
+        },
+        async prepare(sql) {
+          return {
+            async all(...params) {
+              const result = await execStatements(sql, params);
+              return result.rows.map((row) => {
+                const obj = {};
+                for (let i = 0; i < result.columns.length; i++) {
+                  obj[result.columns[i]] = row[i];
+                }
+                return obj;
+              });
+            },
+            async get(...params) {
+              const result = await execStatements(sql, params);
+              if (result.rows.length === 0) return void 0;
+              const obj = {};
+              for (let i = 0; i < result.columns.length; i++) {
+                obj[result.columns[i]] = result.rows[0][i];
+              }
+              return obj;
+            },
+            async run(...params) {
+              const result = await execStatements(sql, params);
+              return {
+                changes: result.changes,
+                lastInsertRowId: result.lastRowId
+              };
+            }
+          };
+        },
+        async transaction(fn) {
+          await conn.exec("BEGIN");
+          try {
+            const result = await fn(conn);
+            await conn.exec("COMMIT");
+            return result;
+          } catch (err) {
+            try {
+              await conn.exec("ROLLBACK");
+            } catch {
+            }
+            throw err;
+          }
+        },
+        async close() {
+          sqlite3.close(db);
+        }
+      };
+      return conn;
+    }
+  });
+}
+
+export { waSqlite };

package/dist/file-migrations/index.d.ts

@@ -0,0 +1,16 @@
+import { M as Migration } from '../types-DRkJlqex.js';
+import '../types-BFSsG77t.js';
+import '../types-DtDutWRU.js';
+
+interface ScannedMigration {
+    version: number;
+    name: string;
+    upPath: string;
+    downPath: string | null;
+}
+declare function scanDirectory(dirPath: string): ScannedMigration[];
+declare function readUpMigrations(scanned: ScannedMigration[]): Migration[];
+declare function readDownMigrations(scanned: ScannedMigration[], versions: number[]): Migration[];
+declare function loadMigrations(dirPath: string): Migration[];
+
+export { type ScannedMigration, loadMigrations, readDownMigrations, readUpMigrations, scanDirectory };

package/dist/file-migrations/index.mjs

@@ -0,0 +1,128 @@
+import { MigrationError } from '../chunk-O7BHI3CF.mjs';
+import { statSync, readdirSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+
+var MIGRATION_FILENAME_PATTERN = /^(\d+)_(\w+)\.(up|down)\.sql$/;
+function hasControlCharacters(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) <= 31) return true;
+  }
+  return false;
+}
+function scanDirectory(dirPath) {
+  if (hasControlCharacters(dirPath)) {
+    throw new MigrationError("Migration path contains invalid characters", 0, "MIGRATION_VALIDATION_ERROR");
+  }
+  const segments = dirPath.split(/[/\\]/);
+  if (segments.includes("..")) {
+    throw new MigrationError(
+      "Migration path must not contain directory traversal segments",
+      0,
+      "MIGRATION_VALIDATION_ERROR"
+    );
+  }
+  const resolvedPath = resolve(dirPath);
+  let stat;
+  try {
+    stat = statSync(resolvedPath);
+  } catch {
+    throw new MigrationError(`Migrations path does not exist: ${resolvedPath}`, 0);
+  }
+  if (!stat.isDirectory()) {
+    throw new MigrationError(`Migrations path is not a directory: ${resolvedPath}`, 0);
+  }
+  const entries = readdirSync(resolvedPath, { withFileTypes: true });
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const match = MIGRATION_FILENAME_PATTERN.exec(entry.name);
+    if (!match) continue;
+    const version = parseInt(match[1], 10);
+    const name = match[2];
+    const direction = match[3];
+    if (!Number.isFinite(version) || version <= 0 || !Number.isSafeInteger(version)) {
+      throw new MigrationError(`Invalid migration version: ${match[1]}`, version, "MIGRATION_VALIDATION_ERROR");
+    }
+    const existing = grouped.get(version);
+    if (existing && existing.name !== name) {
+      throw new MigrationError(
+        `Duplicate migration version ${version}: '${existing.name}' and '${name}'`,
+        version,
+        "MIGRATION_DUPLICATE_VERSION"
+      );
+    }
+    const filePath = join(resolvedPath, entry.name);
+    if (!existing) {
+      grouped.set(version, {
+        name,
+        [direction === "up" ? "upPath" : "downPath"]: filePath
+      });
+    } else {
+      if (direction === "up") existing.upPath = filePath;
+      else existing.downPath = filePath;
+    }
+  }
+  const results = [];
+  for (const [version, entry] of grouped) {
+    if (!entry.upPath) {
+      throw new MigrationError(
+        `Migration version ${version} (${entry.name}) is missing an .up.sql file`,
+        version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    results.push({
+      version,
+      name: entry.name,
+      upPath: entry.upPath,
+      downPath: entry.downPath ?? null
+    });
+  }
+  results.sort((a, b) => a.version - b.version);
+  return results;
+}
+function readUpMigrations(scanned) {
+  return scanned.map((entry) => {
+    const sql = readFileSync(entry.upPath, "utf-8").trim();
+    if (sql.length === 0) {
+      throw new MigrationError(`Migration file is empty: ${entry.upPath}`, entry.version, "MIGRATION_VALIDATION_ERROR");
+    }
+    return {
+      version: entry.version,
+      name: entry.name,
+      up: sql
+    };
+  });
+}
+function readDownMigrations(scanned, versions) {
+  const versionSet = new Set(versions);
+  const filtered = scanned.filter((s) => versionSet.has(s.version));
+  return filtered.map((entry) => {
+    if (!entry.downPath) {
+      throw new MigrationError(
+        `Migration version ${entry.version} (${entry.name}) has no .down.sql file`,
+        entry.version,
+        "MIGRATION_NO_DOWN"
+      );
+    }
+    const downSql = readFileSync(entry.downPath, "utf-8").trim();
+    if (downSql.length === 0) {
+      throw new MigrationError(
+        `Down migration file is empty: ${entry.downPath}`,
+        entry.version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    return {
+      version: entry.version,
+      name: entry.name,
+      up: "",
+      down: downSql
+    };
+  });
+}
+function loadMigrations(dirPath) {
+  return readUpMigrations(scanDirectory(dirPath));
+}
+
+export { loadMigrations, readDownMigrations, readUpMigrations, scanDirectory };

package/dist/index-hXiis3N-.d.ts

@@ -0,0 +1,16 @@
+import { a as SQLiteConnection } from './types-BFSsG77t.js';
+import { e as BackupScheduleOptions } from './types-DtDutWRU.js';
+
+declare class BackupManager {
+    backup(conn: SQLiteConnection, destPath: string): Promise<void>;
+    generateFilename(): string;
+    rotate(dir: string, maxFiles: number): void;
+}
+
+declare class BackupScheduler {
+    private readonly manager;
+    constructor(manager?: BackupManager);
+    schedule(conn: SQLiteConnection, options: BackupScheduleOptions): () => void;
+}
+
+export { BackupManager as B, BackupScheduler as a };