@type32/tauri-sqlite-orm 0.1.2 → 0.1.4

package/dist/index.js

@@ -34,14 +34,12 @@ __export(index_exports, {
   asc: () => asc,
   blob: () => blob,
   boolean: () => boolean,
-  db: () => db2,
   defineTable: () => defineTable,
   desc: () => desc,
   eq: () => eq,
-  getDb: () => getDb,
   gt: () => gt,
   gte: () => gte,
-  initDb: () => initDb,
+  increments: () => increments,
   integer: () => integer,
   like: () => like,
   lt: () => lt,
@@ -57,20 +55,6 @@ __export(index_exports, {
 });
 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(
@@ -99,6 +83,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 +107,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 +154,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,22 +167,32 @@ 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 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 defineTable(tableName, schema) {
   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 = {
@@ -184,7 +201,7 @@ function defineTable(tableName, schema) {
     // 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;
@@ -192,6 +209,45 @@ function defineTable(tableName, schema) {
   return table;
 }
 
+// src/orm.ts
+var import_plugin_sql = __toESM(require("@tauri-apps/plugin-sql"));
+
+// 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) => `${getQualifiedName(column)} ASC`;
+var desc = (column) => `${getQualifiedName(column)} DESC`;
+
 // src/orm.ts
 var SelectQueryBuilder = class {
   _table = null;
@@ -202,7 +258,9 @@ var SelectQueryBuilder = class {
   _limit = null;
   _offset = null;
   _eager = {};
-  constructor(fields) {
+  _dbProvider;
+  constructor(dbProvider, fields) {
+    this._dbProvider = dbProvider;
     if (fields) {
       this._selectedColumns = Object.values(fields).map((c) => c.name);
     }
@@ -238,7 +296,7 @@ var SelectQueryBuilder = class {
     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) {
@@ -266,7 +324,7 @@ var SelectQueryBuilder = class {
       query += ` OFFSET ?`;
       bindings.push(this._offset);
     }
-    return db3.select(query, bindings);
+    return db.select(query, bindings);
   }
 };
 var TauriORM = class {
@@ -274,15 +332,23 @@ 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);
   }
   // --- Drizzle-style CRUD builders ---
   insert(table) {
+    const self = this;
     return new class InsertBuilder {
       _table = table;
       _rows = [];
@@ -291,13 +357,17 @@ var TauriORM = class {
         return this;
       }
       async execute() {
-        const db3 = getDb();
+        const db = await self.getDb();
         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);
@@ -306,12 +376,13 @@ var TauriORM = class {
           const query = `INSERT INTO ${this._table._tableName} (${keys.join(
             ", "
           )}) VALUES (${placeholders})`;
-          await db3.execute(query, values);
+          await db.execute(query, values);
         }
       }
     }();
   }
   update(table) {
+    const self = this;
     return new class UpdateBuilder {
       _table = table;
       _data = null;
@@ -327,10 +398,17 @@ var TauriORM = class {
       async execute() {
         if (!this._data)
           throw new Error("Update requires set() before execute()");
-        const db3 = getDb();
-        const setKeys = Object.keys(this._data);
+        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 setKeys = Object.keys(dataToSet);
         const setClause = setKeys.map((k) => `${k} = ?`).join(", ");
-        const bindings = Object.values(this._data);
+        const bindings = Object.values(dataToSet);
         let query = `UPDATE ${this._table._tableName} SET ${setClause}`;
         if (this._where) {
           if (typeof this._where.toSQL === "function") {
@@ -345,11 +423,12 @@ var TauriORM = class {
             }
           }
         }
-        await db3.execute(query, bindings);
+        await db.execute(query, bindings);
       }
     }();
   }
   delete(table) {
+    const self = this;
     return new class DeleteBuilder {
       _table = table;
       _where = null;
@@ -358,7 +437,7 @@ var TauriORM = class {
         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 +453,7 @@ var TauriORM = class {
             }
           }
         }
-        await db3.execute(query, bindings);
+        await db.execute(query, bindings);
       }
     }();
   }
@@ -382,8 +461,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 +512,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 +543,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
@@ -473,8 +552,251 @@ var TauriORM = class {
       throw new Error("No tables configured. Call db.configure({...}) first.");
     await this.migrate(Object.values(this._tables), options);
   }
+  // --- Schema diff and CLI-like helpers ---
+  async diffSchema() {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = await this.getDb();
+    const configuredNames = Object.values(this._tables).map(
+      (t) => t._tableName
+    );
+    const existing = await dbi.select(
+      `SELECT name FROM sqlite_master WHERE type='table'`
+    );
+    const existingNames = existing.map((r) => r.name);
+    const extraTables = existingNames.filter(
+      (n) => !configuredNames.includes(n)
+    );
+    const missingTables = configuredNames.filter(
+      (n) => !existingNames.includes(n)
+    );
+    const tables = {};
+    for (const tbl of Object.values(this._tables)) {
+      const tableName = tbl._tableName;
+      if (!existingNames.includes(tableName)) {
+        tables[tableName] = {
+          missingColumns: Object.keys(tbl._schema),
+          extraColumns: [],
+          changedColumns: []
+        };
+        continue;
+      }
+      const cols = await dbi.select(`PRAGMA table_info('${tableName}')`);
+      const colMap = new Map(cols.map((c) => [c.name, c]));
+      const modelCols = Object.values(
+        tbl._schema
+      );
+      const missingColumns = [];
+      const extraColumns = [];
+      const changedColumns = [];
+      const modelNamesSet = new Set(modelCols.map((c) => c.name));
+      for (const m of modelCols) {
+        const info = colMap.get(m.name);
+        if (!info) {
+          missingColumns.push(m.name);
+          continue;
+        }
+        const diffs = {};
+        if ((info.type || "").toUpperCase() !== m.type.toUpperCase())
+          diffs.type = true;
+        if (!!info.pk !== !!m.isPrimaryKey) diffs.pk = true;
+        if (!!info.notnull !== !!m.isNotNull) diffs.notNull = true;
+        const modelDv = m.defaultValue && typeof m.defaultValue === "object" && m.defaultValue.raw ? m.defaultValue.raw : m.defaultValue ?? null;
+        if ((info.dflt_value ?? null) !== modelDv)
+          diffs.default = true;
+        if (Object.keys(diffs).length)
+          changedColumns.push({ name: m.name, diffs });
+      }
+      for (const c of cols)
+        if (!modelNamesSet.has(c.name)) extraColumns.push(c.name);
+      tables[tableName] = { missingColumns, extraColumns, changedColumns };
+    }
+    return { extraTables, missingTables, tables };
+  }
+  async generate() {
+    if (!this._tables) throw new Error("No tables configured.");
+    return {
+      statements: Object.values(this._tables).map(
+        (t) => this.buildCreateTableSQL(t)
+      )
+    };
+  }
+  async migrateCli(opts) {
+    return this.migrateConfigured(opts);
+  }
+  async push(opts) {
+    return this.forcePush(opts);
+  }
+  async pull() {
+    return this.pullSchema();
+  }
+  async studio() {
+    const dbi = await this.getDb();
+    return { driver: "sqlite", path: dbi.path };
+  }
+  // --- Schema detection / signature ---
+  async ensureSchemaMeta() {
+    await this.run(
+      `CREATE TABLE IF NOT EXISTS _schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+    );
+  }
+  async getSchemaMeta(key) {
+    const dbi = await this.getDb();
+    await this.ensureSchemaMeta();
+    const rows = await dbi.select(
+      `SELECT value FROM _schema_meta WHERE key = ?`,
+      [key]
+    );
+    return rows?.[0]?.value ?? null;
+  }
+  async setSchemaMeta(key, value) {
+    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`,
+      [key, value]
+    );
+  }
+  normalizeColumn(col) {
+    return {
+      name: col.name,
+      type: col.type,
+      pk: !!col.isPrimaryKey,
+      ai: !!col.autoIncrement,
+      nn: !!col.isNotNull,
+      dv: col.defaultValue && typeof col.defaultValue === "object" && col.defaultValue.raw ? { raw: col.defaultValue.raw } : col.defaultValue ?? null
+    };
+  }
+  computeModelSignature() {
+    if (!this._tables) return "";
+    const entries = Object.entries(this._tables).map(([k, tbl]) => {
+      const cols = Object.values(
+        tbl._schema
+      ).map((c) => this.normalizeColumn(c)).sort((a, b) => a.name.localeCompare(b.name));
+      return { table: tbl._tableName, columns: cols };
+    });
+    entries.sort((a, b) => a.table.localeCompare(b.table));
+    return JSON.stringify(entries);
+  }
+  async isSchemaDirty() {
+    const sig = this.computeModelSignature();
+    const stored = await this.getSchemaMeta("schema_signature");
+    return { dirty: sig !== stored, current: sig, stored };
+  }
+  async migrateIfDirty(options) {
+    const status = await this.isSchemaDirty();
+    if (!this._tables) throw new Error("No tables configured.");
+    if (status.dirty) {
+      await this.migrate(Object.values(this._tables), options);
+      await this.setSchemaMeta(
+        "schema_signature",
+        this.computeModelSignature()
+      );
+      return true;
+    }
+    return false;
+  }
+  // Pull current DB schema (minimal) for configured tables
+  async pullSchema() {
+    if (!this._tables) throw new Error("No tables configured.");
+    const dbi = await this.getDb();
+    const result = {};
+    for (const tbl of Object.values(this._tables)) {
+      const name = tbl._tableName;
+      const cols = await dbi.select(`PRAGMA table_info('${name}')`);
+      result[name] = cols.map((c) => ({
+        name: c.name,
+        type: c.type,
+        notnull: !!c.notnull,
+        pk: !!c.pk,
+        dflt_value: c.dflt_value ?? null
+      }));
+    }
+    return result;
+  }
+  buildCreateTableSQL(table) {
+    return this.generateCreateTableSql(table);
+  }
+  async tableExists(name) {
+    const dbi = await this.getDb();
+    const rows = await dbi.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name = ?`,
+      [name]
+    );
+    return rows.length > 0;
+  }
+  // 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 = 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) {
+        await this.run(this.buildCreateTableSQL(tbl));
+        continue;
+      }
+      const existingCols = await dbi.select(
+        `PRAGMA table_info('${tableName}')`
+      );
+      const existingMap = new Map(existingCols.map((c) => [c.name, c]));
+      const modelCols = Object.values(
+        tbl._schema
+      );
+      const missing = [];
+      let requiresRebuild = false;
+      for (const m of modelCols) {
+        const info = existingMap.get(m.name);
+        if (!info) {
+          missing.push(m);
+          continue;
+        }
+        const typeDiff = (info.type || "").toUpperCase() !== m.type.toUpperCase();
+        const pkDiff = !!info.pk !== !!m.isPrimaryKey;
+        const nnDiff = !!info.notnull !== !!m.isNotNull;
+        const modelDv = m.defaultValue && typeof m.defaultValue === "object" && m.defaultValue.raw ? m.defaultValue.raw : m.defaultValue ?? null;
+        const defDiff = (info.dflt_value ?? null) !== modelDv;
+        if (typeDiff || pkDiff || nnDiff && !modelDv || defDiff) {
+          requiresRebuild = true;
+        }
+      }
+      if (requiresRebuild) {
+        const tmp = `_new_${tableName}`;
+        await this.run(this.buildCreateTableSQL(tbl));
+        await this.run(
+          this.buildCreateTableSQL({ ...tbl, _tableName: tmp })
+        );
+        const existingNames = existingCols.map((c) => c.name);
+        const modelNames = modelCols.map((c) => c.name);
+        const shared = existingNames.filter((n) => modelNames.includes(n));
+        if (preserve && shared.length > 0) {
+          await this.run(
+            `INSERT INTO ${tmp} (${shared.join(", ")}) SELECT ${shared.join(
+              ", "
+            )} FROM ${tableName}`
+          );
+        }
+        await this.run(`DROP TABLE ${tableName}`);
+        await this.run(`ALTER TABLE ${tmp} RENAME TO ${tableName}`);
+      } else {
+        for (const m of missing) {
+          let clause = `${m.name} ${m.type}`;
+          if (m.isNotNull) clause += " NOT NULL";
+          if (m.defaultValue !== void 0) {
+            const dv = m.defaultValue;
+            if (dv && typeof dv === "object" && "raw" in dv)
+              clause += ` DEFAULT ${dv.raw}`;
+            else if (typeof dv === "string")
+              clause += ` DEFAULT '${dv.replace(/'/g, "''")}'`;
+            else clause += ` DEFAULT ${dv}`;
+          }
+          await this.run(`ALTER TABLE ${tableName} ADD COLUMN ${clause}`);
+        }
+      }
+    }
+    await this.setSchemaMeta("schema_signature", this.computeModelSignature());
+  }
 };
-var db2 = new TauriORM();
 function relations(baseTable, builder) {
   const ctx = {
     one: (table, cfg) => ({ kind: "one", table, cfg }),
@@ -500,10 +822,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;
@@ -512,7 +853,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);
@@ -538,23 +879,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);
@@ -566,8 +927,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")
@@ -634,7 +996,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);
@@ -646,8 +1012,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}`;
@@ -666,9 +1033,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();
@@ -687,14 +1054,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);
               }
@@ -705,61 +1090,27 @@ 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,
   asc,
   blob,
   boolean,
-  db,
   defineTable,
   desc,
   eq,
-  getDb,
   gt,
   gte,
-  initDb,
+  increments,
   integer,
   like,
   lt,