@type32/tauri-sqlite-orm 0.1.4 → 0.1.5

package/dist/index.js

@@ -31,37 +31,58 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   TauriORM: () => TauriORM,
+  and: () => and,
   asc: () => asc,
+  between: () => between,
   blob: () => blob,
   boolean: () => boolean,
+  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
+  timestamp: () => timestamp,
+  unique: () => unique,
+  uniqueIndex: () => uniqueIndex
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/schema-builder.ts
 function sql(strings, ...values) {
-  const raw = strings.reduce(
+  const raw2 = strings.reduce(
     (acc, part, idx) => acc + part + (idx < values.length ? String(values[idx]) : ""),
     ""
   );
-  return { raw };
+  return { raw: raw2 };
 }
 function createColumn(params) {
   const col = { ...params };
@@ -188,7 +209,41 @@ function increments(name) {
     autoIncrement: true
   });
 }
-function defineTable(tableName, schema) {
+function unique(name) {
+  return {
+    on: (...cols) => ({ name, columns: cols.map((c) => c.name) })
+  };
+}
+function primaryKey(opts) {
+  return { name: opts.name, columns: opts.columns.map((c) => c.name) };
+}
+function check(name, expr) {
+  return { name, expr };
+}
+function foreignKey(opts) {
+  const first = opts.columns[0];
+  return {
+    name: opts.name,
+    columns: opts.columns.map((c) => c.name),
+    foreignTable: first?.tableName || opts.foreignColumns[0]?.tableName || "",
+    foreignColumns: opts.foreignColumns.map((c) => c.name),
+    onDelete: opts.onDelete,
+    onUpdate: opts.onUpdate
+  };
+}
+function index(name) {
+  return {
+    on: (...cols) => ({ name, columns: cols.map((c) => c.name) }),
+    where: (expr) => ({ name, columns: [], where: expr })
+  };
+}
+function uniqueIndex(name) {
+  return {
+    on: (...cols) => ({ name, columns: cols.map((c) => c.name), unique: true }),
+    where: (expr) => ({ name, columns: [], unique: true, where: expr })
+  };
+}
+function defineTable(tableName, schema, extras) {
   const finalizedSchema = { ...schema };
   for (const key of Object.keys(finalizedSchema)) {
     const col = finalizedSchema[key];
@@ -198,6 +253,8 @@ function defineTable(tableName, schema) {
   const table = {
     _tableName: tableName,
     _schema: finalizedSchema,
+    _constraints: [],
+    _indexes: [],
     // The Drizzle-like type inference properties
     $inferSelect: {},
     $inferInsert: {}
@@ -206,6 +263,29 @@ function defineTable(tableName, schema) {
   for (const [key, col] of Object.entries(finalizedSchema)) {
     table[key] = col;
   }
+  if (extras) {
+    const specs = extras(table) || [];
+    for (const s of specs) {
+      if (s.columns && s.unique !== void 0) {
+        table._indexes.push(s);
+      } else if (s.columns && s.foreignColumns) {
+        table._constraints.push(s);
+      } else if (s.columns && (s.name || s.name === void 0)) {
+        if (s.columns && s.name !== void 0 && s.columns.length > 0) {
+          const pk = s;
+          if (pk.columns.length > 1 || pk.name && pk.name.length > 0) {
+            table._constraints.push(s);
+          } else {
+            table._constraints.push(s);
+          }
+        } else {
+          table._constraints.push(s);
+        }
+      } else if (s.expr) {
+        table._constraints.push(s);
+      }
+    }
+  }
   return table;
 }
 
@@ -213,6 +293,31 @@ function defineTable(tableName, schema) {
 var import_plugin_sql = __toESM(require("@tauri-apps/plugin-sql"));
 
 // src/sql-helpers.ts
+function raw(strings, ...values) {
+  return {
+    toSQL: () => {
+      let clause = "";
+      const bindings = [];
+      for (let i = 0; i < strings.length; i++) {
+        clause += strings[i];
+        if (i < values.length) {
+          const v = values[i];
+          if (v && typeof v === "object" && typeof v.toSQL === "function") {
+            const s = v.toSQL();
+            clause += s.clause;
+            bindings.push(...s.bindings);
+          } else if (v && typeof v === "object" && "_dataType" in v) {
+            clause += getQualifiedName(v);
+          } else {
+            clause += "?";
+            bindings.push(v);
+          }
+        }
+      }
+      return { clause, bindings };
+    }
+  };
+}
 function isColumn(value) {
   return typeof value === "object" && value !== null && "_dataType" in value;
 }
@@ -238,6 +343,36 @@ function comparison(operator, column, value) {
     }
   };
 }
+var and = (...conditions) => ({
+  toSQL: () => {
+    const parts = [];
+    const bindings = [];
+    for (const c of conditions) {
+      const s = c.toSQL();
+      parts.push(`(${s.clause})`);
+      bindings.push(...s.bindings);
+    }
+    return { clause: parts.join(" AND "), bindings };
+  }
+});
+var or = (...conditions) => ({
+  toSQL: () => {
+    const parts = [];
+    const bindings = [];
+    for (const c of conditions) {
+      const s = c.toSQL();
+      parts.push(`(${s.clause})`);
+      bindings.push(...s.bindings);
+    }
+    return { clause: parts.join(" OR "), bindings };
+  }
+});
+var not = (condition) => ({
+  toSQL: () => {
+    const s = condition.toSQL();
+    return { clause: `NOT (${s.clause})`, bindings: s.bindings };
+  }
+});
 var eq = (column, value) => comparison("=", column, value);
 var ne = (column, value) => comparison("!=", column, value);
 var gt = (column, value) => comparison(">", column, value);
@@ -245,32 +380,154 @@ var gte = (column, value) => comparison(">=", column, value);
 var lt = (column, value) => comparison("<", column, value);
 var lte = (column, value) => comparison("<=", column, value);
 var like = (column, value) => comparison("LIKE", column, value);
+var ilike = (column, value) => ({
+  toSQL: () => {
+    const colExpr = `LOWER(${getQualifiedName(column)})`;
+    if (isColumn(value)) {
+      return {
+        clause: `${colExpr} LIKE LOWER(${getQualifiedName(value)})`,
+        bindings: []
+      };
+    }
+    return { clause: `${colExpr} LIKE LOWER(?)`, bindings: [value] };
+  }
+});
+var notIlike = (column, value) => ({
+  toSQL: () => {
+    const colExpr = `LOWER(${getQualifiedName(column)})`;
+    if (isColumn(value)) {
+      return {
+        clause: `${colExpr} NOT LIKE LOWER(${getQualifiedName(value)})`,
+        bindings: []
+      };
+    }
+    return { clause: `${colExpr} NOT LIKE LOWER(?)`, bindings: [value] };
+  }
+});
+var isNull = (column) => ({
+  toSQL: () => ({
+    clause: `${getQualifiedName(column)} IS NULL`,
+    bindings: []
+  })
+});
+var isNotNull = (column) => ({
+  toSQL: () => ({
+    clause: `${getQualifiedName(column)} IS NOT NULL`,
+    bindings: []
+  })
+});
+var between = (column, from, to) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    const [fromClause, fromBindings] = isColumn(from) ? [getQualifiedName(from), []] : ["?", [from]];
+    const [toClause, toBindings] = isColumn(to) ? [getQualifiedName(to), []] : ["?", [to]];
+    return {
+      clause: `${left} BETWEEN ${fromClause} AND ${toClause}`,
+      bindings: [...fromBindings, ...toBindings]
+    };
+  }
+});
+var notBetween = (column, from, to) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    const [fromClause, fromBindings] = isColumn(from) ? [getQualifiedName(from), []] : ["?", [from]];
+    const [toClause, toBindings] = isColumn(to) ? [getQualifiedName(to), []] : ["?", [to]];
+    return {
+      clause: `${left} NOT BETWEEN ${fromClause} AND ${toClause}`,
+      bindings: [...fromBindings, ...toBindings]
+    };
+  }
+});
+var inArray = (column, valuesOrQuery) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    if (Array.isArray(valuesOrQuery)) {
+      const placeholders = valuesOrQuery.map(() => "?").join(", ");
+      return {
+        clause: `${left} IN (${placeholders})`,
+        bindings: valuesOrQuery
+      };
+    }
+    const sq = valuesOrQuery.toSQL ? valuesOrQuery.toSQL() : valuesOrQuery.toSQL();
+    return { clause: `${left} IN (${sq.clause})`, bindings: sq.bindings };
+  }
+});
+var notInArray = (column, valuesOrQuery) => ({
+  toSQL: () => {
+    const left = getQualifiedName(column);
+    if (Array.isArray(valuesOrQuery)) {
+      const placeholders = valuesOrQuery.map(() => "?").join(", ");
+      return {
+        clause: `${left} NOT IN (${placeholders})`,
+        bindings: valuesOrQuery
+      };
+    }
+    const sq = valuesOrQuery.toSQL ? valuesOrQuery.toSQL() : valuesOrQuery.toSQL();
+    return { clause: `${left} NOT IN (${sq.clause})`, bindings: sq.bindings };
+  }
+});
+var exists = (subquery) => ({
+  toSQL: () => {
+    const sq = subquery.toSQL ? subquery.toSQL() : subquery.toSQL();
+    return { clause: `EXISTS (${sq.clause})`, bindings: sq.bindings };
+  }
+});
+var notExists = (subquery) => ({
+  toSQL: () => {
+    const sq = subquery.toSQL ? subquery.toSQL() : subquery.toSQL();
+    return { clause: `NOT EXISTS (${sq.clause})`, bindings: sq.bindings };
+  }
+});
 var asc = (column) => `${getQualifiedName(column)} ASC`;
 var desc = (column) => `${getQualifiedName(column)} DESC`;
 
 // src/orm.ts
 var SelectQueryBuilder = class {
   _table = null;
-  _selectedColumns = ["*"];
+  _selectedColumns = [];
   _joins = [];
   _where = [];
   _orderBy = [];
   _limit = null;
   _offset = null;
-  _eager = {};
+  _groupBy = [];
+  _having = [];
+  _distinct = false;
   _dbProvider;
   constructor(dbProvider, fields) {
     this._dbProvider = dbProvider;
     if (fields) {
-      this._selectedColumns = Object.values(fields).map((c) => c.name);
+      for (const [alias, col] of Object.entries(fields)) {
+        const sql2 = getQualifiedName(col);
+        this._selectedColumns.push({ sql: sql2, alias });
+      }
     }
   }
+  distinct() {
+    this._distinct = true;
+    return this;
+  }
+  select(fields) {
+    this._selectedColumns = [];
+    for (const [alias, expr] of Object.entries(fields)) {
+      if (typeof expr.toSQL === "function") {
+        const s = expr.toSQL();
+        this._selectedColumns.push({ sql: s.clause, alias });
+      } else {
+        this._selectedColumns.push({
+          sql: getQualifiedName(expr),
+          alias
+        });
+      }
+    }
+    return this;
+  }
   from(table) {
     this._table = table;
     return this;
   }
   where(...conditions) {
-    this._where.push(...conditions);
+    this._where.push(...conditions.filter(Boolean));
     return this;
   }
   leftJoin(otherTable, on) {
@@ -279,8 +536,26 @@ var SelectQueryBuilder = class {
     this._joins.push(joinClause);
     return this;
   }
+  groupBy(...exprs) {
+    for (const e of exprs) {
+      if (!e) continue;
+      if (typeof e === "string") this._groupBy.push(e);
+      else this._groupBy.push(getQualifiedName(e));
+    }
+    return this;
+  }
+  having(...conditions) {
+    this._having.push(...conditions);
+    return this;
+  }
   orderBy(...clauses) {
-    this._orderBy.push(...clauses);
+    for (const c of clauses) {
+      if (!c) continue;
+      if (typeof c === "string") this._orderBy.push(c);
+      else if (typeof c.toSQL === "function")
+        this._orderBy.push(c);
+      else this._orderBy.push(getQualifiedName(c));
+    }
     return this;
   }
   limit(value) {
@@ -291,17 +566,15 @@ var SelectQueryBuilder = class {
     this._offset = value;
     return this;
   }
-  // The final execution step
   async execute() {
     if (!this._table) {
       throw new Error("Cannot execute select query without a 'from' table.");
     }
     const db = await this._dbProvider();
     const bindings = [];
-    let query = `SELECT ${this._selectedColumns.join(", ")} FROM ${this._table._tableName}`;
-    if (this._joins.length > 0) {
-      query += ` ${this._joins.join(" ")}`;
-    }
+    const selectList = this._selectedColumns.length > 0 ? this._selectedColumns.map((c) => c.alias ? `${c.sql} AS ${c.alias}` : c.sql).join(", ") : Object.values(this._table._schema).map((c) => `${this._table._tableName}.${c.name}`).join(", ");
+    let query = `SELECT ${this._distinct ? "DISTINCT " : ""}${selectList} FROM ${this._table._tableName}`;
+    if (this._joins.length > 0) query += ` ${this._joins.join(" ")}`;
     if (this._where.length > 0) {
       const whereClauses = this._where.map((condition) => {
         const sql2 = condition.toSQL();
@@ -310,22 +583,47 @@ var SelectQueryBuilder = class {
       });
       query += ` WHERE ${whereClauses.join(" AND ")}`;
     }
+    if (this._groupBy.length > 0) {
+      query += ` GROUP BY ${this._groupBy.join(", ")}`;
+    }
+    if (this._having.length > 0) {
+      const havingClauses = this._having.map((h) => {
+        const sql2 = h.toSQL();
+        bindings.push(...sql2.bindings);
+        return `(${sql2.clause})`;
+      });
+      query += ` HAVING ${havingClauses.join(" AND ")}`;
+    }
     if (this._orderBy.length > 0) {
-      query += ` ORDER BY ${this._orderBy.join(", ")}`;
+      const ordParts = [];
+      for (const ob of this._orderBy) {
+        if (typeof ob === "string") ordParts.push(ob);
+        else {
+          const s = ob.toSQL();
+          ordParts.push(s.clause);
+          bindings.push(...s.bindings);
+        }
+      }
+      query += ` ORDER BY ${ordParts.join(", ")}`;
     }
     if (this._limit !== null) {
       query += ` LIMIT ?`;
       bindings.push(this._limit);
     }
     if (this._offset !== null) {
-      if (this._limit === null) {
-        query += ` LIMIT -1`;
-      }
+      if (this._limit === null) query += ` LIMIT -1`;
       query += ` OFFSET ?`;
       bindings.push(this._offset);
     }
     return db.select(query, bindings);
   }
+  async iterator() {
+    const rows = await this.execute();
+    async function* gen() {
+      for (const r of rows) yield r;
+    }
+    return gen();
+  }
 };
 var TauriORM = class {
   // Soft relational query API: db.query.users.findMany({ with: { posts: true } })
@@ -346,18 +644,67 @@ var TauriORM = class {
   select(fields) {
     return new SelectQueryBuilder(this.getDb.bind(this), fields);
   }
+  selectDistinct(fields) {
+    const qb = new SelectQueryBuilder(this.getDb.bind(this), fields);
+    qb.distinct();
+    return qb;
+  }
   // --- Drizzle-style CRUD builders ---
   insert(table) {
     const self = this;
     return new class InsertBuilder {
       _table = table;
       _rows = [];
+      _selectSql = null;
+      _conflict = null;
+      _returning = null;
       values(rowOrRows) {
         this._rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
         return this;
       }
+      select(qb) {
+        if (qb.toSQL) this._selectSql = qb.toSQL();
+        else this._selectSql = qb.toSQL();
+        return this;
+      }
+      returning(fields) {
+        this._returning = fields ?? {};
+        return this;
+      }
+      $returningId() {
+        this._returning = "__RETURNING_ID__";
+        return this;
+      }
+      onConflictDoNothing(opts) {
+        const target = opts?.target ? Array.isArray(opts.target) ? opts.target.map((c) => c.name) : opts.target.name : void 0;
+        this._conflict = {
+          kind: "doNothing",
+          target,
+          where: opts?.where
+        };
+        return this;
+      }
+      onConflictDoUpdate(opts) {
+        const target = Array.isArray(opts.target) ? opts.target.map((c) => c.name) : opts.target.name;
+        this._conflict = {
+          kind: "doUpdate",
+          target,
+          targetWhere: opts.targetWhere,
+          set: opts.set,
+          setWhere: opts.setWhere
+        };
+        return this;
+      }
       async execute() {
         const db = await self.getDb();
+        if (this._selectSql) {
+          const cols = Object.keys(this._table._schema);
+          let query = `INSERT INTO ${this._table._tableName} (${cols.join(", ")}) ${this._selectSql.clause}`;
+          const bindings = [...this._selectSql.bindings];
+          query += this._buildConflictClause();
+          const ret = await this._executeWithReturning(db, query, bindings);
+          return ret;
+        }
         for (const data of this._rows) {
           const finalData = { ...data };
           const schema = this._table._schema;
@@ -373,11 +720,51 @@ var TauriORM = class {
           const keys = Object.keys(finalData);
           const values = Object.values(finalData);
           const placeholders = values.map(() => "?").join(", ");
-          const query = `INSERT INTO ${this._table._tableName} (${keys.join(
-            ", "
-          )}) VALUES (${placeholders})`;
-          await db.execute(query, values);
+          let query = `INSERT INTO ${this._table._tableName} (${keys.join(", ")}) VALUES (${placeholders})`;
+          const bindings = [...values];
+          query += this._buildConflictClause();
+          const ret = await this._executeWithReturning(db, query, bindings);
+          if (ret !== void 0) return ret;
+        }
+      }
+      _buildConflictClause() {
+        if (!this._conflict) return "";
+        if (this._conflict.kind === "doNothing") {
+          const tgt2 = this._conflict.target ? Array.isArray(this._conflict.target) ? `(${this._conflict.target.join(", ")})` : `(${this._conflict.target})` : "";
+          const where = this._conflict.where ? ` WHERE ${this._conflict.where.toSQL().clause}` : "";
+          return ` ON CONFLICT ${tgt2} DO NOTHING${where}`;
+        }
+        const c = this._conflict;
+        const tgt = Array.isArray(c.target) ? `(${c.target.join(", ")})` : `(${c.target})`;
+        const setKeys = Object.keys(c.set ?? {});
+        const setClause = setKeys.map((k) => {
+          const v = c.set[k];
+          return `${k} = ${typeof v === "object" && v && typeof v.toSQL === "function" ? v.toSQL().clause : "?"}`;
+        }).join(", ");
+        const targetWhere = c.targetWhere ? ` WHERE ${c.targetWhere.toSQL().clause}` : "";
+        const setWhere = c.setWhere ? ` WHERE ${c.setWhere.toSQL().clause}` : "";
+        return ` ON CONFLICT ${tgt}${targetWhere} DO UPDATE SET ${setClause}${setWhere}`;
+      }
+      async _executeWithReturning(db, query, bindings) {
+        if (this._returning === null) {
+          await db.execute(query, bindings);
+          return void 0;
         }
+        if (this._returning === "__RETURNING_ID__") {
+          const rows = await db.select(`SELECT last_insert_rowid() as id`);
+          return rows.map((r) => ({ id: r.id }));
+        }
+        if (typeof this._returning === "object") {
+          const cols = Object.entries(
+            this._returning
+          ).map(
+            ([alias, col]) => `${col.tableName}.${col.name} AS ${alias}`
+          ).join(", ");
+          const retSql = `${query} RETURNING ${cols}`;
+          const res = await db.select(retSql, bindings);
+          return res;
+        }
+        return void 0;
       }
     }();
   }
@@ -387,6 +774,10 @@ var TauriORM = class {
       _table = table;
       _data = null;
       _where = null;
+      _orderBy = [];
+      _limit = null;
+      _from = null;
+      _returning = null;
       set(data) {
         this._data = data;
         return this;
@@ -395,6 +786,28 @@ var TauriORM = class {
         this._where = cond;
         return this;
       }
+      orderBy(...clauses) {
+        for (const c of clauses) {
+          if (!c) continue;
+          if (typeof c === "string") this._orderBy.push(c);
+          else if (typeof c.toSQL === "function")
+            this._orderBy.push(c);
+          else this._orderBy.push(getQualifiedName(c));
+        }
+        return this;
+      }
+      limit(n) {
+        this._limit = n;
+        return this;
+      }
+      from(tbl) {
+        this._from = tbl;
+        return this;
+      }
+      returning(fields) {
+        this._returning = fields ?? {};
+        return this;
+      }
       async execute() {
         if (!this._data)
           throw new Error("Update requires set() before execute()");
@@ -406,10 +819,21 @@ var TauriORM = class {
             dataToSet[key] = col.onUpdateFn();
           }
         }
-        const setKeys = Object.keys(dataToSet);
-        const setClause = setKeys.map((k) => `${k} = ?`).join(", ");
-        const bindings = Object.values(dataToSet);
-        let query = `UPDATE ${this._table._tableName} SET ${setClause}`;
+        const setParts = [];
+        const bindings = [];
+        for (const [k, v] of Object.entries(dataToSet)) {
+          if (v === void 0) continue;
+          if (v && typeof v === "object" && typeof v.toSQL === "function") {
+            const s = v.toSQL();
+            setParts.push(`${k} = ${s.clause}`);
+            bindings.push(...s.bindings);
+          } else {
+            setParts.push(`${k} = ?`);
+            bindings.push(v);
+          }
+        }
+        let query = `UPDATE ${this._table._tableName} SET ${setParts.join(", ")}`;
+        if (this._from) query += ` FROM ${this._from._tableName}`;
         if (this._where) {
           if (typeof this._where.toSQL === "function") {
             const sql2 = this._where.toSQL();
@@ -423,6 +847,31 @@ var TauriORM = class {
             }
           }
         }
+        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);
       }
     }();
@@ -432,10 +881,31 @@ var TauriORM = class {
     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();
         let query = `DELETE FROM ${this._table._tableName}`;
@@ -453,6 +923,31 @@ var TauriORM = class {
             }
           }
         }
+        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);
       }
     }();
@@ -731,8 +1226,8 @@ var TauriORM = class {
     const preserve = options?.preserveData !== false;
     for (const tbl of Object.values(this._tables)) {
       const tableName = tbl._tableName;
-      const exists = await this.tableExists(tableName);
-      if (!exists) {
+      const exists2 = await this.tableExists(tableName);
+      if (!exists2) {
         await this.run(this.buildCreateTableSQL(tbl));
         continue;
       }
@@ -969,10 +1464,10 @@ function makeQueryAPI(tables, relDefs, dbProvider) {
                 const childPk = fkMap[relName].childPk;
                 if (childPk) {
                   if (!acc[relName]) acc[relName] = [];
-                  const exists = acc[relName].some(
+                  const exists2 = acc[relName].some(
                     (r) => r[childPk.name] === childObj[childPk.name]
                   );
-                  if (!exists) acc[relName].push(childObj);
+                  if (!exists2) acc[relName].push(childObj);
                 } else {
                   acc[relName].push(childObj);
                 }
@@ -1102,25 +1597,46 @@ function makeQueryAPI(tables, relDefs, dbProvider) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TauriORM,
+  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
+  timestamp,
+  unique,
+  uniqueIndex
 });