@type32/tauri-sqlite-orm 0.1.18-1 → 0.1.18-10

package/dist/index.mjs

@@ -1,3 +1,483 @@
+// src/builders/query-base.ts
+var BaseQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
+  }
+  query = "";
+  params = [];
+  where(condition) {
+    this.query += ` WHERE ${condition.sql}`;
+    this.params.push(...condition.params);
+    return this;
+  }
+  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;
+  }
+  limit(count2) {
+    this.query += ` LIMIT ${count2}`;
+    return this;
+  }
+  offset(count2) {
+    this.query += ` OFFSET ${count2}`;
+    return this;
+  }
+  build() {
+    return {
+      sql: this.query,
+      params: this.params
+    };
+  }
+};
+
+// src/operators.ts
+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)
+});
+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]
+});
+var gte = (column, value) => ({
+  sql: `${column._.name} >= ?`,
+  params: [value]
+});
+var lt = (column, value) => ({
+  sql: `${column._.name} < ?`,
+  params: [value]
+});
+var lte = (column, value) => ({
+  sql: `${column._.name} <= ?`,
+  params: [value]
+});
+var like = (column, pattern) => ({
+  sql: `${column._.name} LIKE ?`,
+  params: [pattern]
+});
+var isNull = (column) => ({
+  sql: `${column._.name} IS NULL`,
+  params: []
+});
+var isNotNull = (column) => ({
+  sql: `${column._.name} IS NOT NULL`,
+  params: []
+});
+var inArray = (column, values) => ({
+  sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
+  params: values
+});
+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;
+    const columnNames = columns ? columns.map((c) => table._.columns[c]._.name) : ["*"];
+    this.query = `SELECT ${columnNames.join(", ")} FROM ${table._.name}`;
+  }
+  isDistinct = false;
+  groupByColumns = [];
+  havingCondition = null;
+  joins = [];
+  includeRelations = {};
+  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;
+  }
+  leftJoin(table, condition, alias2) {
+    this.joins.push({ type: "LEFT", table, condition, alias: alias2 });
+    return this;
+  }
+  innerJoin(table, condition, alias2) {
+    this.joins.push({ type: "INNER", table, condition, alias: alias2 });
+    return this;
+  }
+  include(relations2) {
+    this.includeRelations = { ...this.includeRelations, ...relations2 };
+    return this;
+  }
+  buildJoins() {
+    let sql2 = "";
+    const params = [];
+    for (const join of this.joins) {
+      const tableAlias = join.alias || join.table._.name;
+      sql2 += ` ${join.type} JOIN ${join.table._.name} ${tableAlias} 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) continue;
+      const foreignTable = relation.foreignTable;
+      const foreignAlias = `${this.table._.name}_${relationName}`;
+      if (relation.type === "one" && relation.fields && relation.references) {
+        const conditions = relation.fields.map(
+          (field, i) => eq(field, relation.references[i])
+        );
+        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.values(foreignTable.relations).find(
+          (r) => r.foreignTable === this.table
+        );
+        if (refRelation && refRelation.fields && refRelation.references) {
+          const conditions = refRelation.fields.map(
+            (field, i) => eq(field, refRelation.references[i])
+          );
+          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 };
+  }
+  async execute() {
+    const { sql: joinSql, params: joinParams } = this.buildJoins();
+    this.query += joinSql;
+    this.params.push(...joinParams);
+    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];
+  }
+};
+
+// 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;
+  }
+  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);
+    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: 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) {
@@ -41,7 +521,7 @@ var SQLiteColumn = class _SQLiteColumn {
     return new _SQLiteColumn(
       this._.name,
       this.type,
-      { ...this.options, primaryKey: true },
+      { ...this.options, primaryKey: true, notNull: true },
       this._.mode
     );
   }
@@ -83,14 +563,13 @@ 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");
-var real = (name) => new SQLiteColumn(name, "REAL");
-var blob = (name) => new SQLiteColumn(name, "BLOB");
-var boolean = (name) => new SQLiteColumn(name, "BOOLEAN");
 var Table = class {
   _;
+  relations = {};
   constructor(name, columns) {
     this._ = {
       name,
@@ -101,194 +580,111 @@ var Table = class {
 var sqliteTable = (tableName, columns) => {
   return new Table(tableName, columns);
 };
-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)
-});
-var or = (...conditions) => ({
-  sql: conditions.map((c) => `(${c.sql})`).join(" OR "),
-  params: conditions.flatMap((c) => c.params)
-});
-var gt = (column, value) => ({
-  sql: `${column._.name} > ?`,
-  params: [value]
-});
-var gte = (column, value) => ({
-  sql: `${column._.name} >= ?`,
-  params: [value]
-});
-var lt = (column, value) => ({
-  sql: `${column._.name} < ?`,
-  params: [value]
-});
-var lte = (column, value) => ({
-  sql: `${column._.name} <= ?`,
-  params: [value]
-});
-var like = (column, pattern) => ({
-  sql: `${column._.name} LIKE ?`,
-  params: [pattern]
-});
-var isNull = (column) => ({
-  sql: `${column._.name} IS NULL`,
+var asc = (column) => ({
+  sql: `${column._.name} ASC`,
   params: []
 });
-var isNotNull = (column) => ({
-  sql: `${column._.name} IS NOT NULL`,
+var desc = (column) => ({
+  sql: `${column._.name} DESC`,
   params: []
 });
-var inArray = (column, values) => ({
-  sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
-  params: values
-});
-var BaseQueryBuilder = class {
-  constructor(db) {
-    this.db = db;
-  }
-  query = "";
-  params = [];
-  where(condition) {
-    this.query += ` WHERE ${condition.sql}`;
-    this.params.push(...condition.params);
-    return this;
-  }
-  orderBy(column, direction = "ASC") {
-    this.query += ` ORDER BY ${column._.name} ${direction}`;
-    return this;
-  }
-  limit(count) {
-    this.query += ` LIMIT ${count}`;
-    return this;
-  }
-  offset(count) {
-    this.query += ` OFFSET ${count}`;
-    return this;
-  }
-  build() {
-    return {
-      sql: this.query,
-      params: this.params
-    };
-  }
-};
-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}`;
-  }
-  async execute() {
-    const { sql, params } = this.build();
-    return this.db.select(sql, params);
-  }
-};
-var InsertQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table) {
-    super(db);
-    this.table = table;
-    this.query = `INSERT INTO ${table._.name}`;
-  }
-  dataSets = [];
-  values(data) {
-    const dataArray = Array.isArray(data) ? data : [data];
-    this.dataSets.push(...dataArray);
-    return this;
-  }
-  async execute() {
-    if (this.dataSets.length === 0) {
-      throw new Error("No data provided for insert");
+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]);
+      }
     }
