@monlite/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,814 @@
+'use strict';
+
+var Database = require('better-sqlite3');
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Database__default = /*#__PURE__*/_interopDefault(Database);
+
+// src/db.ts
+var PROCESS_UNIQUE = crypto.randomBytes(5);
+var counter = crypto.randomBytes(3).readUIntBE(0, 3);
+function objectId() {
+  const time = Math.floor(Date.now() / 1e3);
+  counter = (counter + 1) % 16777216;
+  const buf = Buffer.allocUnsafe(12);
+  buf.writeUInt32BE(time >>> 0, 0);
+  PROCESS_UNIQUE.copy(buf, 4, 0, 5);
+  buf.writeUIntBE(counter, 9, 3);
+  return buf.toString("hex");
+}
+function isObjectId(value) {
+  return typeof value === "string" && /^[0-9a-f]{24}$/i.test(value);
+}
+
+// src/errors.ts
+var MonliteError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MonliteError";
+  }
+};
+var MonliteQueryError = class extends MonliteError {
+  constructor(message) {
+    super(message);
+    this.name = "MonliteQueryError";
+  }
+};
+
+// src/query/sql.ts
+var RESERVED_FIELDS = /* @__PURE__ */ new Set(["_id", "created_at", "updated_at"]);
+function isReserved(field) {
+  return RESERVED_FIELDS.has(field);
+}
+function jsonPath(field) {
+  let path = "$";
+  for (const seg of field.split(".")) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(seg)) {
+      path += "." + seg;
+    } else if (/^\d+$/.test(seg)) {
+      path += "[" + seg + "]";
+    } else {
+      path += '."' + seg.replace(/"/g, '""') + '"';
+    }
+  }
+  return path;
+}
+function pathLiteral(field) {
+  return "'" + jsonPath(field).replace(/'/g, "''") + "'";
+}
+function fieldExpr(field) {
+  if (isReserved(field)) return `"${field}"`;
+  return `json_extract(data, ${pathLiteral(field)})`;
+}
+function bindable(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "number" || typeof value === "string" || typeof value === "bigint") {
+    return value;
+  }
+  if (Buffer.isBuffer(value)) return value;
+  return JSON.stringify(value);
+}
+
+// src/query/where.ts
+function buildWhere(where, ctx) {
+  if (!where) return "1";
+  return translateObject(where, ctx) || "1";
+}
+function asArray(v) {
+  return Array.isArray(v) ? v : [v];
+}
+function translateObject(where, ctx) {
+  const parts = [];
+  for (const key of Object.keys(where)) {
+    const value = where[key];
+    if (value === void 0) continue;
+    if (key === "AND" || key === "OR") {
+      const subs = asArray(value).map((w) => translateObject(w, ctx)).filter(Boolean);
+      if (subs.length) {
+        const join = key === "AND" ? " AND " : " OR ";
+        parts.push("(" + subs.join(join) + ")");
+      }
+    } else if (key === "NOT") {
+      const subs = asArray(value).map((w) => translateObject(w, ctx)).filter(Boolean);
+      if (subs.length) parts.push("NOT (" + subs.join(" AND ") + ")");
+    } else {
+      const clause = translateField(key, value, ctx);
+      if (clause) parts.push(clause);
+    }
+  }
+  return parts.join(" AND ");
+}
+function isFilterObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date) && !Buffer.isBuffer(v) && (v.constructor === Object || v.constructor === void 0);
+}
+function translateField(field, condition, ctx) {
+  if (ctx.onPath && !isReserved(field)) ctx.onPath(field);
+  const expr = fieldExpr(field);
+  if (!isFilterObject(condition)) {
+    return eqExpr(expr, condition, ctx);
+  }
+  const filter = condition;
+  const clauses = [];
+  for (const op of Object.keys(filter)) {
+    const v = filter[op];
+    if (v === void 0) continue;
+    switch (op) {
+      case "equals":
+        clauses.push(eqExpr(expr, v, ctx));
+        break;
+      case "not":
+        clauses.push(notExpr(expr, v, ctx));
+        break;
+      case "gt":
+        clauses.push(cmp(expr, ">", v, ctx));
+        break;
+      case "gte":
+        clauses.push(cmp(expr, ">=", v, ctx));
+        break;
+      case "lt":
+        clauses.push(cmp(expr, "<", v, ctx));
+        break;
+      case "lte":
+        clauses.push(cmp(expr, "<=", v, ctx));
+        break;
+      case "in":
+        clauses.push(inExpr(expr, v, ctx, false));
+        break;
+      case "notIn":
+        clauses.push(inExpr(expr, v, ctx, true));
+        break;
+      case "contains":
+        clauses.push(containsExpr(field, expr, v, ctx));
+        break;
+      case "startsWith":
+        ctx.params.push(bindable(v));
+        clauses.push(`instr(${expr}, ?) = 1`);
+        break;
+      case "endsWith":
+        ctx.params.push(bindable(v));
+        ctx.params.push(bindable(v));
+        clauses.push(`substr(${expr}, -length(?)) = ?`);
+        break;
+      case "has":
+        clauses.push(hasExpr(field, expr, v, ctx));
+        break;
+      case "exists":
+        clauses.push(existsExpr(field, expr, !!v));
+        break;
+      default:
+        throw new MonliteQueryError(
+          `Unknown where operator "${op}" on field "${field}"`
+        );
+    }
+  }
+  if (!clauses.length) return "";
+  return clauses.length === 1 ? clauses[0] : "(" + clauses.join(" AND ") + ")";
+}
+function eqExpr(expr, v, ctx) {
+  if (v === null) return `${expr} IS NULL`;
+  ctx.params.push(bindable(v));
+  return `${expr} = ?`;
+}
+function notExpr(expr, v, ctx) {
+  if (v === null) return `${expr} IS NOT NULL`;
+  ctx.params.push(bindable(v));
+  return `(${expr} IS NULL OR ${expr} != ?)`;
+}
+function cmp(expr, op, v, ctx) {
+  ctx.params.push(bindable(v));
+  return `${expr} ${op} ?`;
+}
+function inExpr(expr, arr, ctx, negate) {
+  if (!Array.isArray(arr)) {
+    throw new MonliteQueryError(
+      `${negate ? "notIn" : "in"} expects an array`
+    );
+  }
+  if (arr.length === 0) return negate ? "1" : "0";
+  const placeholders = arr.map((v) => {
+    ctx.params.push(bindable(v));
+    return "?";
+  }).join(", ");
+  return negate ? `(${expr} IS NULL OR ${expr} NOT IN (${placeholders}))` : `${expr} IN (${placeholders})`;
+}
+function containsExpr(field, expr, v, ctx) {
+  if (isReserved(field)) {
+    ctx.params.push(bindable(v));
+    return `instr(${expr}, ?) > 0`;
+  }
+  const path = pathLiteral(field);
+  ctx.params.push(bindable(v));
+  ctx.params.push(bindable(v));
+  return `(CASE WHEN json_type(data, ${path}) = 'array' THEN EXISTS (SELECT 1 FROM json_each(data, ${path}) WHERE value = ?) ELSE instr(${expr}, ?) > 0 END)`;
+}
+function hasExpr(field, expr, v, ctx) {
+  ctx.params.push(bindable(v));
+  if (isReserved(field)) return `${expr} = ?`;
+  return `EXISTS (SELECT 1 FROM json_each(data, ${pathLiteral(field)}) WHERE value = ?)`;
+}
+function existsExpr(field, expr, want) {
+  if (isReserved(field)) {
+    return want ? `${expr} IS NOT NULL` : `${expr} IS NULL`;
+  }
+  const path = pathLiteral(field);
+  return want ? `json_type(data, ${path}) IS NOT NULL` : `json_type(data, ${path}) IS NULL`;
+}
+
+// src/query/order.ts
+function buildOrderBy(orderBy, onPath) {
+  if (!orderBy) return "";
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  const parts = [];
+  for (const obj of list) {
+    for (const field of Object.keys(obj)) {
+      const dir = obj[field];
+      if (dir === void 0) continue;
+      if (onPath && !isReserved(field)) onPath(field);
+      const d = String(dir).toLowerCase() === "desc" ? "DESC" : "ASC";
+      parts.push(`${fieldExpr(field)} ${d}`);
+    }
+  }
+  return parts.length ? "ORDER BY " + parts.join(", ") : "";
+}
+
+// src/query/path.ts
+function getPath(obj, path) {
+  let cur = obj;
+  for (const seg of path.split(".")) {
+    if (cur == null) return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function setPath(obj, path, value) {
+  const segs = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    if (cur[seg] == null || typeof cur[seg] !== "object") cur[seg] = {};
+    cur = cur[seg];
+  }
+  cur[segs[segs.length - 1]] = value;
+}
+function unsetPath(obj, path) {
+  const segs = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    if (cur[seg] == null || typeof cur[seg] !== "object") return;
+    cur = cur[seg];
+  }
+  delete cur[segs[segs.length - 1]];
+}
+
+// src/query/select.ts
+function project(doc, select) {
+  if (!select) return doc;
+  const keys = Object.keys(select).filter((k) => select[k]);
+  if (!keys.length) return doc;
+  const out = {};
+  for (const key of keys) {
+    const value = getPath(doc, key);
+    if (value !== void 0) setPath(out, key, value);
+  }
+  return out;
+}
+
+// src/query/update.ts
+var UPDATE_OPS = /* @__PURE__ */ new Set(["$set", "$unset", "$inc", "$push", "$pull"]);
+function isUpdateOperators(data) {
+  return data != null && typeof data === "object" && Object.keys(data).some((k) => k.startsWith("$"));
+}
+function sameValue(a, b) {
+  if (a === b) return true;
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function applyUpdate(doc, data) {
+  const next = structuredClone(doc);
+  if (!isUpdateOperators(data)) {
+    return Object.assign(next, data);
+  }
+  for (const key of Object.keys(data)) {
+    if (!key.startsWith("$")) {
+      throw new MonliteQueryError(
+        `Cannot mix update operators with plain field "${key}". Use either a plain object or update operators, not both.`
+      );
+    }
+    if (!UPDATE_OPS.has(key)) {
+      throw new MonliteQueryError(`Unknown update operator "${key}"`);
+    }
+  }
+  const ops = data;
+  if (ops.$set) {
+    for (const [path, value] of Object.entries(ops.$set)) setPath(next, path, value);
+  }
+  if (ops.$inc) {
+    for (const [path, by] of Object.entries(ops.$inc)) {
+      const cur = getPath(next, path);
+      setPath(next, path, (typeof cur === "number" ? cur : 0) + Number(by));
+    }
+  }
+  if (ops.$push) {
+    for (const [path, value] of Object.entries(ops.$push)) {
+      const cur = getPath(next, path);
+      const arr = Array.isArray(cur) ? cur.slice() : [];
+      if (value && typeof value === "object" && Array.isArray(value.$each)) {
+        arr.push(...value.$each);
+      } else {
+        arr.push(value);
+      }
+      setPath(next, path, arr);
+    }
+  }
+  if (ops.$pull) {
+    for (const [path, value] of Object.entries(ops.$pull)) {
+      const cur = getPath(next, path);
+      if (Array.isArray(cur)) {
+        setPath(
+          next,
+          path,
+          cur.filter((x) => !sameValue(x, value))
+        );
+      }
+    }
+  }
+  if (ops.$unset) {
+    for (const path of Object.keys(ops.$unset)) unsetPath(next, path);
+  }
+  return next;
+}
+
+// src/aggregation/aggregate.ts
+var ACCUMULATORS = ["_sum", "_avg", "_min", "_max"];
+var SQL_FN = {
+  _sum: "SUM",
+  _avg: "AVG",
+  _min: "MIN",
+  _max: "MAX"
+};
+function buildAccumulators(args, onPath) {
+  const selects = [];
+  const cols = [];
+  let i = 0;
+  for (const kind of ACCUMULATORS) {
+    const selection = args[kind];
+    if (!selection) continue;
+    for (const field of Object.keys(selection)) {
+      if (!selection[field]) continue;
+      onPath(field);
+      const alias = `agg_${kind.slice(1)}_${i++}`;
+      selects.push(`${SQL_FN[kind]}(${fieldExpr(field)}) AS ${alias}`);
+      cols.push({ alias, kind, field });
+    }
+  }
+  return { selects, cols };
+}
+function aggregate(ctx, args) {
+  const params = [];
+  const where = buildWhere(args.where, { params, onPath: ctx.onPath });
+  const { selects, cols } = buildAccumulators(args, ctx.onPath);
+  const allSelects = [`COUNT(*) AS agg_count`, ...selects];
+  const sql = `SELECT ${allSelects.join(", ")} FROM "${ctx.table}" WHERE ${where}`;
+  const row = ctx.db.prepare(sql).get(...params) ?? {};
+  const result = {};
+  if (args._count) result._count = row.agg_count ?? 0;
+  for (const col of cols) {
+    const bucket = result[col.kind] ??= {};
+    bucket[col.field] = row[col.alias] ?? null;
+  }
+  return result;
+}
+function groupBy(ctx, args) {
+  if (!Array.isArray(args.by) || args.by.length === 0) {
+    throw new Error("groupBy requires a non-empty `by` array");
+  }
+  const params = [];
+  const where = buildWhere(args.where, { params, onPath: ctx.onPath });
+  const groupExprs = [];
+  const selects = [];
+  for (const field of args.by) {
+    ctx.onPath(field);
+    const expr = fieldExpr(field);
+    groupExprs.push(expr);
+    selects.push(`${expr} AS "${field}"`);
+  }
+  selects.push(`COUNT(*) AS agg_count`);
+  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.orderBy) {
+    const parts = [];
+    for (const key of Object.keys(args.orderBy)) {
+      const dir = String(args.orderBy[key]).toLowerCase() === "desc" ? "DESC" : "ASC";
+      if (key === "_count") parts.push(`agg_count ${dir}`);
+      else parts.push(`${fieldExpr(key)} ${dir}`);
+    }
+    if (parts.length) sql += ` ORDER BY ${parts.join(", ")}`;
+  }
+  if (args.take != null) {
+    sql += " LIMIT ?";
+    params.push(args.take);
+  }
+  if (args.skip != null) {
+    sql += (args.take != null ? "" : " LIMIT -1") + " OFFSET ?";
+    params.push(args.skip);
+  }
+  const rows = ctx.db.prepare(sql).all(...params);
+  return rows.map((row) => {
+    const out = {};
+    for (const field of args.by) out[field] = row[field];
+    if (args._count) out._count = row.agg_count;
+    for (const col of cols) {
+      (out[col.kind] ??= {})[col.field] = row[col.alias] ?? null;
+    }
+    return out;
+  });
+}
+
+// src/collection.ts
+var SELECT_COLS = `_id, data, created_at, updated_at`;
+function stripSystem(obj) {
+  const { _id, created_at, updated_at, ...rest } = obj;
+  return rest;
+}
+var Collection = class {
+  constructor(mon, name) {
+    this.mon = mon;
+    this.name = name;
+  }
+  mon;
+  name;
+  initialized = false;
+  trackPath = (path) => this.mon.autoIndexer.track(this.name, path);
+  get db() {
+    return this.mon.sqlite;
+  }
+  ensureTable() {
+    if (this.initialized) return;
+    this.db.exec(
+      `CREATE TABLE IF NOT EXISTS "${this.name}" (
+        _id        TEXT    PRIMARY KEY,
+        data       TEXT    NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )`
+    );
+    this.initialized = true;
+  }
+  rowToDoc(row) {
+    const doc = JSON.parse(row.data);
+    doc._id = row._id;
+    doc.created_at = row.created_at;
+    doc.updated_at = row.updated_at;
+    return doc;
+  }
+  prepareInsert(input) {
+    const now = Date.now();
+    const id = input._id != null ? String(input._id) : objectId();
+    const doc = stripSystem(input);
+    return {
+      _id: id,
+      data: JSON.stringify(doc),
+      created_at: now,
+      updated_at: now
+    };
+  }
+  /* ----------------------------- create ----------------------------- */
+  async create(args) {
+    this.ensureTable();
+    const row = this.prepareInsert(args.data);
+    this.db.prepare(
+      `INSERT INTO "${this.name}" (_id, data, created_at, updated_at) VALUES (?, ?, ?, ?)`
+    ).run(row._id, row.data, row.created_at, row.updated_at);
+    return this.rowToDoc(row);
+  }
+  async createMany(args) {
+    this.ensureTable();
+    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) {
+        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 ------------------------------ */
+  async findMany(args = {}) {
+    this.ensureTable();
+    const params = [];
+    const where = buildWhere(args.where, { params, onPath: this.trackPath });
+    let sql = `SELECT ${SELECT_COLS} FROM "${this.name}" WHERE ${where}`;
+    const order = buildOrderBy(args.orderBy, this.trackPath);
+    if (order) sql += " " + order;
+    if (args.take != null) {
+      sql += " LIMIT ?";
+      params.push(args.take);
+    }
+    if (args.skip != null) {
+      sql += (args.take != null ? "" : " LIMIT -1") + " OFFSET ?";
+      params.push(args.skip);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(
+      (r) => project(this.rowToDoc(r), args.select)
+    );
+  }
+  async findFirst(args = {}) {
+    const rows = await this.findMany({ ...args, take: 1 });
+    return rows[0] ?? null;
+  }
+  async findById(id) {
+    this.ensureTable();
+    const row = this.db.prepare(`SELECT ${SELECT_COLS} FROM "${this.name}" WHERE _id = ?`).get(id);
+    return row ? this.rowToDoc(row) : null;
+  }
+  async count(args = {}) {
+    this.ensureTable();
+    const params = [];
+    const where = buildWhere(args.where, { params, onPath: this.trackPath });
+    const row = this.db.prepare(`SELECT COUNT(*) AS n FROM "${this.name}" WHERE ${where}`).get(...params);
+    return row.n;
+  }
+  /* ----------------------------- update ----------------------------- */
+  runUpdate(where, data, single) {
+    this.ensureTable();
+    const params = [];
+    const clause = buildWhere(where, { params, onPath: this.trackPath });
+    let selectSql = `SELECT ${SELECT_COLS} FROM "${this.name}" WHERE ${clause}`;
+    if (single) selectSql += " LIMIT 1";
+    const rows = this.db.prepare(selectSql).all(...params);
+    if (!rows.length) return [];
+    const now = Date.now();
+    const stmt = this.db.prepare(
+      `UPDATE "${this.name}" SET data = ?, updated_at = ? WHERE _id = ?`
+    );
+    const txn = this.db.transaction(() => {
+      const out = [];
+      for (const row of rows) {
+        const current = JSON.parse(row.data);
+        const updated = stripSystem(applyUpdate(current, data));
+        stmt.run(JSON.stringify(updated), now, row._id);
+        out.push({
+          ...updated,
+          _id: row._id,
+          created_at: row.created_at,
+          updated_at: now
+        });
+      }
+      return out;
+    });
+    return txn();
+  }
+  async update(args) {
+    return this.runUpdate(args.where, args.data, true)[0] ?? null;
+  }
+  async updateMany(args) {
+    return { count: this.runUpdate(args.where, args.data, false).length };
+  }
+  async upsert(args) {
+    this.ensureTable();
+    const existing = await this.findFirst({ where: args.where });
+    if (existing) {
+      const updated = await this.update({
+        where: { _id: existing._id },
+        data: args.update
+      });
+      return updated;
+    }
+    return this.create({ data: args.create });
+  }
+  /* ----------------------------- delete ----------------------------- */
+  runDelete(where, single) {
+    this.ensureTable();
+    const params = [];
+    const clause = buildWhere(where, { params, onPath: this.trackPath });
+    let selectSql = `SELECT ${SELECT_COLS} FROM "${this.name}" WHERE ${clause}`;
+    if (single) selectSql += " LIMIT 1";
+    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(() => {
+      for (const row of rows) stmt.run(row._id);
+    });
+    txn();
+    return rows.map((r) => this.rowToDoc(r));
+  }
+  async delete(args) {
+    return this.runDelete(args.where, true)[0] ?? null;
+  }
+  async deleteMany(args = { where: void 0 }) {
+    return { count: this.runDelete(args.where, false).length };
+  }
+  /* --------------------------- aggregation -------------------------- */
+  async aggregate(args = {}) {
+    this.ensureTable();
+    return aggregate(
+      { db: this.db, table: this.name, onPath: this.trackPath },
+      args
+    );
+  }
+  async groupBy(args) {
+    this.ensureTable();
+    return groupBy(
+      { db: this.db, table: this.name, onPath: this.trackPath },
+      args
+    );
+  }
+};
+
+// src/auto-index.ts
+var AutoIndexer = class {
+  constructor(db, enabled, threshold) {
+    this.db = db;
+    this.enabled = enabled;
+    this.threshold = threshold;
+  }
+  db;
+  enabled;
+  threshold;
+  counts = /* @__PURE__ */ new Map();
+  created = /* @__PURE__ */ new Set();
+  track(collection, path) {
+    if (!this.enabled) return;
+    const key = `${collection}\0${path}`;
+    if (this.created.has(key)) return;
+    const next = (this.counts.get(key) ?? 0) + 1;
+    this.counts.set(key, next);
+    if (next >= this.threshold) {
+      this.create(collection, path);
+      this.created.add(key);
+      this.counts.delete(key);
+    }
+  }
+  create(collection, path) {
+    const safe = path.replace(/[^A-Za-z0-9_]+/g, "_");
+    const indexName = `idx_${collection}_${safe}`;
+    const expr = `json_extract(data, ${pathLiteral(path)})`;
+    try {
+      this.db.exec(
+        `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${collection}"(${expr})`
+      );
+    } catch {
+    }
+  }
+  /** Forget tracking for a collection (or everything when omitted). */
+  reset(collection) {
+    if (!collection) {
+      this.counts.clear();
+      this.created.clear();
+      return;
+    }
+    const prefix = `${collection}\0`;
+    for (const k of [...this.counts.keys()]) {
+      if (k.startsWith(prefix)) this.counts.delete(k);
+    }
+    for (const k of [...this.created.keys()]) {
+      if (k.startsWith(prefix)) this.created.delete(k);
+    }
+  }
+};
+
+// src/db.ts
+function validateName(name) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new MonliteError(
+      `Invalid collection name "${name}". Names must start with a letter or underscore and contain only letters, digits and underscores.`
+    );
+  }
+}
+function buildTagged(strings, values) {
+  let sql = "";
+  const params = [];
+  strings.forEach((part, i) => {
+    sql += part;
+    if (i < values.length) {
+      sql += "?";
+      params.push(bindable(values[i]));
+    }
+  });
+  return { sql, params };
+}
+var Monlite = class {
+  /** The underlying better-sqlite3 connection (escape hatch). */
+  sqlite;
+  /** @internal */
+  autoIndexer;
+  collections = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(filename, options = {}) {
+    const verbose = options.verbose;
+    this.sqlite = new Database__default.default(filename, {
+      readonly: options.readonly ?? false,
+      ...verbose ? { verbose: (msg) => verbose(String(msg)) } : {}
+    });
+    if (!options.readonly && (options.wal ?? true)) {
+      this.sqlite.pragma("journal_mode = WAL");
+    }
+    this.autoIndexer = new AutoIndexer(
+      this.sqlite,
+      options.autoIndex ?? true,
+      options.autoIndexAfter ?? 10
+    );
+  }
+  /** Get (or lazily create) a typed collection handle. */
+  collection(name) {
+    this.assertOpen();
+    validateName(name);
+    let col = this.collections.get(name);
+    if (!col) {
+      col = new Collection(this, name);
+      this.collections.set(name, col);
+    }
+    return col;
+  }
+  /** Tagged-template SQL query returning rows. Values are safely parameterized. */
+  $queryRaw(strings, ...values) {
+    this.assertOpen();
+    const { sql, params } = buildTagged(strings, values);
+    return Promise.resolve(this.sqlite.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))
+    );
+  }
+  /** 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);
+  }
+  /** 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
+    );
+  }
+  /**
+   * Run a function inside a synchronous SQLite transaction. If it throws, the
+   * transaction is rolled back.
+   */
+  async $transaction(fn) {
+    this.assertOpen();
+    const txn = this.sqlite.transaction(() => fn(this));
+    return txn();
+  }
+  /** List all collection (table) names. */
+  $collections() {
+    this.assertOpen();
+    const rows = this.sqlite.prepare(
+      `SELECT name FROM sqlite_master
+         WHERE type='table' AND name NOT LIKE 'sqlite_%'
+         ORDER BY name`
+    ).all();
+    return Promise.resolve(rows.map((r) => r.name));
+  }
+  /** Drop a collection and all of its data. */
+  $drop(name) {
+    this.assertOpen();
+    validateName(name);
+    this.sqlite.exec(`DROP TABLE IF EXISTS "${name}"`);
+    this.collections.delete(name);
+    this.autoIndexer.reset(name);
+    return Promise.resolve();
+  }
+  /** Drop every collection in the database. */
+  async $dropAll() {
+    for (const name of await this.$collections()) await this.$drop(name);
+  }
+  /** Close the underlying SQLite connection. */
+  $disconnect() {
+    if (!this.closed) {
+      this.closed = true;
+      this.sqlite.close();
+    }
+    return Promise.resolve();
+  }
+  assertOpen() {
+    if (this.closed) throw new MonliteError("Database connection is closed");
+  }
+};
+function createDb(filename, options) {
+  return new Monlite(filename, options);
+}
+
+exports.Collection = Collection;
+exports.Monlite = Monlite;
+exports.MonliteError = MonliteError;
+exports.MonliteQueryError = MonliteQueryError;
+exports.createDb = createDb;
+exports.isObjectId = isObjectId;
+exports.objectId = objectId;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map