@type32/tauri-sqlite-orm 0.1.3 → 0.1.5

package/dist/index.js

@@ -31,53 +31,58 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   TauriORM: () => TauriORM,
+  and: () => and,
   asc: () => asc,
+  between: () => between,
   blob: () => blob,
   boolean: () => boolean,
-  db: () => db2,
+  check: () => check,
   defineTable: () => defineTable,
   desc: () => desc,
   eq: () => eq,
-  getDb: () => getDb,
+  exists: () => exists,
+  foreignKey: () => foreignKey,
+  getQualifiedName: () => getQualifiedName,
   gt: () => gt,
   gte: () => gte,
-  initDb: () => initDb,
+  ilike: () => ilike,
+  inArray: () => inArray,
+  increments: () => increments,
+  index: () => index,
   integer: () => integer,
+  isNotNull: () => isNotNull,
+  isNull: () => isNull,
   like: () => like,
   lt: () => lt,
   lte: () => lte,
   makeQueryAPI: () => makeQueryAPI,
   ne: () => ne,
+  not: () => not,
+  notBetween: () => notBetween,
+  notExists: () => notExists,
+  notIlike: () => notIlike,
+  notInArray: () => notInArray,
   numeric: () => numeric,
+  or: () => or,
+  primaryKey: () => primaryKey,
+  raw: () => raw,
   real: () => real,
   relations: () => relations,
   sql: () => sql,
   text: () => text,
