@type32/tauri-sqlite-orm 0.2.12 → 0.2.15

package/dist/index.mjs

@@ -1,174 +1,81 @@
-// src/builders/query-base.ts
-var BaseQueryBuilder = class {
+// src/orm.ts
+import { Kysely as Kysely4, sql as kyselySql } from "kysely";
+
+// src/dialect.ts
+import {
+  CompiledQuery,
+  SqliteAdapter,
+  SqliteIntrospector,
+  SqliteQueryCompiler
+} from "kysely";
+var TauriConnection = 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}`;
+  async executeQuery(compiledQuery) {
+    const { sql: sql6, parameters } = compiledQuery;
+    const params = parameters;
+    const trimmed = sql6.trimStart();
+    const isSelect = /^\s*(SELECT|WITH|PRAGMA)/i.test(trimmed);
+    const hasReturning = /\bRETURNING\b/i.test(sql6);
+    if (isSelect || hasReturning) {
+      const rows = await this.db.select(sql6, params);
+      return { rows };
     }
-    return this;
-  }
-  limit(count2) {
-    this.query += ` LIMIT ${count2}`;
-    return this;
-  }
-  offset(count2) {
-    this.query += ` OFFSET ${count2}`;
-    return this;
-  }
-  build() {
+    const result = await this.db.execute(sql6, params);
     return {
-      sql: this.query,
-      params: this.params
+      rows: [],
+      insertId: BigInt(Math.round(result.lastInsertId ?? 0)),
+      numAffectedRows: BigInt(result.rowsAffected ?? 0)
     };
   }
-  toSQL() {
-    return this.build();
+  async *streamQuery(_compiledQuery) {
+    throw new Error("Streaming queries are not supported by @tauri-apps/plugin-sql");
   }
 };
-
-// src/operators.ts
-var eq = (column, value, tableAlias) => {
-  const columnName = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
-  return {
-    sql: `${columnName} = ?`,
-    params: [value]
-  };
-};
-var ne = (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)
-});
-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 ilike = (column, pattern) => ({
-  sql: `${column._.name} LIKE ? COLLATE NOCASE`,
-  params: [pattern]
-});
-var startsWith = (column, value) => ({
-  sql: `${column._.name} LIKE ?`,
-  params: [`${value}%`]
-});
-var endsWith = (column, value) => ({
-  sql: `${column._.name} LIKE ?`,
-  params: [`%${value}`]
-});
-var contains = (column, value) => ({
-  sql: `${column._.name} LIKE ?`,
-  params: [`%${value}%`]
-});
-var isNull = (column) => ({
-  sql: `${column._.name} IS NULL`,
-  params: []
-});
-var isNotNull = (column) => ({
-  sql: `${column._.name} IS NOT NULL`,
-  params: []
-});
-var exists = (subquery2) => ({
-  sql: `EXISTS (${subquery2.sql})`,
-  params: subquery2.params
-});
-var notExists = (subquery2) => ({
-  sql: `NOT EXISTS (${subquery2.sql})`,
-  params: subquery2.params
-});
-var eqSubquery = (column, subquery2) => ({
-  sql: `${column._.name} = ${subquery2.sql}`,
-  params: subquery2.params
-});
-var neSubquery = (column, subquery2) => ({
-  sql: `${column._.name} != ${subquery2.sql}`,
-  params: subquery2.params
-});
-var gtSubquery = (column, subquery2) => ({
-  sql: `${column._.name} > ${subquery2.sql}`,
-  params: subquery2.params
-});
-var gteSubquery = (column, subquery2) => ({
-  sql: `${column._.name} >= ${subquery2.sql}`,
-  params: subquery2.params
-});
-var ltSubquery = (column, subquery2) => ({
-  sql: `${column._.name} < ${subquery2.sql}`,
-  params: subquery2.params
-});
-var lteSubquery = (column, subquery2) => ({
-  sql: `${column._.name} <= ${subquery2.sql}`,
-  params: subquery2.params
-});
-var inArray = (column, values) => {
-  if ("_isSubquery" in values && values._isSubquery) {
-    return {
-      sql: `${column._.name} IN ${values.sql}`,
-      params: values.params
-    };
+var TauriDriver = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async init() {
+  }
+  async acquireConnection() {
+    return new TauriConnection(this.db);
+  }
+  async beginTransaction(conn, _settings) {
+    await conn.executeQuery(CompiledQuery.raw("BEGIN"));
+  }
+  async commitTransaction(conn) {
+    await conn.executeQuery(CompiledQuery.raw("COMMIT"));
+  }
+  async rollbackTransaction(conn) {
+    await conn.executeQuery(CompiledQuery.raw("ROLLBACK"));
+  }
+  async releaseConnection(_conn) {
+  }
+  async destroy() {
   }
-  return {
-    sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
-    params: values
-  };
 };
-var notIn = (column, values) => {
-  if ("_isSubquery" in values && values._isSubquery) {
-    return {
-      sql: `${column._.name} NOT IN ${values.sql}`,
-      params: values.params
-    };
+var TauriDialect = class {
+  constructor(db) {
+    this.db = db;
+  }
+  createAdapter() {
+    return new SqliteAdapter();
+  }
+  createDriver() {
+    return new TauriDriver(this.db);
+  }
+  createIntrospector(db) {
+    return new SqliteIntrospector(db);
+  }
+  createQueryCompiler() {
+    return new SqliteQueryCompiler();
   }
-  return {
-    sql: `${column._.name} NOT IN (${values.map(() => "?").join(",")})`,
-    params: values
-  };
 };
-var between = (column, min2, max2) => ({
-  sql: `${column._.name} BETWEEN ? AND ?`,
-  params: [min2, max2]
-});
+
+// src/builders/select.ts
+import { sql } from "kysely";
 
 // src/serialization.ts
 function serializeValue(value, column) {
@@ -272,71 +179,116 @@ function deserializeValue(value, column) {
 }
 
 // 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}"`
+function getDbNameToTsName(table) {
+  const map = {};
+  for (const [tsName, col] of Object.entries(table._.columns)) {
+    map[col._.name] = tsName;
+  }
+  return map;
+}
+function normalizeRowKey(key) {
+  if (key.startsWith('"') && key.endsWith('"')) {
+    return key.slice(1, -1);
+  }
+  return key;
+}
+function resolveRelationColumns(table, include) {
+  const allEntries = Object.entries(table._.columns);
+  if (include === true || typeof include !== "object") {
+    return allEntries.map(([, col]) => col);
+  }
+  const cols = include.columns;
+  if (!cols) {
+    return allEntries.map(([, col]) => col);
+  }
+  const names = Array.isArray(cols) ? cols : Object.entries(cols).filter(([, v]) => v).map(([k]) => k);
+  const pkNames = allEntries.filter(([, c]) => c.options.primaryKey).map(([k]) => k);
+  const combined = /* @__PURE__ */ new Set([...names, ...pkNames]);
+  return allEntries.filter(([tsName]) => combined.has(tsName)).map(([, col]) => col);
+}
+var SelectQueryBuilder = class {
+  constructor(kysely, table, columns) {
+    this.kysely = kysely;
+    this._table = table;
+    this._columns = columns;
+    const selected = columns ? columns.map((c) => table._.columns[c]) : Object.values(table._.columns);
+    const colSelections = selected.map(
+      (col) => `${table._.name}.${col._.name} as "${table._.name}.${col._.name}"`
     );
-    this.query = `FROM ${table._.name} ${this.selectedTableAlias}`;
-  }
-  isDistinct = false;
-  groupByColumns = [];
-  havingCondition = null;
-  joins = [];
-  includeRelations = {};
-  selectedTableAlias;
-  selectedColumns = [];
+    this._includedColumnAliases = colSelections;
+    this._builder = kysely.selectFrom(table._.name).select(colSelections);
+  }
+  _builder;
+  _table;
+  _columns;
+  _includeRelations = {};
+  _manualJoins = [];
+  _isDistinct = false;
+  _includedColumnAliases = [];
   distinct() {
-    this.isDistinct = true;
+    this._isDistinct = true;
+    this._builder = this._builder.distinct();
+    return this;
+  }
+  where(condition) {
+    this._builder = this._builder.where(condition);
+    return this;
+  }
+  orderBy(column, direction = "asc") {
+    if ("toOperationNode" in column) {
+      this._builder = this._builder.orderBy(column, direction);
+    } else {
+      this._builder = this._builder.orderBy(
+        sql.ref(column._.name),
+        direction
+      );
+    }
+    return this;
+  }
+  limit(count2) {
+    this._builder = this._builder.limit(count2);
+    return this;
+  }
+  offset(count2) {
+    this._builder = this._builder.offset(count2);
     return this;
   }
   groupBy(...columns) {
-    this.groupByColumns.push(...columns);
-    const columnNames = columns.map((col) => `${this.selectedTableAlias}.${col._.name}`).join(", ");
-    this.query += ` GROUP BY ${columnNames}`;
+    for (const col of columns) {
+      this._builder = this._builder.groupBy(
+        sql`${sql.ref(this._table._.name)}.${sql.ref(col._.name)}`
+      );
+    }
     return this;
   }
   having(condition) {
-    this.havingCondition = condition;
-    this.query += ` HAVING ${condition.sql}`;
-    this.params.push(...condition.params);
+    this._builder = this._builder.having(condition);
     return this;
   }
   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._manualJoins.push({ type: "LEFT", table, condition, alias: alias2 });
