@monlite/core 0.1.0 → 0.3.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() {
@@ -376,6 +376,44 @@ function aggregate(ctx, args) {
   }
   return result;
 }
+var HAVING_FNS = [
+  ["_sum", "SUM"],
+  ["_avg", "AVG"],
+  ["_min", "MIN"],
+  ["_max", "MAX"]
+];
+function comparisonSql(expr, cmp2, params) {
+  const out = [];
+  const ops = [
+    ["equals", "="],
+    ["not", "<>"],
+    ["gt", ">"],
+    ["gte", ">="],
+    ["lt", "<"],
+    ["lte", "<="]
+  ];
+  for (const [key, op] of ops) {
+    const v = cmp2[key];
+    if (v === void 0) continue;
+    params.push(v);
+    out.push(`${expr} ${op} ?`);
+  }
+  return out;
+}
+function buildHaving(having, params) {
+  const parts = [];
+  if (having._count) {
+    parts.push(...comparisonSql("COUNT(*)", having._count, params));
+  }
+  for (const [kind, fn] of HAVING_FNS) {
+    const selection = having[kind];
+    if (!selection) continue;
+    for (const field of Object.keys(selection)) {
+      parts.push(...comparisonSql(`${fn}(${fieldExpr(field)})`, selection[field], params));
+    }
+  }
+  return parts.join(" AND ");
+}
 function groupBy(ctx, args) {
   if (!Array.isArray(args.by) || args.by.length === 0) {
     throw new Error("groupBy requires a non-empty `by` array");
@@ -394,6 +432,10 @@ function groupBy(ctx, args) {
   const { selects: accSelects, cols } = buildAccumulators(args, ctx.onPath);
   selects.push(...accSelects);
   let sql = `SELECT ${selects.join(", ")} FROM "${ctx.table}" WHERE ${where} GROUP BY ${groupExprs.join(", ")}`;
+  if (args.having) {
+    const havingSql = buildHaving(args.having, params);
+    if (havingSql) sql += ` HAVING ${havingSql}`;
+  }
   if (args.orderBy) {
     const parts = [];
     for (const key of Object.keys(args.orderBy)) {
@@ -439,7 +481,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 +527,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 ------------------------------ */
@@ -531,6 +572,24 @@ var Collection = class {
     const row = this.db.prepare(`SELECT COUNT(*) AS n FROM "${this.name}" WHERE ${where}`).get(...params);
     return row.n;
   }
+  /**
+   * Return the distinct values of a field across the collection. Array fields
+   * are unwound (each element counts as a value), matching MongoDB's `distinct`.
+   */
+  async distinct(field, where) {
+    this.ensureTable();
+    const params = [];
+    const clause = buildWhere(where, { params, onPath: this.trackPath });
+    let sql;
+    if (isReserved(field)) {
+      sql = `SELECT DISTINCT ${fieldExpr(field)} AS v FROM "${this.name}" WHERE ${clause} ORDER BY v`;
+    } else {
+      this.trackPath(field);
+      sql = `SELECT DISTINCT je.value AS v FROM "${this.name}" CROSS JOIN json_each("${this.name}".data, ${pathLiteral(field)}) je WHERE ${clause} ORDER BY v`;
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => r.v);
+  }
   /* ----------------------------- update ----------------------------- */
   runUpdate(where, data, single) {
     this.ensureTable();
@@ -544,7 +603,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 +618,6 @@ var Collection = class {
       }
       return out;
     });
-    return txn();
   }
   async update(args) {
     return this.runUpdate(args.where, args.data, true)[0] ?? null;
@@ -589,10 +647,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 +727,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 +876,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 +918,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 +946,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 +962,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 +975,7 @@ var Monlite = class {
   $disconnect() {
     if (!this.closed) {
       this.closed = true;
-      this.sqlite.close();
+      this.driver.close();
     }
     return Promise.resolve();
   }