@type32/tauri-sqlite-orm 0.1.18-2 → 0.1.18-21

package/dist/index.mjs

@@ -1,110 +1,48 @@
-// src/orm.ts
-var SQLiteColumn = class _SQLiteColumn {
-  constructor(name, type, options = {}, mode) {
-    this.type = type;
-    this.options = options;
-    this._ = {
-      name,
-      dataType: type,
-      mode: mode || "default",
-      notNull: options.notNull ?? false,
-      hasDefault: options.default !== void 0 || options.$defaultFn !== void 0,
-      autoincrement: options.autoincrement ?? false
-    };
-  }
-  _;
-  notNull() {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      { ...this.options, notNull: true },
-      this._.mode
-    );
-  }
-  default(value) {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      { ...this.options, default: value },
-      this._.mode
-    );
-  }
-  $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
-    );
+// src/builders/query-base.ts
+var BaseQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
   }
-  autoincrement() {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      { ...this.options, autoincrement: true },
-      this._.mode
-    );
+  query = "";
+  params = [];
+  where(condition) {
+    this.query += ` WHERE ${condition.sql}`;
+    this.params.push(...condition.params);
+    return this;
   }
-  unique() {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      { ...this.options, unique: true },
-      this._.mode
-    );
+  orderBy(column, direction = "ASC") {
+    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;
   }
-  references(ref, column) {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      {
-        ...this.options,
-        references: {
-          table: ref,
-          column: ref._.columns[column]
-        }
-      },
-      this._.mode
-    );
+  limit(count2) {
+    this.query += ` LIMIT ${count2}`;
+    return this;
   }
-  $onUpdateFn(fn) {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      { ...this.options, $onUpdateFn: fn },
-      this._.mode
-    );
+  offset(count2) {
+    this.query += ` OFFSET ${count2}`;
+    return this;
   }
-};
-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
+  build() {
+    return {
+      sql: this.query,
+      params: this.params
     };
   }
 };
