@type32/tauri-sqlite-orm 0.1.17 → 0.1.18-0

package/dist/index.js

@@ -1,1361 +1,404 @@
 "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) => {
+var __copyProps = (to, from, except, desc) => {
   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 });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.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, {
+  DeleteQueryBuilder: () => DeleteQueryBuilder,
+  InsertQueryBuilder: () => InsertQueryBuilder,
+  SQLiteColumn: () => SQLiteColumn,
+  SelectQueryBuilder: () => SelectQueryBuilder,
+  Table: () => Table,
   TauriORM: () => TauriORM,
+  UpdateQueryBuilder: () => UpdateQueryBuilder,
   and: () => and,
-  asc: () => asc,
-  between: () => between,
   blob: () => blob,
   boolean: () => boolean,
-  check: () => check,
-  defineTable: () => defineTable,
-  desc: () => desc,
   eq: () => eq,
-  exists: () => exists,
-  foreignKey: () => foreignKey,
-  getQualifiedName: () => getQualifiedName,
   gt: () => gt,
   gte: () => gte,
-  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,
-  unique: () => unique,
-  uniqueIndex: () => uniqueIndex
+  sqliteTable: () => sqliteTable,
+  text: () => text
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/schema-builder.ts
-function sql(strings, ...values) {
-  const raw2 = strings.reduce(
-    (acc, part, idx) => acc + part + (idx < values.length ? String(values[idx]) : ""),
-    ""
-  );
-  return { raw: raw2 };
-}
-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.$defaultFn = (fn) => {
-    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 = {
-      table: t.tableName,
-      column: t.name,
-      onDelete: actions?.onDelete,
-      onUpdate: actions?.onUpdate
-    };
-    return col;
-  };
-  return col;
-}
-function text(nameOrConfig, maybeConfig) {
-  const name = typeof nameOrConfig === "string" ? nameOrConfig : "";
-  const config = typeof nameOrConfig === "string" ? maybeConfig : nameOrConfig;
-  const col = createColumn({
-    name,
-    type: "TEXT",
-    _dataType: ""
-  });
-  if (config?.enum) col.enumValues = config.enum;
-  if (config?.mode) col.mode = config.mode;
-  return col;
-}
-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" || config?.mode === "timestamp_ms")
-    dt = /* @__PURE__ */ new Date();
-  const col = createColumn({
-    name,
-    type: "INTEGER",
-    mode: config?.mode ?? "number",
-    _dataType: dt
-  });
-  return col;
-}
-function real(name) {
-  return createColumn({
-    name: name ?? "",
-    type: "REAL",
-    _dataType: 0
-  });
-}
-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;
-  return createColumn({
-    name,
-    type: "BLOB",
-    mode: config?.mode,
-    _dataType: dt
-  });
-}
-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;
-  return createColumn({
-    name,
-    type: "NUMERIC",
-    mode: config?.mode,
-    _dataType: dt
-  });
-}
-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),
-      // runtime marker for DDL rendering
-      kind: "unique"
-    })
-  };
-}
-function primaryKey(opts) {
-  return {
-    name: opts.name,
-    columns: opts.columns.map((c) => c.name),
-    // runtime marker for DDL rendering
-    kind: "primaryKey"
-  };
-}
-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) => ({
+// src/orm.ts
+var SQLiteColumn = class _SQLiteColumn {
+  constructor(name, type, options = {}, mode) {
+    this.type = type;
+    this.options = options;
+    this._ = {
       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;
+      dataType: type,
+      mode: mode || "default",
+      notNull: options.notNull ?? false,
+      hasDefault: options.default !== void 0 || options.$defaultFn !== void 0,
+      autoincrement: options.autoincrement ?? false
+    };
   }
-  const table = {
-    tableName,
-    _schema: finalizedSchema,
-    _constraints: [],
-    _indexes: [],
-    // The Drizzle-like type inference properties
-    $inferSelect: {},
-    $inferInsert: {}
-    // omit PK columns
-  };
-  for (const [key, col] of Object.entries(finalizedSchema)) {
-    table[key] = col;
+  _;
+  notNull() {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      { ...this.options, notNull: true },
+      this._.mode
+    );
   }
-  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);
-      }
-    }
+  default(value) {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      { ...this.options, default: value },
+      this._.mode
+    );
   }