-    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;
-  }
-};
-var UpdateQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table) {
-    super(db);
-    this.table = table;
-    this.query = `UPDATE ${table._.name}`;
-  }
-  updateData = {};
-  set(data) {
-    this.updateData = { ...this.updateData, ...data };
-    return this;
-  }
-  async execute() {
-    const entries = Object.entries(this.updateData);
-    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(", ");
-    this.query += ` SET ${setClause}`;
-    this.params.push(...entries.map(([, value]) => value));
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
-  }
-};
-var DeleteQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table) {
-    super(db);
-    this.table = table;
-    this.query = `DELETE FROM ${table._.name}`;
-  }
-  async execute() {
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
-  }
+  });
+  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);
+        }
+      }
+      for (const [key, value] of Object.entries(schema)) {
+        if (!(value instanceof Table) && typeof value === "object") {
+          const tableName = key.replace("Relations", "");
+          const table = Array.from(this.tables.values()).find(
+            (t) => t._.name === tableName
+          );
+          if (table) {
+            for (const [relName, rel] of Object.entries(value)) {
+              if (rel instanceof OneRelation) {
+                table.relations[relName] = {
+                  type: "one",
+                  foreignTable: rel.foreignTable,
+                  fields: rel.config?.fields,
+                  references: rel.config?.references
+                };
+              } else if (rel instanceof ManyRelation) {
+                table.relations[relName] = {
+                  type: "many",
+                  foreignTable: rel.foreignTable
+                };
+              }
+            }
+          }
+        }
       }
     }
   }
   tables = /* @__PURE__ */ new Map();
+  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() {
     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}`;
-        }
-        if (col.options.references) {
-          sql += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+      const existingTableInfo = await this.db.select(
+        `PRAGMA table_info('${table._.name}')`
+      );
+      if (existingTableInfo.length === 0) {
+        const columnsSql = Object.values(table._.columns).map((col) => this.buildColumnDefinition(col)).join(", ");
+        const createSql = `CREATE TABLE ${table._.name} (${columnsSql})`;
+        await this.db.execute(createSql);
+      } else {
+        const existingColumnNames = new Set(
+          existingTableInfo.map((c) => c.name)
+        );
+        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}`;
+            await this.db.execute(alterSql);
+          }
         }
-        return sql;
-      }).join(", ");
-      const createSql = `CREATE TABLE IF NOT EXISTS ${table._.name} (${columnsSql})`;
-      await this.db.execute(createSql);
+      }
     }
   }
   select(table, columns) {
@@ -303,6 +699,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 {
@@ -314,6 +719,9 @@ var TauriORM = class {
       throw error;
     }
   }
+  rollback() {
+    throw new Error("Transaction rolled back");
+  }
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
@@ -342,7 +750,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() {
@@ -374,32 +785,70 @@ var TauriORM = class {
     return false;
   }
 };
-var relations = (table, relationsCallback) => {
+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"
-    })
+    one: (table, config) => {
+      return new OneRelation(table, config);
+    },
+    many: (table) => {
+      return new ManyRelation(table);
+    }
   });
 };
+var getTableColumns = (table) => {
+  return table._.columns;
+};
+var alias = (table, alias2) => {
+  return table;
+};
+
+// src/column-helpers.ts
+var columnHelpers = (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");
 export {
+  BaseQueryBuilder,
   DeleteQueryBuilder,
   InsertQueryBuilder,
+  ManyRelation,
+  OneRelation,
+  Relation,
   SQLiteColumn,
   SelectQueryBuilder,
   Table,
   TauriORM,
   UpdateQueryBuilder,
+  WithQueryBuilder,
+  alias,
   and,
+  asc,
+  avg,
   blob,
   boolean,
+  columnHelpers,
+  count,
+  countDistinct,
+  desc,
   eq,
+  getTableColumns,
   gt,
   gte,
   inArray,
@@ -409,9 +858,13 @@ export {
   like,
   lt,
   lte,
+  max,
+  min,
+  not,
   or,
   real,
   relations,
+  sql,
   sqliteTable,
-  text
+  sum
 };