@type32/tauri-sqlite-orm 0.1.20 → 0.2.1

package/dist/index.js

@@ -21,47 +21,77 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   BaseQueryBuilder: () => BaseQueryBuilder,
+  ColumnNotFoundError: () => ColumnNotFoundError,
   DeleteQueryBuilder: () => DeleteQueryBuilder,
   InsertQueryBuilder: () => InsertQueryBuilder,
+  InsertValidationError: () => InsertValidationError,
   ManyRelation: () => ManyRelation,
+  ManyToManyRelation: () => ManyToManyRelation,
+  MigrationError: () => MigrationError,
+  MissingWhereClauseError: () => MissingWhereClauseError,
   OneRelation: () => OneRelation,
+  QueryBuilderError: () => QueryBuilderError,
   Relation: () => Relation,
+  RelationError: () => RelationError,
   SQLiteColumn: () => SQLiteColumn,
   SelectQueryBuilder: () => SelectQueryBuilder,
   Table: () => Table,
+  TableNotFoundError: () => TableNotFoundError,
   TauriORM: () => TauriORM,
+  TauriORMError: () => TauriORMError,
   UpdateQueryBuilder: () => UpdateQueryBuilder,
+  UpdateValidationError: () => UpdateValidationError,
+  ValidationError: () => ValidationError,
   WithQueryBuilder: () => WithQueryBuilder,
   alias: () => alias,
   and: () => and,
+  as: () => as,
   asc: () => asc,
   avg: () => avg,
+  between: () => between,
   blob: () => blob,
   boolean: () => boolean,
+  contains: () => contains,
   count: () => count,
   countDistinct: () => countDistinct,
   desc: () => desc,
+  endsWith: () => endsWith,
   enumType: () => enumType,
   eq: () => eq,
+  eqSubquery: () => eqSubquery,
+  exists: () => exists,
   getTableColumns: () => getTableColumns,
+  groupConcat: () => groupConcat,
   gt: () => gt,
+  gtSubquery: () => gtSubquery,
   gte: () => gte,
+  gteSubquery: () => gteSubquery,
+  ilike: () => ilike,
   inArray: () => inArray,
   integer: () => integer,
   isNotNull: () => isNotNull,
   isNull: () => isNull,
   like: () => like,
   lt: () => lt,
+  ltSubquery: () => ltSubquery,
   lte: () => lte,
+  lteSubquery: () => lteSubquery,
   max: () => max,
   min: () => min,
+  ne: () => ne,
+  neSubquery: () => neSubquery,
   not: () => not,
+  notExists: () => notExists,
+  notIn: () => notIn,
   numeric: () => numeric,
   or: () => or,
   real: () => real,
   relations: () => relations,
+  scalarSubquery: () => scalarSubquery,
   sql: () => sql,
   sqliteTable: () => sqliteTable,
+  startsWith: () => startsWith,
+  subquery: () => subquery,
   sum: () => sum,
   text: () => text
 });
@@ -102,6 +132,9 @@ var BaseQueryBuilder = class {
       params: this.params
     };
   }
+  toSQL() {
+    return this.build();
+  }
 };
 
 // src/operators.ts
@@ -112,6 +145,13 @@ var eq = (column, value, tableAlias) => {
     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)
@@ -144,6 +184,22 @@ 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: []
@@ -152,33 +208,65 @@ var isNotNull = (column) => ({
   sql: `${column._.name} IS NOT NULL`,
   params: []
 });