-  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);
-          }
+  $defaultFn(fn) {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      { ...this.options, $defaultFn: fn },
+      this._.mode
+    );
+  }
+  primaryKey() {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      { ...this.options, primaryKey: true },
+      this._.mode
+    );
+  }
+  autoincrement() {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      { ...this.options, autoincrement: true },
+      this._.mode
+    );
+  }
+  unique() {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      { ...this.options, unique: true },
+      this._.mode
+    );
+  }
+  references(ref, column) {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      {
+        ...this.options,
+        references: {
+          table: ref,
+          column: ref._.columns[column]
         }
-      }
-      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 };
+      },
+      this._.mode
+    );
   }
-});
-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 };
+  $onUpdateFn(fn) {
+    return new _SQLiteColumn(
+      this._.name,
+      this.type,
+      { ...this.options, $onUpdateFn: fn },
+      this._.mode
+    );
   }
-});
-var not = (condition) => ({
-  toSQL: () => {
-    const s = condition.toSQL();
-    return { clause: `NOT (${s.clause})`, bindings: s.bindings };
+};
+var text = (name) => new SQLiteColumn(name, "TEXT");
+var integer = (name, config) => new SQLiteColumn(name, "INTEGER", {}, config?.mode || "default");
+var real = (name) => new SQLiteColumn(name, "REAL");
+var blob = (name) => new SQLiteColumn(name, "BLOB");
+var boolean = (name) => new SQLiteColumn(name, "BOOLEAN");
+var Table = class {
+  _;
+  constructor(name, columns) {
+    this._ = {
+      name,
+      columns
+    };
   }
+};
+var sqliteTable = (tableName, columns) => {
+  return new Table(tableName, columns);
+};
+var eq = (column, value) => ({
+  sql: `${column._.name} = ?`,
+  params: [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 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 and = (...conditions) => ({
+  sql: conditions.map((c) => `(${c.sql})`).join(" AND "),
+  params: conditions.flatMap((c) => c.params)
 });
-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 or = (...conditions) => ({
+  sql: conditions.map((c) => `(${c.sql})`).join(" OR "),
+  params: conditions.flatMap((c) => c.params)
 });
-var isNull = (column) => ({
-  toSQL: () => ({
-    clause: `${getQualifiedName(column)} IS NULL`,
-    bindings: []
-  })
+var gt = (column, value) => ({
+  sql: `${column._.name} > ?`,
+  params: [value]
 });
-var isNotNull = (column) => ({
-  toSQL: () => ({
-    clause: `${getQualifiedName(column)} IS NOT NULL`,
-    bindings: []
-  })
+var gte = (column, value) => ({
+  sql: `${column._.name} >= ?`,
+  params: [value]
 });
-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 lt = (column, value) => ({
+  sql: `${column._.name} < ?`,
+  params: [value]
 });
-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 lte = (column, value) => ({
+  sql: `${column._.name} <= ?`,
+  params: [value]
 });
-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 like = (column, pattern) => ({
+  sql: `${column._.name} LIKE ?`,
+  params: [pattern]
 });
-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 isNull = (column) => ({
+  sql: `${column._.name} IS NULL`,
+  params: []
 });
-var exists = (subquery) => ({
-  toSQL: () => {
-    const sq = subquery.toSQL ? subquery.toSQL() : subquery.toSQL();
-    return { clause: `EXISTS (${sq.clause})`, bindings: sq.bindings };
-  }
+var isNotNull = (column) => ({
+  sql: `${column._.name} IS NOT NULL`,
+  params: []
 });
-var notExists = (subquery) => ({
-  toSQL: () => {
-    const sq = subquery.toSQL ? subquery.toSQL() : subquery.toSQL();
-    return { clause: `NOT EXISTS (${sq.clause})`, bindings: sq.bindings };
-  }
+var inArray = (column, values) => ({
+  sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
+  params: values
 });
-var asc = (column) => `${getQualifiedName(column)} ASC`;
-var desc = (column) => `${getQualifiedName(column)} DESC`;
-
-// src/orm.ts
-function getTableName(table) {
-  const anyTable = table;
-  return anyTable.tableName || anyTable.name || "";
-}
-var SelectQueryBuilder = class {
-  _table = null;
-  _selectedColumns = [];
-  _joins = [];
-  _where = [];
-  _orderBy = [];
-  _limit = null;
-  _offset = null;
-  _groupBy = [];
-  _having = [];
-  _distinct = false;
-  _dbProvider;
-  constructor(dbProvider, fields) {
-    this._dbProvider = dbProvider;
-    if (fields) {
-      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
-        });
-      }
-    }
+var BaseQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
+  }
+  query = "";
+  params = [];
+  where(condition) {
+    this.query += ` WHERE ${condition.sql}`;
+    this.params.push(...condition.params);
     return this;
   }
-  from(table) {
-    this._table = table;
+  orderBy(column, direction = "ASC") {
+    this.query += ` ORDER BY ${column._.name} ${direction}`;
     return this;
   }
-  where(...conditions) {
-    this._where.push(...conditions.filter(Boolean));
+  limit(count) {
+    this.query += ` LIMIT ${count}`;
     return this;
   }
-  leftJoin(otherTable, on) {
-    const onSql = on.toSQL();
-    const joinClause = `LEFT JOIN ${otherTable.tableName} ON ${onSql.clause}`;
-    this._joins.push(joinClause);
+  offset(count) {
+    this.query += ` OFFSET ${count}`;
     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;
+  build() {
+    return {
+      sql: this.query,
+      params: this.params
+    };
   }
-  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;
+};
+var SelectQueryBuilder = class extends BaseQueryBuilder {
+  constructor(db, table, columns) {
+    super(db);
+    this.table = table;
+    this.columns = columns;
+    const columnNames = columns ? columns.map((c) => table._.columns[c]._.name) : ["*"];
+    this.query = `SELECT ${columnNames.join(", ")} FROM ${table._.name}`;
   }
-  limit(value) {
-    this._limit = value;
-    return this;
+  async execute() {
+    const { sql, params } = this.build();
+    return this.db.select(sql, ...params);
   }
-  offset(value) {
-    this._offset = value;
+};
+var InsertQueryBuilder = class extends BaseQueryBuilder {
+  constructor(db, table) {
+    super(db);
+    this.table = table;
+    this.query = `INSERT INTO ${table._.name}`;
+  }
+  dataSets = [];
+  values(data) {
+    const dataArray = Array.isArray(data) ? data : [data];
+    this.dataSets.push(...dataArray);
     return this;
   }
   async execute() {
-    if (!this._table) {
-      throw new Error("Cannot execute select query without a 'from' table.");
-    }
-    const db = await this._dbProvider();
-    const baseTableName = getTableName(this._table);
-    if (!baseTableName) {
-      throw new Error(
-        "Invalid table passed to select.from(): missing table name"
-      );
-    }
-    const bindings = [];
-    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) => `${baseTableName}.${c.name}`).join(", ");
-    let query = `SELECT ${this._distinct ? "DISTINCT " : ""}${selectList} FROM ${baseTableName}`;
-    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._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) {
-      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`;
-      query += ` OFFSET ?`;
-      bindings.push(this._offset);
-    }
-    return db.select(query, bindings);
-  }
-  async iterator() {
-    const rows = await this.execute();
-    async function* gen() {
-      for (const r of rows) yield r;
+    if (this.dataSets.length === 0) {
+      throw new Error("No data provided for insert");
     }
-    return gen();
+    const columns = Object.keys(
+      this.dataSets[0]
+    );
+    const columnNames = columns.map(
+      (c) => this.table._.columns[c]._.name
+    );
+    const placeholders = `(${columnNames.map(() => "?").join(", ")})`;
+    const valuesSql = this.dataSets.map(() => placeholders).join(", ");
+    this.query += ` (${columnNames.join(", ")}) VALUES ${valuesSql}`;
+    const params = this.dataSets.flatMap(
+      (data) => columns.map((col) => data[col])
+    );
+    const result = await this.db.execute(this.query, ...params);
+    return result.lastInsertId ?? 0;
   }
 };
-var TauriORM = class {
-  // Soft relational query API: db.query.users.findMany({ with: { posts: true } })
-  query = {};
-  _tables = null;
-  _relations = null;
-  _dbPromise;
-  constructor(dbUri) {
-    this._dbPromise = import_plugin_sql.default.load(dbUri).then(async (db) => {
-      await db.execute("PRAGMA foreign_keys = ON");
-      return db;
-    });
-  }
-  async getDb() {
-    return this._dbPromise;
-  }
-  // Deprecated: use configure()
-  configureQuery(tables, relations2) {
-    this.configure(tables, relations2);
-  }
-  select(fields) {
-    return new SelectQueryBuilder(this.getDb.bind(this), fields);
+var UpdateQueryBuilder = class extends BaseQueryBuilder {
+  constructor(db, table) {
+    super(db);
+    this.table = table;
+    this.query = `UPDATE ${table._.name}`;
+  }
+  updateData = {};
+  set(data) {
+    this.updateData = { ...this.updateData, ...data };
+    return this;
   }
-  selectDistinct(fields) {
-    const qb = new SelectQueryBuilder(this.getDb.bind(this), fields);
-    qb.distinct();
-    return qb;
+  async execute() {
+    const entries = Object.entries(this.updateData);
+    const setClause = entries.map(([key]) => {
+      const column = this.table._.columns[key];
+      if (!column)
+        throw new Error(
+          `Column ${key} does not exist on table ${this.table._.name}`
+        );
+      return `${column._.name} = ?`;
+    }).join(", ");
+    this.query += ` SET ${setClause}`;
+    this.params.push(...entries.map(([, value]) => value));
+    const { sql, params } = this.build();
+    const result = await this.db.execute(sql, ...params);
+    return result.rowsAffected;
   }
-  // --- 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 db = await self.getDb();
-        const tableName = getTableName(this._table);
-        if (!tableName)
-          throw new Error(
-            "Invalid table passed to insert(): missing table name"
-          );
-        if (this._selectSql) {
-          const cols = Object.keys(this._table._schema);
-          let query = `INSERT INTO ${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) {
-          let coerceValue2 = function(col, value) {
-            if (col && col.mode === "boolean") {
-              return value ? 1 : 0;
-            }
-            if (value instanceof Date) {
-              if (col && col.mode === "timestamp_ms")
-                return value.getTime();
-              if (col && col.mode === "timestamp")
-                return Math.floor(value.getTime() / 1e3);
-            }
-            return value;
-          };
-          var coerceValue = coerceValue2;
-          const finalData = Object.assign({}, data);
-          const schema = this._table._schema;
-          for (const [key, col] of Object.entries(schema)) {
-            if (finalData[key] === void 0) {
-              if (col.defaultFn) {
-                finalData[key] = coerceValue2(col, col.defaultFn());
-              } else if (col.onUpdateFn && !this._rows.includes(data)) {
-                finalData[key] = coerceValue2(col, col.onUpdateFn());
-              }
-            }
-          }
-          const entries = Object.entries(finalData).filter(
-            ([_, value]) => value !== void 0
-          );
-          const keys = entries.map(([k]) => {
-            const col = schema[k];
-            return col?.name ?? k;
-          });
-          const values = entries.map(([k, v]) => {
-            const col = schema[k];
-            return coerceValue2(col, v);
-          });
-          if (keys.length === 0) {
-            let query2 = `INSERT INTO ${tableName} DEFAULT VALUES`;
-            const bindings2 = [];
-            query2 += this._buildConflictClause();
-            const ret2 = await this._executeWithReturning(db, query2, bindings2);
-            if (ret2 !== void 0) return ret2;
-            continue;
-          }
-          const placeholders = values.map(() => "?").join(", ");
-          let query = `INSERT INTO ${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;
-      }
-    }();
+};
+var DeleteQueryBuilder = class extends BaseQueryBuilder {
+  constructor(db, table) {
+    super(db);
+    this.table = table;
+    this.query = `DELETE FROM ${table._.name}`;
   }
-  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;
-      }
-      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;
-      }
-      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 db = await self.getDb();
-        const tableName = getTableName(this._table);
-        if (!tableName)
-          throw new Error(
-            "Invalid table passed to update(): missing table name"
-          );
-        const schema = this._table._schema;
-        const dataToSet = { ...this._data };
-        for (const [key, col] of Object.entries(schema)) {
-          if (!(key in dataToSet) && col.onUpdateFn) {
-            const v = col.onUpdateFn();
-            if (col.mode === "boolean") dataToSet[key] = v ? 1 : 0;
-            else if (v instanceof Date) {
-              if (col.mode === "timestamp_ms")
-                dataToSet[key] = v.getTime();
-              else if (col.mode === "timestamp")
-                dataToSet[key] = Math.floor(v.getTime() / 1e3);
-              else dataToSet[key] = v;
-            } else dataToSet[key] = v;
-          }
-        }
-        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();
-            const colName = schema[k]?.name ?? k;
-            setParts.push(`${colName} = ${s.clause}`);
-            bindings.push(...s.bindings);
-          } else {
-            const colName = schema[k]?.name ?? k;
-            let val = v;
-            const col = schema[k];
-            if (col && col.mode === "boolean") val = v ? 1 : 0;
-            else if (v instanceof Date) {
-              if (col && col.mode === "timestamp_ms")
-                val = v.getTime();
-              else if (col && col.mode === "timestamp")
-                val = Math.floor(v.getTime() / 1e3);
-            }
-            setParts.push(`${colName} = ?`);
-            bindings.push(val);
-          }
-        }
-        let query = `UPDATE ${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();
-            query += ` WHERE ${sql2.clause}`;
-            bindings.push(...sql2.bindings);
-          } else {
-            const entries = Object.entries(this._where);
-            if (entries.length > 0) {
-              query += ` WHERE ${entries.map(([k]) => `${schema[k]?.name ?? k} = ?`).join(" AND ")}`;
-              bindings.push(...entries.map(([, v]) => v));
-            }
-          }
-        }
-        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);
-      }
-    }();
+  async execute() {
+    const { sql, params } = this.build();
+    const result = await this.db.execute(sql, ...params);
+    return result.rowsAffected;
   }
-  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 db = await self.getDb();
-        const tableName = getTableName(this._table);
-        if (!tableName)
-          throw new Error(
-            "Invalid table passed to delete(): missing table name"
-          );
-        let query = `DELETE FROM ${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) {
-              const schema = this._table._schema;
-              query += ` WHERE ${entries.map(([k]) => `${schema[k]?.name ?? k} = ?`).join(" AND ")}`;
-              bindings.push(...entries.map(([, v]) => v));
-            }
-          }
-        }
-        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);
+};
+var TauriORM = class {
+  constructor(db, schema = void 0) {
+    this.db = db;
+    if (schema) {
+      for (const table of Object.values(schema)) {
+        this.tables.set(table._.name, table);
       }
-    }();
-  }
-  // 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 db = await this.getDb();
-    await db.execute(query, bindings);
-  }
-  // --- Migrations API ---
-  formatDefaultValue(col) {
-    const dv = col.defaultValue;
-    if (dv === void 0) return null;
-    if (dv && typeof dv === "object" && "raw" in dv) {
-      return dv.raw;
-    }
-    if (dv instanceof Date) {
-      const isMs = col.mode === "timestamp_ms";
-      const num = isMs ? dv.getTime() : Math.floor(dv.getTime() / 1e3);
-      return String(num);
-    }
-    if (col.mode === "boolean") {
-      return String(dv ? 1 : 0);
-    }
-    if (typeof dv === "string") {
-      return `'${dv.replace(/'/g, "''")}'`;
     }
-    return String(dv);
   }
-  generateCreateTableSql(table) {
-    const tableName = getTableName(table);
-    if (!tableName)
-      throw new Error("Invalid table passed to DDL: missing table name");
-    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 formatted = this.formatDefaultValue(col);
-        if (formatted !== null) def += ` DEFAULT ${formatted}`;
-      }
-      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;
-    });
-    const tableConstraints = [];
-    const constraints = table._constraints;
-    if (constraints && constraints.length) {
-      for (const spec of constraints) {
-        if (spec.expr) {
-          const name = spec.name;
-          const expr = spec.expr.raw ?? spec.expr?.raw ?? String(spec.expr);
-          tableConstraints.push(
-            name ? `CONSTRAINT ${name} CHECK (${expr})` : `CHECK (${expr})`
-          );
-          continue;
+  tables = /* @__PURE__ */ new Map();
+  async migrate() {
+    for (const table of this.tables.values()) {
+      const columnsSql = Object.entries(table._.columns).map(([name, col]) => {
+        let sql = `${col._.name} ${col.type}`;
+        if (col.options.primaryKey) sql += " PRIMARY KEY";
+        if (col._.autoincrement) sql += " AUTOINCREMENT";
+        if (col._.notNull) sql += " NOT NULL";
+        if (col.options.unique) sql += " UNIQUE";
+        if (col.options.default !== void 0) {
+          const value = col.options.default;
+          sql += ` DEFAULT ${typeof value === "string" ? `'${value}'` : value}`;
         }
-        if (spec.foreignColumns) {
-          const name = spec.name;
-          const cols = spec.columns.join(", ");
-          const fTable = spec.foreignTable;
-          const fCols = spec.foreignColumns.join(", ");
-          let clause = `${name ? `CONSTRAINT ${name} ` : ""}FOREIGN KEY (${cols}) REFERENCES ${fTable} (${fCols})`;
-          if (spec.onDelete)
-            clause += ` ON DELETE ${String(
-              spec.onDelete
-            ).toUpperCase()}`;
-          if (spec.onUpdate)
-            clause += ` ON UPDATE ${String(
-              spec.onUpdate
-            ).toUpperCase()}`;
-          tableConstraints.push(clause);
-          continue;
+        if (col.options.references) {
+          sql += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
         }
-        if (spec.columns) {
-          const cols = spec.columns.join(", ");
-          const name = spec.name;
-          const isPk = spec.kind === "primaryKey" || name && name.toLowerCase().includes("pk");
-          if (isPk) {
-            tableConstraints.push(
-              name ? `CONSTRAINT ${name} PRIMARY KEY (${cols})` : `PRIMARY KEY (${cols})`
-            );
-          } else {
-            tableConstraints.push(
-              name ? `CONSTRAINT ${name} UNIQUE (${cols})` : `UNIQUE (${cols})`
-            );
-          }
-          continue;
-        }
-      }
+        return sql;
+      }).join(", ");
+      const createSql = `CREATE TABLE IF NOT EXISTS ${table._.name} (${columnsSql})`;
+      await this.db.execute(createSql);
     }
-    const parts = [...columnDefs, ...tableConstraints];
-    return `CREATE TABLE IF NOT EXISTS ${tableName} (${parts.join(", ")});`;
   }
-  async createTableIfNotExists(table) {
-    const sql2 = this.generateCreateTableSql(table);
-    await this.run(sql2);
-    await this.createIndexesForTable(table);
-  }
-  async createTablesIfNotExist(tables) {
-    for (const t of tables) {
-      await this.createTableIfNotExists(t);
-    }
+  select(table, columns) {
+    return new SelectQueryBuilder(this.db, table, columns);
   }
-  generateCreateIndexSqls(table) {
-    const tableName = table.tableName;
-    const indexes = table._indexes || [];
-    const stmts = [];
-    for (const idx of indexes) {
-      const unique2 = idx.unique ? "UNIQUE " : "";
-      if (!idx.name) continue;
-      const colList = Array.isArray(idx.columns) ? idx.columns : [];
-      if (colList.length === 0) continue;
-      const cols = `(${colList.join(", ")})`;
-      const where = idx.where?.raw ? ` WHERE ${idx.where.raw}` : "";
-      stmts.push(
-        `CREATE ${unique2}INDEX IF NOT EXISTS ${idx.name} ON ${tableName} ${cols}${where};`
-      );
-    }
-    return stmts;
-  }
-  async createIndexesForTable(table) {
-    const stmts = this.generateCreateIndexSqls(table);
-    for (const s of stmts) await this.run(s);
-  }
-  async ensureMigrationsTable() {
-    await this.run(
-      `CREATE TABLE IF NOT EXISTS _migrations (name TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)`
-    );
-  }
-  async hasMigration(name) {
-    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 db = await this.getDb();
-    await db.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();
-    }
-    await this.forcePushForTables(tables, { preserveData: true });
-    if (track) {
-      const name = options?.name ?? `init:${tables.map((t) => t.tableName).join(",")}`;
-      const already = await this.hasMigration(name);
-      if (!already) await this.recordMigration(name);
-    }
+  insert(table) {
+    return new InsertQueryBuilder(this.db, table);
   }
-  // Configure schema and relations, and generate db.query automatically
-  configure(tables, relDefs) {
-    this._tables = tables;
-    this._relations = relDefs ?? {};
-    this.query = makeQueryAPI(
-      tables,
-      this._relations ?? {},
-      this.getDb.bind(this)
-    );
-    return this;
+  update(table) {
+    return new UpdateQueryBuilder(this.db, table);
   }
-  // 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);
-    await this.setSchemaMeta("schema_signature", this.computeModelSignature());
+  delete(table) {
+    return new DeleteQueryBuilder(this.db, table);
   }
-  // --- 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) => getTableName(t)
-    );
-    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 = getTableName(tbl);
-      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 };
+  async transaction(callback) {
+    await this.db.execute("BEGIN TRANSACTION");
+    try {
+      const result = await callback(this);
+      await this.db.execute("COMMIT");
+      return result;
+    } catch (error) {
+      await this.db.execute("ROLLBACK");
+      throw error;
     }
-    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(
+    await this.db.execute(
       `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(
+    const rows = await this.db.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(
+    await this.db.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,
+      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
+      pk: !!col.options.primaryKey,
+      ai: !!col._.autoincrement,
+      nn: !!col._.notNull,
+      dv: col.options.default && typeof col.options.default === "object" && col.options.default.raw ? { raw: col.options.default.raw } : col.options.default ?? 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 };
+    const entries = Array.from(this.tables.values()).map((tbl) => {
+      const cols = Object.values(tbl._.columns).map((c) => this.normalizeColumn(c)).sort((a, b) => a.name.localeCompare(b.name));
+      return { table: tbl._.name, columns: cols };
     });
     entries.sort((a, b) => a.table.localeCompare(b.table));
     return JSON.stringify(entries);
@@ -1363,22 +406,15 @@ var TauriORM = class {
   getSchemaSignature() {
     return this.computeModelSignature();
   }
-  async printSchemaDiff() {
-    const diff = await this.diffSchema();
-    console.log("Schema diff:", JSON.stringify(diff, null, 2));
-  }
   async isSchemaDirty() {
     const sig = this.computeModelSignature();
     const stored = await this.getSchemaMeta("schema_signature");
     return { dirty: sig !== stored, current: sig, stored };
   }
-  async migrateIfDirty(options) {
+  async migrateIfDirty() {
     const status = await this.isSchemaDirty();
-    if (!this._tables) throw new Error("No tables configured.");
     if (status.dirty) {
-      await this.forcePushForTables(Object.values(this._tables), {
-        preserveData: true
-      });
+      await this.migrate();
       await this.setSchemaMeta(
         "schema_signature",
         this.computeModelSignature()
@@ -1387,455 +423,46 @@ var TauriORM = class {
     }
     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.");
-    await this.forcePushForTables(Object.values(this._tables), options);
-  }
-  async forcePushForTables(tables, options) {
-    const dbi = await this.getDb();
-    const preserve = options?.preserveData !== false;
-    for (const tbl of tables) {
-      const tableName = getTableName(tbl);
-      const exists2 = await this.tableExists(tableName);
-      if (!exists2) {
-        await this.run(this.buildCreateTableSQL(tbl));
-        await this.createIndexesForTable(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}`);
-        await this.createIndexesForTable(tbl);
-      } else {
-        for (const m of missing) {
-          let clause = `${m.name} ${m.type}`;
-          if (m.isNotNull) clause += " NOT NULL";
-          if (m.defaultValue !== void 0) {
-            const formatted = this.formatDefaultValue(m);
-            if (formatted !== null) clause += ` DEFAULT ${formatted}`;
-          }
-          await this.run(`ALTER TABLE ${tableName} ADD COLUMN ${clause}`);
-        }
-        await this.createIndexesForTable(tbl);
-      }
-    }
-    await this.setSchemaMeta("schema_signature", this.computeModelSignature());
-  }
 };
-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 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, dbProvider) {
-  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 = await dbProvider();
-        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;
-            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}`
-              );
-          }
-          let sqlText = `SELECT ${selectParts.join(", ")} FROM ${base.tableName}${joins.length ? " " + joins.join(" ") : ""}`;
-          const bindings = [];
-          if (opts?.where) {
-            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);
-            } 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));
-              }
-            }
-          }
-          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")
-            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 exists2 = acc[relName].some(
-                    (r) => r[childPk.name] === childObj[childPk.name]
-                  );
-                  if (!exists2) 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 === "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);
-          } 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));
-            }
-          }
-        }
-        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}`;
-        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);
-            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();
-              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 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((x) => Boolean(x));
-                if (children.length > 0)
-                  await loadRelationsFor(children, child, enabled.with);
-              }
-            }
-          }
-        }
-        if (Object.keys(withSpec).length > 0) {
-          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;
-}
+var relations = (table, relationsCallback) => {
+  return relationsCallback({
+    one: (table2, config) => ({
+      table: table2,
+      type: "one",
+      foreignKey: config.fields[0],
+      localKey: config.references[0]
+    }),
+    many: (table2) => ({
+      table: table2,
+      type: "many"
+    })
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DeleteQueryBuilder,
+  InsertQueryBuilder,
+  SQLiteColumn,
+  SelectQueryBuilder,
+  Table,
   TauriORM,
+  UpdateQueryBuilder,
   and,
-  asc,
-  between,
   blob,
   boolean,
-  check,
-  defineTable,
-  desc,
   eq,
-  exists,
-  foreignKey,
-  getQualifiedName,
   gt,
   gte,
-  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,
-  unique,
-  uniqueIndex
+  sqliteTable,
+  text
 });