-  timestamp: () => timestamp
+  timestamp: () => timestamp,
+  unique: () => unique,
+  uniqueIndex: () => uniqueIndex
 });
 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(
+  const raw2 = strings.reduce(
     (acc, part, idx) => acc + part + (idx < values.length ? String(values[idx]) : ""),
     ""
   );
-  return { raw };
+  return { raw: raw2 };
 }
 function createColumn(params) {
   const col = { ...params };
@@ -99,6 +104,18 @@ function createColumn(params) {
     col.defaultFn = fn;
     return col;
   };
+  col.$default = (fn) => {
+    col.defaultFn = fn;
+    return col;
+  };
+  col.$onUpdate = (fn) => {
+    col.onUpdateFn = fn;
+    return col;
+  };
+  col.$onUpdateFn = (fn) => {
+    col.onUpdateFn = fn;
+    return col;
+  };
   col.references = (target, actions) => {
     const t = target();
     col.references = {
@@ -111,34 +128,43 @@ function createColumn(params) {
   };
   return col;
 }
-function text(name, config) {
+function text(nameOrConfig, maybeConfig) {
+  const name = typeof nameOrConfig === "string" ? nameOrConfig : "";
+  const config = typeof nameOrConfig === "string" ? maybeConfig : nameOrConfig;
   const col = createColumn({
     name,
     type: "TEXT",
-    isPrimaryKey: config?.isPrimaryKey,
     _dataType: ""
   });
   if (config?.enum) col.enumValues = config.enum;
+  if (config?.mode) col.mode = config.mode;
   return col;
 }
-function integer(name, config) {
+function integer(nameOrConfig, maybeConfig) {
+  const name = typeof nameOrConfig === "string" ? nameOrConfig : "";
+  const config = typeof nameOrConfig === "string" ? maybeConfig : nameOrConfig;
   let dt = 0;
   if (config?.mode === "boolean") dt = false;
-  if (config?.mode === "timestamp") dt = /* @__PURE__ */ new Date();
+  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms")
+    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 });
+  return createColumn({
+    name: name ?? "",
+    type: "REAL",
+    _dataType: 0
+  });
 }
-function blob(name, config) {
+function blob(nameOrConfig, maybeConfig) {
+  const name = typeof nameOrConfig === "string" ? nameOrConfig : "";
+  const config = typeof nameOrConfig === "string" ? maybeConfig : nameOrConfig;
   let dt = new Uint8Array();
   if (config?.mode === "bigint") dt = 0n;
   if (config?.mode === "json") dt = void 0;
@@ -149,7 +175,9 @@ function blob(name, config) {
     _dataType: dt
   });
 }
-function numeric(name, config) {
+function numeric(nameOrConfig, maybeConfig) {
+  const name = typeof nameOrConfig === "string" ? nameOrConfig : "";
+  const config = typeof nameOrConfig === "string" ? maybeConfig : nameOrConfig;
   let dt = "";
   if (config?.mode === "number") dt = 0;
   if (config?.mode === "bigint") dt = 0n;
@@ -160,59 +188,346 @@ function numeric(name, config) {
     _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) {
+function boolean(name) {
+  return createColumn({
+    name: name ?? "",
+    type: "INTEGER",
+    _dataType: false,
+    mode: "boolean"
+  });
+}
+function timestamp(name) {
+  return createColumn({
+    name: name ?? "",
+    type: "INTEGER",
+    _dataType: /* @__PURE__ */ new Date(),
+    mode: "timestamp"
+  });
+}
+function increments(name) {
+  return integer(name ?? "").primaryKey({
+    autoIncrement: true
+  });
+}
+function unique(name) {
+  return {
+    on: (...cols) => ({ name, columns: cols.map((c) => c.name) })
+  };
+}
+function primaryKey(opts) {
+  return { name: opts.name, columns: opts.columns.map((c) => c.name) };
+}
+function check(name, expr) {
+  return { name, expr };
+}
+function foreignKey(opts) {
+  const first = opts.columns[0];
+  return {
+    name: opts.name,
+    columns: opts.columns.map((c) => c.name),
+    foreignTable: first?.tableName || opts.foreignColumns[0]?.tableName || "",
+    foreignColumns: opts.foreignColumns.map((c) => c.name),
+    onDelete: opts.onDelete,
+    onUpdate: opts.onUpdate
+  };
+}
+function index(name) {
+  return {
+    on: (...cols) => ({ name, columns: cols.map((c) => c.name) }),
+    where: (expr) => ({ name, columns: [], where: expr })
+  };
+}
+function uniqueIndex(name) {
+  return {
+    on: (...cols) => ({ name, columns: cols.map((c) => c.name), unique: true }),
+    where: (expr) => ({ name, columns: [], unique: true, where: expr })
+  };
+}
+function defineTable(tableName, schema, extras) {
   const finalizedSchema = { ...schema };
   for (const key of Object.keys(finalizedSchema)) {
     const col = finalizedSchema[key];
+    if (!col.name || col.name === "") col.name = key;
     col.tableName = tableName;
   }
   const table = {
     _tableName: tableName,
     _schema: finalizedSchema,
+    _constraints: [],
+    _indexes: [],
     // The Drizzle-like type inference properties
     $inferSelect: {},
     $inferInsert: {}
-    // Example: omit 'id' for inserts
+    // omit PK columns
   };
   for (const [key, col] of Object.entries(finalizedSchema)) {
     table[key] = col;
   }
+  if (extras) {
+    const specs = extras(table) || [];
+    for (const s of specs) {
+      if (s.columns && s.unique !== void 0) {
+        table._indexes.push(s);
+      } else if (s.columns && s.foreignColumns) {
+        table._constraints.push(s);
+      } else if (s.columns && (s.name || s.name === void 0)) {
+        if (s.columns && s.name !== void 0 && s.columns.length > 0) {
+          const pk = s;
+          if (pk.columns.length > 1 || pk.name && pk.name.length > 0) {
+            table._constraints.push(s);
+          } else {
+            table._constraints.push(s);
+          }
+        } else {
+          table._constraints.push(s);
+        }
+      } else if (s.expr) {
+        table._constraints.push(s);
+      }
+    }
+  }
   return table;
 }
 
+// src/orm.ts
+var import_plugin_sql = __toESM(require("@tauri-apps/plugin-sql"));
+
+// src/sql-helpers.ts
+function raw(strings, ...values) {
+  return {
+    toSQL: () => {
+      let clause = "";
+      const bindings = [];
+      for (let i = 0; i < strings.length; i++) {
+        clause += strings[i];
+        if (i < values.length) {
+          const v = values[i];
+          if (v && typeof v === "object" && typeof v.toSQL === "function") {
+            const s = v.toSQL();
+            clause += s.clause;
+            bindings.push(...s.bindings);
+          } else if (v && typeof v === "object" && "_dataType" in v) {
+            clause += getQualifiedName(v);
+          } else {
+            clause += "?";
+            bindings.push(v);
+          }
+        }
+      }
+      return { clause, bindings };
+    }
+  };
+}
+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 and = (...conditions) => ({
+  toSQL: () => {
+    const parts = [];
+    const bindings = [];
+    for (const c of conditions) {
+      const s = c.toSQL();
+      parts.push(`(${s.clause})`);
+      bindings.push(...s.bindings);
+    }
+    return { clause: parts.join(" AND "), bindings };
+  }
+});
+var or = (...conditions) => ({
+  toSQL: () => {
+    const parts = [];
+    const bindings = [];
+    for (const c of conditions) {
+      const s = c.toSQL();
+      parts.push(`(${s.clause})`);
+      bindings.push(...s.bindings);
+    }
+    return { clause: parts.join(" OR "), bindings };
+  }
+});
+var not = (condition) => ({
+  toSQL: () => {
+    const s = condition.toSQL();
+    return { clause: `NOT (${s.clause})`, bindings: s.bindings };
+  }
+});
+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 ilike = (column, value) => ({
+  toSQL: () => {
+    const colExpr = `LOWER(${getQualifiedName(column)})`;
+    if (isColumn(value)) {
+      return {
+        clause: `${colExpr} LIKE LOWER(${getQualifiedName(value)})`,
+        bindings: []
+      };
+    }
+    return { clause: `${colExpr} LIKE LOWER(?)`, bindings: [value] };
+  }
+});
+var notIlike = (column, value) => ({
+  toSQL: () => {
+    const colExpr = `LOWER(${getQualifiedName(column)})`;
+    if (isColumn(value)) {
+      return {
+        clause: `${colExpr} NOT LIKE LOWER(${getQualifiedName(value)})`,
+        bindings: []
+      };
+    }
+    return { clause: `${colExpr} NOT LIKE LOWER(?)`, bindings: [value] };
+  }
+});
+var isNull = (column) => ({
+  toSQL: () => ({
+    clause: `${getQualifiedName(column)} IS NULL`,
+    bindings: []
+  })
+});
+var isNotNull = (column) => ({
+  toSQL: () => ({
+    clause: `${getQualifiedName(column)} IS NOT NULL`,
+    bindings: []
+  })
+});
+var between = (column, from, to) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    const [fromClause, fromBindings] = isColumn(from) ? [getQualifiedName(from), []] : ["?", [from]];
+    const [toClause, toBindings] = isColumn(to) ? [getQualifiedName(to), []] : ["?", [to]];
+    return {
+      clause: `${left} BETWEEN ${fromClause} AND ${toClause}`,
+      bindings: [...fromBindings, ...toBindings]
+    };
+  }
+});
+var notBetween = (column, from, to) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    const [fromClause, fromBindings] = isColumn(from) ? [getQualifiedName(from), []] : ["?", [from]];
+    const [toClause, toBindings] = isColumn(to) ? [getQualifiedName(to), []] : ["?", [to]];
+    return {
+      clause: `${left} NOT BETWEEN ${fromClause} AND ${toClause}`,
+      bindings: [...fromBindings, ...toBindings]
+    };
+  }
+});
+var inArray = (column, valuesOrQuery) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    if (Array.isArray(valuesOrQuery)) {
+      const placeholders = valuesOrQuery.map(() => "?").join(", ");
+      return {
+        clause: `${left} IN (${placeholders})`,
+        bindings: valuesOrQuery
+      };
+    }
+    const sq = valuesOrQuery.toSQL ? valuesOrQuery.toSQL() : valuesOrQuery.toSQL();
+    return { clause: `${left} IN (${sq.clause})`, bindings: sq.bindings };
+  }
+});
+var notInArray = (column, valuesOrQuery) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    if (Array.isArray(valuesOrQuery)) {
+      const placeholders = valuesOrQuery.map(() => "?").join(", ");
+      return {
+        clause: `${left} NOT IN (${placeholders})`,
+        bindings: valuesOrQuery
+      };
+    }
+    const sq = valuesOrQuery.toSQL ? valuesOrQuery.toSQL() : valuesOrQuery.toSQL();
+    return { clause: `${left} NOT IN (${sq.clause})`, bindings: sq.bindings };
+  }
+});
+var exists = (subquery) => ({
+  toSQL: () => {
+    const sq = subquery.toSQL ? subquery.toSQL() : subquery.toSQL();
+    return { clause: `EXISTS (${sq.clause})`, bindings: sq.bindings };
+  }
+});
+var notExists = (subquery) => ({
+  toSQL: () => {
+    const sq = subquery.toSQL ? subquery.toSQL() : subquery.toSQL();
+    return { clause: `NOT EXISTS (${sq.clause})`, bindings: sq.bindings };
+  }
+});
+var asc = (column) => `${getQualifiedName(column)} ASC`;
+var desc = (column) => `${getQualifiedName(column)} DESC`;
+
 // src/orm.ts
 var SelectQueryBuilder = class {
   _table = null;
-  _selectedColumns = ["*"];
+  _selectedColumns = [];
   _joins = [];
   _where = [];
   _orderBy = [];
   _limit = null;
   _offset = null;
-  _eager = {};
-  constructor(fields) {
+  _groupBy = [];
+  _having = [];
+  _distinct = false;
+  _dbProvider;
+  constructor(dbProvider, fields) {
+    this._dbProvider = dbProvider;
     if (fields) {
-      this._selectedColumns = Object.values(fields).map((c) => c.name);
+      for (const [alias, col] of Object.entries(fields)) {
+        const sql2 = getQualifiedName(col);
+        this._selectedColumns.push({ sql: sql2, alias });
+      }
     }
   }
+  distinct() {
+    this._distinct = true;
+    return this;
+  }
+  select(fields) {
+    this._selectedColumns = [];
+    for (const [alias, expr] of Object.entries(fields)) {
+      if (typeof expr.toSQL === "function") {
+        const s = expr.toSQL();
+        this._selectedColumns.push({ sql: s.clause, alias });
+      } else {
+        this._selectedColumns.push({
+          sql: getQualifiedName(expr),
+          alias
+        });
+      }
+    }
+    return this;
+  }
   from(table) {
     this._table = table;
     return this;
   }
   where(...conditions) {
-    this._where.push(...conditions);
+    this._where.push(...conditions.filter(Boolean));
     return this;
   }
   leftJoin(otherTable, on) {
@@ -221,8 +536,26 @@ var SelectQueryBuilder = class {
     this._joins.push(joinClause);
     return this;
   }
+  groupBy(...exprs) {
+    for (const e of exprs) {
+      if (!e) continue;
+      if (typeof e === "string") this._groupBy.push(e);
+      else this._groupBy.push(getQualifiedName(e));
+    }
+    return this;
+  }
+  having(...conditions) {
+    this._having.push(...conditions);
+    return this;
+  }
   orderBy(...clauses) {
-    this._orderBy.push(...clauses);
+    for (const c of clauses) {
+      if (!c) continue;
+      if (typeof c === "string") this._orderBy.push(c);
+      else if (typeof c.toSQL === "function")
+        this._orderBy.push(c);
+      else this._orderBy.push(getQualifiedName(c));
+    }
     return this;
   }
   limit(value) {
@@ -233,17 +566,15 @@ var SelectQueryBuilder = class {
     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 db = await this._dbProvider();
     const bindings = [];
-    let query = `SELECT ${this._selectedColumns.join(", ")} FROM ${this._table._tableName}`;
-    if (this._joins.length > 0) {
-      query += ` ${this._joins.join(" ")}`;
-    }
+    const selectList = this._selectedColumns.length > 0 ? this._selectedColumns.map((c) => c.alias ? `${c.sql} AS ${c.alias}` : c.sql).join(", ") : Object.values(this._table._schema).map((c) => `${this._table._tableName}.${c.name}`).join(", ");
+    let query = `SELECT ${this._distinct ? "DISTINCT " : ""}${selectList} 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();
@@ -252,21 +583,46 @@ var SelectQueryBuilder = class {
       });
       query += ` WHERE ${whereClauses.join(" AND ")}`;
     }
+    if (this._groupBy.length > 0) {
+      query += ` GROUP BY ${this._groupBy.join(", ")}`;
+    }
+    if (this._having.length > 0) {
+      const havingClauses = this._having.map((h) => {
+        const sql2 = h.toSQL();
+        bindings.push(...sql2.bindings);
+        return `(${sql2.clause})`;
+      });
+      query += ` HAVING ${havingClauses.join(" AND ")}`;
+    }
     if (this._orderBy.length > 0) {
-      query += ` ORDER BY ${this._orderBy.join(", ")}`;
+      const ordParts = [];
+      for (const ob of this._orderBy) {
+        if (typeof ob === "string") ordParts.push(ob);
+        else {
+          const s = ob.toSQL();
+          ordParts.push(s.clause);
+          bindings.push(...s.bindings);
+        }
+      }
+      query += ` ORDER BY ${ordParts.join(", ")}`;
     }
     if (this._limit !== null) {
       query += ` LIMIT ?`;
       bindings.push(this._limit);
     }
     if (this._offset !== null) {
-      if (this._limit === null) {
-        query += ` LIMIT -1`;
-      }
+      if (this._limit === null) query += ` LIMIT -1`;
       query += ` OFFSET ?`;
       bindings.push(this._offset);
     }
-    return db3.select(query, bindings);
+    return db.select(query, bindings);
+  }
+  async iterator() {
+    const rows = await this.execute();
+    async function* gen() {
+      for (const r of rows) yield r;
+    }
+    return gen();
   }
 };
 var TauriORM = class {
@@ -274,48 +630,154 @@ var TauriORM = class {
   query = {};
   _tables = null;
   _relations = null;
+  _dbPromise;
+  constructor(dbUri) {
+    this._dbPromise = import_plugin_sql.default.load(dbUri);
+  }
+  async getDb() {
+    return this._dbPromise;
+  }
   // Deprecated: use configure()
   configureQuery(tables, relations2) {
     this.configure(tables, relations2);
   }
   select(fields) {
-    return new SelectQueryBuilder(fields);
+    return new SelectQueryBuilder(this.getDb.bind(this), fields);
+  }
+  selectDistinct(fields) {
+    const qb = new SelectQueryBuilder(this.getDb.bind(this), fields);
+    qb.distinct();
+    return qb;
   }
   // --- Drizzle-style CRUD builders ---
   insert(table) {
+    const self = this;
     return new class InsertBuilder {
       _table = table;
       _rows = [];
+      _selectSql = null;
+      _conflict = null;
+      _returning = null;
       values(rowOrRows) {
         this._rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
         return this;
       }
+      select(qb) {
+        if (qb.toSQL) this._selectSql = qb.toSQL();
+        else this._selectSql = qb.toSQL();
+        return this;
+      }
+      returning(fields) {
+        this._returning = fields ?? {};
+        return this;
+      }
+      $returningId() {
+        this._returning = "__RETURNING_ID__";
+        return this;
+      }
+      onConflictDoNothing(opts) {
+        const target = opts?.target ? Array.isArray(opts.target) ? opts.target.map((c) => c.name) : opts.target.name : void 0;
+        this._conflict = {
+          kind: "doNothing",
+          target,
+          where: opts?.where
+        };
+        return this;
+      }
+      onConflictDoUpdate(opts) {
+        const target = Array.isArray(opts.target) ? opts.target.map((c) => c.name) : opts.target.name;
+        this._conflict = {
+          kind: "doUpdate",
+          target,
+          targetWhere: opts.targetWhere,
+          set: opts.set,
+          setWhere: opts.setWhere
+        };
+        return this;
+      }
       async execute() {
-        const db3 = getDb();
+        const db = await self.getDb();
+        if (this._selectSql) {
+          const cols = Object.keys(this._table._schema);
+          let query = `INSERT INTO ${this._table._tableName} (${cols.join(", ")}) ${this._selectSql.clause}`;
+          const bindings = [...this._selectSql.bindings];
+          query += this._buildConflictClause();
+          const ret = await this._executeWithReturning(db, query, bindings);
+          return ret;
+        }
         for (const data of this._rows) {
           const finalData = { ...data };
           const schema = this._table._schema;
           for (const [key, col] of Object.entries(schema)) {
-            if (finalData[key] === void 0 && col.defaultFn) {
-              finalData[key] = col.defaultFn();
+            if (finalData[key] === void 0) {
+              if (col.defaultFn) {
+                finalData[key] = col.defaultFn();
+              } else if (col.onUpdateFn) {
+                finalData[key] = col.onUpdateFn();
+              }
             }
           }
           const keys = Object.keys(finalData);
           const values = Object.values(finalData);
           const placeholders = values.map(() => "?").join(", ");
-          const query = `INSERT INTO ${this._table._tableName} (${keys.join(
-            ", "
-          )}) VALUES (${placeholders})`;
-          await db3.execute(query, values);
+          let query = `INSERT INTO ${this._table._tableName} (${keys.join(", ")}) VALUES (${placeholders})`;
+          const bindings = [...values];
+          query += this._buildConflictClause();
+          const ret = await this._executeWithReturning(db, query, bindings);
+          if (ret !== void 0) return ret;
+        }
+      }
+      _buildConflictClause() {
+        if (!this._conflict) return "";
+        if (this._conflict.kind === "doNothing") {
+          const tgt2 = this._conflict.target ? Array.isArray(this._conflict.target) ? `(${this._conflict.target.join(", ")})` : `(${this._conflict.target})` : "";
+          const where = this._conflict.where ? ` WHERE ${this._conflict.where.toSQL().clause}` : "";
+          return ` ON CONFLICT ${tgt2} DO NOTHING${where}`;
         }
+        const c = this._conflict;
+        const tgt = Array.isArray(c.target) ? `(${c.target.join(", ")})` : `(${c.target})`;
+        const setKeys = Object.keys(c.set ?? {});
+        const setClause = setKeys.map((k) => {
+          const v = c.set[k];
+          return `${k} = ${typeof v === "object" && v && typeof v.toSQL === "function" ? v.toSQL().clause : "?"}`;
+        }).join(", ");
+        const targetWhere = c.targetWhere ? ` WHERE ${c.targetWhere.toSQL().clause}` : "";
+        const setWhere = c.setWhere ? ` WHERE ${c.setWhere.toSQL().clause}` : "";
+        return ` ON CONFLICT ${tgt}${targetWhere} DO UPDATE SET ${setClause}${setWhere}`;
+      }
+      async _executeWithReturning(db, query, bindings) {
+        if (this._returning === null) {
+          await db.execute(query, bindings);
+          return void 0;
+        }
+        if (this._returning === "__RETURNING_ID__") {
+          const rows = await db.select(`SELECT last_insert_rowid() as id`);
+          return rows.map((r) => ({ id: r.id }));
+        }
+        if (typeof this._returning === "object") {
+          const cols = Object.entries(
+            this._returning
+          ).map(
+            ([alias, col]) => `${col.tableName}.${col.name} AS ${alias}`
+          ).join(", ");
+          const retSql = `${query} RETURNING ${cols}`;
+          const res = await db.select(retSql, bindings);
+          return res;
+        }
+        return void 0;
       }
     }();
   }
   update(table) {
+    const self = this;
     return new class UpdateBuilder {
       _table = table;
       _data = null;
       _where = null;
+      _orderBy = [];
+      _limit = null;
+      _from = null;
+      _returning = null;
       set(data) {
         this._data = data;
         return this;
@@ -324,14 +786,54 @@ var TauriORM = class {
         this._where = cond;
         return this;
       }
+      orderBy(...clauses) {
+        for (const c of clauses) {
+          if (!c) continue;
+          if (typeof c === "string") this._orderBy.push(c);
+          else if (typeof c.toSQL === "function")
+            this._orderBy.push(c);
+          else this._orderBy.push(getQualifiedName(c));
+        }
+        return this;
+      }
+      limit(n) {
+        this._limit = n;
+        return this;
+      }
+      from(tbl) {
+        this._from = tbl;
+        return this;
+      }
+      returning(fields) {
+        this._returning = fields ?? {};
+        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}`;
+        const db = await self.getDb();
+        const schema = this._table._schema;
+        const dataToSet = { ...this._data };
+        for (const [key, col] of Object.entries(schema)) {
+          if (!(key in dataToSet) && col.onUpdateFn) {
+            dataToSet[key] = col.onUpdateFn();
+          }
+        }
+        const setParts = [];
+        const bindings = [];
+        for (const [k, v] of Object.entries(dataToSet)) {
+          if (v === void 0) continue;
+          if (v && typeof v === "object" && typeof v.toSQL === "function") {
+            const s = v.toSQL();
+            setParts.push(`${k} = ${s.clause}`);
+            bindings.push(...s.bindings);
+          } else {
+            setParts.push(`${k} = ?`);
+            bindings.push(v);
+          }
+        }
+        let query = `UPDATE ${this._table._tableName} SET ${setParts.join(", ")}`;
+        if (this._from) query += ` FROM ${this._from._tableName}`;
         if (this._where) {
           if (typeof this._where.toSQL === "function") {
             const sql2 = this._where.toSQL();
@@ -345,20 +847,67 @@ var TauriORM = class {
             }
           }
         }
-        await db3.execute(query, bindings);
+        if (this._orderBy.length > 0) {
+          const ordParts = [];
+          for (const ob of this._orderBy) {
+            if (typeof ob === "string") ordParts.push(ob);
+            else {
+              const s = ob.toSQL();
+              ordParts.push(s.clause);
+              bindings.push(...s.bindings);
+            }
+          }
+          query += ` ORDER BY ${ordParts.join(", ")}`;
+        }
+        if (this._limit !== null) {
+          query += ` LIMIT ?`;
+          bindings.push(this._limit);
+        }
+        if (this._returning) {
+          const cols = Object.entries(
+            this._returning
+          ).map(
+            ([alias, col]) => `${col.tableName}.${col.name} AS ${alias}`
+          ).join(", ");
+          const retSql = `${query} RETURNING ${cols}`;
+          return await db.select(retSql, bindings);
+        }
+        await db.execute(query, bindings);
       }
     }();
   }
   delete(table) {
+    const self = this;
     return new class DeleteBuilder {
       _table = table;
       _where = null;
+      _orderBy = [];
+      _limit = null;
+      _returning = null;
       where(cond) {
         this._where = cond;
         return this;
       }
+      orderBy(...clauses) {
+        for (const c of clauses) {
+          if (!c) continue;
+          if (typeof c === "string") this._orderBy.push(c);
+          else if (typeof c.toSQL === "function")
+            this._orderBy.push(c);
+          else this._orderBy.push(getQualifiedName(c));
+        }
+        return this;
+      }
+      limit(n) {
+        this._limit = n;
+        return this;
+      }
+      returning(fields) {
+        this._returning = fields ?? {};
+        return this;
+      }
       async execute() {
-        const db3 = getDb();
+        const db = await self.getDb();
         let query = `DELETE FROM ${this._table._tableName}`;
         const bindings = [];
         if (this._where) {
@@ -374,7 +923,32 @@ var TauriORM = class {
             }
           }
         }
-        await db3.execute(query, bindings);
+        if (this._orderBy.length > 0) {
+          const ordParts = [];
+          for (const ob of this._orderBy) {
+            if (typeof ob === "string") ordParts.push(ob);
+            else {
+              const s = ob.toSQL();
+              ordParts.push(s.clause);
+              bindings.push(...s.bindings);
+            }
+          }
+          query += ` ORDER BY ${ordParts.join(", ")}`;
+        }
+        if (this._limit !== null) {
+          query += ` LIMIT ?`;
+          bindings.push(this._limit);
+        }
+        if (this._returning) {
+          const cols = Object.entries(
+            this._returning
+          ).map(
+            ([alias, col]) => `${col.tableName}.${col.name} AS ${alias}`
+          ).join(", ");
+          const retSql = `${query} RETURNING ${cols}`;
+          return await db.select(retSql, bindings);
+        }
+        await db.execute(query, bindings);
       }
     }();
   }
@@ -382,8 +956,8 @@ var TauriORM = class {
   // 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);
+    const db = await this.getDb();
+    await db.execute(query, bindings);
   }
   // --- Migrations API ---
   generateCreateTableSql(table) {
@@ -433,16 +1007,16 @@ var TauriORM = class {
     );
   }
   async hasMigration(name) {
-    const db3 = getDb();
-    const rows = await db3.select(
+    const db = await this.getDb();
+    const rows = await db.select(
       `SELECT name FROM _migrations WHERE name = ?`,
       [name]
     );
     return Array.isArray(rows) && rows.length > 0;
   }
   async recordMigration(name) {
-    const db3 = getDb();
-    await db3.execute(
+    const db = await this.getDb();
+    await db.execute(
       `INSERT INTO _migrations (name, applied_at) VALUES (?, ?)`,
       [name, Date.now()]
     );
@@ -464,7 +1038,7 @@ var TauriORM = class {
   configure(tables, relDefs) {
     this._tables = tables;
     this._relations = relDefs ?? {};
-    this.query = makeQueryAPI(tables, this._relations);
+    this.query = makeQueryAPI(tables, this._relations, this.getDb.bind(this));
     return this;
   }
   // Convenience: migrate from configured tables
@@ -476,7 +1050,7 @@ var TauriORM = class {
   // --- Schema diff and CLI-like helpers ---
   async diffSchema() {
     if (!this._tables) throw new Error("No tables configured.");
-    const dbi = getDb();
+    const dbi = await this.getDb();
     const configuredNames = Object.values(this._tables).map(
       (t) => t._tableName
     );
@@ -551,7 +1125,7 @@ var TauriORM = class {
     return this.pullSchema();
   }
   async studio() {
-    const dbi = getDb();
+    const dbi = await this.getDb();
     return { driver: "sqlite", path: dbi.path };
   }
   // --- Schema detection / signature ---
@@ -561,7 +1135,7 @@ var TauriORM = class {
     );
   }
   async getSchemaMeta(key) {
-    const dbi = getDb();
+    const dbi = await this.getDb();
     await this.ensureSchemaMeta();
     const rows = await dbi.select(
       `SELECT value FROM _schema_meta WHERE key = ?`,
@@ -570,7 +1144,7 @@ var TauriORM = class {
     return rows?.[0]?.value ?? null;
   }
   async setSchemaMeta(key, value) {
-    const dbi = getDb();
+    const dbi = await this.getDb();
     await this.ensureSchemaMeta();
     await dbi.execute(
       `INSERT INTO _schema_meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
@@ -619,7 +1193,7 @@ var TauriORM = class {
   // Pull current DB schema (minimal) for configured tables
   async pullSchema() {
     if (!this._tables) throw new Error("No tables configured.");
-    const dbi = getDb();
+    const dbi = await this.getDb();
     const result = {};
     for (const tbl of Object.values(this._tables)) {
       const name = tbl._tableName;
@@ -638,7 +1212,7 @@ var TauriORM = class {
     return this.generateCreateTableSql(table);
   }
   async tableExists(name) {
-    const dbi = getDb();
+    const dbi = await this.getDb();
     const rows = await dbi.select(
       `SELECT name FROM sqlite_master WHERE type='table' AND name = ?`,
       [name]
@@ -648,12 +1222,12 @@ var TauriORM = class {
   // Force push model to DB: add missing tables/columns, rebuild tables if incompatible
   async forcePush(options) {
     if (!this._tables) throw new Error("No tables configured.");
-    const dbi = getDb();
+    const dbi = await this.getDb();
     const preserve = options?.preserveData !== false;
     for (const tbl of Object.values(this._tables)) {
       const tableName = tbl._tableName;
-      const exists = await this.tableExists(tableName);
-      if (!exists) {
+      const exists2 = await this.tableExists(tableName);
+      if (!exists2) {
         await this.run(this.buildCreateTableSQL(tbl));
         continue;
       }
@@ -718,7 +1292,6 @@ var TauriORM = class {
     await this.setSchemaMeta("schema_signature", this.computeModelSignature());
   }
 };
-var db2 = new TauriORM();
 function relations(baseTable, builder) {
   const ctx = {
     one: (table, cfg) => ({ kind: "one", table, cfg }),
@@ -744,10 +1317,29 @@ function guessChildFk(child, base, rel) {
   ];
   return childCols.find((c) => guessNames.includes(c.name)) || childCols.find((c) => /.*_id$/i.test(c.name)) || null;
 }
+function guessOneRelationJoin(base, rel) {
+  const child = rel.table;
+  const basePk = getPrimaryKey(base);
+  const childCols = Object.values(child._schema);
+  if (rel.cfg?.fields && rel.cfg?.references && rel.cfg.fields[0] && rel.cfg.references[0]) {
+    const fk = rel.cfg.fields[0];
+    const ref = rel.cfg.references[0];
+    if (childCols.some((c) => c.name === fk.name)) {
+      return { lhsTable: child, lhsCol: fk, rhsTable: base, rhsCol: ref };
+    }
+    const baseCols = Object.values(base._schema);
+    if (baseCols.some((c) => c.name === fk.name)) {
+      return { lhsTable: base, lhsCol: fk, rhsTable: child, rhsCol: ref };
+    }
+  }
+  const childFk = guessChildFk(child, base, rel);
+  if (!childFk) return null;
+  return { lhsTable: child, lhsCol: childFk, rhsTable: base, rhsCol: basePk };
+}
 function isFlatWith(spec) {
   return Object.values(spec).every((v) => typeof v === "boolean");
 }
-function makeQueryAPI(tables, relDefs) {
+function makeQueryAPI(tables, relDefs, dbProvider) {
   const api = {};
   const tableKeyByName = {};
   for (const [k, t] of Object.entries(tables)) tableKeyByName[t._tableName] = k;
@@ -756,7 +1348,7 @@ function makeQueryAPI(tables, relDefs) {
       async findMany(opts) {
         const base = tbl;
         const withSpec = opts?.with ?? {};
-        const dbi = getDb();
+        const dbi = await dbProvider();
         const rels = relDefs[tblKey] ?? {};
         if (opts?.join && isFlatWith(withSpec)) {
           const baseCols = Object.values(base._schema);
@@ -782,23 +1374,43 @@ function makeQueryAPI(tables, relDefs) {
             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 };
+            if (rel.kind === "one") {
+              const mapping = guessOneRelationJoin(base, rel);
+              if (!mapping) continue;
+              if (mapping.lhsTable._tableName === child._tableName) {
+                fkMap[relName] = { childFk: mapping.lhsCol, childPk };
+                joins.push(
+                  `LEFT JOIN ${child._tableName} ON ${mapping.lhsTable._tableName}.${mapping.lhsCol.name} = ${mapping.rhsTable._tableName}.${mapping.rhsCol.name}`
+                );
+              } else {
+                fkMap[relName] = { childFk: mapping.rhsCol, childPk };
+                joins.push(
+                  `LEFT JOIN ${child._tableName} ON ${mapping.lhsTable._tableName}.${mapping.lhsCol.name} = ${mapping.rhsTable._tableName}.${mapping.rhsCol.name}`
+                );
+              }
+            } else {
+              const childFk = guessChildFk(child, base, rel);
+              if (!childFk) continue;
+              fkMap[relName] = { childFk, childPk };
+              joins.push(
+                `LEFT JOIN ${child._tableName} ON ${child._tableName}.${childFk.name} = ${base._tableName}.${basePk.name}`
+              );
+            }
             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") {
+            if (typeof opts.where === "function") {
+              const w = opts.where(base, { eq, ne, gt, gte, lt, lte, like }).toSQL();
+              sqlText += ` WHERE ${w.clause}`;
+              bindings.push(...w.bindings);
+            } else if (typeof opts.where.toSQL === "function") {
               const w = opts.where.toSQL();
               sqlText += ` WHERE ${w.clause}`;
               bindings.push(...w.bindings);
@@ -810,8 +1422,9 @@ function makeQueryAPI(tables, relDefs) {
               }
             }
           }
-          if (opts?.orderBy?.length)
-            sqlText += ` ORDER BY ${opts.orderBy.join(", ")}`;
+          const orderByClauses = typeof opts?.orderBy === "function" ? opts.orderBy(base, { asc, desc }) : opts?.orderBy;
+          if (orderByClauses?.length)
+            sqlText += ` ORDER BY ${orderByClauses.join(", ")}`;
           if (typeof opts?.limit === "number")
             sqlText += ` LIMIT ${opts.limit}`;
           if (typeof opts?.offset === "number")
@@ -851,10 +1464,10 @@ function makeQueryAPI(tables, relDefs) {
                 const childPk = fkMap[relName].childPk;
                 if (childPk) {
                   if (!acc[relName]) acc[relName] = [];
-                  const exists = acc[relName].some(
+                  const exists2 = acc[relName].some(
                     (r) => r[childPk.name] === childObj[childPk.name]
                   );
-                  if (!exists) acc[relName].push(childObj);
+                  if (!exists2) acc[relName].push(childObj);
                 } else {
                   acc[relName].push(childObj);
                 }
@@ -878,7 +1491,11 @@ function makeQueryAPI(tables, relDefs) {
         let baseSql = `SELECT ${baseSelected.join(", ")} FROM ${base._tableName}`;
         const baseBindings = [];
         if (opts?.where) {
-          if (typeof opts.where.toSQL === "function") {
+          if (typeof opts.where === "function") {
+            const w = opts.where(base, { eq, ne, gt, gte, lt, lte, like }).toSQL();
+            baseSql += ` WHERE ${w.clause}`;
+            baseBindings.push(...w.bindings);
+          } else if (typeof opts.where.toSQL === "function") {
             const w = opts.where.toSQL();
             baseSql += ` WHERE ${w.clause}`;
             baseBindings.push(...w.bindings);
@@ -890,8 +1507,9 @@ function makeQueryAPI(tables, relDefs) {
             }
           }
         }
-        if (opts?.orderBy?.length)
-          baseSql += ` ORDER BY ${opts.orderBy.join(", ")}`;
+        const orderByClauses2 = typeof opts?.orderBy === "function" ? opts.orderBy(base, { asc, desc }) : opts?.orderBy;
+        if (orderByClauses2?.length)
+          baseSql += ` ORDER BY ${orderByClauses2.join(", ")}`;
         if (typeof opts?.limit === "number") baseSql += ` LIMIT ${opts.limit}`;
         if (typeof opts?.offset === "number")
           baseSql += ` OFFSET ${opts.offset}`;
@@ -910,9 +1528,9 @@ function makeQueryAPI(tables, relDefs) {
             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 fkCol = guessChildFk(child, parentTable, rel);
+              if (!fkCol) continue;
               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();
@@ -931,14 +1549,32 @@ function makeQueryAPI(tables, relDefs) {
                   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;
+              const mapping = guessOneRelationJoin(parentTable, rel);
+              if (!mapping) continue;
+              if (mapping.lhsTable._tableName === child._tableName) {
+                const sql2 = `SELECT ${selectCols.join(", ")} FROM ${child._tableName} WHERE ${mapping.lhsCol.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[mapping.lhsCol.name], r);
+                for (const p of parents)
+                  p[relName] = mapOne.get(p[parentPk.name]) ?? null;
+              } else {
+                const parentFkName = mapping.lhsCol.name;
+                const childPkName = mapping.rhsCol.name;
+                const childIds = parents.map((p) => p[parentFkName]).filter((v2) => v2 !== void 0 && v2 !== null);
+                if (childIds.length === 0) {
+                  for (const p of parents) p[relName] = null;
+                } else {
+                  const sql2 = `SELECT ${selectCols.join(", ")} FROM ${child._tableName} WHERE ${childPkName} IN (${childIds.map(() => "?").join(", ")})`;
+                  const rows = await dbi.select(sql2, childIds);
+                  const mapOne = /* @__PURE__ */ new Map();
+                  for (const r of rows) mapOne.set(r[childPkName], r);
+                  for (const p of parents)
+                    p[relName] = mapOne.get(p[parentFkName]) ?? null;
+                }
+              }
               if (enabled?.with) {
-                const children = parents.map((p) => p[relName]).filter(Boolean);
+                const children = parents.map((p) => p[relName]).filter((x) => Boolean(x));
                 if (children.length > 0)
                   await loadRelationsFor(children, child, enabled.with);
               }
@@ -949,71 +1585,58 @@ function makeQueryAPI(tables, relDefs) {
           await loadRelationsFor(result, base, withSpec);
         }
         return result;
+      },
+      async findFirst(opts) {
+        const rows = await api[tblKey].findMany({ ...opts, limit: 1 });
+        return rows?.[0] ?? null;
       }
     };
   }
   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,
+  and,
   asc,
+  between,
   blob,
   boolean,
-  db,
+  check,
   defineTable,
   desc,
   eq,
-  getDb,
+  exists,
+  foreignKey,
+  getQualifiedName,
   gt,
   gte,
-  initDb,
+  ilike,
+  inArray,
+  increments,
+  index,
   integer,
+  isNotNull,
+  isNull,
   like,
   lt,
   lte,
   makeQueryAPI,
   ne,
+  not,
+  notBetween,
+  notExists,
+  notIlike,
+  notInArray,
   numeric,
+  or,
+  primaryKey,
+  raw,
   real,
   relations,
   sql,
   text,
-  timestamp
+  timestamp,
+  unique,
+  uniqueIndex
 });