@type32/tauri-sqlite-orm 0.1.0

package/dist/index.js

@@ -0,0 +1,764 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TauriORM: () => TauriORM,
+  asc: () => asc,
+  blob: () => blob,
+  boolean: () => boolean,
+  db: () => db2,
+  defineTable: () => defineTable,
+  desc: () => desc,
+  eq: () => eq,
+  getDb: () => getDb,
+  gt: () => gt,
+  gte: () => gte,
+  initDb: () => initDb,
+  integer: () => integer,
+  like: () => like,
+  lt: () => lt,
+  lte: () => lte,
+  makeQueryAPI: () => makeQueryAPI,
+  ne: () => ne,
+  numeric: () => numeric,
+  real: () => real,
+  relations: () => relations,
+  sql: () => sql,
+  text: () => text,
+  timestamp: () => timestamp
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/connection.ts
+var import_plugin_sql = __toESM(require("@tauri-apps/plugin-sql"));
+var db = null;
+async function initDb(dbPath) {
+  db = await import_plugin_sql.default.load(dbPath);
+  return db;
+}
+function getDb() {
+  if (!db) {
+    throw new Error("Database not initialized. Please call initDb() first.");
+  }
+  return db;
+}
+
+// src/schema-builder.ts
+function sql(strings, ...values) {
+  const raw = strings.reduce(
+    (acc, part, idx) => acc + part + (idx < values.length ? String(values[idx]) : ""),
+    ""
+  );
+  return { raw };
+}
+function createColumn(params) {
+  const col = { ...params };
+  col.primaryKey = (opts) => {
+    col.isPrimaryKey = true;
+    if (opts?.autoIncrement) col.autoIncrement = true;
+    return col;
+  };
+  col.notNull = () => {
+    col.isNotNull = true;
+    return col;
+  };
+  col.default = (value) => {
+    col.defaultValue = value;
+    return col;
+  };
+  col.$type = () => col;
+  col.references = (target, actions) => {
+    const t = target();
+    col.references = {
+      table: t.tableName,
+      column: t.name,
+      onDelete: actions?.onDelete,
+      onUpdate: actions?.onUpdate
+    };
+    return col;
+  };
+  return col;
+}
+function text(name, config) {
+  const col = createColumn({
+    name,
+    type: "TEXT",
+    isPrimaryKey: config?.isPrimaryKey,
+    _dataType: ""
+  });
+  if (config?.enum) col.enumValues = config.enum;
+  return col;
+}
+function integer(name, config) {
+  let dt = 0;
+  if (config?.mode === "boolean") dt = false;
+  if (config?.mode === "timestamp") dt = /* @__PURE__ */ new Date();
+  const col = createColumn({
+    name,
+    type: "INTEGER",
+    isPrimaryKey: config?.isPrimaryKey,
+    autoIncrement: config?.autoIncrement,
+    mode: config?.mode ?? "number",
+    _dataType: dt
+  });
+  return col;
+}
+function real(name) {
+  return createColumn({ name, type: "REAL", _dataType: 0 });
+}
+function blob(name, config) {
+  let dt = new Uint8Array();
+  if (config?.mode === "bigint") dt = 0n;
+  if (config?.mode === "json") dt = void 0;
+  return createColumn({
+    name,
+    type: "BLOB",
+    mode: config?.mode,
+    _dataType: dt
+  });
+}
+function numeric(name, config) {
+  let dt = "";
+  if (config?.mode === "number") dt = 0;
+  if (config?.mode === "bigint") dt = 0n;
+  return createColumn({
+    name,
+    type: "NUMERIC",
+    mode: config?.mode,
+    _dataType: dt
+  });
+}
+var boolean = (name) => createColumn({
+  name,
+  type: "INTEGER",
+  _dataType: false,
+  mode: "boolean"
+});
+var timestamp = (name) => createColumn({
+  name,
+  type: "INTEGER",
+  _dataType: /* @__PURE__ */ new Date(),
+  mode: "timestamp"
+});
+function defineTable(tableName, schema) {
+  const finalizedSchema = { ...schema };
+  for (const key of Object.keys(finalizedSchema)) {
+    const col = finalizedSchema[key];
+    col.tableName = tableName;
+  }
+  const table = {
+    _tableName: tableName,
+    _schema: finalizedSchema,
+    // The Drizzle-like type inference properties
+    $inferSelect: {},
+    $inferInsert: {}
+    // Example: omit 'id' for inserts
+  };
+  for (const [key, col] of Object.entries(finalizedSchema)) {
+    table[key] = col;
+  }
+  return table;
+}
+
+// src/orm.ts
+var SelectQueryBuilder = class {
+  _table = null;
+  _selectedColumns = ["*"];
+  _joins = [];
+  _where = [];
+  _orderBy = [];
+  _limit = null;
+  _offset = null;
+  _eager = {};
+  constructor(fields) {
+    if (fields) {
+      this._selectedColumns = Object.values(fields).map((c) => c.name);
+    }
+  }
+  from(table) {
+    this._table = table;
+    return this;
+  }
+  where(...conditions) {
+    this._where.push(...conditions);
+    return this;
+  }
+  leftJoin(otherTable, on) {
+    const onSql = on.toSQL();
+    const joinClause = `LEFT JOIN ${otherTable._tableName} ON ${onSql.clause}`;
+    this._joins.push(joinClause);
+    return this;
+  }
+  orderBy(...clauses) {
+    this._orderBy.push(...clauses);
+    return this;
+  }
+  limit(value) {
+    this._limit = value;
+    return this;
+  }
+  offset(value) {
+    this._offset = value;
+    return this;
+  }
+  // The final execution step
+  async execute() {
+    if (!this._table) {
+      throw new Error("Cannot execute select query without a 'from' table.");
+    }
+    const db3 = getDb();
+    const bindings = [];
+    let query = `SELECT ${this._selectedColumns.join(", ")} FROM ${this._table._tableName}`;
+    if (this._joins.length > 0) {
+      query += ` ${this._joins.join(" ")}`;
+    }
+    if (this._where.length > 0) {
+      const whereClauses = this._where.map((condition) => {
+        const sql2 = condition.toSQL();
+        bindings.push(...sql2.bindings);
+        return `(${sql2.clause})`;
+      });
+      query += ` WHERE ${whereClauses.join(" AND ")}`;
+    }
+    if (this._orderBy.length > 0) {
+      query += ` ORDER BY ${this._orderBy.join(", ")}`;
+    }
+    if (this._limit !== null) {
+      query += ` LIMIT ?`;
+      bindings.push(this._limit);
+    }
+    if (this._offset !== null) {
+      if (this._limit === null) {
+        query += ` LIMIT -1`;
+      }
+      query += ` OFFSET ?`;
+      bindings.push(this._offset);
+    }
+    return db3.select(query, bindings);
+  }
+};
+var TauriORM = class {
+  // Soft relational query API: db.query.users.findMany({ with: { posts: true } })
+  query = {};
+  _tables = null;
+  _relations = null;
+  // Deprecated: use configure()
+  configureQuery(tables, relations2) {
+    this.configure(tables, relations2);
+  }
+  select(fields) {
+    return new SelectQueryBuilder(fields);
+  }
+  // --- Drizzle-style CRUD builders ---
+  insert(table) {
+    return new class InsertBuilder {
+      _table = table;
+      _rows = [];
+      values(rowOrRows) {
+        this._rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
+        return this;
+      }
+      async execute() {
+        const db3 = getDb();
+        for (const data of this._rows) {
+          const keys = Object.keys(data);
+          const values = Object.values(data);
+          const placeholders = values.map(() => "?").join(", ");
+          const query = `INSERT INTO ${this._table._tableName} (${keys.join(
+            ", "
+          )}) VALUES (${placeholders})`;
+          await db3.execute(query, values);
+        }
+      }
+    }();
+  }
+  update(table) {
+    return new class UpdateBuilder {
+      _table = table;
+      _data = null;
+      _where = null;
+      set(data) {
+        this._data = data;
+        return this;
+      }
+      where(cond) {
+        this._where = cond;
+        return this;
+      }
+      async execute() {
+        if (!this._data)
+          throw new Error("Update requires set() before execute()");
+        const db3 = getDb();
+        const setKeys = Object.keys(this._data);
+        const setClause = setKeys.map((k) => `${k} = ?`).join(", ");
+        const bindings = Object.values(this._data);
+        let query = `UPDATE ${this._table._tableName} SET ${setClause}`;
+        if (this._where) {
+          if (typeof this._where.toSQL === "function") {
+            const sql2 = this._where.toSQL();
+            query += ` WHERE ${sql2.clause}`;
+            bindings.push(...sql2.bindings);
+          } else {
+            const entries = Object.entries(this._where);
+            if (entries.length > 0) {
+              query += ` WHERE ${entries.map(([k]) => `${k} = ?`).join(" AND ")}`;
+              bindings.push(...entries.map(([, v]) => v));
+            }
+          }
+        }
+        await db3.execute(query, bindings);
+      }
+    }();
+  }
+  delete(table) {
+    return new class DeleteBuilder {
+      _table = table;
+      _where = null;
+      where(cond) {
+        this._where = cond;
+        return this;
+      }
+      async execute() {
+        const db3 = getDb();
+        let query = `DELETE FROM ${this._table._tableName}`;
+        const bindings = [];
+        if (this._where) {
+          if (typeof this._where.toSQL === "function") {
+            const sql2 = this._where.toSQL();
+            query += ` WHERE ${sql2.clause}`;
+            bindings.push(...sql2.bindings);
+          } else {
+            const entries = Object.entries(this._where);
+            if (entries.length > 0) {
+              query += ` WHERE ${entries.map(([k]) => `${k} = ?`).join(" AND ")}`;
+              bindings.push(...entries.map(([, v]) => v));
+            }
+          }
+        }
+        await db3.execute(query, bindings);
+      }
+    }();
+  }
+  // legacy direct methods removed in favor of builder APIs
+  // legacy direct methods removed in favor of builder APIs
+  // legacy direct methods removed in favor of builder APIs
+  async run(query, bindings = []) {
+    const db3 = getDb();
+    await db3.execute(query, bindings);
+  }
+  // --- Migrations API ---
+  generateCreateTableSql(table) {
+    const tableName = table._tableName;
+    const columns = Object.values(table._schema);
+    const columnDefs = columns.map((col) => {
+      let def = `${col.name} ${col.type}`;
+      if (col.isPrimaryKey) {
+        def += col.autoIncrement ? " PRIMARY KEY AUTOINCREMENT" : " PRIMARY KEY";
+      }
+      if (col.isNotNull) def += " NOT NULL";
+      if (col.defaultValue !== void 0) {
+        const dv = col.defaultValue;
+        if (dv && typeof dv === "object" && "raw" in dv) {
+          def += ` DEFAULT ${dv.raw}`;
+        } else if (typeof dv === "string") {
+          def += ` DEFAULT '${dv.replace(/'/g, "''")}'`;
+        } else {
+          def += ` DEFAULT ${dv}`;
+        }
+      }
+      if (col.references && !col.isPrimaryKey) {
+        def += ` REFERENCES ${col.references.table} (${col.references.column})`;
+        if (col.references.onDelete)
+          def += ` ON DELETE ${col.references.onDelete.toUpperCase()}`;
+        if (col.references.onUpdate)
+          def += ` ON UPDATE ${col.references.onUpdate.toUpperCase()}`;
+      }
+      return def;
+    });
+    return `CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefs.join(
+      ", "
+    )});`;
+  }
+  async createTableIfNotExists(table) {
+    const sql2 = this.generateCreateTableSql(table);
+    await this.run(sql2);
+  }
+  async createTablesIfNotExist(tables) {
+    for (const t of tables) {
+      await this.createTableIfNotExists(t);
+    }
+  }
+  async ensureMigrationsTable() {
+    await this.run(
+      `CREATE TABLE IF NOT EXISTS _migrations (name TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)`
+    );
+  }
+  async hasMigration(name) {
+    const db3 = getDb();
+    const rows = await db3.select(
+      `SELECT name FROM _migrations WHERE name = ?`,
+      [name]
+    );
+    return Array.isArray(rows) && rows.length > 0;
+  }
+  async recordMigration(name) {
+    const db3 = getDb();
+    await db3.execute(
+      `INSERT INTO _migrations (name, applied_at) VALUES (?, ?)`,
+      [name, Date.now()]
+    );
+  }
+  async migrate(tables, options) {
+    const track = options?.track ?? true;
+    if (track) {
+      await this.ensureMigrationsTable();
+      const name = options?.name ?? `init:${tables.map((t) => t._tableName).join(",")}`;
+      const already = await this.hasMigration(name);
+      if (already) return;
+      await this.createTablesIfNotExist(tables);
+      await this.recordMigration(name);
+      return;
+    }
+    await this.createTablesIfNotExist(tables);
+  }
+  // Configure schema and relations, and generate db.query automatically
+  configure(tables, relDefs) {
+    this._tables = tables;
+    this._relations = relDefs ?? {};
+    this.query = makeQueryAPI(tables, this._relations);
+    return this;
+  }
+  // Convenience: migrate from configured tables
+  async migrateConfigured(options) {
+    if (!this._tables)
+      throw new Error("No tables configured. Call db.configure({...}) first.");
+    await this.migrate(Object.values(this._tables), options);
+  }
+};
+var db2 = new TauriORM();
+function relations(baseTable, builder) {
+  const ctx = {
+    one: (table, cfg) => ({ kind: "one", table, cfg }),
+    many: (table, cfg) => ({ kind: "many", table, cfg })
+  };
+  const rels = builder(ctx);
+  return rels;
+}
+function getPrimaryKey(table) {
+  const cols = Object.values(table._schema);
+  return cols.find((c) => c.isPrimaryKey) || cols.find((c) => c.name === "id") || cols[0];
+}
+function guessChildFk(child, base, rel) {
+  const childCols = Object.values(child._schema);
+  if (rel && rel.kind === "one" && rel.cfg?.fields?.[0])
+    return rel.cfg.fields[0];
+  const basePk = getPrimaryKey(base);
+  const guessNames = [
+    `${base._tableName}_id`,
+    `${base._tableName}Id`,
+    `${basePk.name}`,
+    `${base._tableName.slice(0, -1)}Id`
+  ];
+  return childCols.find((c) => guessNames.includes(c.name)) || childCols.find((c) => /.*_id$/i.test(c.name)) || null;
+}
+function isFlatWith(spec) {
+  return Object.values(spec).every((v) => typeof v === "boolean");
+}
+function makeQueryAPI(tables, relDefs) {
+  const api = {};
+  const tableKeyByName = {};
+  for (const [k, t] of Object.entries(tables)) tableKeyByName[t._tableName] = k;
+  for (const [tblKey, tbl] of Object.entries(tables)) {
+    api[tblKey] = {
+      async findMany(opts) {
+        const base = tbl;
+        const withSpec = opts?.with ?? {};
+        const dbi = getDb();
+        const rels = relDefs[tblKey] ?? {};
+        if (opts?.join && isFlatWith(withSpec)) {
+          const baseCols = Object.values(base._schema);
+          const basePk = baseCols.find((c) => c.isPrimaryKey) || baseCols.find((c) => c.name === "id") || baseCols[0];
+          const selectParts = [];
+          let baseSelected2;
+          if (opts?.columns && !Array.isArray(opts.columns)) {
+            baseSelected2 = Object.entries(opts.columns).filter(([, v]) => !!v).map(([k]) => k);
+          } else if (Array.isArray(opts?.columns) && opts.columns.length > 0) {
+            baseSelected2 = opts.columns;
+          } else {
+            baseSelected2 = baseCols.map((c) => c.name);
+          }
+          for (const name of baseSelected2)
+            selectParts.push(`${base._tableName}.${name} AS __base_${name}`);
+          const joins = [];
+          const relColsMap = {};
+          const fkMap = {};
+          for (const [relName, enabled] of Object.entries(withSpec)) {
+            if (!enabled) continue;
+            const rel = rels[relName];
+            if (!rel) continue;
+            const child = rel.table;
+            const childCols = Object.values(child._schema);
+            const childPk = childCols.find((c) => c.isPrimaryKey) || childCols.find((c) => c.name === "id") || null;
+            const childFk = guessChildFk(child, base, rel);
+            if (!childFk) continue;
+            fkMap[relName] = { childFk, childPk };
+            const selected = typeof enabled === "object" && enabled.columns?.length ? enabled.columns : childCols.map((c) => c.name);
+            relColsMap[relName] = selected;
+            for (const name of selected)
+              selectParts.push(
+                `${child._tableName}.${name} AS __rel_${relName}_${name}`
+              );
+            joins.push(
+              `LEFT JOIN ${child._tableName} ON ${child._tableName}.${childFk.name} = ${base._tableName}.${basePk.name}`
+            );
+          }
+          let sqlText = `SELECT ${selectParts.join(", ")} FROM ${base._tableName}${joins.length ? " " + joins.join(" ") : ""}`;
+          const bindings = [];
+          if (opts?.where) {
+            if (typeof opts.where.toSQL === "function") {
+              const w = opts.where.toSQL();
+              sqlText += ` WHERE ${w.clause}`;
+              bindings.push(...w.bindings);
+            } else {
+              const entries = Object.entries(opts.where);
+              if (entries.length > 0) {
+                sqlText += ` WHERE ${entries.map(([k]) => `${base._tableName}.${k} = ?`).join(" AND ")}`;
+                bindings.push(...entries.map(([, v]) => v));
+              }
+            }
+          }
+          if (opts?.orderBy?.length)
+            sqlText += ` ORDER BY ${opts.orderBy.join(", ")}`;
+          if (typeof opts?.limit === "number")
+            sqlText += ` LIMIT ${opts.limit}`;
+          if (typeof opts?.offset === "number")
+            sqlText += ` OFFSET ${opts.offset}`;
+          const rows = await dbi.select(sqlText, bindings);
+          const groups = /* @__PURE__ */ new Map();
+          for (const row of rows) {
+            const baseObj = {};
+            for (const name of baseSelected2)
+              baseObj[name] = row[`__base_${name}`];
+            const baseKey = baseObj[basePk.name];
+            if (!groups.has(baseKey)) {
+              const seed = { ...baseObj };
+              for (const [relName, enabled] of Object.entries(withSpec)) {
+                if (!enabled) continue;
+                const rel = rels[relName];
+                if (!rel) continue;
+                seed[relName] = rel.kind === "many" ? [] : null;
+              }
+              groups.set(baseKey, seed);
+            }
+            const acc = groups.get(baseKey);
+            for (const [relName, enabled] of Object.entries(withSpec)) {
+              if (!enabled) continue;
+              const rel = rels[relName];
+              if (!rel) continue;
+              const childCols = relColsMap[relName];
+              const childObj = {};
+              let allNull = true;
+              for (const name of childCols) {
+                const v = row[`__rel_${relName}_${name}`];
+                childObj[name] = v;
+                if (v !== null && v !== void 0) allNull = false;
+              }
+              if (allNull) continue;
+              if (rel.kind === "many") {
+                const childPk = fkMap[relName].childPk;
+                if (childPk) {
+                  if (!acc[relName]) acc[relName] = [];
+                  const exists = acc[relName].some(
+                    (r) => r[childPk.name] === childObj[childPk.name]
+                  );
+                  if (!exists) acc[relName].push(childObj);
+                } else {
+                  acc[relName].push(childObj);
+                }
+              } else {
+                acc[relName] = childObj;
+              }
+            }
+          }
+          return Array.from(groups.values());
+        }
+        let baseSelected;
+        if (opts?.columns && !Array.isArray(opts.columns)) {
+          baseSelected = Object.entries(opts.columns).filter(([, v]) => !!v).map(([k]) => k);
+        } else if (Array.isArray(opts?.columns) && opts.columns.length > 0) {
+          baseSelected = opts.columns;
+        } else {
+          baseSelected = Object.values(base._schema).map(
+            (c) => c.name
+          );
+        }
+        let baseSql = `SELECT ${baseSelected.join(", ")} FROM ${base._tableName}`;
+        const baseBindings = [];
+        if (opts?.where) {
+          if (typeof opts.where.toSQL === "function") {
+            const w = opts.where.toSQL();
+            baseSql += ` WHERE ${w.clause}`;
+            baseBindings.push(...w.bindings);
+          } else {
+            const entries = Object.entries(opts.where);
+            if (entries.length > 0) {
+              baseSql += ` WHERE ${entries.map(([k]) => `${k} = ?`).join(" AND ")}`;
+              baseBindings.push(...entries.map(([, v]) => v));
+            }
+          }
+        }
+        if (opts?.orderBy?.length)
+          baseSql += ` ORDER BY ${opts.orderBy.join(", ")}`;
+        if (typeof opts?.limit === "number") baseSql += ` LIMIT ${opts.limit}`;
+        if (typeof opts?.offset === "number")
+          baseSql += ` OFFSET ${opts.offset}`;
+        const baseRows = await dbi.select(baseSql, baseBindings);
+        const result = baseRows.map((r) => ({ ...r }));
+        async function loadRelationsFor(parents, parentTable, spec) {
+          const parentPk = getPrimaryKey(parentTable);
+          const parentIds = parents.map((p) => p[parentPk.name]);
+          const relsMap = relDefs[Object.keys(tables).find(
+            (k) => tables[k]._tableName === parentTable._tableName
+          )] || {};
+          for (const [relName, v] of Object.entries(spec)) {
+            const enabled = v;
+            const rel = relsMap[relName];
+            if (!rel) continue;
+            const child = rel.table;
+            const childCols = Object.values(child._schema);
+            const selectCols = enabled?.columns && enabled.columns.length > 0 ? enabled.columns : childCols.map((c) => c.name);
+            const fkCol = guessChildFk(child, parentTable, rel);
+            if (!fkCol) continue;
+            if (rel.kind === "many") {
+              const sql2 = `SELECT ${selectCols.join(", ")} FROM ${child._tableName} WHERE ${fkCol.name} IN (${parentIds.map(() => "?").join(", ")})`;
+              const rows = await dbi.select(sql2, parentIds);
+              const buckets = /* @__PURE__ */ new Map();
+              for (const r of rows) {
+                const key = r[fkCol.name];
+                if (!buckets.has(key)) buckets.set(key, []);
+                buckets.get(key).push(r);
+              }
+              for (const p of parents)
+                p[relName] = buckets.get(p[parentPk.name]) ?? [];
+              if (enabled?.with) {
+                const children = parents.flatMap(
+                  (p) => p[relName]
+                );
+                if (children.length > 0)
+                  await loadRelationsFor(children, child, enabled.with);
+              }
+            } else {
+              const sql2 = `SELECT ${selectCols.join(", ")} FROM ${child._tableName} WHERE ${fkCol.name} IN (${parentIds.map(() => "?").join(", ")})`;
+              const rows = await dbi.select(sql2, parentIds);
+              const mapOne = /* @__PURE__ */ new Map();
+              for (const r of rows) mapOne.set(r[fkCol.name], r);
+              for (const p of parents)
+                p[relName] = mapOne.get(p[parentPk.name]) ?? null;
+              if (enabled?.with) {
+                const children = parents.map((p) => p[relName]).filter(Boolean);
+                if (children.length > 0)
+                  await loadRelationsFor(children, child, enabled.with);
+              }
+            }
+          }
+        }
+        if (Object.keys(withSpec).length > 0) {
+          await loadRelationsFor(result, base, withSpec);
+        }
+        return result;
+      }
+    };
+  }
+  return api;
+}
+
+// src/sql-helpers.ts
+function isColumn(value) {
+  return typeof value === "object" && value !== null && "_dataType" in value;
+}
+function getQualifiedName(column) {
+  if (column.tableName) return `${column.tableName}.${column.name}`;
+  return column.name;
+}
+function comparison(operator, column, value) {
+  return {
+    toSQL: () => {
+      if (isColumn(value)) {
+        return {
+          clause: `${getQualifiedName(column)} ${operator} ${getQualifiedName(
+            value
+          )}`,
+          bindings: []
+        };
+      }
+      return {
+        clause: `${getQualifiedName(column)} ${operator} ?`,
+        bindings: [value]
+      };
+    }
+  };
+}
+var eq = (column, value) => comparison("=", column, value);
+var ne = (column, value) => comparison("!=", column, value);
+var gt = (column, value) => comparison(">", column, value);
+var gte = (column, value) => comparison(">=", column, value);
+var lt = (column, value) => comparison("<", column, value);
+var lte = (column, value) => comparison("<=", column, value);
+var like = (column, value) => comparison("LIKE", column, value);
+var asc = (column) => `${column.name} ASC`;
+var desc = (column) => `${column.name} DESC`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TauriORM,
+  asc,
+  blob,
+  boolean,
+  db,
+  defineTable,
+  desc,
+  eq,
+  getDb,
+  gt,
+  gte,
+  initDb,
+  integer,
+  like,
+  lt,
+  lte,
+  makeQueryAPI,
+  ne,
+  numeric,
+  real,
+  relations,
+  sql,
+  text,
+  timestamp
+});