-var inArray = (column, values) => ({
-  sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
-  params: values
+var exists = (subquery2) => ({
+  sql: `EXISTS (${subquery2.sql})`,
+  params: subquery2.params
 });
-var count = (column) => ({
-  sql: `COUNT(${column ? column._.name : "*"})`,
-  params: []
+var notExists = (subquery2) => ({
+  sql: `NOT EXISTS (${subquery2.sql})`,
+  params: subquery2.params
 });
-var countDistinct = (column) => ({
-  sql: `COUNT(DISTINCT ${column._.name})`,
-  params: []
+var eqSubquery = (column, subquery2) => ({
+  sql: `${column._.name} = ${subquery2.sql}`,
+  params: subquery2.params
 });
-var sum = (column) => ({
-  sql: `SUM(${column._.name})`,
-  params: []
+var neSubquery = (column, subquery2) => ({
+  sql: `${column._.name} != ${subquery2.sql}`,
+  params: subquery2.params
 });
-var avg = (column) => ({
-  sql: `AVG(${column._.name})`,
-  params: []
+var gtSubquery = (column, subquery2) => ({
+  sql: `${column._.name} > ${subquery2.sql}`,
+  params: subquery2.params
 });
-var max = (column) => ({
-  sql: `MAX(${column._.name})`,
-  params: []
+var gteSubquery = (column, subquery2) => ({
+  sql: `${column._.name} >= ${subquery2.sql}`,
+  params: subquery2.params
 });
-var min = (column) => ({
-  sql: `MIN(${column._.name})`,
-  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
+    };
+  }
+  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
+    };
+  }
+  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
@@ -244,42 +332,30 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
       sql2 += ` ${join.type} JOIN ${join.table._.name} ${join.alias} ON ${join.condition.sql}`;
       params.push(...join.condition.params);
     }
-    for (const [relationName, include] of Object.entries(this.includeRelations)) {
-      if (!include) continue;
-      const relation = this.table.relations[relationName];
-      if (!relation) {
-        console.warn(
-          `[Tauri-ORM] Relation "${relationName}" not found on table "${this.table._.name}". Skipping include.`
-        );
-        continue;
+    const processRelations = (parentTable, parentAlias, relations2, depth = 0) => {
+      if (depth > 10) {
+        console.warn("[Tauri-ORM] Maximum relation depth (10) exceeded. Skipping deeper relations.");
+        return;
       }
-      const foreignTable = relation.foreignTable;
-      const foreignAlias = `${this.selectedTableAlias}_${relationName}`;
-      const aliasedColumns = Object.values(foreignTable._.columns).map(
-        (col) => `${foreignAlias}.${col._.name} AS "${foreignAlias}.${col._.name}"`
-      );
-      this.selectedColumns.push(...aliasedColumns);
-      if (relation.type === "one" && relation.fields && relation.references) {
-        const conditions = relation.fields.map((field, i) => {
-          const localColumn = `${this.selectedTableAlias}.${field._.name}`;
-          const foreignColumn = `${foreignAlias}.${relation.references[i]._.name}`;
-          return {
-            sql: `${localColumn} = ${foreignColumn}`,
-            params: []
-          };
-        });
-        const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
-        sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
-        params.push(...condition.params);
-      } else if (relation.type === "many") {
-        const refRelation = Object.entries(foreignTable.relations).find(
-          ([_, r]) => r.foreignTable === this.table
+      for (const [relationName, include] of Object.entries(relations2)) {
+        if (!include) continue;
+        const relation = parentTable.relations[relationName];
+        if (!relation) {
+          console.warn(
+            `[Tauri-ORM] Relation "${relationName}" not found on table "${parentTable._.name}". Skipping include.`
+          );
+          continue;
+        }
+        const foreignTable = relation.foreignTable;
+        const foreignAlias = `${parentAlias}_${relationName}`;
+        const aliasedColumns = Object.values(foreignTable._.columns).map(
+          (col) => `${foreignAlias}.${col._.name} AS "${foreignAlias}.${col._.name}"`
         );
-        if (refRelation && refRelation[1].fields && refRelation[1].references) {
-          const [_, relationConfig] = refRelation;
-          const conditions = relationConfig.fields.map((field, i) => {
-            const localColumn = `${foreignAlias}.${field._.name}`;
-            const foreignColumn = `${this.selectedTableAlias}.${relationConfig.references[i]._.name}`;
+        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: []
@@ -288,9 +364,64 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
           const condition = conditions.length > 1 ? and(...conditions) : conditions[0];
           sql2 += ` LEFT JOIN ${foreignTable._.name} ${foreignAlias} ON ${condition.sql}`;
           params.push(...condition.params);
+        } else if (relation.type === "many") {
+          const refRelation = Object.entries(foreignTable.relations).find(
+            ([_, r]) => r.foreignTable === 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);
+            }
+          }
+        }
+        if (typeof include === "object" && include.with) {
+          processRelations(foreignTable, foreignAlias, include.with, depth + 1);
         }
       }
-    }
+    };
+    processRelations(this.table, this.selectedTableAlias, this.includeRelations, 0);
     return { sql: sql2, params };
   }
   // Enhanced execute method that handles relation data mapping
@@ -301,7 +432,6 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     this.query += joinSql;
     this.params.push(...joinParams);
     const { sql: sql2, params } = this.build();
-    console.log("Executing SQL:", sql2, "with params:", params);
     const rawResults = await this.db.select(sql2, params);
     const hasIncludes = Object.values(this.includeRelations).some((i) => i);
     if (hasIncludes) {
@@ -331,6 +461,36 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
       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("_");
+    };
+    const setNestedValue = (obj, path, value, columnName) => {
+      let current = 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;
+        } else {
+          if (!current[key]) current[key] = {};
+          current = current[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;
+      }
+      return currentRelation;
+    };
     for (const row of rawResults) {
       const mainTableKey = mainTablePks.map((pk) => row[`${this.selectedTableAlias}.${pk}`] ?? row[pk]).join("_");
       if (!groupedResults.has(mainTableKey)) {
@@ -344,11 +504,9 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
           if (tableAlias === this.selectedTableAlias) {
             result[columnName] = value;
           } else {
-            const parts = tableAlias.split("_");
-            if (parts.length >= 2 && parts[0] === this.selectedTableAlias) {
-              const relationName = parts.slice(1).join("_");
-              if (!relations2[relationName]) relations2[relationName] = {};
-              relations2[relationName][columnName] = value;
+            const relationPath = parseRelationPath(tableAlias, this.selectedTableAlias);
+            if (relationPath.length > 0) {
+              setNestedValue(relations2, relationPath, value, columnName);
             } else {
               if (!result[tableAlias]) result[tableAlias] = {};
               result[tableAlias][columnName] = value;
@@ -358,24 +516,72 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
           result[key] = value;
         }
       }
-      for (const [relName, relData] of Object.entries(relations2)) {
-        const relationConfig = this.table.relations[relName];
-        if (!relationConfig) continue;
-        const hasData = Object.values(relData).some(
-          (v) => v !== null && v !== void 0 && v !== ""
-        );
-        if (!hasData) continue;
-        if (relationConfig.type === "many") {
-          if (!result[relName]) result[relName] = [];
-          const relatedPks = Object.values(relationConfig.foreignTable._.columns).filter((c) => c.options.primaryKey).map((c) => c._.name);
-          const relDataKey = relatedPks.map((pk) => relData[pk]).join("_");
-          if (relatedPks.length === 0 || !result[relName].some((r) => relatedPks.map((pk) => r[pk]).join("_") === relDataKey)) {
-            result[relName].push(relData);
+      const attachRelations = (target, relationsData, table, pathPrefix = []) => {
+        for (const [relName, relData] of Object.entries(relationsData)) {
+          const currentPath = [...pathPrefix, relName];
+          const relationConfig = getNestedRelation(table, currentPath);
+          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 hasData = Object.values(directData).some(
+              (v) => v !== null && v !== void 0 && v !== ""
+            );
+            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 newItem = { ...directData };
+                if (Object.keys(nestedData).length > 0) {
+                  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, []);
+              }
+            }
           }
-        } else {
-          result[relName] = relData;
         }
-      }
+      };
+      attachRelations(result, relations2, this.table);
     }
     return Array.from(groupedResults.values());
   }
@@ -388,6 +594,82 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     const result = await this.execute();
     return result[0];
   }
+  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]
+    };
+  }
+};
+
+// src/errors.ts
+var TauriORMError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TauriORMError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var QueryBuilderError = class extends TauriORMError {
+  constructor(message) {
+    super(message);
+    this.name = "QueryBuilderError";
+  }
+};
+var MissingWhereClauseError = class extends QueryBuilderError {
+  constructor(operation, tableName) {
+    super(
+      `${operation} operation on table "${tableName}" requires a WHERE clause to prevent accidental data loss. Use .where() to specify conditions, or use .allowGlobalOperation() to explicitly allow operations without WHERE.`
+    );
+    this.name = "MissingWhereClauseError";
+  }
+};
+var ValidationError = class extends TauriORMError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var InsertValidationError = class extends ValidationError {
+  constructor(message) {
+    super(message);
+    this.name = "InsertValidationError";
+  }
+};
+var UpdateValidationError = class extends ValidationError {
+  constructor(message) {
+    super(message);
+    this.name = "UpdateValidationError";
+  }
+};
+var MigrationError = class extends TauriORMError {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+  }
+};
+var RelationError = class extends TauriORMError {
+  constructor(message) {
+    super(message);
+    this.name = "RelationError";
+  }
+};
+var ColumnNotFoundError = class extends TauriORMError {
+  constructor(columnName, tableName) {
+    super(`Column "${columnName}" does not exist on table "${tableName}"`);
+    this.name = "ColumnNotFoundError";
+  }
+};
+var TableNotFoundError = class extends TauriORMError {
+  constructor(tableName) {
+    super(`Table "${tableName}" not found in schema`);
+    this.name = "TableNotFoundError";
+  }
 };
 
 // src/builders/update.ts
@@ -399,10 +681,37 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
   }
   updateData = {};
   returningColumns = [];
+  hasWhereClause = false;
+  allowGlobal = false;
+  incrementDecrementOps = [];
   set(data) {
     this.updateData = { ...this.updateData, ...data };
     return this;
   }
+  where(condition) {
+    this.hasWhereClause = true;
+    return super.where(condition);
+  }
+  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 });
+    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 });
+    return this;
+  }
+  allowGlobalOperation() {
+    this.allowGlobal = true;
+    return this;
+  }
   returning(...columns) {
     this.returningColumns.push(...columns);
     return this;
@@ -425,24 +734,37 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
       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 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 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}`
-        );
+    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(value);
       }
-      return `${column._.name} = ?`;
-    }).join(", ");
-    const setParams = entries.map(([, value]) => value);
+    }
+    for (const op of this.incrementDecrementOps) {
+      const sign = op.op === "increment" ? "+" : "-";
+      setClauses.push(`${op.column} = ${op.column} ${sign} ?`);
+      setParams.push(op.value);
+    }
+    const setClause = setClauses.join(", ");
     const sql2 = `${tablePart} SET ${setClause}${whereClause}`;
     const params = [...setParams, ...whereParams];
     return { sql: sql2, params };
   }
   async execute() {
+    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(", ");
@@ -459,6 +781,17 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
     );
     return this.returning(...allColumns).execute();
   }
+  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
+      };
+    }
+    return { sql: updateSql, params };
+  }
 };
 
 // src/builders/insert.ts
@@ -527,7 +860,7 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
   }
   async execute() {
     if (this.dataSets.length === 0) {
-      throw new Error("No data provided for insert");
+      throw new InsertValidationError("No data provided for insert. Use .values() to provide data.");
     }
     const processedDataSets = this.dataSets.map(
       (data) => this.processDefaultValues(data)
@@ -585,6 +918,42 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
     );
     return this.returning(...allColumns).execute();
   }
+  toSQL() {
+    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) => 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(", ");
+      return {
+        sql: `${finalQuery} RETURNING ${returningNames}`,
+        params
+      };
+    }
+    return { sql: finalQuery, params };
+  }
 };
 
 // src/builders/delete.ts
@@ -595,11 +964,24 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
     this.query = `DELETE FROM ${table._.name}`;
   }
   returningColumns = [];
+  hasWhereClause = false;
+  allowGlobal = false;
+  where(condition) {
+    this.hasWhereClause = true;
+    return super.where(condition);
+  }
+  allowGlobalOperation() {
+    this.allowGlobal = true;
+    return this;
+  }
   returning(...columns) {
     this.returningColumns.push(...columns);
     return this;
   }
   async execute() {
+    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(", ");
@@ -614,6 +996,17 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
     const allColumns = Object.keys(this.table._.columns);
     return this.returning(...allColumns).execute();
   }
+  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
+      };
+    }
+    return { sql: sql2, params };
+  }
 };
 
 // src/builders/with.ts
@@ -699,6 +1092,8 @@ var SQLiteColumn = class _SQLiteColumn {
     return new _SQLiteColumn(this._.name, this.type, { ...this.options, unique: true }, this._.mode);
   }
   references(ref, column) {
+    const columnKey = typeof column === "string" ? column : column._.name;
+    const columnObj = typeof column === "string" ? ref._.columns[column] : column;
     return new _SQLiteColumn(
       this._.name,
       this.type,
@@ -706,7 +1101,7 @@ var SQLiteColumn = class _SQLiteColumn {
         ...this.options,
         references: {
           table: ref,
-          column: ref._.columns[column]
+          column: columnObj
         }
       },
       this._.mode
@@ -995,6 +1390,12 @@ 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) => {
@@ -1002,6 +1403,9 @@ 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)) {
@@ -1017,6 +1421,14 @@ 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;
@@ -1028,6 +1440,53 @@ var alias = (table, alias2) => {
   return table;
 };
 
+// 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
+});
+
+// src/subquery.ts
+var subquery = (query) => {
+  const { sql: sql2, params } = query.toSQL();
+  return {
+    sql: `(${sql2})`,
+    params,
+    _isSubquery: true
+  };
+};
+var scalarSubquery = (query) => {
+  return subquery(query);
+};
+
 // src/column-helpers.ts
 var text = (name, config) => new SQLiteColumn(name, "TEXT", config, config?.mode);
 var integer = (name, config) => new SQLiteColumn(name, "INTEGER", {}, config?.mode || "default");
@@ -1039,47 +1498,77 @@ var enumType = (name, values) => text(name, { enum: values });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseQueryBuilder,
+  ColumnNotFoundError,
   DeleteQueryBuilder,
   InsertQueryBuilder,
+  InsertValidationError,
   ManyRelation,
+  ManyToManyRelation,
+  MigrationError,
+  MissingWhereClauseError,
   OneRelation,
+  QueryBuilderError,
   Relation,
+  RelationError,
   SQLiteColumn,
   SelectQueryBuilder,
   Table,
+  TableNotFoundError,
   TauriORM,
+  TauriORMError,
   UpdateQueryBuilder,
+  UpdateValidationError,
+  ValidationError,
   WithQueryBuilder,
   alias,
   and,
+  as,
   asc,
   avg,
+  between,
   blob,
   boolean,
+  contains,
   count,
   countDistinct,
   desc,
+  endsWith,
   enumType,
   eq,
+  eqSubquery,
+  exists,
   getTableColumns,
+  groupConcat,
   gt,
+  gtSubquery,
   gte,
+  gteSubquery,
+  ilike,
   inArray,
   integer,
   isNotNull,
   isNull,
   like,
   lt,
+  ltSubquery,
   lte,
+  lteSubquery,
   max,
   min,
+  ne,
+  neSubquery,
   not,
+  notExists,
+  notIn,
   numeric,
   or,
   real,
   relations,
+  scalarSubquery,
   sql,
   sqliteTable,
+  startsWith,
+  subquery,
   sum,
   text
 });