+    const aliasedCols = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} as "${alias2}.${col._.name}"`
     );
-    this.selectedColumns.push(...aliasedColumns);
+    this._builder = this._builder.leftJoin(`${table._.name} as ${alias2}`, (join) => join.on(condition)).select(aliasedCols);
     return this;
   }
   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._manualJoins.push({ type: "INNER", table, condition, alias: alias2 });
+    const aliasedCols = Object.values(table._.columns).map(
+      (col) => `${alias2}.${col._.name} as "${alias2}.${col._.name}"`
     );
-    this.selectedColumns.push(...aliasedColumns);
+    this._builder = this._builder.innerJoin(`${table._.name} as ${alias2}`, (join) => join.on(condition)).select(aliasedCols);
     return this;
   }
   include(relations2) {
-    this.includeRelations = { ...this.includeRelations, ...relations2 };
+    this._includeRelations = { ...this._includeRelations, ...relations2 };
     return this;
   }
-  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);
-    }
+  applyIncludes() {
     const processRelations = (parentTable, parentAlias, relations2, depth = 0) => {
       if (depth > 10) {
-        console.warn("[Tauri-ORM] Maximum relation depth (10) exceeded. Skipping deeper relations.");
+        console.warn("[Tauri-ORM] Maximum relation depth (10) exceeded.");
         return;
       }
       for (const [relationName, include] of Object.entries(relations2)) {
@@ -344,78 +296,43 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
         const relation = parentTable.relations[relationName];
         if (!relation) {
           console.warn(
-            `[Tauri-ORM] Relation "${relationName}" not found on table "${parentTable._.name}". Skipping include.`
+            `[Tauri-ORM] Relation "${relationName}" not found on table "${parentTable._.name}". Skipping.`
           );
           continue;
         }
         const foreignTable = relation.foreignTable;
         const foreignAlias = `${parentAlias}_${relationName}`;
-        const aliasedColumns = Object.values(foreignTable._.columns).map(
-          (col) => `${foreignAlias}.${col._.name} AS "${foreignAlias}.${col._.name}"`
+        const selectedCols = resolveRelationColumns(foreignTable, include);
+        const aliasedCols = selectedCols.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 = `${parentAlias}.${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);
+          const onCondition = sql`${sql.join(
+            relation.fields.map(
+              (field, i) => sql`${sql.ref(`${parentAlias}.${field._.name}`)} = ${sql.ref(`${foreignAlias}.${relation.references[i]._.name}`)}`
+            ),
+            sql` AND `
+          )}`;
+          this._builder = this._builder.leftJoin(
+            `${foreignTable._.name} as ${foreignAlias}`,
+            (join) => join.on(onCondition)
+          ).select(aliasedCols);
         } else if (relation.type === "many") {
           const refRelation = Object.entries(foreignTable.relations).find(
-            ([_, r]) => r.foreignTable === parentTable
+            ([, r]) => r.foreignTable === parentTable
           );
           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 = `${parentAlias}.${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);
-          }
-        } else if (relation.type === "manyToMany" && relation.junctionTable && relation.junctionFields && relation.junctionReferences) {
-          const junctionTable = relation.junctionTable;
-          const junctionAlias = `${foreignAlias}_junction`;
-          const parentTablePks = Object.values(parentTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
-          if (parentTablePks.length > 0 && relation.junctionFields.length > 0) {
-            const junctionConditions = relation.junctionFields.map((field, i) => {
-              const parentPk = parentTablePks[i] || parentTablePks[0];
-              const localColumn = `${parentAlias}.${parentPk}`;
-              const junctionColumn = `${junctionAlias}.${field._.name}`;
-              return {
-                sql: `${localColumn} = ${junctionColumn}`,
-                params: []
-              };
-            });
-            const junctionCondition = junctionConditions.length > 1 ? and(...junctionConditions) : junctionConditions[0];
-            sql2 += ` LEFT JOIN ${junctionTable._.name} ${junctionAlias} ON ${junctionCondition.sql}`;
-            params.push(...junctionCondition.params);
-            const foreignTablePks = Object.values(foreignTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
-            if (foreignTablePks.length > 0 && relation.junctionReferences.length > 0) {
-              const foreignConditions = relation.junctionReferences.map((field, i) => {
-                const foreignPk = foreignTablePks[i] || foreignTablePks[0];
-                const junctionColumn = `${junctionAlias}.${field._.name}`;
-                const foreignColumn = `${foreignAlias}.${foreignPk}`;
-                return {
-                  sql: `${junctionColumn} = ${foreignColumn}`,
-                  params: []
-                };
-              });
-              const foreignCondition = foreignConditions.length > 1 ? and(...foreignConditions) : foreignConditions[0];
-              sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${foreignCondition.sql}`;
-              params.push(...foreignCondition.params);
-            }
+            const [, relationConfig] = refRelation;
+            const onCondition = sql`${sql.join(
+              relationConfig.fields.map(
+                (field, i) => sql`${sql.ref(`${foreignAlias}.${field._.name}`)} = ${sql.ref(`${parentAlias}.${relationConfig.references[i]._.name}`)}`
+              ),
+              sql` AND `
+            )}`;
+            this._builder = this._builder.leftJoin(
+              `${foreignTable._.name} as ${foreignAlias}`,
+              (join) => join.on(onCondition)
+            ).select(aliasedCols);
           }
         }
         if (typeof include === "object" && include.with) {
@@ -423,178 +340,159 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
         }
       }
     };
-    processRelations(this.table, this.selectedTableAlias, this.includeRelations, 0);
-    return { sql: sql2, params };
+    processRelations(this._table, this._table._.name, this._includeRelations, 0);
   }
-  // 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();
-    const rawResults = await this.db.select(sql2, params);
-    const hasIncludes = Object.values(this.includeRelations).some((i) => i);
+    this.applyIncludes();
+    const rawResults = await this._builder.execute();
+    const hasIncludes = Object.values(this._includeRelations).some((i) => i);
     if (hasIncludes) {
       return this.processRelationResults(rawResults);
     }
