@monlite/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
-import Database from 'better-sqlite3';
 import { randomBytes } from 'crypto';
+import { createRequire } from 'module';
 
-// src/db.ts
+// src/id.ts
 var PROCESS_UNIQUE = randomBytes(5);
 var counter = randomBytes(3).readUIntBE(0, 3);
 function objectId() {
@@ -439,7 +439,7 @@ var Collection = class {
   initialized = false;
   trackPath = (path) => this.mon.autoIndexer.track(this.name, path);
   get db() {
-    return this.mon.sqlite;
+    return this.mon.driver;
   }
   ensureTable() {
     if (this.initialized) return;
@@ -485,13 +485,12 @@ var Collection = class {
     const stmt = this.db.prepare(
       `INSERT INTO "${this.name}" (_id, data, created_at, updated_at) VALUES (?, ?, ?, ?)`
     );
-    const insertAll = this.db.transaction((items) => {
-      for (const item of items) {
+    this.db.transaction(() => {
+      for (const item of args.data) {
         const row = this.prepareInsert(item);
         stmt.run(row._id, row.data, row.created_at, row.updated_at);
       }
     });
-    insertAll(args.data);
     return { count: args.data.length };
   }
   /* ------------------------------ read ------------------------------ */
@@ -544,7 +543,7 @@ var Collection = class {
     const stmt = this.db.prepare(
       `UPDATE "${this.name}" SET data = ?, updated_at = ? WHERE _id = ?`
     );
-    const txn = this.db.transaction(() => {
+    return this.db.transaction(() => {
       const out = [];
       for (const row of rows) {
         const current = JSON.parse(row.data);
@@ -559,7 +558,6 @@ var Collection = class {
       }
       return out;
     });
-    return txn();
   }
   async update(args) {
     return this.runUpdate(args.where, args.data, true)[0] ?? null;
@@ -589,10 +587,9 @@ var Collection = class {
     const rows = this.db.prepare(selectSql).all(...params);
     if (!rows.length) return [];
     const stmt = this.db.prepare(`DELETE FROM "${this.name}" WHERE _id = ?`);
-    const txn = this.db.transaction(() => {
+    this.db.transaction(() => {
       for (const row of rows) stmt.run(row._id);
     });
-    txn();
     return rows.map((r) => this.rowToDoc(r));
   }
   async delete(args) {
@@ -670,6 +667,134 @@ var AutoIndexer = class {
   }
 };
 
+// src/driver/better-sqlite3.ts
+var BetterSqlite3Driver = class {
+  name = "better-sqlite3";
+  raw;
+  verbose;
+  constructor(BetterSqlite3, filename, options) {
+    this.verbose = options.verbose;
+    this.raw = new BetterSqlite3(filename, {
+      readonly: options.readonly ?? false
+    });
+    if (!options.readonly && (options.wal ?? true)) {
+      this.raw.pragma("journal_mode = WAL");
+    }
+  }
+  exec(sql) {
+    this.verbose?.(sql);
+    this.raw.exec(sql);
+  }
+  prepare(sql) {
+    this.verbose?.(sql);
+    return this.raw.prepare(sql);
+  }
+  transaction(fn) {
+    return this.raw.transaction(fn)();
+  }
+  close() {
+    this.raw.close();
+  }
+};
+
+// src/driver/node-sqlite.ts
+var NodeSqliteDriver = class {
+  name = "node:sqlite";
+  raw;
+  verbose;
+  depth = 0;
+  constructor(nodeSqlite, filename, options) {
+    this.verbose = options.verbose;
+    const { DatabaseSync } = nodeSqlite;
+    this.raw = new DatabaseSync(filename, {
+      readOnly: options.readonly ?? false
+    });
+    if (!options.readonly && (options.wal ?? true)) {
+      this.raw.exec("PRAGMA journal_mode = WAL");
+    }
+  }
+  exec(sql) {
+    this.verbose?.(sql);
+    this.raw.exec(sql);
+  }
+  prepare(sql) {
+    this.verbose?.(sql);
+    const stmt = this.raw.prepare(sql);
+    return {
+      run: (...p) => stmt.run(...p),
+      get: (...p) => stmt.get(...p),
+      all: (...p) => stmt.all(...p)
+    };
+  }
+  transaction(fn) {
+    const savepoint = `monlite_sp_${this.depth}`;
+    if (this.depth === 0) this.raw.exec("BEGIN");
+    else this.raw.exec(`SAVEPOINT ${savepoint}`);
+    this.depth++;
+    try {
+      const result = fn();
+      this.depth--;
+      if (this.depth === 0) this.raw.exec("COMMIT");
+      else this.raw.exec(`RELEASE ${savepoint}`);
+      return result;
+    } catch (err) {
+      this.depth--;
+      if (this.depth === 0) this.raw.exec("ROLLBACK");
+      else this.raw.exec(`ROLLBACK TO ${savepoint}; RELEASE ${savepoint}`);
+      throw err;
+    }
+  }
+  close() {
+    this.raw.close();
+  }
+};
+
+// src/driver/index.ts
+var req = createRequire(import.meta.url);
+function loadBetterSqlite3() {
+  try {
+    const mod = req("better-sqlite3");
+    return mod?.default ?? mod;
+  } catch {
+    return null;
+  }
+}
+function loadNodeSqlite() {
+  try {
+    return req("node:sqlite");
+  } catch {
+    return null;
+  }
+}
+function createDriver(filename, options = {}) {
+  const choice = options.driver ?? "auto";
+  if (choice === "better-sqlite3") {
+    const mod = loadBetterSqlite3();
+    if (!mod) {
+      throw new MonliteError(
+        `driver "better-sqlite3" was requested but the package is not installed. Run \`npm install better-sqlite3\`.`
+      );
+    }
+    return new BetterSqlite3Driver(mod, filename, options);
+  }
+  if (choice === "node:sqlite") {
+    const mod = loadNodeSqlite();
+    if (!mod) {
+      throw new MonliteError(
+        `driver "node:sqlite" is unavailable. It requires Node >= 22.5.`
+      );
+    }
+    return new NodeSqliteDriver(mod, filename, options);
+  }
+  const better = loadBetterSqlite3();
+  if (better) return new BetterSqlite3Driver(better, filename, options);
+  const node = loadNodeSqlite();
+  if (node) return new NodeSqliteDriver(node, filename, options);
+  throw new MonliteError(
+    `No SQLite driver available. Either install better-sqlite3 (\`npm install better-sqlite3\`) or run on Node >= 22.5 for the built-in node:sqlite backend.`
+  );
+}
+
 // src/db.ts
 function validateName(name) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
@@ -691,27 +816,33 @@ function buildTagged(strings, values) {
   return { sql, params };
 }
 var Monlite = class {
-  /** The underlying better-sqlite3 connection (escape hatch). */
-  sqlite;
+  /** @internal The active SQLite driver. */
+  driver;
   /** @internal */
   autoIndexer;
   collections = /* @__PURE__ */ new Map();
   closed = false;
   constructor(filename, options = {}) {
-    const verbose = options.verbose;
-    this.sqlite = new Database(filename, {
-      readonly: options.readonly ?? false,
-      ...verbose ? { verbose: (msg) => verbose(String(msg)) } : {}
+    this.driver = createDriver(filename, {
+      driver: options.driver,
+      readonly: options.readonly,
+      wal: options.wal,
+      verbose: options.verbose
     });
-    if (!options.readonly && (options.wal ?? true)) {
-      this.sqlite.pragma("journal_mode = WAL");
-    }
     this.autoIndexer = new AutoIndexer(
-      this.sqlite,
+      this.driver,
       options.autoIndex ?? true,
       options.autoIndexAfter ?? 10
     );
   }
+  /** The underlying native database handle (escape hatch). */
+  get sqlite() {
+    return this.driver.raw;
+  }
+  /** Name of the active backend: `"better-sqlite3"` or `"node:sqlite"`. */
+  get driverName() {
+    return this.driver.name;
+  }
   /** Get (or lazily create) a typed collection handle. */
   collection(name) {
     this.assertOpen();
@@ -727,26 +858,26 @@ var Monlite = class {
   $queryRaw(strings, ...values) {
     this.assertOpen();
     const { sql, params } = buildTagged(strings, values);
-    return Promise.resolve(this.sqlite.prepare(sql).all(...params));
+    return Promise.resolve(this.driver.prepare(sql).all(...params));
   }
   /** Like {@link $queryRaw} but takes a raw SQL string and positional params. */
   $queryRawUnsafe(sql, ...params) {
     this.assertOpen();
     return Promise.resolve(
-      this.sqlite.prepare(sql).all(...params.map(bindable))
+      this.driver.prepare(sql).all(...params.map(bindable))
     );
   }
   /** Tagged-template SQL statement returning the number of affected rows. */
   $executeRaw(strings, ...values) {
     this.assertOpen();
     const { sql, params } = buildTagged(strings, values);
-    return Promise.resolve(this.sqlite.prepare(sql).run(...params).changes);
+    return Promise.resolve(this.driver.prepare(sql).run(...params).changes);
   }
   /** Like {@link $executeRaw} but takes a raw SQL string and positional params. */
   $executeRawUnsafe(sql, ...params) {
     this.assertOpen();
     return Promise.resolve(
-      this.sqlite.prepare(sql).run(...params.map(bindable)).changes
+      this.driver.prepare(sql).run(...params.map(bindable)).changes
     );
   }
   /**
@@ -755,13 +886,12 @@ var Monlite = class {
    */
   async $transaction(fn) {
     this.assertOpen();
-    const txn = this.sqlite.transaction(() => fn(this));
-    return txn();
+    return this.driver.transaction(() => fn(this));
   }
   /** List all collection (table) names. */
   $collections() {
     this.assertOpen();
-    const rows = this.sqlite.prepare(
+    const rows = this.driver.prepare(
       `SELECT name FROM sqlite_master
          WHERE type='table' AND name NOT LIKE 'sqlite_%'
          ORDER BY name`
@@ -772,7 +902,7 @@ var Monlite = class {
   $drop(name) {
     this.assertOpen();
     validateName(name);
-    this.sqlite.exec(`DROP TABLE IF EXISTS "${name}"`);
+    this.driver.exec(`DROP TABLE IF EXISTS "${name}"`);
     this.collections.delete(name);
     this.autoIndexer.reset(name);
     return Promise.resolve();
@@ -785,7 +915,7 @@ var Monlite = class {
   $disconnect() {
     if (!this.closed) {
       this.closed = true;
-      this.sqlite.close();
+      this.driver.close();
     }
     return Promise.resolve();
   }