@type32/tauri-sqlite-orm 0.1.18-9 → 0.1.20

package/dist/index.js

@@ -27,7 +27,6 @@ __export(index_exports, {
   OneRelation: () => OneRelation,
   Relation: () => Relation,
   SQLiteColumn: () => SQLiteColumn,
-  SelectBuilder: () => SelectBuilder,
   SelectQueryBuilder: () => SelectQueryBuilder,
   Table: () => Table,
   TauriORM: () => TauriORM,
@@ -42,6 +41,7 @@ __export(index_exports, {
   count: () => count,
   countDistinct: () => countDistinct,
   desc: () => desc,
+  enumType: () => enumType,
   eq: () => eq,
   getTableColumns: () => getTableColumns,
   gt: () => gt,
@@ -56,6 +56,7 @@ __export(index_exports, {
   max: () => max,
   min: () => min,
   not: () => not,
+  numeric: () => numeric,
   or: () => or,
   real: () => real,
   relations: () => relations,
@@ -66,129 +67,51 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/schema.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,
-      table: 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
-    );
+// src/builders/query-base.ts
+var BaseQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
   }
-  unique() {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      { ...this.options, unique: true },
-      this._.mode
-    );
+  query = "";
+  params = [];
+  where(condition) {
+    this.query += ` WHERE ${condition.sql}`;
+    this.params.push(...condition.params);
+    return this;
   }
-  references(ref, column) {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      {
-        ...this.options,
-        references: {
-          table: ref,
-          column: ref._.columns[column]
-        }
-      },
-      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;
   }
-  $onUpdateFn(fn) {
-    return new _SQLiteColumn(
-      this._.name,
-      this.type,
-      { ...this.options, $onUpdateFn: fn },
-      this._.mode
-    );
+  limit(count2) {
+    this.query += ` LIMIT ${count2}`;
+    return this;
   }
-  as(alias2) {
+  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) => {
-  const table = new Table(tableName, columns);
-  for (const col of Object.values(columns)) {
-    col._.table = table;
-  }
-  return table;
-};
-var getTableColumns = (table) => {
-  return table._.columns;
-};
-var alias = (table, alias2) => {
-  return table;
-};
 
-// src/query-builder.ts
-var eq = (column, value) => ({
-  sql: `${column._.name} = ?`,
-  params: [value]
-});
+// src/operators.ts
+var eq = (column, value, tableAlias) => {
+  const columnName = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  return {
+    sql: `${columnName} = ?`,
+    params: [value]
+  };
+};
 var and = (...conditions) => ({
   sql: conditions.map((c) => `(${c.sql})`).join(" AND "),
   params: conditions.flatMap((c) => c.params)
@@ -233,14 +156,6 @@ 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: []
@@ -265,170 +180,206 @@ 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;
-  }
-  query = "";
-  params = [];
-  build() {
-    return {
-      sql: this.query,
-      params: this.params
-    };
-  }
-};
+
+// src/builders/select.ts
 var SelectQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table, selection) {
+  constructor(db, table, columns) {
     super(db);
-    this.selection = selection;
-    this.fromTable = table;
-    this.query = "";
-    this.params = [];
+    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;
-  joinClauses = [];
-  fromTable;
-  orderByClauses = [];
-  limitCount;
-  offsetCount;
-  whereCondition;
-  where(condition) {
-    this.whereCondition = condition;
-    return this;
-  }
-  leftJoin(table, on) {
-    this.joinClauses.push({ type: "LEFT JOIN", table, on });
-    return this;
-  }
-  innerJoin(table, on) {
-    this.joinClauses.push({ type: "INNER JOIN", table, on });
-    return this;
-  }
-  rightJoin(table, on) {
-    this.joinClauses.push({ type: "RIGHT JOIN", table, on });
-    return this;
-  }
-  fullJoin(table, on) {
-    this.joinClauses.push({ type: "FULL JOIN", table, on });
-    return this;
-  }
+  havingCondition = null;
+  joins = [];
+  includeRelations = {};
+  selectedTableAlias;
+  selectedColumns = [];
   distinct() {
     this.isDistinct = true;
     return this;
   }
   groupBy(...columns) {
     this.groupByColumns.push(...columns);
+    const columnNames = columns.map((col) => `${this.selectedTableAlias}.${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;
   }
-  orderBy(column, direction = "ASC") {
-    if ("sql" in column) {
-      this.orderByClauses.push({
-        sql: `${column.sql} ${direction}`,
-        params: column.params
-      });
-    } else {
-      this.orderByClauses.push({
-        sql: `${column._.name} ${direction}`,
-        params: []
-      });
-    }
+  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;
   }
-  limit(count2) {
-    this.limitCount = count2;
+  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;
   }
-  offset(count2) {
-    this.offsetCount = count2;
+  include(relations2) {
+    this.includeRelations = { ...this.includeRelations, ...relations2 };
     return this;
   }
-  buildSelectQuery() {
-    const selectionEntries = this.selection ? Object.entries(this.selection) : [];
-    let columnsClause;
-    const selectParams = [];
-    if (selectionEntries.length === 0) {
-      columnsClause = "*";
-    } else {
-      columnsClause = selectionEntries.map(([alias2, col]) => {
-        if (col instanceof SQLiteColumn) {
-          return `${col._.table._.name}.${col._.name} AS "${alias2}"`;
-        } else {
-          selectParams.push(...col.params);
-          return `(${col.sql}) AS "${alias2}"`;
-        }
-      }).join(", ");
-    }
-    let query = `SELECT ${this.isDistinct ? "DISTINCT " : ""}${columnsClause} FROM ${this.fromTable._.name}`;
-    const queryParams = [...selectParams];
-    if (this.joinClauses.length > 0) {
-      const joins = this.joinClauses.map((j) => {
-        queryParams.push(...j.on.params);
-        return `${j.type} ${j.table._.name} ON ${j.on.sql}`;
-      });
-      query += ` ${joins.join(" ")}`;
+  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);
     }
-    if (this.whereCondition) {
-      query += ` WHERE ${this.whereCondition.sql}`;
-      queryParams.push(...this.whereCondition.params);
-    }
-    if (this.groupByColumns.length > 0) {
-      const columnNames = this.groupByColumns.map((c) => c._.name).join(", ");
-      query += ` GROUP BY ${columnNames}`;
+    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);
+        }
+      }
     }
-    if (this.havingCondition) {
-      query += ` HAVING ${this.havingCondition.sql}`;
-      queryParams.push(...this.havingCondition.params);
+    return { sql: sql2, params };
+  }
+  // Enhanced execute method that handles relation data mapping
+  async execute() {
+    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);
     }
-    if (this.orderByClauses.length > 0) {
-      const orderBySql = this.orderByClauses.map((c) => c.sql).join(", ");
-      query += ` ORDER BY ${orderBySql}`;
-      queryParams.push(...this.orderByClauses.flatMap((c) => c.params));
+    const hasJoins = this.joins.length > 0;
+    if (hasJoins) {
+      return rawResults;
     }
-    if (this.limitCount !== void 0) {
-      query += ` LIMIT ${this.limitCount}`;
+    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;
+    });
+  }
+  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;
     }
-    if (this.offsetCount !== void 0) {
-      query += ` OFFSET ${this.offsetCount}`;
+    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 {
-      sql: query,
-      params: queryParams
-    };
-  }
-  build() {
-    return this.buildSelectQuery();
-  }
-  async execute() {
-    const { sql: sql2, params } = this.buildSelectQuery();
-    return this.db.select(sql2, params);
+    return Array.from(groupedResults.values());
   }
+  // Update the return type signatures
   async all() {
     return this.execute();
   }
@@ -438,19 +389,79 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     return result[0];
   }
 };
-var SelectBuilder = class {
-  constructor(db, selection) {
-    this.db = db;
-    this.selection = selection;
+
+// src/builders/update.ts
+var UpdateQueryBuilder = class extends BaseQueryBuilder {
+  constructor(db, table) {
+    super(db);
+    this.table = table;
+    this.query = `UPDATE ${table._.name}`;
+  }
+  updateData = {};
+  returningColumns = [];
+  set(data) {
+    this.updateData = { ...this.updateData, ...data };
+    return this;
+  }
+  returning(...columns) {
+    this.returningColumns.push(...columns);
+    return this;
   }
-  from(table) {
-    return new SelectQueryBuilder(
-      this.db,
-      table,
-      this.selection
+  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;
+    let whereClause = "";
+    const whereIndex = baseQuery.indexOf(" WHERE ");
+    if (whereIndex !== -1) {
+      tablePart = baseQuery.substring(0, whereIndex);
+      whereClause = baseQuery.substring(whereIndex);
+    }
+    const entries = Object.entries(finalUpdateData);
+    if (entries.length === 0) {
+      throw new Error("Cannot execute an update query without a .set() call.");
+    }
+    const setClause = entries.map(([key]) => {
+      const column = this.table._.columns[key];
+      if (!column) {
+        throw new Error(
+          `Column ${key} does not exist on table ${this.table._.name}`
+        );
+      }
+      return `${column._.name} = ?`;
+    }).join(", ");
+    const setParams = entries.map(([, value]) => value);
+    const sql2 = `${tablePart} SET ${setClause}${whereClause}`;
+    const params = [...setParams, ...whereParams];
+    return { sql: sql2, params };
+  }
+  async execute() {
+    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);
@@ -468,13 +479,7 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
     return this;
   }
   returning(...columns) {
-    for (const col of columns) {
-      if (typeof col === "string") {
-        this.returningColumns.push(this.table._.columns[col]);
-      } else {
-        this.returningColumns.push(col);
-      }
-    }
+    this.returningColumns.push(...columns);
     return this;
   }
   onConflictDoNothing(target) {
@@ -559,7 +564,7 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
         params.push(...setValues);
       }
       if (this.returningColumns.length > 0) {
-        const returningNames = this.returningColumns.map((col) => col._.name).join(", ");
+        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);
@@ -581,81 +586,8 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
     return this.returning(...allColumns).execute();
   }
 };
-var UpdateQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table) {
-    super(db);
-    this.table = table;
-    this.query = `UPDATE ${table._.name}`;
-  }
-  updateData = {};
-  returningColumns = [];
-  set(data) {
-    this.updateData = { ...this.updateData, ...data };
-    return this;
-  }
-  returning(...columns) {
-    for (const col of columns) {
-      if (typeof col === "string") {
-        this.returningColumns.push(this.table._.columns[col]);
-      } else {
-        this.returningColumns.push(col);
-      }
-    }
-    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;
-    let whereClause = "";
-    const whereIndex = baseQuery.indexOf(" WHERE ");
-    if (whereIndex !== -1) {
-      tablePart = baseQuery.substring(0, whereIndex);
-      whereClause = baseQuery.substring(whereIndex);
-    }
-    const entries = Object.entries(finalUpdateData);
-    if (entries.length === 0) {
-      throw new Error("Cannot execute an update query without a .set() call.");
-    }
-    const setClause = entries.map(([key]) => {
-      const column = this.table._.columns[key];
-      if (!column) {
-        throw new Error(
-          `Column ${key} does not exist on table ${this.table._.name}`
-        );
-      }
-      return `${column._.name} = ?`;
-    }).join(", ");
-    const setParams = entries.map(([, value]) => value);
-    const sql2 = `${tablePart} SET ${setClause}${whereClause}`;
-    const params = [...setParams, ...whereParams];
-    return { sql: sql2, params };
-  }
-  async execute() {
-    const { sql: updateSql, params } = this.buildUpdateClause();
-    if (this.returningColumns.length > 0) {
-      const returningNames = this.returningColumns.map((col) => 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/delete.ts
 var DeleteQueryBuilder = class extends BaseQueryBuilder {
   constructor(db, table) {
     super(db);
@@ -664,19 +596,13 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
   }
   returningColumns = [];
   returning(...columns) {
-    for (const col of columns) {
-      if (typeof col === "string") {
-        this.returningColumns.push(this.table._.columns[col]);
-      } else {
-        this.returningColumns.push(col);
-      }
-    }
+    this.returningColumns.push(...columns);
     return this;
   }
   async execute() {
     const { sql: sql2, params } = this.build();
     if (this.returningColumns.length > 0) {
-      const returningNames = this.returningColumns.map((col) => col._.name).join(", ");
+      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
       const sqlWithReturning = `${sql2} RETURNING ${returningNames}`;
       return this.db.select(sqlWithReturning, params);
     } else {
@@ -685,12 +611,12 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
     }
   }
   async returningAll() {
-    const allColumns = Object.keys(
-      this.table._.columns
-    );
+    const allColumns = Object.keys(this.table._.columns);
     return this.returning(...allColumns).execute();
   }
 };
+
+// src/builders/with.ts
 var WithQueryBuilder = class {
   constructor(db) {
     this.db = db;
@@ -700,12 +626,8 @@ var WithQueryBuilder = class {
     this.ctes.push({ alias: alias2, query: query.sql, params: query.params });
     return this;
   }
-  select(table, selection) {
-    const builder = new SelectQueryBuilder(
-      this.db,
-      table,
-      selection
-    );
+  select(table, columns) {
+    const builder = new SelectQueryBuilder(this.db, table, columns);
     this.applyWithClause(builder);
     return builder;
   }
@@ -737,13 +659,117 @@ var WithQueryBuilder = class {
 };
 
 // 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)) {
-        if (table instanceof Table) {
-          this.tables.set(table._.name, table);
+      for (const [key, value] of Object.entries(schema)) {
+        if (value instanceof Table) {
+          this.tables.set(value._.name, value);
         }
       }
     }
@@ -768,31 +794,60 @@ var TauriORM = class {
     }
     return sql2;
   }
-  async migrate() {
+  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 existingTableInfo = await this.db.select(
-        `PRAGMA table_info('${table._.name}')`
-      );
-      if (existingTableInfo.length === 0) {
+      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 ${table._.name} (${columnsSql})`;
+        const createSql = `CREATE TABLE ${tableName}
+                                   (
+                                       ${columnsSql}
+                                   )`;
         await this.db.execute(createSql);
       } else {
-        const existingColumnNames = new Set(
-          existingTableInfo.map((c) => c.name)
-        );
+        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 ${table._.name} ADD COLUMN ${columnSql}`;
+            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 (options?.performDestructiveActions) {
+      for (const tableName of dbTableNames) {
+        if (!schemaTableNames.has(tableName)) {
+          await this.dropTable(tableName);
+        }
       }
     }
   }
-  select(selection) {
-    return new SelectBuilder(this.db, selection);
+  select(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);
@@ -829,13 +884,25 @@ var TauriORM = class {
   // --- 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;
@@ -843,7 +910,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]
     );
   }
@@ -880,14 +950,34 @@ 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) {
@@ -905,16 +995,47 @@ var ManyRelation = class extends Relation {
     super(foreignTable);
   }
 };
-var relations = (_table, relationsCallback) => {
-  return relationsCallback({
-    one: (table, config) => {
-      return new OneRelation(table, config);
+var relations = (table, relationsCallback) => {
+  const builtRelations = relationsCallback({
+    one: (foreignTable, config) => {
+      return new OneRelation(foreignTable, config);
     },
-    many: (table) => {
-      return new ManyRelation(table);
+    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 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseQueryBuilder,
@@ -924,7 +1045,6 @@ var relations = (_table, relationsCallback) => {
   OneRelation,
   Relation,
   SQLiteColumn,
-  SelectBuilder,
   SelectQueryBuilder,
   Table,
   TauriORM,
@@ -939,6 +1059,7 @@ var relations = (_table, relationsCallback) => {
   count,
   countDistinct,
   desc,
+  enumType,
   eq,
   getTableColumns,
   gt,
@@ -953,6 +1074,7 @@ var relations = (_table, relationsCallback) => {
   max,
   min,
   not,
+  numeric,
   or,
   real,
   relations,