@type32/tauri-sqlite-orm 0.1.18-5 → 0.1.18-7

package/dist/index.js

@@ -7,11 +7,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
+var __copyProps = (to, from, except, desc2) => {
   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: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
   }
   return to;
 };
@@ -27,10 +27,18 @@ __export(index_exports, {
   Table: () => Table,
   TauriORM: () => TauriORM,
   UpdateQueryBuilder: () => UpdateQueryBuilder,
+  WithQueryBuilder: () => WithQueryBuilder,
+  alias: () => alias,
   and: () => and,
+  asc: () => asc,
+  avg: () => avg,
   blob: () => blob,
   boolean: () => boolean,
+  count: () => count,
+  countDistinct: () => countDistinct,
+  desc: () => desc,
   eq: () => eq,
+  getTableColumns: () => getTableColumns,
   gt: () => gt,
   gte: () => gte,
   inArray: () => inArray,
@@ -40,10 +48,15 @@ __export(index_exports, {
   like: () => like,
   lt: () => lt,
   lte: () => lte,
+  max: () => max,
+  min: () => min,
+  not: () => not,
   or: () => or,
   real: () => real,
   relations: () => relations,
+  sql: () => sql,
   sqliteTable: () => sqliteTable,
+  sum: () => sum,
   text: () => text
 });
 module.exports = __toCommonJS(index_exports);
@@ -91,7 +104,7 @@ var SQLiteColumn = class _SQLiteColumn {
     return new _SQLiteColumn(
       this._.name,
       this.type,
-      { ...this.options, primaryKey: true },
+      { ...this.options, primaryKey: true, notNull: true },
       this._.mode
     );
   }
@@ -133,6 +146,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");
@@ -163,6 +179,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]
@@ -195,6 +215,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;
@@ -207,15 +279,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() {
@@ -233,9 +310,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 {
@@ -245,26 +350,69 @@ 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 processedDataSets = this.dataSets.map(
+      (data) => this.processDefaultValues(data)
+    );
     const groups = /* @__PURE__ */ new Map();
     for (const dataSet of processedDataSets) {
       const keys = Object.keys(dataSet).sort().join(",");
@@ -273,7 +421,9 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
       }
       groups.get(keys).push(dataSet);
     }
-    let lastInsertId = void 0;
+    let results = [];
+    let lastInsertId;
+    let rowsAffected = 0;
     for (const [_, dataSets] of groups) {
       const columns = Object.keys(dataSets[0]);
       const columnNames = columns.map(
@@ -281,16 +431,40 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
       );
       const placeholders = `(${columns.map(() => "?").join(", ")})`;
       const valuesSql = dataSets.map(() => placeholders).join(", ");
+      const conflictClause = this.buildConflictClause();
       const finalQuery = `${this.query} (${columnNames.join(
         ", "
-      )}) VALUES ${valuesSql}`;
+      )}) VALUES ${valuesSql}${conflictClause}`;
       const params = dataSets.flatMap(
         (data) => columns.map((col) => data[col] ?? null)
       );
-      const result = await this.db.execute(finalQuery, params);
-      lastInsertId = result.lastInsertId;
+      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 ?? 0;
+    return [{ lastInsertId, rowsAffected }];
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
   }
 };
 var UpdateQueryBuilder = class extends BaseQueryBuilder {
@@ -300,15 +474,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;
@@ -334,14 +514,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 {
@@ -350,10 +542,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 {
@@ -367,23 +616,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()) {
@@ -420,6 +669,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 {
@@ -431,6 +689,9 @@ var TauriORM = class {
       throw error;
     }
   }
+  rollback() {
+    throw new Error("Transaction rolled back");
+  }
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
@@ -508,6 +769,12 @@ var relations = (table, relationsCallback) => {
     })
   });
 };
+var getTableColumns = (table) => {
+  return table._.columns;
+};
+var alias = (table, alias2) => {
+  return table;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DeleteQueryBuilder,
@@ -517,10 +784,18 @@ var relations = (table, relationsCallback) => {
   Table,
   TauriORM,
   UpdateQueryBuilder,
+  WithQueryBuilder,
+  alias,
   and,
+  asc,
+  avg,
   blob,
   boolean,
+  count,
+  countDistinct,
+  desc,
   eq,
+  getTableColumns,
   gt,
   gte,
   inArray,
@@ -530,9 +805,14 @@ var relations = (table, relationsCallback) => {
   like,
   lt,
   lte,
+  max,
+  min,
+  not,
   or,
   real,
   relations,
+  sql,
   sqliteTable,
+  sum,
   text
 });