@type32/tauri-sqlite-orm 0.1.18-4 → 0.1.18-6

package/dist/index.mjs

@@ -83,6 +83,9 @@ var SQLiteColumn = class _SQLiteColumn {
       this._.mode
     );
   }
+  as(alias2) {
+    return this;
+  }
 };
 var text = (name) => new SQLiteColumn(name, "TEXT");
 var integer = (name, config) => new SQLiteColumn(name, "INTEGER", {}, config?.mode || "default");
@@ -113,6 +116,10 @@ var or = (...conditions) => ({
   sql: conditions.map((c) => `(${c.sql})`).join(" OR "),
   params: conditions.flatMap((c) => c.params)
 });
+var not = (condition) => ({
+  sql: `NOT (${condition.sql})`,
+  params: condition.params
+});
 var gt = (column, value) => ({
   sql: `${column._.name} > ?`,
   params: [value]
@@ -145,6 +152,58 @@ var inArray = (column, values) => ({
   sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
   params: values
 });
+var asc = (column) => ({
+  sql: `${column._.name} ASC`,
+  params: []
+});
+var desc = (column) => ({
+  sql: `${column._.name} DESC`,
+  params: []
+});
+var count = (column) => ({
+  sql: `COUNT(${column ? column._.name : "*"})`,
+  params: []
+});
+var countDistinct = (column) => ({
+  sql: `COUNT(DISTINCT ${column._.name})`,
+  params: []
+});
+var sum = (column) => ({
+  sql: `SUM(${column._.name})`,
+  params: []
+});
+var avg = (column) => ({
+  sql: `AVG(${column._.name})`,
+  params: []
+});
+var max = (column) => ({
+  sql: `MAX(${column._.name})`,
+  params: []
+});
+var min = (column) => ({
+  sql: `MIN(${column._.name})`,
+  params: []
+});
+var sql = (strings, ...values) => {
+  const queryParts = [];
+  const params = [];
+  strings.forEach((str, i) => {
+    queryParts.push(str);
+    if (values[i] !== void 0) {
+      if (typeof values[i] === "object" && values[i].sql) {
+        queryParts.push(values[i].sql);
+        params.push(...values[i].params);
+      } else {
+        queryParts.push("?");
+        params.push(values[i]);
+      }
+    }
+  });
+  return {
+    sql: queryParts.join(""),
+    params
+  };
+};
 var BaseQueryBuilder = class {
   constructor(db) {
     this.db = db;
@@ -157,15 +216,20 @@ var BaseQueryBuilder = class {
     return this;
   }
   orderBy(column, direction = "ASC") {
-    this.query += ` ORDER BY ${column._.name} ${direction}`;
+    if ("sql" in column) {
+      this.query += ` ORDER BY ${column.sql} ${direction}`;
+      this.params.push(...column.params);
+    } else {
+      this.query += ` ORDER BY ${column._.name} ${direction}`;
+    }
     return this;
   }
-  limit(count) {
-    this.query += ` LIMIT ${count}`;
+  limit(count2) {
+    this.query += ` LIMIT ${count2}`;
     return this;
   }
-  offset(count) {
-    this.query += ` OFFSET ${count}`;
+  offset(count2) {
+    this.query += ` OFFSET ${count2}`;
     return this;
   }
   build() {
@@ -183,9 +247,37 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     const columnNames = columns ? columns.map((c) => table._.columns[c]._.name) : ["*"];
     this.query = `SELECT ${columnNames.join(", ")} FROM ${table._.name}`;
   }
+  isDistinct = false;
+  groupByColumns = [];
+  havingCondition = null;
+  distinct() {
+    this.isDistinct = true;
+    this.query = this.query.replace("SELECT", "SELECT DISTINCT");
+    return this;
+  }
+  groupBy(...columns) {
+    this.groupByColumns.push(...columns);
+    const columnNames = columns.map((col) => col._.name).join(", ");
+    this.query += ` GROUP BY ${columnNames}`;
+    return this;
+  }
+  having(condition) {
+    this.havingCondition = condition;
+    this.query += ` HAVING ${condition.sql}`;
+    this.params.push(...condition.params);
+    return this;
+  }
   async execute() {
-    const { sql, params } = this.build();
-    return this.db.select(sql, params);
+    const { sql: sql2, params } = this.build();
+    return this.db.select(sql2, params);
+  }
+  async all() {
+    return this.execute();
+  }
+  async get() {
+    this.limit(1);
+    const result = await this.execute();
+    return result[0];
   }
 };
 var InsertQueryBuilder = class extends BaseQueryBuilder {
@@ -195,46 +287,121 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
     this.query = `INSERT INTO ${table._.name}`;
   }
   dataSets = [];
+  returningColumns = [];
+  onConflictAction = null;
+  conflictTarget = [];
+  updateSet = {};
   values(data) {
     const dataArray = Array.isArray(data) ? data : [data];
     this.dataSets.push(...dataArray);
     return this;
   }
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
+  onConflictDoNothing(target) {
+    this.onConflictAction = "nothing";
+    if (target) {
+      this.conflictTarget = Array.isArray(target) ? target : [target];
+    }
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    this.onConflictAction = "update";
+    this.conflictTarget = Array.isArray(config.target) ? config.target : [config.target];
+    this.updateSet = config.set;
+    return this;
+  }
+  processDefaultValues(data) {
+    const finalData = { ...data };
+    for (const [key, column] of Object.entries(this.table._.columns)) {
+      const typedKey = key;
+      if (finalData[typedKey] === void 0) {
+        if (column.options.$defaultFn) {
+          finalData[typedKey] = column.options.$defaultFn();
+        }
+      }
+    }
+    return finalData;
+  }
+  buildConflictClause() {
+    if (!this.onConflictAction) return "";
+    let clause = " ON CONFLICT";
+    if (this.conflictTarget.length > 0) {
+      const targetNames = this.conflictTarget.map((col) => col._.name).join(", ");
+      clause += ` (${targetNames})`;
+    }
+    if (this.onConflictAction === "nothing") {
+      clause += " DO NOTHING";
+    } else if (this.onConflictAction === "update") {
+      const setEntries = Object.entries(this.updateSet);
+      if (setEntries.length > 0) {
+        const setClause = setEntries.map(([key]) => `${key} = ?`).join(", ");
+        clause += ` DO UPDATE SET ${setClause}`;
+      }
+    }
+    return clause;
+  }
   async execute() {
     if (this.dataSets.length === 0) {
       throw new Error("No data provided for insert");
     }
-    const processedDataSets = this.dataSets.map((dataSet) => {
-      const finalData = { ...dataSet };
-      for (const [key, column] of Object.entries(this.table._.columns)) {
-        if (finalData[key] === void 0) {
-          if (column.options.$defaultFn) {
-            finalData[key] = column.options.$defaultFn();
-          }
-        }
-      }
-      return finalData;
-    });
-    const allKeys = /* @__PURE__ */ new Set();
+    const processedDataSets = this.dataSets.map(
+      (data) => this.processDefaultValues(data)
+    );
+    const groups = /* @__PURE__ */ new Map();
     for (const dataSet of processedDataSets) {
-      for (const key of Object.keys(dataSet)) {
-        allKeys.add(key);
+      const keys = Object.keys(dataSet).sort().join(",");
+      if (!groups.has(keys)) {
+        groups.set(keys, []);
       }
+      groups.get(keys).push(dataSet);
     }
-    const columns = Array.from(allKeys);
-    const columnNames = columns.map(
-      (key) => this.table._.columns[key]._.name
-    );
-    const placeholders = `(${columns.map(() => "?").join(", ")})`;
-    const valuesSql = processedDataSets.map(() => placeholders).join(", ");
-    const finalQuery = `${this.query} (${columnNames.join(
-      ", "
-    )}) VALUES ${valuesSql}`;
-    const params = processedDataSets.flatMap(
-      (data) => columns.map((col) => data[col] ?? null)
+    let results = [];
+    let lastInsertId;
+    let rowsAffected = 0;
+    for (const [_, dataSets] of groups) {
+      const columns = Object.keys(dataSets[0]);
+      const columnNames = columns.map(
+        (key) => this.table._.columns[key]._.name
+      );
+      const placeholders = `(${columns.map(() => "?").join(", ")})`;
+      const valuesSql = dataSets.map(() => placeholders).join(", ");
+      const conflictClause = this.buildConflictClause();
+      const finalQuery = `${this.query} (${columnNames.join(
+        ", "
+      )}) VALUES ${valuesSql}${conflictClause}`;
+      const params = dataSets.flatMap(
+        (data) => columns.map((col) => data[col] ?? null)
+      );
+      if (this.onConflictAction === "update") {
+        const setValues = Object.entries(this.updateSet).map(
+          ([, value]) => value
+        );
+        params.push(...setValues);
+      }
+      if (this.returningColumns.length > 0) {
+        const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+        const queryWithReturning = `${finalQuery} RETURNING ${returningNames}`;
+        const rows = await this.db.select(queryWithReturning, params);
+        results = results.concat(rows);
+      } else {
+        const result = await this.db.execute(finalQuery, params);
+        lastInsertId = result.lastInsertId;
+        rowsAffected += result.rowsAffected;
+      }
+    }
+    if (this.returningColumns.length > 0) {
+      return results;
+    }
+    return [{ lastInsertId, rowsAffected }];
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
     );
-    const result = await this.db.execute(finalQuery, params);
-    return result.lastInsertId ?? 0;
+    return this.returning(...allColumns).execute();
   }
 };
 var UpdateQueryBuilder = class extends BaseQueryBuilder {
@@ -244,15 +411,21 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
     this.query = `UPDATE ${table._.name}`;
   }
   updateData = {};
+  returningColumns = [];
   set(data) {
     this.updateData = { ...this.updateData, ...data };
     return this;
   }
-  build() {
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
+  buildUpdateClause() {
     const finalUpdateData = { ...this.updateData };
     for (const [key, column] of Object.entries(this.table._.columns)) {
-      if (finalUpdateData[key] === void 0 && column.options.$onUpdateFn) {
-        finalUpdateData[key] = column.options.$onUpdateFn();
+      const typedKey = key;
+      if (finalUpdateData[typedKey] === void 0 && column.options.$onUpdateFn) {
+        finalUpdateData[typedKey] = column.options.$onUpdateFn();
       }
     }
     const baseQuery = this.query;
@@ -278,14 +451,26 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
       return `${column._.name} = ?`;
     }).join(", ");
     const setParams = entries.map(([, value]) => value);
-    const sql = `${tablePart} SET ${setClause}${whereClause}`;
+    const sql2 = `${tablePart} SET ${setClause}${whereClause}`;
     const params = [...setParams, ...whereParams];
-    return { sql, params };
+    return { sql: sql2, params };
   }
   async execute() {
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
+    const { sql: updateSql, params } = this.buildUpdateClause();
+    if (this.returningColumns.length > 0) {
+      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+      const sqlWithReturning = `${updateSql} RETURNING ${returningNames}`;
+      return this.db.select(sqlWithReturning, params);
+    } else {
+      const result = await this.db.execute(updateSql, params);
+      return [{ rowsAffected: result.rowsAffected }];
+    }
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
   }
 };
 var DeleteQueryBuilder = class extends BaseQueryBuilder {
@@ -294,10 +479,67 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
     this.table = table;
     this.query = `DELETE FROM ${table._.name}`;
   }
+  returningColumns = [];
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
   async execute() {
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
+    const { sql: sql2, params } = this.build();
+    if (this.returningColumns.length > 0) {
+      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+      const sqlWithReturning = `${sql2} RETURNING ${returningNames}`;
+      return this.db.select(sqlWithReturning, params);
+    } else {
+      const result = await this.db.execute(sql2, params);
+      return [{ rowsAffected: result.rowsAffected }];
+    }
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
+  }
+};
+var WithQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
+  }
+  ctes = [];
+  with(alias2, query) {
+    this.ctes.push({ alias: alias2, query: query.sql, params: query.params });
+    return this;
+  }
+  select(table, columns) {
+    const builder = new SelectQueryBuilder(this.db, table, columns);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  insert(table) {
+    const builder = new InsertQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  update(table) {
+    const builder = new UpdateQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  delete(table) {
+    const builder = new DeleteQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  applyWithClause(builder) {
+    if (this.ctes.length > 0) {
+      const cteSql = this.ctes.map((cte) => `${cte.alias} AS (${cte.query})`).join(", ");
+      builder["query"] = `WITH ${cteSql} ${builder["query"]}`;
+      builder["params"] = [
+        ...this.ctes.flatMap((cte) => cte.params),
+        ...builder["params"]
+      ];
+    }
   }
 };
 var TauriORM = class {
@@ -311,23 +553,23 @@ var TauriORM = class {
   }
   tables = /* @__PURE__ */ new Map();
   buildColumnDefinition(col, forAlterTable = false) {
-    let sql = `${col._.name} ${col.type}`;
+    let sql2 = `${col._.name} ${col.type}`;
     if (col.options.primaryKey && !forAlterTable) {
-      sql += " PRIMARY KEY";
+      sql2 += " PRIMARY KEY";
       if (col._.autoincrement) {
-        sql += " AUTOINCREMENT";
+        sql2 += " AUTOINCREMENT";
       }
     }
-    if (col._.notNull) sql += " NOT NULL";
-    if (col.options.unique) sql += " UNIQUE";
+    if (col._.notNull) sql2 += " NOT NULL";
+    if (col.options.unique) sql2 += " UNIQUE";
     if (col.options.default !== void 0) {
       const value = col.options.default;
-      sql += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
+      sql2 += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
     }
     if (col.options.references) {
-      sql += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+      sql2 += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
     }
-    return sql;
+    return sql2;
   }
   async migrate() {
     for (const table of this.tables.values()) {
@@ -364,6 +606,15 @@ var TauriORM = class {
   delete(table) {
     return new DeleteQueryBuilder(this.db, table);
   }
+  $with(alias2) {
+    const withBuilder = new WithQueryBuilder(this.db);
+    return {
+      as: (query) => {
+        withBuilder.with(alias2, query);
+        return withBuilder;
+      }
+    };
+  }
   async transaction(callback) {
     await this.db.execute("BEGIN TRANSACTION");
     try {
@@ -375,6 +626,9 @@ var TauriORM = class {
       throw error;
     }
   }
+  rollback() {
+    throw new Error("Transaction rolled back");
+  }
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
@@ -452,6 +706,12 @@ var relations = (table, relationsCallback) => {
     })
   });
 };
+var getTableColumns = (table) => {
+  return table._.columns;
+};
+var alias = (table, alias2) => {
+  return table;
+};
 export {
   DeleteQueryBuilder,
   InsertQueryBuilder,
@@ -460,10 +720,18 @@ export {
   Table,
   TauriORM,
   UpdateQueryBuilder,
+  WithQueryBuilder,
+  alias,
   and,
+  asc,
+  avg,
   blob,
   boolean,
+  count,
+  countDistinct,
+  desc,
   eq,
+  getTableColumns,
   gt,
   gte,
   inArray,
@@ -473,9 +741,14 @@ export {
   like,
   lt,
   lte,
+  max,
+  min,
+  not,
   or,
   real,
   relations,
+  sql,
   sqliteTable,
+  sum,
   text
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@type32/tauri-sqlite-orm",
-  "version": "0.1.18-4",
+  "version": "0.1.18-6",
   "description": "A Drizzle-like ORM for Tauri v2's SQL JS API plugin.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",