-var sqliteTable = (tableName, columns) => {
-  return new Table(tableName, columns);
+
+// src/operators.ts
+var eq = (column, value, tableAlias) => {
+  const columnName = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  return {
+    sql: `${columnName} = ?`,
+    params: [value]
+  };
 };
-var eq = (column, value) => ({
-  sql: `${column._.name} = ?`,
-  params: [value]
-});
 var and = (...conditions) => ({
   sql: conditions.map((c) => `(${c.sql})`).join(" AND "),
   params: conditions.flatMap((c) => c.params)
@@ -113,6 +51,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,81 +87,241 @@ var inArray = (column, values) => ({
   sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
   params: values
 });
-var BaseQueryBuilder = class {
-  constructor(db) {
-    this.db = db;
+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: []
+});
+
+// src/builders/select.ts
+var SelectQueryBuilder = class extends BaseQueryBuilder {
+  constructor(db, table, columns) {
+    super(db);
+    this.table = table;
+    this.columns = columns;
+    this.selectedTableAlias = table._.name;
+    const selected = columns ? columns.map((c) => this.table._.columns[c]) : Object.values(this.table._.columns);
+    this.selectedColumns = selected.map(
+      (col) => `${this.selectedTableAlias}.${col._.name} AS "${this.selectedTableAlias}.${col._.name}"`
+    );
+    this.query = `FROM ${table._.name} ${this.selectedTableAlias}`;
+  }
+  isDistinct = false;
+  groupByColumns = [];
+  havingCondition = null;
+  joins = [];
+  includeRelations = {};
+  selectedTableAlias;
+  selectedColumns = [];
+  distinct() {
+    this.isDistinct = true;
+    return this;
   }
-  query = "";
-  params = [];
-  where(condition) {
-    this.query += ` WHERE ${condition.sql}`;
-    this.params.push(...condition.params);
+  groupBy(...columns) {
+    this.groupByColumns.push(...columns);
+    const columnNames = columns.map((col) => `${this.selectedTableAlias}.${col._.name}`).join(", ");
+    this.query += ` GROUP BY ${columnNames}`;
     return this;
   }
-  orderBy(column, direction = "ASC") {
-    this.query += ` ORDER BY ${column._.name} ${direction}`;
+  having(condition) {
+    this.havingCondition = condition;
+    this.query += ` HAVING ${condition.sql}`;
+    this.params.push(...condition.params);
     return this;
   }
-  limit(count) {
-    this.query += ` LIMIT ${count}`;
+  leftJoin(table, condition, alias2) {
+    this.joins.push({ type: "LEFT", table, condition, alias: alias2 });
+    const aliasedColumns = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} AS "${alias2}.${col._.name}"`
+    );
+    this.selectedColumns.push(...aliasedColumns);
     return this;
   }
-  offset(count) {
-    this.query += ` OFFSET ${count}`;
+  innerJoin(table, condition, alias2) {
+    this.joins.push({ type: "INNER", table, condition, alias: alias2 });
+    const aliasedColumns = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} AS "${alias2}.${col._.name}"`
+    );
+    this.selectedColumns.push(...aliasedColumns);
     return this;
   }
-  build() {
-    return {
-      sql: this.query,
-      params: this.params
-    };
+  include(relations2) {
+    this.includeRelations = { ...this.includeRelations, ...relations2 };
+    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}`;
+  buildJoins() {
+    let sql2 = "";
+    const params = [];
+    for (const join of this.joins) {
+      sql2 += ` ${join.type} JOIN ${join.table._.name} ${join.alias} ON ${join.condition.sql}`;
+      params.push(...join.condition.params);
+    }
+    for (const [relationName, include] of Object.entries(this.includeRelations)) {
+      if (!include) continue;
+      const relation = this.table.relations[relationName];
+      if (!relation) {
+        console.warn(
+          `[Tauri-ORM] Relation "${relationName}" not found on table "${this.table._.name}". Skipping include.`
+        );
+        continue;
+      }
+      const foreignTable = relation.foreignTable;
+      const foreignAlias = `${this.selectedTableAlias}_${relationName}`;
+      const aliasedColumns = Object.values(foreignTable._.columns).map(
+        (col) => `${foreignAlias}.${col._.name} AS "${foreignAlias}.${col._.name}"`
+      );
+      this.selectedColumns.push(...aliasedColumns);
+      if (relation.type === "one" && relation.fields && relation.references) {
+        const conditions = relation.fields.map((field, i) => {
+          const localColumn = `${this.selectedTableAlias}.${field._.name}`;
+          const foreignColumn = `${foreignAlias}.${relation.references[i]._.name}`;
+          return {
+            sql: `${localColumn} = ${foreignColumn}`,
+            params: []
+          };
+        });
+        const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
+        sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
+        params.push(...condition.params);
+      } else if (relation.type === "many") {
+        const refRelation = Object.entries(foreignTable.relations).find(
+          ([_, r]) => r.foreignTable === this.table
+        );
+        if (refRelation && refRelation[1].fields && refRelation[1].references) {
+          const [_, relationConfig] = refRelation;
+          const conditions = relationConfig.fields.map((field, i) => {
+            const localColumn = `${foreignAlias}.${field._.name}`;
+            const foreignColumn = `${this.selectedTableAlias}.${relationConfig.references[i]._.name}`;
+            return {
+              sql: `${localColumn} = ${foreignColumn}`,
+              params: []
+            };
+          });
+          const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
+          sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
+          params.push(...condition.params);
+        }
+      }
+    }
+    return { sql: sql2, params };
   }
+  // Enhanced execute method that handles relation data mapping
   async execute() {
-    const { sql, params } = this.build();
-    return this.db.select(sql, params);
+    const { sql: joinSql, params: joinParams } = this.buildJoins();
+    const distinct = this.isDistinct ? "DISTINCT " : "";
+    this.query = `SELECT ${distinct}${this.selectedColumns.join(", ")} ${this.query}`;
+    this.query += joinSql;
+    this.params.push(...joinParams);
+    const { sql: sql2, params } = this.build();
+    console.log("Executing SQL:", sql2, "with params:", params);
+    const rawResults = await this.db.select(sql2, params);
+    const hasIncludes = Object.values(this.includeRelations).some((i) => i);
+    if (hasIncludes) {
+      return this.processRelationResults(rawResults);
+    }
+    const hasJoins = this.joins.length > 0;
+    if (hasJoins) {
+      return rawResults;
+    }
+    const prefix = `${this.selectedTableAlias}.`;
+    return rawResults.map((row) => {
+      const newRow = {};
+      for (const key in row) {
+        if (key.startsWith(prefix)) {
+          newRow[key.substring(prefix.length)] = row[key];
+        } else {
+          newRow[key] = row[key];
+        }
+      }
+      return newRow;
+    });
   }
-};
-var InsertQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table) {
-    super(db);
-    this.table = table;
-    this.query = `INSERT INTO ${table._.name}`;
+  processRelationResults(rawResults) {
+    if (!rawResults.length) return [];
+    const mainTablePks = Object.values(this.table._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
+    if (mainTablePks.length === 0) {
+      return rawResults;
+    }
+    const groupedResults = /* @__PURE__ */ new Map();
+    for (const row of rawResults) {
+      const mainTableKey = mainTablePks.map((pk) => row[`${this.selectedTableAlias}.${pk}`] ?? row[pk]).join("_");
+      if (!groupedResults.has(mainTableKey)) {
+        groupedResults.set(mainTableKey, {});
+      }
+      const result = groupedResults.get(mainTableKey);
+      const relations2 = {};
+      for (const [key, value] of Object.entries(row)) {
+        if (key.includes(".")) {
+          const [tableAlias, columnName] = key.split(".");
+          if (tableAlias === this.selectedTableAlias) {
+            result[columnName] = value;
+          } else {
+            const parts = tableAlias.split("_");
+            if (parts.length >= 2 && parts[0] === this.selectedTableAlias) {
+              const relationName = parts.slice(1).join("_");
+              if (!relations2[relationName]) relations2[relationName] = {};
+              relations2[relationName][columnName] = value;
+            } else {
+              if (!result[tableAlias]) result[tableAlias] = {};
+              result[tableAlias][columnName] = value;
+            }
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      for (const [relName, relData] of Object.entries(relations2)) {
+        const relationConfig = this.table.relations[relName];
+        if (!relationConfig) continue;
+        const hasData = Object.values(relData).some(
+          (v) => v !== null && v !== void 0 && v !== ""
+        );
+        if (!hasData) continue;
+        if (relationConfig.type === "many") {
+          if (!result[relName]) result[relName] = [];
+          const relatedPks = Object.values(relationConfig.foreignTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
+          const relDataKey = relatedPks.map((pk) => relData[pk]).join("_");
+          if (relatedPks.length === 0 || !result[relName].some((r) => relatedPks.map((pk) => r[pk]).join("_") === relDataKey)) {
+            result[relName].push(relData);
+          }
+        } else {
+          result[relName] = relData;
+        }
+      }
+    }
+    return Array.from(groupedResults.values());
   }
-  dataSets = [];
-  values(data) {
-    const dataArray = Array.isArray(data) ? data : [data];
-    this.dataSets.push(...dataArray);
-    return this;
+  // Update the return type signatures
+  async all() {
+    return this.execute();
   }
-  async execute() {
-    if (this.dataSets.length === 0) {
-      throw new Error("No data provided for insert");
-    }
-    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;
+  async get() {
+    this.limit(1);
+    const result = await this.execute();
+    return result[0];
   }
 };
+
+// src/builders/update.ts
 var UpdateQueryBuilder = class extends BaseQueryBuilder {
   constructor(db, table) {
     super(db);
@@ -227,11 +329,23 @@ 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.push(...columns);
+    return this;
+  }
+  buildUpdateClause() {
+    const finalUpdateData = { ...this.updateData };
+    for (const [key, column] of Object.entries(this.table._.columns)) {
+      const typedKey = key;
+      if (finalUpdateData[typedKey] === void 0 && column.options.$onUpdateFn) {
+        finalUpdateData[typedKey] = column.options.$onUpdateFn();
+      }
+    }
     const baseQuery = this.query;
     const whereParams = this.params;
     let tablePart = baseQuery;
@@ -241,7 +355,7 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
       tablePart = baseQuery.substring(0, whereIndex);
       whereClause = baseQuery.substring(whereIndex);
     }
-    const entries = Object.entries(this.updateData);
+    const entries = Object.entries(finalUpdateData);
     if (entries.length === 0) {
       throw new Error("Cannot execute an update query without a .set() call.");
     }
@@ -255,61 +369,416 @@ 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();
   }
 };
+
+// src/builders/insert.ts
+var InsertQueryBuilder = class extends BaseQueryBuilder {
+  constructor(db, table) {
+    super(db);
+    this.table = table;
+    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.push(...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(
+      (data) => this.processDefaultValues(data)
+    );
+    const groups = /* @__PURE__ */ new Map();
+    for (const dataSet of processedDataSets) {
+      const keys = Object.keys(dataSet).sort().join(",");
+      if (!groups.has(keys)) {
+        groups.set(keys, []);
+      }
+      groups.get(keys).push(dataSet);
+    }
+    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
+    );
+    return this.returning(...allColumns).execute();
+  }
+};
+
+// src/builders/delete.ts
 var DeleteQueryBuilder = class extends BaseQueryBuilder {
   constructor(db, table) {
     super(db);
     this.table = table;
     this.query = `DELETE FROM ${table._.name}`;
   }
+  returningColumns = [];
+  returning(...columns) {
+    this.returningColumns.push(...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();
+  }
+};
+
+// src/builders/with.ts
+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"]
+      ];
+    }
   }
 };
+
+// src/orm.ts
+var SQLiteColumn = class _SQLiteColumn {
+  constructor(name, type, options = {}, mode) {
+    this.type = type;
+    this.options = options;
+    this._ = {
+      name,
+      dataType: type,
+      mode: mode || "default",
+      notNull: options.notNull ?? false,
+      hasDefault: options.default !== void 0 || options.$defaultFn !== void 0,
+      autoincrement: options.autoincrement ?? false,
+      enum: options.enum,
+      customType: void 0
+    };
+  }
+  _;
+  notNull() {
+    return new _SQLiteColumn(this._.name, this.type, { ...this.options, notNull: true }, this._.mode);
+  }
+  default(value) {
+    return new _SQLiteColumn(this._.name, this.type, { ...this.options, default: value }, this._.mode);
+  }
+  $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, notNull: 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]
+        }
+      },
+      this._.mode
+    );
+  }
+  $onUpdateFn(fn) {
+    return new _SQLiteColumn(this._.name, this.type, { ...this.options, $onUpdateFn: fn }, this._.mode);
+  }
+  $type() {
+    return this;
+  }
+  as(alias2) {
+    return this;
+  }
+};
+var Table = class {
+  _;
+  relations = {};
+  constructor(name, columns) {
+    this._ = {
+      name,
+      columns
+    };
+  }
+};
+var sqliteTable = (tableName, columns) => {
+  return new Table(tableName, columns);
+};
+var asc = (column) => ({
+  sql: `${column._.name} ASC`,
+  params: []
+});
+var desc = (column) => ({
+  sql: `${column._.name} DESC`,
+  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 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);
+      for (const [key, value] of Object.entries(schema)) {
+        if (value instanceof Table) {
+          this.tables.set(value._.name, value);
+        }
       }
     }
   }
   tables = /* @__PURE__ */ new Map();
-  async migrate() {
+  buildColumnDefinition(col, forAlterTable = false) {
+    let sql2 = `${col._.name} ${col.type}`;
+    if (col.options.primaryKey && !forAlterTable) {
+      sql2 += " PRIMARY KEY";
+      if (col._.autoincrement) {
+        sql2 += " AUTOINCREMENT";
+      }
+    }
+    if (col._.notNull) sql2 += " NOT NULL";
+    if (col.options.unique) sql2 += " UNIQUE";
+    if (col.options.default !== void 0) {
+      const value = col.options.default;
+      sql2 += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
+    }
+    if (col.options.references) {
+      sql2 += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+    }
+    return sql2;
+  }
+  async migrate(options) {
+    const dbTables = await this.db.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`
+    );
+    const dbTableNames = new Set(dbTables.map((t) => t.name));
+    const schemaTableNames = new Set(Array.from(this.tables.keys()));
     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}`;
+      const tableName = table._.name;
+      const tableExists = dbTableNames.has(tableName);
+      if (!tableExists) {
+        const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
+        const createSql = `CREATE TABLE ${tableName}
+                                   (
+                                       ${columnsSql}
+                                   )`;
+        await this.db.execute(createSql);
+      } else {
+        const existingTableInfo = await this.db.select(`PRAGMA table_info('${tableName}')`);
+        const existingColumnNames = new Set(existingTableInfo.map((c) => c.name));
+        const schemaColumnNames = new Set(Object.keys(table._.columns));
+        for (const column of Object.values(table._.columns)) {
+          if (!existingColumnNames.has(column._.name)) {
+            const columnSql = this.buildColumnDefinition(column, true);
+            const alterSql = `ALTER TABLE ${tableName}
+                            ADD COLUMN ${columnSql}`;
+            await this.db.execute(alterSql);
+          }
+        }
+        if (options?.performDestructiveActions) {
+          for (const colName of existingColumnNames) {
+            if (!schemaColumnNames.has(colName)) {
+              await this.dropColumn(tableName, colName);
+            }
+          }
         }
-        if (col.options.references) {
-          sql += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+      }
+    }
+    if (options?.performDestructiveActions) {
+      for (const tableName of dbTableNames) {
+        if (!schemaTableNames.has(tableName)) {
+          await this.dropTable(tableName);
         }
-        return sql;
-      }).join(", ");
-      const createSql = `CREATE TABLE IF NOT EXISTS ${table._.name} (${columnsSql})`;
-      await this.db.execute(createSql);
+      }
     }
   }
   select(table, columns) {
-    return new SelectQueryBuilder(this.db, table, columns);
+    const internalTable = this.tables.get(table._.name);
+    if (!internalTable) {
+      console.warn(
+        `[Tauri-ORM] Table "${table._.name}" was not passed in the schema to the ORM constructor. Relations will not be available.`
+      );
+      return new SelectQueryBuilder(this.db, table, columns);
+    }
+    return new SelectQueryBuilder(this.db, internalTable, columns);
   }
   insert(table) {
     return new InsertQueryBuilder(this.db, table);
@@ -320,6 +789,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 {
@@ -331,16 +809,31 @@ var TauriORM = class {
       throw error;
     }
   }
+  rollback() {
+    throw new Error("Transaction rolled back");
+  }
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
-      `CREATE TABLE IF NOT EXISTS _schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+      `CREATE TABLE IF NOT EXISTS _schema_meta
+             (
+                 key
+                 TEXT
+                 PRIMARY
+                 KEY,
+                 value
+                 TEXT
+                 NOT
+                 NULL
+             )`
     );
   }
   async getSchemaMeta(key) {
     await this.ensureSchemaMeta();
     const rows = await this.db.select(
-      `SELECT value FROM _schema_meta WHERE key = ?`,
+      `SELECT value
+             FROM _schema_meta
+             WHERE key = ?`,
       [key]
     );
     return rows?.[0]?.value ?? null;
@@ -348,7 +841,10 @@ var TauriORM = class {
   async setSchemaMeta(key, value) {
     await this.ensureSchemaMeta();
     await this.db.execute(
-      `INSERT INTO _schema_meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+      `INSERT INTO _schema_meta(key, value)
+             VALUES (?, ?) ON CONFLICT(key) DO
+             UPDATE
+             SET value = excluded.value`,
       [key, value]
     );
   }
@@ -359,7 +855,10 @@ var TauriORM = class {
       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
+      unique: !!col.options.unique,
+      dv: col.options.default && typeof col.options.default === "object" && col.options.default.raw ? { raw: col.options.default.raw } : col.options.default ?? null,
+      hasDefaultFn: col.options.$defaultFn !== void 0,
+      hasOnUpdateFn: col.options.$onUpdateFn !== void 0
     };
   }
   computeModelSignature() {
@@ -382,41 +881,117 @@ var TauriORM = class {
     const status = await this.isSchemaDirty();
     if (status.dirty) {
       await this.migrate();
-      await this.setSchemaMeta(
-        "schema_signature",
-        this.computeModelSignature()
-      );
+      await this.setSchemaMeta("schema_signature", this.computeModelSignature());
       return true;
     }
     return false;
   }
+  async doesTableExist(tableName) {
+    const result = await this.db.select(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
+      [tableName]
+    );
+    return result.length > 0;
+  }
+  async dropTable(tableName) {
+    await this.db.execute(`DROP TABLE IF EXISTS ${tableName}`);
+  }
+  async doesColumnExist(tableName, columnName) {
+    const result = await this.db.select(`PRAGMA table_info('${tableName}')`);
+    return result.some((col) => col.name === columnName);
+  }
+  async renameTable(from, to) {
+    await this.db.execute(`ALTER TABLE ${from} RENAME TO ${to}`);
+  }
+  async dropColumn(tableName, columnName) {
+    await this.db.execute(`ALTER TABLE ${tableName} DROP COLUMN ${columnName}`);
+  }
+  async renameColumn(tableName, from, to) {
+    await this.db.execute(`ALTER TABLE ${tableName} RENAME COLUMN ${from} TO ${to}`);
+  }
+};
+var Relation = class {
+  constructor(foreignTable) {
+    this.foreignTable = foreignTable;
+  }
+};
+var OneRelation = class extends Relation {
+  constructor(foreignTable, config) {
+    super(foreignTable);
+    this.config = config;
+  }
+};
+var ManyRelation = class extends Relation {
+  constructor(foreignTable) {
+    super(foreignTable);
+  }
 };
 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"
-    })
+  const builtRelations = relationsCallback({
+    one: (foreignTable, config) => {
+      return new OneRelation(foreignTable, config);
+    },
+    many: (foreignTable) => {
+      return new ManyRelation(foreignTable);
+    }
   });
+  for (const [name, relation] of Object.entries(builtRelations)) {
+    if (relation instanceof OneRelation) {
+      table.relations[name] = {
+        type: "one",
+        foreignTable: relation.foreignTable,
+        fields: relation.config?.fields,
+        references: relation.config?.references
+      };
+    } else if (relation instanceof ManyRelation) {
+      table.relations[name] = {
+        type: "many",
+        foreignTable: relation.foreignTable
+      };
+    }
+  }
+  return builtRelations;
 };
+var getTableColumns = (table) => {
+  return table._.columns;
+};
+var alias = (table, alias2) => {
+  return table;
+};
+
+// src/column-helpers.ts
+var text = (name, config) => new SQLiteColumn(name, "TEXT", config, config?.mode);
+var integer = (name, config) => new SQLiteColumn(name, "INTEGER", {}, config?.mode || "default");
+var real = (name) => new SQLiteColumn(name, "REAL");
+var blob = (name, config) => new SQLiteColumn(name, "BLOB", {}, config?.mode);
+var boolean = (name) => new SQLiteColumn(name, "BOOLEAN");
+var numeric = (name, config) => new SQLiteColumn(name, "NUMERIC", {}, config?.mode);
+var enumType = (name, values) => text(name, { enum: values });
 export {
+  BaseQueryBuilder,
   DeleteQueryBuilder,
   InsertQueryBuilder,
+  ManyRelation,
+  OneRelation,
+  Relation,
   SQLiteColumn,
   SelectQueryBuilder,
   Table,
   TauriORM,
   UpdateQueryBuilder,
+  WithQueryBuilder,
+  alias,
   and,
+  asc,
+  avg,
   blob,
   boolean,
+  count,
+  countDistinct,
+  desc,
+  enumType,
   eq,
+  getTableColumns,
   gt,
   gte,
   inArray,
@@ -426,9 +1001,15 @@ export {
   like,
   lt,
   lte,
+  max,
+  min,
+  not,
+  numeric,
   or,
   real,
   relations,
+  sql,
   sqliteTable,
+  sum,
   text
 };