-    const hasJoins = this.joins.length > 0;
-    if (hasJoins) {
+    const hasManualJoins = this._manualJoins.length > 0;
+    if (hasManualJoins) {
       return rawResults;
     }
-    const prefix = `${this.selectedTableAlias}.`;
+    const prefix = `${this._table._.name}.`;
+    const dbNameToTs = getDbNameToTsName(this._table);
     return rawResults.map((row) => {
-      const newRow = {};
+      const out = {};
       for (const key in row) {
-        const columnName = key.startsWith(prefix) ? key.substring(prefix.length) : key;
-        const column = this.table._.columns[columnName];
-        if (column) {
-          newRow[columnName] = deserializeValue(row[key], column);
-        } else {
-          newRow[columnName] = row[key];
-        }
+        const normKey = normalizeRowKey(key);
+        const dbColName = normKey.startsWith(prefix) ? normKey.slice(prefix.length) : normKey;
+        const tsName = dbNameToTs[dbColName] ?? dbColName;
+        const column = this._table._.columns[tsName];
+        out[tsName] = column ? deserializeValue(row[key], column) : row[key];
       }
-      return newRow;
+      return out;
     });
   }
   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 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();
     const parseRelationPath = (tableAlias, baseAlias) => {
-      if (!tableAlias.startsWith(baseAlias + "_")) {
-        return [];
-      }
-      const path = tableAlias.substring(baseAlias.length + 1);
-      return path.split("_");
+      if (!tableAlias.startsWith(baseAlias + "_")) return [];
+      return tableAlias.slice(baseAlias.length + 1).split("_");
     };
-    const setNestedValue = (obj, path, value, columnName) => {
-      let current = obj;
+    const setNestedValue = (obj, path, columnName, value) => {
+      let cur = obj;
       for (let i = 0; i < path.length; i++) {
         const key = path[i];
         if (i === path.length - 1) {
-          if (!current[key]) current[key] = {};
-          current[key][columnName] = value;
+          if (!cur[key]) cur[key] = {};
+          cur[key][columnName] = value;
         } else {
-          if (!current[key]) current[key] = {};
-          current = current[key];
+          if (!cur[key]) cur[key] = {};
+          cur = cur[key];
         }
       }
     };
     const getNestedRelation = (table, path) => {
-      let currentTable = table;
-      let currentRelation = null;
-      for (const relationName of path) {
-        currentRelation = currentTable.relations[relationName];
-        if (!currentRelation) return null;
-        currentTable = currentRelation.foreignTable;
+      let current = table;
+      let relation = null;
+      for (const name of path) {
+        relation = current.relations[name];
+        if (!relation) return null;
+        current = relation.foreignTable;
       }
-      return currentRelation;
+      return relation;
     };
     for (const row of rawResults) {
-      const mainTableKey = mainTablePks.map((pk) => row[`${this.selectedTableAlias}.${pk}`] ?? row[pk]).join("_");
+      const getVal = (logicalKey) => {
+        const quoted = `"${logicalKey}"`;
+        return row[quoted] ?? row[logicalKey];
+      };
+      const mainTableKey = mainTablePks.map((pk) => getVal(`${this._table._.name}.${pk}`) ?? getVal(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) {
-            const column = this.table._.columns[columnName];
-            result[columnName] = column ? deserializeValue(value, column) : value;
+        const normKey = normalizeRowKey(key);
+        if (!normKey.includes(".")) {
+          const mainDbToTs = getDbNameToTsName(this._table);
+          const tsName = mainDbToTs[normKey] ?? normKey;
+          const column = this._table._.columns[tsName];
+          result[tsName] = column ? deserializeValue(value, column) : value;
+          continue;
+        }
+        const dotIndex = normKey.indexOf(".");
+        const tableAlias = normKey.slice(0, dotIndex);
+        const columnName = normKey.slice(dotIndex + 1);
+        if (tableAlias === this._table._.name) {
+          const mainDbToTs = getDbNameToTsName(this._table);
+          const tsName = mainDbToTs[columnName] ?? columnName;
+          const column = this._table._.columns[tsName];
+          result[tsName] = column ? deserializeValue(value, column) : value;
+        } else {
+          const path = parseRelationPath(tableAlias, this._table._.name);
+          if (path.length > 0) {
+            const relationConfig = getNestedRelation(this._table, path);
+            const foreignTable = relationConfig?.foreignTable;
+            const foreignDbToTs = foreignTable ? getDbNameToTsName(foreignTable) : {};
+            const tsName = foreignDbToTs[columnName] ?? columnName;
+            const col = foreignTable?._.columns?.[tsName];
+            setNestedValue(relations2, path, tsName, col ? deserializeValue(value, col) : value);
           } else {
-            const relationPath = parseRelationPath(tableAlias, this.selectedTableAlias);
-            if (relationPath.length > 0) {
-              const relationConfig = getNestedRelation(this.table, relationPath);
-              const column = relationConfig?.foreignTable?._.columns?.[columnName];
-              const deserializedValue = column ? deserializeValue(value, column) : value;
-              setNestedValue(relations2, relationPath, deserializedValue, columnName);
-            } else {
-              if (!result[tableAlias]) result[tableAlias] = {};
-              result[tableAlias][columnName] = value;
-            }
+            if (!result[tableAlias]) result[tableAlias] = {};
+            result[tableAlias][columnName] = value;
           }
-        } else {
-          const column = this.table._.columns[key];
-          result[key] = column ? deserializeValue(value, column) : value;
         }
       }
-      const attachRelations = (target, relationsData, table, pathPrefix = []) => {
-        for (const [relName, relData] of Object.entries(relationsData)) {
-          const currentPath = [...pathPrefix, relName];
-          const relationConfig = getNestedRelation(table, currentPath);
+      const attachRelations = (target, relData, table) => {
+        for (const [relName, data] of Object.entries(relData)) {
+          const relationConfig = table.relations[relName];
           if (!relationConfig) continue;
-          const hasDirectData = typeof relData === "object" && relData !== null && Object.entries(relData).some(([k, v]) => {
-            return typeof v !== "object" && v !== null && v !== void 0 && v !== "";
-          });
-          if (!hasDirectData && typeof relData === "object" && relData !== null) {
-            const hasNestedData = Object.values(relData).some(
-              (v) => typeof v === "object" && v !== null && Object.keys(v).length > 0
-            );
-            if (!hasNestedData) continue;
-          }
-          if (relationConfig.type === "many" || relationConfig.type === "manyToMany") {
-            if (!target[relName]) target[relName] = [];
-            const directData = {};
-            const nestedData = {};
-            if (typeof relData === "object" && relData !== null) {
-              for (const [k, v] of Object.entries(relData)) {
-                if (typeof v === "object" && v !== null) {
-                  nestedData[k] = v;
-                } else {
-                  directData[k] = v;
-                }
+          const directData = {};
+          const nestedData = {};
+          if (typeof data === "object" && data !== null) {
+            for (const [k, v] of Object.entries(data)) {
+              if (typeof v === "object" && v !== null) {
+                nestedData[k] = v;
+              } else {
+                directData[k] = v;
               }
             }
-            const hasData = Object.values(directData).some(
-              (v) => v !== null && v !== void 0 && v !== ""
-            );
+          }
+          const hasData = Object.values(directData).some(
+            (v) => v !== null && v !== void 0 && v !== ""
+          );
+          if (relationConfig.type === "many") {
+            if (!target[relName]) target[relName] = [];
             if (hasData) {
-              const relatedPks = Object.values(relationConfig.foreignTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
-              const relDataKey = relatedPks.map((pk) => directData[pk]).join("_");
-              if (relatedPks.length === 0 || !target[relName].some((r) => relatedPks.map((pk) => r[pk]).join("_") === relDataKey)) {
+              const relPks = Object.values(relationConfig.foreignTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
+              const key = relPks.map((pk) => directData[pk]).join("_");
+              if (relPks.length === 0 || !target[relName].some(
+                (r) => relPks.map((pk) => r[pk]).join("_") === key
+              )) {
                 const newItem = { ...directData };
                 if (Object.keys(nestedData).length > 0) {
-                  attachRelations(newItem, nestedData, relationConfig.foreignTable, []);
+                  attachRelations(newItem, nestedData, relationConfig.foreignTable);
                 }
                 target[relName].push(newItem);
               }
             }
           } else {
-            const directData = {};
-            const nestedData = {};
-            if (typeof relData === "object" && relData !== null) {
-              for (const [k, v] of Object.entries(relData)) {
-                if (typeof v === "object" && v !== null) {
-                  nestedData[k] = v;
-                } else {
-                  directData[k] = v;
-                }
-              }
-            }
-            const hasData = Object.values(directData).some(
-              (v) => v !== null && v !== void 0 && v !== ""
-            );
             if (hasData || Object.keys(nestedData).length > 0) {
               target[relName] = { ...directData };
               if (Object.keys(nestedData).length > 0) {
-                attachRelations(target[relName], nestedData, relationConfig.foreignTable, []);
+                attachRelations(
+                  target[relName],
+                  nestedData,
+                  relationConfig.foreignTable
+                );
               }
             }
           }
         }
       };
-      attachRelations(result, relations2, this.table);
+      attachRelations(result, relations2, this._table);
     }
     return Array.from(groupedResults.values());
   }
-  // Update the return type signatures
   async all() {
     return this.execute();
   }
@@ -603,39 +501,32 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     const result = await this.execute();
     return result[0];
   }
+  async first() {
+    return this.get();
+  }
   async exists() {
-    const originalColumns = this.selectedColumns;
-    this.selectedColumns = ["1"];
-    const { sql: joinSql, params: joinParams } = this.buildJoins();
-    const query = `SELECT 1 ${this.query}${joinSql} LIMIT 1`;
-    const params = [...this.params, ...joinParams];
-    this.selectedColumns = originalColumns;
-    const result = await this.db.select(query, params);
-    return result.length > 0;
+    this.applyIncludes();
+    const compiledResult = await this._builder.clearSelect().select(sql.raw("1").as("__exists__")).limit(1).execute();
+    return compiledResult.length > 0;
   }
   async count() {
-    const originalColumns = this.selectedColumns;
-    this.selectedColumns = ["COUNT(*) as count"];
-    const { sql: joinSql, params: joinParams } = this.buildJoins();
-    const query = `SELECT COUNT(*) as count ${this.query}${joinSql}`;
-    const params = [...this.params, ...joinParams];
-    this.selectedColumns = originalColumns;
-    const result = await this.db.select(query, params);
-    return result[0]?.count || 0;
-  }
-  async first() {
-    return this.get();
+    this.applyIncludes();
+    const result = await this._builder.clearSelect().select(sql`COUNT(*)`.as("count")).execute();
+    const row = result[0];
+    const val = row ? row['"count"'] ?? row.count : void 0;
+    return Number(val ?? 0);
   }
   async pluck(column) {
-    const columnName = this.table._.columns[column]._.name;
-    const originalColumns = this.selectedColumns;
-    this.selectedColumns = [`${this.selectedTableAlias}.${columnName} AS "${columnName}"`];
-    const { sql: joinSql, params: joinParams } = this.buildJoins();
-    const query = `SELECT ${this.selectedColumns.join(", ")} ${this.query}${joinSql}`;
-    const params = [...this.params, ...joinParams];
-    this.selectedColumns = originalColumns;
-    const results = await this.db.select(query, params);
-    return results.map((row) => row[columnName]);
+    this.applyIncludes();
+    const col = this._table._.columns[column];
+    const alias2 = col._.name;
+    const results = await this._builder.clearSelect().select(
+      sql.raw(`${this._table._.name}.${alias2}`).as(alias2)
+    ).execute();
+    return results.map((row) => {
+      const val = row['"' + alias2 + '"'] ?? row[alias2];
+      return col ? deserializeValue(val, col) : val;
+    });
   }
   async paginate(page = 1, pageSize = 10) {
     if (page < 1) page = 1;
@@ -655,16 +546,19 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     };
   }
   toSQL() {
-    const { sql: joinSql, params: joinParams } = this.buildJoins();
-    const distinct = this.isDistinct ? "DISTINCT " : "";
-    const finalQuery = `SELECT ${distinct}${this.selectedColumns.join(", ")} ${this.query}${joinSql}`;
-    return {
-      sql: finalQuery,
-      params: [...this.params, ...joinParams]
-    };
+    this.applyIncludes();
+    const compiled = this._builder.compile();
+    return { sql: compiled.sql, params: [...compiled.parameters] };
+  }
+  toKyselyExpression() {
+    this.applyIncludes();
+    return this._builder;
   }
 };
 
+// src/builders/update.ts
+import { sql as sql2 } from "kysely";
+
 // src/errors.ts
 var TauriORMError = class extends Error {
   constructor(message) {
@@ -733,414 +627,384 @@ var TableNotFoundError = class extends TauriORMError {
 };
 
 // src/builders/update.ts
-var UpdateQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table) {
-    super(db);
-    this.table = table;
-    this.query = `UPDATE ${table._.name}`;
-  }
-  updateData = {};
-  returningColumns = [];
-  hasWhereClause = false;
-  allowGlobal = false;
-  incrementDecrementOps = [];
+var UpdateQueryBuilder = class {
+  constructor(kysely, table) {
+    this.kysely = kysely;
+    this._table = table;
+    this._builder = kysely.updateTable(table._.name);
+  }
+  _builder;
+  _table;
+  _updateData = {};
+  _returningColumns = [];
+  _hasWhereClause = false;
+  _allowGlobal = false;
+  _incrementDecrementOps = [];
   set(data) {
-    this.updateData = { ...this.updateData, ...data };
+    this._updateData = { ...this._updateData, ...data };
     return this;
   }
   where(condition) {
-    this.hasWhereClause = true;
-    return super.where(condition);
+    this._hasWhereClause = true;
+    this._builder = this._builder.where(condition);
+    return this;
   }
   increment(column, value = 1) {
-    const col = this.table._.columns[column];
-    if (!col) {
-      throw new ColumnNotFoundError(String(column), this.table._.name);
-    }
-    this.incrementDecrementOps.push({ column: col._.name, op: "increment", value });
+    const col = this._table._.columns[column];
+    if (!col) throw new ColumnNotFoundError(String(column), this._table._.name);
+    this._incrementDecrementOps.push({ column: col._.name, op: "increment", value });
     return this;
   }
   decrement(column, value = 1) {
-    const col = this.table._.columns[column];
-    if (!col) {
-      throw new ColumnNotFoundError(String(column), this.table._.name);
-    }
-    this.incrementDecrementOps.push({ column: col._.name, op: "decrement", value });
+    const col = this._table._.columns[column];
+    if (!col) throw new ColumnNotFoundError(String(column), this._table._.name);
+    this._incrementDecrementOps.push({ column: col._.name, op: "decrement", value });
     return this;
   }
   allowGlobalOperation() {
-    this.allowGlobal = true;
+    this._allowGlobal = true;
     return this;
   }
   returning(...columns) {
-    this.returningColumns.push(...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();
-      }
+  mapReturningRows(rows) {
+    const dbNameToTs = {};
+    for (const [tsName, col] of Object.entries(this._table._.columns)) {
+      dbNameToTs[col._.name] = tsName;
     }
-    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 norm = (k) => k.startsWith('"') && k.endsWith('"') ? k.slice(1, -1) : k;
+    return rows.map((row) => {
+      const out = {};
+      for (const [dbKey, value] of Object.entries(row)) {
+        const logicalKey = norm(dbKey);
+        const tsName = dbNameToTs[logicalKey] ?? logicalKey;
+        const column = this._table._.columns[tsName];
+        out[tsName] = column ? deserializeValue(value, column) : value;
+      }
+      return out;
+    });
+  }
+  buildSetClause() {
+    const finalData = { ...this._updateData };
+    for (const [key, column] of Object.entries(this._table._.columns)) {
+      if (finalData[key] === void 0 && column.options.$onUpdateFn) {
+        ;
+        finalData[key] = column.options.$onUpdateFn();
+      }
     }
-    const entries = Object.entries(finalUpdateData);
+    const entries = Object.entries(finalData);
     const hasSetData = entries.length > 0;
-    const hasIncrementDecrement = this.incrementDecrementOps.length > 0;
-    if (!hasSetData && !hasIncrementDecrement) {
-      throw new UpdateValidationError("Cannot execute an update query without a .set(), .increment(), or .decrement() call.");
+    const hasOps = this._incrementDecrementOps.length > 0;
+    if (!hasSetData && !hasOps) {
+      throw new UpdateValidationError(
+        "Cannot execute an update query without a .set(), .increment(), or .decrement() call."
+      );
     }
-    const setClauses = [];
-    const setParams = [];
-    if (hasSetData) {
-      for (const [key, value] of entries) {
-        const column = this.table._.columns[key];
-        if (!column) {
-          throw new ColumnNotFoundError(key, this.table._.name);
-        }
-        setClauses.push(`${column._.name} = ?`);
-        setParams.push(serializeValue(value, column));
-      }
+    const setMap = {};
+    for (const [key, value] of entries) {
+      const column = this._table._.columns[key];
+      if (!column) throw new ColumnNotFoundError(key, this._table._.name);
+      setMap[column._.name] = serializeValue(value, column);
     }
-    for (const op of this.incrementDecrementOps) {
+    for (const op of this._incrementDecrementOps) {
       const sign = op.op === "increment" ? "+" : "-";
-      setClauses.push(`${op.column} = ${op.column} ${sign} ?`);
-      setParams.push(op.value);
+      setMap[op.column] = sql2.raw(`${op.column} ${sign} ${op.value}`);
     }
-    const setClause = setClauses.join(", ");
-    const sql2 = `${tablePart} SET ${setClause}${whereClause}`;
-    const params = [...setParams, ...whereParams];
-    return { sql: sql2, params };
+    return setMap;
   }
   async execute() {
-    if (!this.hasWhereClause && !this.allowGlobal) {
-      throw new MissingWhereClauseError("UPDATE", this.table._.name);
+    if (!this._hasWhereClause && !this._allowGlobal) {
+      throw new MissingWhereClauseError("UPDATE", this._table._.name);
     }
-    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 }];
+    const setMap = this.buildSetClause();
+    let builder = this._builder.set(setMap);
+    if (this._returningColumns.length > 0) {
+      const cols = this._returningColumns.map(
+        (k) => this._table._.columns[k]._.name
+      );
+      const rows = await builder.returning(cols).execute();
+      return this.mapReturningRows(rows);
     }
+    const result = await builder.executeTakeFirst();
+    return [{ rowsAffected: Number(result?.numUpdatedRows ?? 0) }];
   }
   async returningAll() {
-    const allColumns = Object.keys(
-      this.table._.columns
-    );
-    return this.returning(...allColumns).execute();
+    const allCols = Object.keys(this._table._.columns);
+    return this.returning(...allCols).execute();
   }
   async returningFirst() {
-    const allColumns = Object.keys(
-      this.table._.columns
-    );
-    const results = await this.returning(...allColumns).execute();
+    const results = await this.returningAll();
     return results[0];
   }
   toSQL() {
-    const { sql: updateSql, params } = this.buildUpdateClause();
-    if (this.returningColumns.length > 0) {
-      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
-      return {
-        sql: `${updateSql} RETURNING ${returningNames}`,
-        params
-      };
+    const setMap = this.buildSetClause();
+    let builder = this._builder.set(setMap);
+    if (this._returningColumns.length > 0) {
+      builder = builder.returning(
+        this._returningColumns.map((k) => this._table._.columns[k]._.name)
+      );
     }
-    return { sql: updateSql, params };
+    const compiled = builder.compile();
+    return { sql: compiled.sql, params: [...compiled.parameters] };
   }
 };
 
 // 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 = {};
+var InsertQueryBuilder = class {
+  constructor(kysely, table) {
+    this.kysely = kysely;
+    this._table = table;
+    this._builder = kysely.insertInto(table._.name);
+  }
+  _builder;
+  _table;
+  _dataSets = [];
+  _returningColumns = [];
+  _onConflictAction = null;
+  _conflictTarget = [];
+  _updateSet = {};
   values(data) {
-    const dataArray = Array.isArray(data) ? data : [data];
-    this.dataSets.push(...dataArray);
+    const arr = Array.isArray(data) ? data : [data];
+    this._dataSets.push(...arr);
     return this;
   }
   returning(...columns) {
-    this.returningColumns.push(...columns);
+    this._returningColumns.push(...columns);
     return this;
   }
   onConflictDoNothing(target) {
-    this.onConflictAction = "nothing";
+    this._onConflictAction = "nothing";
     if (target) {
-      this.conflictTarget = Array.isArray(target) ? target : [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;
+    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();
-        }
+  processDefaults(data) {
+    const out = { ...data };
+    for (const [key, column] of Object.entries(this._table._.columns)) {
+      if (out[key] === void 0 && column.options.$defaultFn) {
+        ;
+        out[key] = 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})`;
+    return out;
+  }
+  mapReturningRows(rows) {
+    const dbNameToTs = {};
+    for (const [tsName, col] of Object.entries(this._table._.columns)) {
+      dbNameToTs[col._.name] = tsName;
     }
-    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}`;
+    const norm = (k) => k.startsWith('"') && k.endsWith('"') ? k.slice(1, -1) : k;
+    return rows.map((row) => {
+      const out = {};
+      for (const [dbKey, value] of Object.entries(row)) {
+        const logicalKey = norm(dbKey);
+        const tsName = dbNameToTs[logicalKey] ?? logicalKey;
+        const column = this._table._.columns[tsName];
+        out[tsName] = column ? deserializeValue(value, column) : value;
       }
+      return out;
+    });
+  }
+  serializeDataSet(data) {
+    const out = {};
+    for (const [key, value] of Object.entries(data)) {
+      const column = this._table._.columns[key];
+      out[column ? column._.name : key] = column ? serializeValue(value, column) : value;
     }
-    return clause;
+    return out;
   }
   async execute() {
-    if (this.dataSets.length === 0) {
-      throw new InsertValidationError("No data provided for insert. Use .values() to provide data.");
-    }
-    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
+    if (this._dataSets.length === 0) {
+      throw new InsertValidationError(
+        "No data provided for insert. Use .values() to provide data."
       );
-      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) => {
-          const value = data[col] ?? null;
-          const column = this.table._.columns[col];
-          return column ? serializeValue(value, column) : value;
-        })
-      );
-      if (this.onConflictAction === "update") {
-        const setValues = Object.entries(this.updateSet).map(
-          ([key, value]) => {
-            const column = this.table._.columns[key];
-            return column ? serializeValue(value, column) : value;
-          }
+    }
+    const processed = this._dataSets.map((d) => this.serializeDataSet(this.processDefaults(d)));
+    let builder = this._builder.values(processed.length === 1 ? processed[0] : processed);
+    if (this._onConflictAction === "nothing") {
+      if (this._conflictTarget.length > 0) {
+        const targetCols = this._conflictTarget.map((c) => c._.name);
+        builder = builder.onConflict(
+          (oc) => oc.columns(targetCols).doNothing()
         );
-        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;
+        builder = builder.onConflict((oc) => oc.doNothing());
       }
+    } else if (this._onConflictAction === "update") {
+      const targetCols = this._conflictTarget.map((c) => c._.name);
+      const updateData = this.serializeDataSet(this._updateSet);
+      builder = builder.onConflict(
+        (oc) => oc.columns(targetCols).doUpdateSet(updateData)
+      );
     }
-    if (this.returningColumns.length > 0) {
-      return results;
+    if (this._returningColumns.length > 0) {
+      const cols = this._returningColumns.map(
+        (k) => this._table._.columns[k]._.name
+      );
+      const rows = await builder.returning(cols).execute();
+      return this.mapReturningRows(rows);
     }
-    return [{ lastInsertId, rowsAffected }];
+    const result = await builder.executeTakeFirst();
+    return [
+      {
+        lastInsertId: Number(result?.insertId ?? 0),
+        rowsAffected: Number(result?.numInsertedOrUpdatedRows ?? 0)
+      }
+    ];
   }
   async returningAll() {
-    const allColumns = Object.keys(
-      this.table._.columns
-    );
-    return this.returning(...allColumns).execute();
+    const allCols = Object.keys(this._table._.columns);
+    return this.returning(...allCols).execute();
   }
   async returningFirst() {
-    const allColumns = Object.keys(
-      this.table._.columns
-    );
-    const results = await this.returning(...allColumns).execute();
+    const results = await this.returningAll();
     return results[0];
   }
   toSQL() {
-    if (this.dataSets.length === 0) {
-      throw new InsertValidationError("No data provided for insert. Use .values() to provide data.");
+    if (this._dataSets.length === 0) {
+      throw new InsertValidationError(
+        "No data provided for insert. Use .values() to provide data."
+      );
     }
-    const processedDataSets = this.dataSets.map(
-      (data) => this.processDefaultValues(data)
-    );
-    const dataSet = processedDataSets[0];
-    const columns = Object.keys(dataSet);
-    const columnNames = columns.map(
-      (key) => this.table._.columns[key]._.name
-    );
-    const placeholders = `(${columns.map(() => "?").join(", ")})`;
-    const valuesSql = processedDataSets.map(() => placeholders).join(", ");
-    const conflictClause = this.buildConflictClause();
-    const finalQuery = `${this.query} (${columnNames.join(
-      ", "
-    )}) VALUES ${valuesSql}${conflictClause}`;
-    const params = processedDataSets.flatMap(
-      (data) => columns.map((col) => {
-        const value = data[col] ?? null;
-        const column = this.table._.columns[col];
-        return column ? serializeValue(value, column) : value;
-      })
-    );
-    if (this.onConflictAction === "update") {
-      const setValues = Object.entries(this.updateSet).map(
-        ([key, value]) => {
-          const column = this.table._.columns[key];
-          return column ? serializeValue(value, column) : value;
-        }
+    const processed = this._dataSets.map((d) => this.serializeDataSet(this.processDefaults(d)));
+    let builder = this._builder.values(processed.length === 1 ? processed[0] : processed);
+    if (this._onConflictAction === "nothing") {
+      if (this._conflictTarget.length > 0) {
+        builder = builder.onConflict(
+          (oc) => oc.columns(this._conflictTarget.map((c) => c._.name)).doNothing()
+        );
+      } else {
+        builder = builder.onConflict((oc) => oc.doNothing());
+      }
+    } else if (this._onConflictAction === "update") {
+      const updateData = this.serializeDataSet(this._updateSet);
+      builder = builder.onConflict(
+        (oc) => oc.columns(this._conflictTarget.map((c) => c._.name)).doUpdateSet(updateData)
       );
-      params.push(...setValues);
     }
-    if (this.returningColumns.length > 0) {
-      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
-      return {
-        sql: `${finalQuery} RETURNING ${returningNames}`,
-        params
-      };
+    if (this._returningColumns.length > 0) {
+      builder = builder.returning(
+        this._returningColumns.map((k) => this._table._.columns[k]._.name)
+      );
     }
-    return { sql: finalQuery, params };
+    const compiled = builder.compile();
+    return { sql: compiled.sql, params: [...compiled.parameters] };
   }
 };
 
 // src/builders/delete.ts
-var DeleteQueryBuilder = class extends BaseQueryBuilder {
-  constructor(db, table) {
-    super(db);
-    this.table = table;
-    this.query = `DELETE FROM ${table._.name}`;
-  }
-  returningColumns = [];
-  hasWhereClause = false;
-  allowGlobal = false;
+var DeleteQueryBuilder = class {
+  constructor(kysely, table) {
+    this.kysely = kysely;
+    this._table = table;
+    this._builder = kysely.deleteFrom(table._.name);
+  }
+  _builder;
+  _table;
+  _returningColumns = [];
+  _hasWhereClause = false;
+  _allowGlobal = false;
+  mapReturningRows(rows) {
+    const dbNameToTs = {};
+    for (const [tsName, col] of Object.entries(this._table._.columns)) {
+      dbNameToTs[col._.name] = tsName;
+    }
+    const norm = (k) => k.startsWith('"') && k.endsWith('"') ? k.slice(1, -1) : k;
+    return rows.map((row) => {
+      const out = {};
+      for (const [dbKey, value] of Object.entries(row)) {
+        const logicalKey = norm(dbKey);
+        const tsName = dbNameToTs[logicalKey] ?? logicalKey;
+        const column = this._table._.columns[tsName];
+        out[tsName] = column ? deserializeValue(value, column) : value;
+      }
+      return out;
+    });
+  }
   where(condition) {
-    this.hasWhereClause = true;
-    return super.where(condition);
+    this._hasWhereClause = true;
+    this._builder = this._builder.where(condition);
+    return this;
   }
   allowGlobalOperation() {
-    this.allowGlobal = true;
+    this._allowGlobal = true;
     return this;
   }
   returning(...columns) {
-    this.returningColumns.push(...columns);
+    this._returningColumns.push(...columns);
     return this;
   }
   async execute() {
-    if (!this.hasWhereClause && !this.allowGlobal) {
-      throw new MissingWhereClauseError("DELETE", this.table._.name);
+    if (!this._hasWhereClause && !this._allowGlobal) {
+      throw new MissingWhereClauseError("DELETE", this._table._.name);
     }
-    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 }];
+    if (this._returningColumns.length > 0) {
+      const cols = this._returningColumns.map(
+        (k) => this._table._.columns[k]._.name
+      );
+      const rows = await this._builder.returning(cols).execute();
+      return this.mapReturningRows(rows);
     }
+    const result = await this._builder.executeTakeFirst();
+    return [{ rowsAffected: Number(result?.numDeletedRows ?? 0) }];
   }
   async returningAll() {
-    const allColumns = Object.keys(this.table._.columns);
-    return this.returning(...allColumns).execute();
+    const allCols = Object.keys(this._table._.columns);
+    return this.returning(...allCols).execute();
   }
   async returningFirst() {
-    const allColumns = Object.keys(this.table._.columns);
-    const results = await this.returning(...allColumns).execute();
+    const results = await this.returningAll();
     return results[0];
   }
   toSQL() {
-    const { sql: sql2, params } = this.build();
-    if (this.returningColumns.length > 0) {
-      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
-      return {
-        sql: `${sql2} RETURNING ${returningNames}`,
-        params
-      };
+    let builder = this._builder;
+    if (this._returningColumns.length > 0) {
+      builder = builder.returning(
+        this._returningColumns.map((k) => this._table._.columns[k]._.name)
+      );
     }
-    return { sql: sql2, params };
+    const compiled = builder.compile();
+    return { sql: compiled.sql, params: [...compiled.parameters] };
   }
 };
 
 // src/builders/with.ts
 var WithQueryBuilder = class {
-  constructor(db) {
-    this.db = db;
+  constructor(kysely) {
+    this.kysely = kysely;
   }
-  ctes = [];
+  _ctes = [];
   with(alias2, query) {
-    this.ctes.push({ alias: alias2, query: query.sql, params: query.params });
+    this._ctes.push({ alias: alias2, query: query.toKyselyExpression() });
     return this;
   }
+  applyWith(builder) {
+    let b = builder;
+    for (const { alias: alias2, query } of this._ctes) {
+      b = b.with(alias2, () => query);
+    }
+    return b;
+  }
   select(table, columns) {
-    const builder = new SelectQueryBuilder(this.db, table, columns);
-    this.applyWithClause(builder);
-    return builder;
+    return new SelectQueryBuilder(this.kysely, table, columns);
   }
   insert(table) {
-    const builder = new InsertQueryBuilder(this.db, table);
-    this.applyWithClause(builder);
-    return builder;
+    return new InsertQueryBuilder(this.kysely, table);
   }
   update(table) {
-    const builder = new UpdateQueryBuilder(this.db, table);
-    this.applyWithClause(builder);
-    return builder;
+    return new UpdateQueryBuilder(this.kysely, table);
   }
   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"]
-      ];
-    }
+    return new DeleteQueryBuilder(this.kysely, table);
   }
 };
 
@@ -1183,7 +1047,7 @@ var SQLiteColumn = class _SQLiteColumn {
   unique() {
     return new _SQLiteColumn(this._.name, this.type, { ...this.options, unique: true, mode: this._.mode });
   }
-  references(ref, column) {
+  references(ref, column, options) {
     const columnKey = typeof column === "string" ? column : column._.name;
     const columnObj = typeof column === "string" ? ref._.columns[column] : column;
     return new _SQLiteColumn(
@@ -1193,7 +1057,9 @@ var SQLiteColumn = class _SQLiteColumn {
         ...this.options,
         references: {
           table: ref,
-          column: columnObj
+          column: columnObj,
+          onDelete: options?.onDelete,
+          onUpdate: options?.onUpdate
         },
         mode: this._.mode
       }
@@ -1222,39 +1088,14 @@ var Table = class {
 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 asc = (column) => kyselySql`${kyselySql.ref(column._.name)} ASC`;
+var desc = (column) => kyselySql`${kyselySql.ref(column._.name)} DESC`;
 var TauriORM = class {
   constructor(db, schema = void 0) {
     this.db = db;
+    this.kysely = new Kysely4({ dialect: new TauriDialect(db) });
     if (schema) {
-      for (const [key, value] of Object.entries(schema)) {
+      for (const [, value] of Object.entries(schema)) {
         if (value instanceof Table) {
           this.tables.set(value._.name, value);
         }
@@ -1262,24 +1103,31 @@ var TauriORM = class {
     }
   }
   tables = /* @__PURE__ */ new Map();
+  kysely;
   buildColumnDefinition(col, forAlterTable = false) {
-    let sql2 = `${col._.name} ${col.type}`;
+    let sql6 = `${col._.name} ${col.type}`;
     if (col.options.primaryKey && !forAlterTable) {
-      sql2 += " PRIMARY KEY";
+      sql6 += " PRIMARY KEY";
       if (col._.autoincrement) {
-        sql2 += " AUTOINCREMENT";
+        sql6 += " AUTOINCREMENT";
       }
     }
-    if (col._.notNull) sql2 += " NOT NULL";
-    if (col.options.unique) sql2 += " UNIQUE";
+    if (col._.notNull) sql6 += " NOT NULL";
+    if (col.options.unique) sql6 += " UNIQUE";
     if (col.options.default !== void 0) {
       const value = col.options.default;
-      sql2 += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
+      sql6 += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
     }
     if (col.options.references) {
-      sql2 += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+      sql6 += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+      if (col.options.references.onDelete) {
+        sql6 += ` ON DELETE ${col.options.references.onDelete.toUpperCase()}`;
+      }
+      if (col.options.references.onUpdate) {
+        sql6 += ` ON UPDATE ${col.options.references.onUpdate.toUpperCase()}`;
+      }
     }
-    return sql2;
+    return sql6;
   }
   async checkMigration() {
     const dbTables = await this.db.select(
@@ -1321,15 +1169,16 @@ var TauriORM = class {
       const schemaColumns = table._.columns;
       let needsRecreate = false;
       for (const [colName, column] of Object.entries(schemaColumns)) {
-        const existing = existingColumns.get(colName);
+        const dbColName = column._.name;
+        const existing = existingColumns.get(dbColName);
         if (!existing) {
           if (!this.canAddColumnWithAlter(column)) {
             needsRecreate = true;
             break;
           }
-          changes.columnsToAdd.push({ table: tableName, column: colName });
+          changes.columnsToAdd.push({ table: tableName, column: dbColName });
         } else {
-          const hasUniqueInDB = uniqueColumns.has(colName);
+          const hasUniqueInDB = uniqueColumns.has(dbColName);
           const wantsUnique = !!column.options.unique;
           if (hasUniqueInDB !== wantsUnique || this.hasColumnDefinitionChanged(column, existing)) {
             needsRecreate = true;
@@ -1338,7 +1187,8 @@ var TauriORM = class {
         }
       }
       for (const existingCol of existingColumns.keys()) {
-        if (!schemaColumns[existingCol]) {
+        const schemaHasCol = Object.values(schemaColumns).some((c) => c._.name === existingCol);
+        if (!schemaHasCol) {
           needsRecreate = true;
           break;
         }
@@ -1390,7 +1240,8 @@ var TauriORM = class {
         let needsRecreate = false;
         const columnsToAdd = [];
         for (const [colName, column] of Object.entries(schemaColumns)) {
-          const existing = existingColumns.get(colName);
+          const dbColName = column._.name;
+          const existing = existingColumns.get(dbColName);
           if (!existing) {
             if (this.canAddColumnWithAlter(column)) {
               columnsToAdd.push(column);
@@ -1399,7 +1250,7 @@ var TauriORM = class {
               break;
             }
           } else {
-            const hasUniqueInDB = uniqueColumns.has(colName);
+            const hasUniqueInDB = uniqueColumns.has(dbColName);
             const wantsUnique = !!column.options.unique;
             if (hasUniqueInDB !== wantsUnique) {
               needsRecreate = true;
@@ -1413,7 +1264,8 @@ var TauriORM = class {
         }
         if (options?.performDestructiveActions) {
           for (const existingCol of existingColumns.keys()) {
-            if (!schemaColumns[existingCol]) {
+            const schemaHasCol = Object.values(schemaColumns).some((c) => c._.name === existingCol);
+            if (!schemaHasCol) {
               needsRecreate = true;
               break;
             }
@@ -1458,7 +1310,7 @@ var TauriORM = class {
     await this.db.execute(`CREATE TABLE ${tempTableName} (${columnsSql})`);
     const oldColumns = await this.db.select(`PRAGMA table_info('${tableName}')`);
     const oldColumnNames = oldColumns.map((c) => c.name);
-    const newColumnNames = Object.keys(table._.columns);
+    const newColumnNames = Object.values(table._.columns).map((c) => c._.name);
     const commonColumns = oldColumnNames.filter((name) => newColumnNames.includes(name));
     if (commonColumns.length > 0) {
       const columnsList = commonColumns.join(", ");
@@ -1475,18 +1327,18 @@ var TauriORM = class {
       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.kysely, table, columns);
     }
-    return new SelectQueryBuilder(this.db, internalTable, columns);
+    return new SelectQueryBuilder(this.kysely, internalTable, columns);
   }
   insert(table) {
-    return new InsertQueryBuilder(this.db, table);
+    return new InsertQueryBuilder(this.kysely, table);
   }
   update(table) {
-    return new UpdateQueryBuilder(this.db, table);
+    return new UpdateQueryBuilder(this.kysely, table);
   }
   delete(table) {
-    return new DeleteQueryBuilder(this.db, table);
+    return new DeleteQueryBuilder(this.kysely, table);
   }
   async upsert(table, data, conflictTarget) {
     const columns = conflictTarget.map((col) => table._.columns[col]);
@@ -1496,7 +1348,7 @@ var TauriORM = class {
     }).execute();
   }
   $with(alias2) {
-    const withBuilder = new WithQueryBuilder(this.db);
+    const withBuilder = new WithQueryBuilder(this.kysely);
     return {
       as: (query) => {
         withBuilder.with(alias2, query);
@@ -1505,14 +1357,14 @@ var TauriORM = class {
     };
   }
   async transaction(callback) {
-    await this.db.execute("BEGIN TRANSACTION");
+    await this.db.execute("BEGIN");
     try {
       const result = await callback(this);
       await this.db.execute("COMMIT");
       return result;
-    } catch (error) {
+    } catch (e) {
       await this.db.execute("ROLLBACK");
-      throw error;
+      throw e;
     }
   }
   rollback() {
@@ -1564,7 +1416,9 @@ var TauriORM = class {
       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
+      hasOnUpdateFn: col.options.$onUpdateFn !== void 0,
+      onDelete: col.options.references?.onDelete ?? null,
+      onUpdate: col.options.references?.onUpdate ?? null
     };
   }
   computeModelSignature() {
@@ -1632,12 +1486,6 @@ var ManyRelation = class extends Relation {
     super(foreignTable);
   }
 };
-var ManyToManyRelation = class extends Relation {
-  constructor(foreignTable, config) {
-    super(foreignTable);
-    this.config = config;
-  }
-};
 var relations = (table, relationsCallback) => {
   const builtRelations = relationsCallback({
     one: (foreignTable, config) => {
@@ -1645,9 +1493,6 @@ var relations = (table, relationsCallback) => {
     },
     many: (foreignTable) => {
       return new ManyRelation(foreignTable);
-    },
-    manyToMany: (foreignTable, config) => {
-      return new ManyToManyRelation(foreignTable, config);
     }
   });
   for (const [name, relation] of Object.entries(builtRelations)) {
@@ -1663,14 +1508,6 @@ var relations = (table, relationsCallback) => {
         type: "many",
         foreignTable: relation.foreignTable
       };
-    } else if (relation instanceof ManyToManyRelation) {
-      table.relations[name] = {
-        type: "manyToMany",
-        foreignTable: relation.foreignTable,
-        junctionTable: relation.config.junctionTable,
-        junctionFields: relation.config.junctionFields,
-        junctionReferences: relation.config.junctionReferences
-      };
     }
   }
   return builtRelations;
@@ -1682,51 +1519,101 @@ var alias = (table, alias2) => {
   return table;
 };
 
+// src/operators.ts
+import { isExpression, sql as sql3 } from "kysely";
+var eq = (column, value, tableAlias) => {
+  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  const serialized = serializeValue(value, column);
+  return sql3`${sql3.ref(colRef)} = ${sql3.val(serialized)}`;
+};
+var ne = (column, value, tableAlias) => {
+  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  const serialized = serializeValue(value, column);
+  return sql3`${sql3.ref(colRef)} != ${sql3.val(serialized)}`;
+};
+var and = (...conditions) => {
+  if (conditions.length === 0) return sql3`1 = 1`;
+  if (conditions.length === 1) return conditions[0];
+  return sql3`(${sql3.join(conditions.map((c) => sql3`(${c})`), sql3` AND `)})`;
+};
+var or = (...conditions) => {
+  if (conditions.length === 0) return sql3`1 = 1`;
+  if (conditions.length === 1) return conditions[0];
+  return sql3`(${sql3.join(conditions.map((c) => sql3`(${c})`), sql3` OR `)})`;
+};
+var not = (condition) => sql3`NOT (${condition})`;
+var gt = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql3`${sql3.ref(column._.name)} > ${sql3.val(serialized)}`;
+};
+var gte = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql3`${sql3.ref(column._.name)} >= ${sql3.val(serialized)}`;
+};
+var lt = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql3`${sql3.ref(column._.name)} < ${sql3.val(serialized)}`;
+};
+var lte = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql3`${sql3.ref(column._.name)} <= ${sql3.val(serialized)}`;
+};
+var like = (column, pattern) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(pattern)}`;
+var ilike = (column, pattern) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(pattern)} COLLATE NOCASE`;
+var startsWith = (column, value) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(`${value}%`)}`;
+var endsWith = (column, value) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(`%${value}`)}`;
+var contains = (column, value) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(`%${value}%`)}`;
+var isNull = (column) => sql3`${sql3.ref(column._.name)} IS NULL`;
+var isNotNull = (column) => sql3`${sql3.ref(column._.name)} IS NOT NULL`;
+var exists = (subquery2) => sql3`EXISTS ${subquery2}`;
+var notExists = (subquery2) => sql3`NOT EXISTS ${subquery2}`;
+var eqSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} = (${subquery2})`;
+var neSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} != (${subquery2})`;
+var gtSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} > (${subquery2})`;
+var gteSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} >= (${subquery2})`;
+var ltSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} < (${subquery2})`;
+var lteSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} <= (${subquery2})`;
+var inArray = (column, values) => {
+  if (isExpression(values)) {
+    return sql3`${sql3.ref(column._.name)} IN (${values})`;
+  }
+  const arr = values;
+  if (arr.length === 0) return sql3`1 = 0`;
+  const serialized = arr.map((v) => sql3.val(serializeValue(v, column)));
+  return sql3`${sql3.ref(column._.name)} IN (${sql3.join(serialized)})`;
+};
+var notIn = (column, values) => {
+  if (isExpression(values)) {
+    return sql3`${sql3.ref(column._.name)} NOT IN (${values})`;
+  }
+  const arr = values;
+  if (arr.length === 0) return sql3`1 = 1`;
+  const serialized = arr.map((v) => sql3.val(serializeValue(v, column)));
+  return sql3`${sql3.ref(column._.name)} NOT IN (${sql3.join(serialized)})`;
+};
+var between = (column, min2, max2) => {
+  const serializedMin = serializeValue(min2, column);
+  const serializedMax = serializeValue(max2, column);
+  return sql3`${sql3.ref(column._.name)} BETWEEN ${sql3.val(serializedMin)} AND ${sql3.val(serializedMax)}`;
+};
+
 // src/aggregates.ts
-var count = (column) => ({
-  sql: `COUNT(${column ? column._.name : "*"})`,
-  params: []
-});
-var countDistinct = (column) => ({
-  sql: `COUNT(DISTINCT ${column._.name})`,
-  params: []
-});
-var sum = (column) => ({
-  sql: `SUM(${column._.name})`,
-  params: []
-});
-var avg = (column) => ({
-  sql: `AVG(${column._.name})`,
-  params: []
-});
-var max = (column) => ({
-  sql: `MAX(${column._.name})`,
-  params: []
-});
-var min = (column) => ({
-  sql: `MIN(${column._.name})`,
-  params: []
-});
-var groupConcat = (column, separator = ",") => ({
-  sql: `GROUP_CONCAT(${column._.name}, ?)`,
-  params: [separator]
-});
-var as = (aggregate, alias2) => ({
-  ...aggregate,
-  alias: alias2
-});
+import { sql as sql4 } from "kysely";
+var count = (column) => sql4`COUNT(${column ? sql4.ref(column._.name) : sql4.raw("*")})`;
+var countDistinct = (column) => sql4`COUNT(DISTINCT ${sql4.ref(column._.name)})`;
+var sum = (column) => sql4`SUM(${sql4.ref(column._.name)})`;
+var avg = (column) => sql4`AVG(${sql4.ref(column._.name)})`;
+var max = (column) => sql4`MAX(${sql4.ref(column._.name)})`;
+var min = (column) => sql4`MIN(${sql4.ref(column._.name)})`;
+var groupConcat = (column, separator = ",") => sql4`GROUP_CONCAT(${sql4.ref(column._.name)}, ${sql4.val(separator)})`;
+var as = (aggregate, alias2) => Object.assign(aggregate, { alias: alias2 });
 
 // src/subquery.ts
 var subquery = (query) => {
-  const { sql: sql2, params } = query.toSQL();
-  return {
-    sql: `(${sql2})`,
-    params,
-    _isSubquery: true
-  };
+  return query.toKyselyExpression();
 };
 var scalarSubquery = (query) => {
-  return subquery(query);
+  return query.toKyselyExpression();
 };
 
 // src/column-helpers.ts
@@ -1745,14 +1632,15 @@ function numeric(name, config) {
   return new SQLiteColumn(name, "NUMERIC", config);
 }
 var enumType = (name, values) => text(name, { enum: values });
+
+// src/index.ts
+import { sql as sql5 } from "kysely";
 export {
-  BaseQueryBuilder,
   ColumnNotFoundError,
   DeleteQueryBuilder,
   InsertQueryBuilder,
   InsertValidationError,
   ManyRelation,
-  ManyToManyRelation,
   MigrationError,
   MissingWhereClauseError,
   OneRelation,
@@ -1763,6 +1651,7 @@ export {
   SelectQueryBuilder,
   Table,
   TableNotFoundError,
+  TauriDialect,
   TauriORM,
   TauriORMError,
   UpdateQueryBuilder,
@@ -1814,7 +1703,7 @@ export {
   real,
   relations,
   scalarSubquery,
-  sql,
+  sql5 as sql,
   sqliteTable,
   startsWith,
   subquery,