@type32/tauri-sqlite-orm 0.1.18-5 → 0.1.18-6

package/dist/index.d.mts

@@ -38,6 +38,7 @@ declare class SQLiteColumn<TName extends string = string, TType extends ColumnDa
     unique(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
     references<T extends AnyTable, K extends keyof T["_"]["columns"] & string>(ref: T, column: K): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
     $onUpdateFn(fn: () => ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
+    as(alias: string): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
 }
 declare const text: <TName extends string>(name: TName) => SQLiteColumn<TName, "TEXT", "default", false, false, false>;
 declare const integer: <TName extends string, TMode extends Mode = "default">(name: TName, config?: {
@@ -77,6 +78,7 @@ type SQLCondition = {
 declare const eq: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
 declare const and: (...conditions: SQLCondition[]) => SQLCondition;
 declare const or: (...conditions: SQLCondition[]) => SQLCondition;
+declare const not: (condition: SQLCondition) => SQLCondition;
 declare const gt: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
 declare const gte: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
 declare const lt: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
@@ -85,13 +87,35 @@ declare const like: (column: AnySQLiteColumn, pattern: string) => SQLCondition;
 declare const isNull: (column: AnySQLiteColumn) => SQLCondition;
 declare const isNotNull: (column: AnySQLiteColumn) => SQLCondition;
 declare const inArray: <T>(column: AnySQLiteColumn, values: T[]) => SQLCondition;
+declare const asc: (column: AnySQLiteColumn) => {
+    sql: string;
+    params: never[];
+};
+declare const desc: (column: AnySQLiteColumn) => {
+    sql: string;
+    params: never[];
+};
+declare const count: (column?: AnySQLiteColumn) => SQLCondition;
+declare const countDistinct: (column: AnySQLiteColumn) => SQLCondition;
+declare const sum: (column: AnySQLiteColumn) => SQLCondition;
+declare const avg: (column: AnySQLiteColumn) => SQLCondition;
+declare const max: (column: AnySQLiteColumn) => SQLCondition;
+declare const min: (column: AnySQLiteColumn) => SQLCondition;
+declare const sql: <T = unknown>(strings: TemplateStringsArray, ...values: any[]) => {
+    sql: string;
+    params: any[];
+    mapWith?: (value: any) => T;
+};
 declare class BaseQueryBuilder {
     protected db: Database;
     protected query: string;
     protected params: any[];
     constructor(db: Database);
     where(condition: SQLCondition): this;
-    orderBy(column: AnySQLiteColumn, direction?: "ASC" | "DESC"): this;
+    orderBy(column: AnySQLiteColumn | {
+        sql: string;
+        params: any[];
+    }, direction?: "ASC" | "DESC"): this;
     limit(count: number): this;
     offset(count: number): this;
     build(): {
@@ -102,31 +126,69 @@ declare class BaseQueryBuilder {
 declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable["_"]["columns"])[] | undefined = undefined> extends BaseQueryBuilder {
     private table;
     private columns?;
+    private isDistinct;
+    private groupByColumns;
+    private havingCondition;
     constructor(db: Database, table: TTable, columns?: TSelectedColumns | undefined);
+    distinct(): this;
+    groupBy(...columns: AnySQLiteColumn[]): this;
+    having(condition: SQLCondition): this;
     execute(): Promise<TSelectedColumns extends (keyof TTable["_"]["columns"])[] ? Pick<InferSelectModel<TTable>, TSelectedColumns[number]>[] : InferSelectModel<TTable>[]>;
+    all(): Promise<TSelectedColumns extends (keyof TTable["_"]["columns"])[] ? Pick<InferSelectModel<TTable>, TSelectedColumns[number]>[] : InferSelectModel<TTable>[]>;
+    get(): Promise<TSelectedColumns extends (keyof TTable["_"]["columns"])[] ? Pick<InferSelectModel<TTable>, TSelectedColumns[number]> | undefined : InferSelectModel<TTable> | undefined>;
 }
 declare class InsertQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     private table;
     private dataSets;
+    private returningColumns;
+    private onConflictAction;
+    private conflictTarget;
+    private updateSet;
     constructor(db: Database, table: T);
     values(data: Partial<InferInsertModel<T>> | Partial<InferInsertModel<T>>[]): this;
-    execute(): Promise<number>;
+    returning(...columns: (keyof T["_"]["columns"])[]): this;
+    onConflictDoNothing(target?: AnySQLiteColumn | AnySQLiteColumn[]): this;
+    onConflictDoUpdate(config: {
+        target: AnySQLiteColumn | AnySQLiteColumn[];
+        set: Partial<InferInsertModel<T>>;
+    }): this;
+    private processDefaultValues;
+    private buildConflictClause;
+    execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
+    returningAll(): Promise<InferSelectModel<T>[]>;
 }
 declare class UpdateQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     private table;
     private updateData;
+    private returningColumns;
     constructor(db: Database, table: T);
     set(data: Partial<InferInsertModel<T>>): this;
-    build(): {
-        sql: string;
-        params: any[];
-    };
-    execute(): Promise<number>;
+    returning(...columns: (keyof T["_"]["columns"])[]): this;
+    private buildUpdateClause;
+    execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
+    returningAll(): Promise<InferSelectModel<T>[]>;
 }
 declare class DeleteQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     private table;
+    private returningColumns;
     constructor(db: Database, table: T);
-    execute(): Promise<number>;
+    returning(...columns: (keyof T["_"]["columns"])[]): this;
+    execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
+    returningAll(): Promise<InferSelectModel<T>[]>;
+}
+declare class WithQueryBuilder {
+    private db;
+    private ctes;
+    constructor(db: Database);
+    with(alias: string, query: {
+        sql: string;
+        params: any[];
+    }): this;
+    select<T extends AnyTable, C extends (keyof T["_"]["columns"])[] | undefined = undefined>(table: T, columns?: C): SelectQueryBuilder<T, C>;
+    insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
+    update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;
+    delete<T extends AnyTable>(table: T): DeleteQueryBuilder<T>;
+    private applyWithClause;
 }
 declare class TauriORM {
     private db;
@@ -138,7 +200,14 @@ declare class TauriORM {
     insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
     update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;
     delete<T extends AnyTable>(table: T): DeleteQueryBuilder<T>;
+    $with(alias: string): {
+        as: (query: {
+            sql: string;
+            params: any[];
+        }) => WithQueryBuilder;
+    };
     transaction<T>(callback: (tx: TauriORM) => Promise<T>): Promise<T>;
+    rollback(): never;
     private ensureSchemaMeta;
     private getSchemaMeta;
     private setSchemaMeta;
@@ -156,5 +225,7 @@ declare const relations: <T extends AnyTable, R extends Record<string, any>>(tab
     one: any;
     many: any;
 }) => R) => R;
+declare const getTableColumns: <T extends AnyTable>(table: T) => Record<string, AnySQLiteColumn>;
+declare const alias: <T extends AnyTable>(table: T, alias: string) => Table<T["_"]["columns"], T["_"]["name"]>;
 
-export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, type ColumnOptions, DeleteQueryBuilder, type InferInsertModel, type InferSelectModel, InsertQueryBuilder, type Mode, type SQLCondition, SQLiteColumn, SelectQueryBuilder, Table, TauriORM, UpdateQueryBuilder, and, blob, boolean, eq, gt, gte, inArray, integer, isNotNull, isNull, like, lt, lte, or, real, relations, sqliteTable, text };
+export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, type ColumnOptions, DeleteQueryBuilder, type InferInsertModel, type InferSelectModel, InsertQueryBuilder, type Mode, type SQLCondition, SQLiteColumn, SelectQueryBuilder, Table, TauriORM, UpdateQueryBuilder, WithQueryBuilder, alias, and, asc, avg, blob, boolean, count, countDistinct, desc, eq, getTableColumns, gt, gte, inArray, integer, isNotNull, isNull, like, lt, lte, max, min, not, or, real, relations, sql, sqliteTable, sum, text };

package/dist/index.d.ts

@@ -38,6 +38,7 @@ declare class SQLiteColumn<TName extends string = string, TType extends ColumnDa
     unique(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
     references<T extends AnyTable, K extends keyof T["_"]["columns"] & string>(ref: T, column: K): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
     $onUpdateFn(fn: () => ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
+    as(alias: string): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
 }
 declare const text: <TName extends string>(name: TName) => SQLiteColumn<TName, "TEXT", "default", false, false, false>;
 declare const integer: <TName extends string, TMode extends Mode = "default">(name: TName, config?: {
@@ -77,6 +78,7 @@ type SQLCondition = {
 declare const eq: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
 declare const and: (...conditions: SQLCondition[]) => SQLCondition;
 declare const or: (...conditions: SQLCondition[]) => SQLCondition;
+declare const not: (condition: SQLCondition) => SQLCondition;
 declare const gt: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
 declare const gte: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
 declare const lt: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
@@ -85,13 +87,35 @@ declare const like: (column: AnySQLiteColumn, pattern: string) => SQLCondition;
 declare const isNull: (column: AnySQLiteColumn) => SQLCondition;
 declare const isNotNull: (column: AnySQLiteColumn) => SQLCondition;
 declare const inArray: <T>(column: AnySQLiteColumn, values: T[]) => SQLCondition;
+declare const asc: (column: AnySQLiteColumn) => {
+    sql: string;
+    params: never[];
+};
+declare const desc: (column: AnySQLiteColumn) => {
+    sql: string;
+    params: never[];
+};
+declare const count: (column?: AnySQLiteColumn) => SQLCondition;
+declare const countDistinct: (column: AnySQLiteColumn) => SQLCondition;
+declare const sum: (column: AnySQLiteColumn) => SQLCondition;
+declare const avg: (column: AnySQLiteColumn) => SQLCondition;
+declare const max: (column: AnySQLiteColumn) => SQLCondition;
+declare const min: (column: AnySQLiteColumn) => SQLCondition;
+declare const sql: <T = unknown>(strings: TemplateStringsArray, ...values: any[]) => {
+    sql: string;
+    params: any[];
+    mapWith?: (value: any) => T;
+};
 declare class BaseQueryBuilder {
     protected db: Database;
     protected query: string;
     protected params: any[];
     constructor(db: Database);
     where(condition: SQLCondition): this;
-    orderBy(column: AnySQLiteColumn, direction?: "ASC" | "DESC"): this;
+    orderBy(column: AnySQLiteColumn | {
+        sql: string;
+        params: any[];
+    }, direction?: "ASC" | "DESC"): this;
     limit(count: number): this;
     offset(count: number): this;
     build(): {
@@ -102,31 +126,69 @@ declare class BaseQueryBuilder {
 declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable["_"]["columns"])[] | undefined = undefined> extends BaseQueryBuilder {
     private table;
     private columns?;
+    private isDistinct;
+    private groupByColumns;
+    private havingCondition;
     constructor(db: Database, table: TTable, columns?: TSelectedColumns | undefined);
+    distinct(): this;
+    groupBy(...columns: AnySQLiteColumn[]): this;
+    having(condition: SQLCondition): this;
     execute(): Promise<TSelectedColumns extends (keyof TTable["_"]["columns"])[] ? Pick<InferSelectModel<TTable>, TSelectedColumns[number]>[] : InferSelectModel<TTable>[]>;
+    all(): Promise<TSelectedColumns extends (keyof TTable["_"]["columns"])[] ? Pick<InferSelectModel<TTable>, TSelectedColumns[number]>[] : InferSelectModel<TTable>[]>;
+    get(): Promise<TSelectedColumns extends (keyof TTable["_"]["columns"])[] ? Pick<InferSelectModel<TTable>, TSelectedColumns[number]> | undefined : InferSelectModel<TTable> | undefined>;
 }
 declare class InsertQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     private table;
     private dataSets;
+    private returningColumns;
+    private onConflictAction;
+    private conflictTarget;
+    private updateSet;
     constructor(db: Database, table: T);
     values(data: Partial<InferInsertModel<T>> | Partial<InferInsertModel<T>>[]): this;
-    execute(): Promise<number>;
+    returning(...columns: (keyof T["_"]["columns"])[]): this;
+    onConflictDoNothing(target?: AnySQLiteColumn | AnySQLiteColumn[]): this;
+    onConflictDoUpdate(config: {
+        target: AnySQLiteColumn | AnySQLiteColumn[];
+        set: Partial<InferInsertModel<T>>;
+    }): this;
+    private processDefaultValues;
+    private buildConflictClause;
+    execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
+    returningAll(): Promise<InferSelectModel<T>[]>;
 }
 declare class UpdateQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     private table;
     private updateData;
+    private returningColumns;
     constructor(db: Database, table: T);
     set(data: Partial<InferInsertModel<T>>): this;
-    build(): {
-        sql: string;
-        params: any[];
-    };
-    execute(): Promise<number>;
+    returning(...columns: (keyof T["_"]["columns"])[]): this;
+    private buildUpdateClause;
+    execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
+    returningAll(): Promise<InferSelectModel<T>[]>;
 }
 declare class DeleteQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     private table;
+    private returningColumns;
     constructor(db: Database, table: T);
-    execute(): Promise<number>;
+    returning(...columns: (keyof T["_"]["columns"])[]): this;
+    execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
+    returningAll(): Promise<InferSelectModel<T>[]>;
+}
+declare class WithQueryBuilder {
+    private db;
+    private ctes;
+    constructor(db: Database);
+    with(alias: string, query: {
+        sql: string;
+        params: any[];
+    }): this;
+    select<T extends AnyTable, C extends (keyof T["_"]["columns"])[] | undefined = undefined>(table: T, columns?: C): SelectQueryBuilder<T, C>;
+    insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
+    update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;
+    delete<T extends AnyTable>(table: T): DeleteQueryBuilder<T>;
+    private applyWithClause;
 }
 declare class TauriORM {
     private db;
@@ -138,7 +200,14 @@ declare class TauriORM {
     insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
     update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;
     delete<T extends AnyTable>(table: T): DeleteQueryBuilder<T>;
+    $with(alias: string): {
+        as: (query: {
+            sql: string;
+            params: any[];
+        }) => WithQueryBuilder;
+    };
     transaction<T>(callback: (tx: TauriORM) => Promise<T>): Promise<T>;
+    rollback(): never;
     private ensureSchemaMeta;
     private getSchemaMeta;
     private setSchemaMeta;
@@ -156,5 +225,7 @@ declare const relations: <T extends AnyTable, R extends Record<string, any>>(tab
     one: any;
     many: any;
 }) => R) => R;
+declare const getTableColumns: <T extends AnyTable>(table: T) => Record<string, AnySQLiteColumn>;
+declare const alias: <T extends AnyTable>(table: T, alias: string) => Table<T["_"]["columns"], T["_"]["name"]>;
 
-export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, type ColumnOptions, DeleteQueryBuilder, type InferInsertModel, type InferSelectModel, InsertQueryBuilder, type Mode, type SQLCondition, SQLiteColumn, SelectQueryBuilder, Table, TauriORM, UpdateQueryBuilder, and, blob, boolean, eq, gt, gte, inArray, integer, isNotNull, isNull, like, lt, lte, or, real, relations, sqliteTable, text };
+export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, type ColumnOptions, DeleteQueryBuilder, type InferInsertModel, type InferSelectModel, InsertQueryBuilder, type Mode, type SQLCondition, SQLiteColumn, SelectQueryBuilder, Table, TauriORM, UpdateQueryBuilder, WithQueryBuilder, alias, and, asc, avg, blob, boolean, count, countDistinct, desc, eq, getTableColumns, gt, gte, inArray, integer, isNotNull, isNull, like, lt, lte, max, min, not, or, real, relations, sql, sqliteTable, sum, text };

package/dist/index.js

@@ -7,11 +7,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
+var __copyProps = (to, from, except, desc2) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
   }
   return to;
 };
@@ -27,10 +27,18 @@ __export(index_exports, {
   Table: () => Table,
   TauriORM: () => TauriORM,
   UpdateQueryBuilder: () => UpdateQueryBuilder,
+  WithQueryBuilder: () => WithQueryBuilder,
+  alias: () => alias,
   and: () => and,
+  asc: () => asc,
+  avg: () => avg,
   blob: () => blob,
   boolean: () => boolean,
+  count: () => count,
+  countDistinct: () => countDistinct,
+  desc: () => desc,
   eq: () => eq,
+  getTableColumns: () => getTableColumns,
   gt: () => gt,
   gte: () => gte,
   inArray: () => inArray,
@@ -40,10 +48,15 @@ __export(index_exports, {
   like: () => like,
   lt: () => lt,
   lte: () => lte,
+  max: () => max,
+  min: () => min,
+  not: () => not,
   or: () => or,
   real: () => real,
   relations: () => relations,
+  sql: () => sql,
   sqliteTable: () => sqliteTable,
+  sum: () => sum,
   text: () => text
 });
 module.exports = __toCommonJS(index_exports);
@@ -133,6 +146,9 @@ var SQLiteColumn = class _SQLiteColumn {
       this._.mode
     );
   }
+  as(alias2) {
+    return this;
+  }
 };
 var text = (name) => new SQLiteColumn(name, "TEXT");
 var integer = (name, config) => new SQLiteColumn(name, "INTEGER", {}, config?.mode || "default");
@@ -163,6 +179,10 @@ var or = (...conditions) => ({
   sql: conditions.map((c) => `(${c.sql})`).join(" OR "),
   params: conditions.flatMap((c) => c.params)
 });
+var not = (condition) => ({
+  sql: `NOT (${condition.sql})`,
+  params: condition.params
+});
 var gt = (column, value) => ({
   sql: `${column._.name} > ?`,
   params: [value]
@@ -195,6 +215,58 @@ var inArray = (column, values) => ({
   sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
   params: values
 });
+var asc = (column) => ({
+  sql: `${column._.name} ASC`,
+  params: []
+});
+var desc = (column) => ({
+  sql: `${column._.name} DESC`,
+  params: []
+});
+var count = (column) => ({
+  sql: `COUNT(${column ? column._.name : "*"})`,
+  params: []
+});
+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 sql = (strings, ...values) => {
+  const queryParts = [];
+  const params = [];
+  strings.forEach((str, i) => {
+    queryParts.push(str);
+    if (values[i] !== void 0) {
+      if (typeof values[i] === "object" && values[i].sql) {
+        queryParts.push(values[i].sql);
+        params.push(...values[i].params);
+      } else {
+        queryParts.push("?");
+        params.push(values[i]);
+      }
+    }
+  });
+  return {
+    sql: queryParts.join(""),
+    params
+  };
+};
 var BaseQueryBuilder = class {
   constructor(db) {
     this.db = db;
@@ -207,15 +279,20 @@ var BaseQueryBuilder = class {
     return this;
   }
   orderBy(column, direction = "ASC") {
-    this.query += ` ORDER BY ${column._.name} ${direction}`;
+    if ("sql" in column) {
+      this.query += ` ORDER BY ${column.sql} ${direction}`;
+      this.params.push(...column.params);
+    } else {
+      this.query += ` ORDER BY ${column._.name} ${direction}`;
+    }
     return this;
   }
-  limit(count) {
-    this.query += ` LIMIT ${count}`;
+  limit(count2) {
+    this.query += ` LIMIT ${count2}`;
     return this;
   }
-  offset(count) {
-    this.query += ` OFFSET ${count}`;
+  offset(count2) {
+    this.query += ` OFFSET ${count2}`;
     return this;
   }
   build() {
@@ -233,9 +310,37 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     const columnNames = columns ? columns.map((c) => table._.columns[c]._.name) : ["*"];
     this.query = `SELECT ${columnNames.join(", ")} FROM ${table._.name}`;
   }
+  isDistinct = false;
+  groupByColumns = [];
+  havingCondition = null;
+  distinct() {
+    this.isDistinct = true;
+    this.query = this.query.replace("SELECT", "SELECT DISTINCT");
+    return this;
+  }
+  groupBy(...columns) {
+    this.groupByColumns.push(...columns);
+    const columnNames = columns.map((col) => col._.name).join(", ");
+    this.query += ` GROUP BY ${columnNames}`;
+    return this;
+  }
+  having(condition) {
+    this.havingCondition = condition;
+    this.query += ` HAVING ${condition.sql}`;
+    this.params.push(...condition.params);
+    return this;
+  }
   async execute() {
-    const { sql, params } = this.build();
-    return this.db.select(sql, params);
+    const { sql: sql2, params } = this.build();
+    return this.db.select(sql2, params);
+  }
+  async all() {
+    return this.execute();
+  }
+  async get() {
+    this.limit(1);
+    const result = await this.execute();
+    return result[0];
   }
 };
 var InsertQueryBuilder = class extends BaseQueryBuilder {
@@ -245,26 +350,69 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
     this.query = `INSERT INTO ${table._.name}`;
   }
   dataSets = [];
+  returningColumns = [];
+  onConflictAction = null;
+  conflictTarget = [];
+  updateSet = {};
   values(data) {
     const dataArray = Array.isArray(data) ? data : [data];
     this.dataSets.push(...dataArray);
     return this;
   }
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
+  onConflictDoNothing(target) {
+    this.onConflictAction = "nothing";
+    if (target) {
+      this.conflictTarget = Array.isArray(target) ? target : [target];
+    }
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    this.onConflictAction = "update";
+    this.conflictTarget = Array.isArray(config.target) ? config.target : [config.target];
+    this.updateSet = config.set;
+    return this;
+  }
+  processDefaultValues(data) {
+    const finalData = { ...data };
+    for (const [key, column] of Object.entries(this.table._.columns)) {
+      const typedKey = key;
+      if (finalData[typedKey] === void 0) {
+        if (column.options.$defaultFn) {
+          finalData[typedKey] = column.options.$defaultFn();
+        }
+      }
+    }
+    return finalData;
+  }
+  buildConflictClause() {
+    if (!this.onConflictAction) return "";
+    let clause = " ON CONFLICT";
+    if (this.conflictTarget.length > 0) {
+      const targetNames = this.conflictTarget.map((col) => col._.name).join(", ");
+      clause += ` (${targetNames})`;
+    }
+    if (this.onConflictAction === "nothing") {
+      clause += " DO NOTHING";
+    } else if (this.onConflictAction === "update") {
+      const setEntries = Object.entries(this.updateSet);
+      if (setEntries.length > 0) {
+        const setClause = setEntries.map(([key]) => `${key} = ?`).join(", ");
+        clause += ` DO UPDATE SET ${setClause}`;
+      }
+    }
+    return clause;
+  }
   async execute() {
     if (this.dataSets.length === 0) {
       throw new Error("No data provided for insert");
     }
-    const processedDataSets = this.dataSets.map((dataSet) => {
-      const finalData = { ...dataSet };
-      for (const [key, column] of Object.entries(this.table._.columns)) {
-        if (finalData[key] === void 0) {
-          if (column.options.$defaultFn) {
-            finalData[key] = column.options.$defaultFn();
-          }
-        }
-      }
-      return finalData;
-    });
+    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(",");
@@ -273,7 +421,9 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
       }
       groups.get(keys).push(dataSet);
     }
-    let lastInsertId = void 0;
+    let results = [];
+    let lastInsertId;
+    let rowsAffected = 0;
     for (const [_, dataSets] of groups) {
       const columns = Object.keys(dataSets[0]);
       const columnNames = columns.map(
@@ -281,16 +431,40 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
       );
       const placeholders = `(${columns.map(() => "?").join(", ")})`;
       const valuesSql = dataSets.map(() => placeholders).join(", ");
+      const conflictClause = this.buildConflictClause();
       const finalQuery = `${this.query} (${columnNames.join(
         ", "
-      )}) VALUES ${valuesSql}`;
+      )}) VALUES ${valuesSql}${conflictClause}`;
       const params = dataSets.flatMap(
         (data) => columns.map((col) => data[col] ?? null)
       );
-      const result = await this.db.execute(finalQuery, params);
-      lastInsertId = result.lastInsertId;
+      if (this.onConflictAction === "update") {
+        const setValues = Object.entries(this.updateSet).map(
+          ([, value]) => value
+        );
+        params.push(...setValues);
+      }
+      if (this.returningColumns.length > 0) {
+        const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+        const queryWithReturning = `${finalQuery} RETURNING ${returningNames}`;
+        const rows = await this.db.select(queryWithReturning, params);
+        results = results.concat(rows);
+      } else {
+        const result = await this.db.execute(finalQuery, params);
+        lastInsertId = result.lastInsertId;
+        rowsAffected += result.rowsAffected;
+      }
+    }
+    if (this.returningColumns.length > 0) {
+      return results;
     }
-    return lastInsertId ?? 0;
+    return [{ lastInsertId, rowsAffected }];
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
   }
 };
 var UpdateQueryBuilder = class extends BaseQueryBuilder {
@@ -300,15 +474,21 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
     this.query = `UPDATE ${table._.name}`;
   }
   updateData = {};
+  returningColumns = [];
   set(data) {
     this.updateData = { ...this.updateData, ...data };
     return this;
   }
-  build() {
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
+  buildUpdateClause() {
     const finalUpdateData = { ...this.updateData };
     for (const [key, column] of Object.entries(this.table._.columns)) {
-      if (finalUpdateData[key] === void 0 && column.options.$onUpdateFn) {
-        finalUpdateData[key] = column.options.$onUpdateFn();
+      const typedKey = key;
+      if (finalUpdateData[typedKey] === void 0 && column.options.$onUpdateFn) {
+        finalUpdateData[typedKey] = column.options.$onUpdateFn();
       }
     }
     const baseQuery = this.query;
@@ -334,14 +514,26 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
       return `${column._.name} = ?`;
     }).join(", ");
     const setParams = entries.map(([, value]) => value);
-    const sql = `${tablePart} SET ${setClause}${whereClause}`;
+    const sql2 = `${tablePart} SET ${setClause}${whereClause}`;
     const params = [...setParams, ...whereParams];
-    return { sql, params };
+    return { sql: sql2, params };
   }
   async execute() {
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
+    const { sql: updateSql, params } = this.buildUpdateClause();
+    if (this.returningColumns.length > 0) {
+      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+      const sqlWithReturning = `${updateSql} RETURNING ${returningNames}`;
+      return this.db.select(sqlWithReturning, params);
+    } else {
+      const result = await this.db.execute(updateSql, params);
+      return [{ rowsAffected: result.rowsAffected }];
+    }
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
   }
 };
 var DeleteQueryBuilder = class extends BaseQueryBuilder {
@@ -350,10 +542,67 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
     this.table = table;
     this.query = `DELETE FROM ${table._.name}`;
   }
+  returningColumns = [];
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
   async execute() {
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
+    const { sql: sql2, params } = this.build();
+    if (this.returningColumns.length > 0) {
+      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+      const sqlWithReturning = `${sql2} RETURNING ${returningNames}`;
+      return this.db.select(sqlWithReturning, params);
+    } else {
+      const result = await this.db.execute(sql2, params);
+      return [{ rowsAffected: result.rowsAffected }];
+    }
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
+  }
+};
+var WithQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
+  }
+  ctes = [];
+  with(alias2, query) {
+    this.ctes.push({ alias: alias2, query: query.sql, params: query.params });
+    return this;
+  }
+  select(table, columns) {
+    const builder = new SelectQueryBuilder(this.db, table, columns);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  insert(table) {
+    const builder = new InsertQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  update(table) {
+    const builder = new UpdateQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  delete(table) {
+    const builder = new DeleteQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  applyWithClause(builder) {
+    if (this.ctes.length > 0) {
+      const cteSql = this.ctes.map((cte) => `${cte.alias} AS (${cte.query})`).join(", ");
+      builder["query"] = `WITH ${cteSql} ${builder["query"]}`;
+      builder["params"] = [
+        ...this.ctes.flatMap((cte) => cte.params),
+        ...builder["params"]
+      ];
+    }
   }
 };
 var TauriORM = class {
@@ -367,23 +616,23 @@ var TauriORM = class {
   }
   tables = /* @__PURE__ */ new Map();
   buildColumnDefinition(col, forAlterTable = false) {
-    let sql = `${col._.name} ${col.type}`;
+    let sql2 = `${col._.name} ${col.type}`;
     if (col.options.primaryKey && !forAlterTable) {
-      sql += " PRIMARY KEY";
+      sql2 += " PRIMARY KEY";
       if (col._.autoincrement) {
-        sql += " AUTOINCREMENT";
+        sql2 += " AUTOINCREMENT";
       }
     }
-    if (col._.notNull) sql += " NOT NULL";
-    if (col.options.unique) sql += " UNIQUE";
+    if (col._.notNull) sql2 += " NOT NULL";
+    if (col.options.unique) sql2 += " UNIQUE";
     if (col.options.default !== void 0) {
       const value = col.options.default;
-      sql += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
+      sql2 += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
     }
     if (col.options.references) {
-      sql += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+      sql2 += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
     }
-    return sql;
+    return sql2;
   }
   async migrate() {
     for (const table of this.tables.values()) {
@@ -420,6 +669,15 @@ var TauriORM = class {
   delete(table) {
     return new DeleteQueryBuilder(this.db, table);
   }
+  $with(alias2) {
+    const withBuilder = new WithQueryBuilder(this.db);
+    return {
+      as: (query) => {
+        withBuilder.with(alias2, query);
+        return withBuilder;
+      }
+    };
+  }
   async transaction(callback) {
     await this.db.execute("BEGIN TRANSACTION");
     try {
@@ -431,6 +689,9 @@ var TauriORM = class {
       throw error;
     }
   }
+  rollback() {
+    throw new Error("Transaction rolled back");
+  }
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
@@ -508,6 +769,12 @@ var relations = (table, relationsCallback) => {
     })
   });
 };
+var getTableColumns = (table) => {
+  return table._.columns;
+};
+var alias = (table, alias2) => {
+  return table;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DeleteQueryBuilder,
@@ -517,10 +784,18 @@ var relations = (table, relationsCallback) => {
   Table,
   TauriORM,
   UpdateQueryBuilder,
+  WithQueryBuilder,
+  alias,
   and,
+  asc,
+  avg,
   blob,
   boolean,
+  count,
+  countDistinct,
+  desc,
   eq,
+  getTableColumns,
   gt,
   gte,
   inArray,
@@ -530,9 +805,14 @@ var relations = (table, relationsCallback) => {
   like,
   lt,
   lte,
+  max,
+  min,
+  not,
   or,
   real,
   relations,
+  sql,
   sqliteTable,
+  sum,
   text
 });

package/dist/index.mjs

@@ -83,6 +83,9 @@ var SQLiteColumn = class _SQLiteColumn {
       this._.mode
     );
   }
+  as(alias2) {
+    return this;
+  }
 };
 var text = (name) => new SQLiteColumn(name, "TEXT");
 var integer = (name, config) => new SQLiteColumn(name, "INTEGER", {}, config?.mode || "default");
@@ -113,6 +116,10 @@ var or = (...conditions) => ({
   sql: conditions.map((c) => `(${c.sql})`).join(" OR "),
   params: conditions.flatMap((c) => c.params)
 });
+var not = (condition) => ({
+  sql: `NOT (${condition.sql})`,
+  params: condition.params
+});
 var gt = (column, value) => ({
   sql: `${column._.name} > ?`,
   params: [value]
@@ -145,6 +152,58 @@ var inArray = (column, values) => ({
   sql: `${column._.name} IN (${values.map(() => "?").join(",")})`,
   params: values
 });
+var asc = (column) => ({
+  sql: `${column._.name} ASC`,
+  params: []
+});
+var desc = (column) => ({
+  sql: `${column._.name} DESC`,
+  params: []
+});
+var count = (column) => ({
+  sql: `COUNT(${column ? column._.name : "*"})`,
+  params: []
+});
+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 sql = (strings, ...values) => {
+  const queryParts = [];
+  const params = [];
+  strings.forEach((str, i) => {
+    queryParts.push(str);
+    if (values[i] !== void 0) {
+      if (typeof values[i] === "object" && values[i].sql) {
+        queryParts.push(values[i].sql);
+        params.push(...values[i].params);
+      } else {
+        queryParts.push("?");
+        params.push(values[i]);
+      }
+    }
+  });
+  return {
+    sql: queryParts.join(""),
+    params
+  };
+};
 var BaseQueryBuilder = class {
   constructor(db) {
     this.db = db;
@@ -157,15 +216,20 @@ var BaseQueryBuilder = class {
     return this;
   }
   orderBy(column, direction = "ASC") {
-    this.query += ` ORDER BY ${column._.name} ${direction}`;
+    if ("sql" in column) {
+      this.query += ` ORDER BY ${column.sql} ${direction}`;
+      this.params.push(...column.params);
+    } else {
+      this.query += ` ORDER BY ${column._.name} ${direction}`;
+    }
     return this;
   }
-  limit(count) {
-    this.query += ` LIMIT ${count}`;
+  limit(count2) {
+    this.query += ` LIMIT ${count2}`;
     return this;
   }
-  offset(count) {
-    this.query += ` OFFSET ${count}`;
+  offset(count2) {
+    this.query += ` OFFSET ${count2}`;
     return this;
   }
   build() {
@@ -183,9 +247,37 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
     const columnNames = columns ? columns.map((c) => table._.columns[c]._.name) : ["*"];
     this.query = `SELECT ${columnNames.join(", ")} FROM ${table._.name}`;
   }
+  isDistinct = false;
+  groupByColumns = [];
+  havingCondition = null;
+  distinct() {
+    this.isDistinct = true;
+    this.query = this.query.replace("SELECT", "SELECT DISTINCT");
+    return this;
+  }
+  groupBy(...columns) {
+    this.groupByColumns.push(...columns);
+    const columnNames = columns.map((col) => col._.name).join(", ");
+    this.query += ` GROUP BY ${columnNames}`;
+    return this;
+  }
+  having(condition) {
+    this.havingCondition = condition;
+    this.query += ` HAVING ${condition.sql}`;
+    this.params.push(...condition.params);
+    return this;
+  }
   async execute() {
-    const { sql, params } = this.build();
-    return this.db.select(sql, params);
+    const { sql: sql2, params } = this.build();
+    return this.db.select(sql2, params);
+  }
+  async all() {
+    return this.execute();
+  }
+  async get() {
+    this.limit(1);
+    const result = await this.execute();
+    return result[0];
   }
 };
 var InsertQueryBuilder = class extends BaseQueryBuilder {
@@ -195,26 +287,69 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
     this.query = `INSERT INTO ${table._.name}`;
   }
   dataSets = [];
+  returningColumns = [];
+  onConflictAction = null;
+  conflictTarget = [];
+  updateSet = {};
   values(data) {
     const dataArray = Array.isArray(data) ? data : [data];
     this.dataSets.push(...dataArray);
     return this;
   }
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
+  onConflictDoNothing(target) {
+    this.onConflictAction = "nothing";
+    if (target) {
+      this.conflictTarget = Array.isArray(target) ? target : [target];
+    }
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    this.onConflictAction = "update";
+    this.conflictTarget = Array.isArray(config.target) ? config.target : [config.target];
+    this.updateSet = config.set;
+    return this;
+  }
+  processDefaultValues(data) {
+    const finalData = { ...data };
+    for (const [key, column] of Object.entries(this.table._.columns)) {
+      const typedKey = key;
+      if (finalData[typedKey] === void 0) {
+        if (column.options.$defaultFn) {
+          finalData[typedKey] = column.options.$defaultFn();
+        }
+      }
+    }
+    return finalData;
+  }
+  buildConflictClause() {
+    if (!this.onConflictAction) return "";
+    let clause = " ON CONFLICT";
+    if (this.conflictTarget.length > 0) {
+      const targetNames = this.conflictTarget.map((col) => col._.name).join(", ");
+      clause += ` (${targetNames})`;
+    }
+    if (this.onConflictAction === "nothing") {
+      clause += " DO NOTHING";
+    } else if (this.onConflictAction === "update") {
+      const setEntries = Object.entries(this.updateSet);
+      if (setEntries.length > 0) {
+        const setClause = setEntries.map(([key]) => `${key} = ?`).join(", ");
+        clause += ` DO UPDATE SET ${setClause}`;
+      }
+    }
+    return clause;
+  }
   async execute() {
     if (this.dataSets.length === 0) {
       throw new Error("No data provided for insert");
     }
-    const processedDataSets = this.dataSets.map((dataSet) => {
-      const finalData = { ...dataSet };
-      for (const [key, column] of Object.entries(this.table._.columns)) {
-        if (finalData[key] === void 0) {
-          if (column.options.$defaultFn) {
-            finalData[key] = column.options.$defaultFn();
-          }
-        }
-      }
-      return finalData;
-    });
+    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(",");
@@ -223,7 +358,9 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
       }
       groups.get(keys).push(dataSet);
     }
-    let lastInsertId = void 0;
+    let results = [];
+    let lastInsertId;
+    let rowsAffected = 0;
     for (const [_, dataSets] of groups) {
       const columns = Object.keys(dataSets[0]);
       const columnNames = columns.map(
@@ -231,16 +368,40 @@ var InsertQueryBuilder = class extends BaseQueryBuilder {
       );
       const placeholders = `(${columns.map(() => "?").join(", ")})`;
       const valuesSql = dataSets.map(() => placeholders).join(", ");
+      const conflictClause = this.buildConflictClause();
       const finalQuery = `${this.query} (${columnNames.join(
         ", "
-      )}) VALUES ${valuesSql}`;
+      )}) VALUES ${valuesSql}${conflictClause}`;
       const params = dataSets.flatMap(
         (data) => columns.map((col) => data[col] ?? null)
       );
-      const result = await this.db.execute(finalQuery, params);
-      lastInsertId = result.lastInsertId;
+      if (this.onConflictAction === "update") {
+        const setValues = Object.entries(this.updateSet).map(
+          ([, value]) => value
+        );
+        params.push(...setValues);
+      }
+      if (this.returningColumns.length > 0) {
+        const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+        const queryWithReturning = `${finalQuery} RETURNING ${returningNames}`;
+        const rows = await this.db.select(queryWithReturning, params);
+        results = results.concat(rows);
+      } else {
+        const result = await this.db.execute(finalQuery, params);
+        lastInsertId = result.lastInsertId;
+        rowsAffected += result.rowsAffected;
+      }
+    }
+    if (this.returningColumns.length > 0) {
+      return results;
     }
-    return lastInsertId ?? 0;
+    return [{ lastInsertId, rowsAffected }];
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
   }
 };
 var UpdateQueryBuilder = class extends BaseQueryBuilder {
@@ -250,15 +411,21 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
     this.query = `UPDATE ${table._.name}`;
   }
   updateData = {};
+  returningColumns = [];
   set(data) {
     this.updateData = { ...this.updateData, ...data };
     return this;
   }
-  build() {
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
+  buildUpdateClause() {
     const finalUpdateData = { ...this.updateData };
     for (const [key, column] of Object.entries(this.table._.columns)) {
-      if (finalUpdateData[key] === void 0 && column.options.$onUpdateFn) {
-        finalUpdateData[key] = column.options.$onUpdateFn();
+      const typedKey = key;
+      if (finalUpdateData[typedKey] === void 0 && column.options.$onUpdateFn) {
+        finalUpdateData[typedKey] = column.options.$onUpdateFn();
       }
     }
     const baseQuery = this.query;
@@ -284,14 +451,26 @@ var UpdateQueryBuilder = class extends BaseQueryBuilder {
       return `${column._.name} = ?`;
     }).join(", ");
     const setParams = entries.map(([, value]) => value);
-    const sql = `${tablePart} SET ${setClause}${whereClause}`;
+    const sql2 = `${tablePart} SET ${setClause}${whereClause}`;
     const params = [...setParams, ...whereParams];
-    return { sql, params };
+    return { sql: sql2, params };
   }
   async execute() {
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
+    const { sql: updateSql, params } = this.buildUpdateClause();
+    if (this.returningColumns.length > 0) {
+      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+      const sqlWithReturning = `${updateSql} RETURNING ${returningNames}`;
+      return this.db.select(sqlWithReturning, params);
+    } else {
+      const result = await this.db.execute(updateSql, params);
+      return [{ rowsAffected: result.rowsAffected }];
+    }
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
   }
 };
 var DeleteQueryBuilder = class extends BaseQueryBuilder {
@@ -300,10 +479,67 @@ var DeleteQueryBuilder = class extends BaseQueryBuilder {
     this.table = table;
     this.query = `DELETE FROM ${table._.name}`;
   }
+  returningColumns = [];
+  returning(...columns) {
+    this.returningColumns = columns;
+    return this;
+  }
   async execute() {
-    const { sql, params } = this.build();
-    const result = await this.db.execute(sql, params);
-    return result.rowsAffected;
+    const { sql: sql2, params } = this.build();
+    if (this.returningColumns.length > 0) {
+      const returningNames = this.returningColumns.map((col) => this.table._.columns[col]._.name).join(", ");
+      const sqlWithReturning = `${sql2} RETURNING ${returningNames}`;
+      return this.db.select(sqlWithReturning, params);
+    } else {
+      const result = await this.db.execute(sql2, params);
+      return [{ rowsAffected: result.rowsAffected }];
+    }
+  }
+  async returningAll() {
+    const allColumns = Object.keys(
+      this.table._.columns
+    );
+    return this.returning(...allColumns).execute();
+  }
+};
+var WithQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
+  }
+  ctes = [];
+  with(alias2, query) {
+    this.ctes.push({ alias: alias2, query: query.sql, params: query.params });
+    return this;
+  }
+  select(table, columns) {
+    const builder = new SelectQueryBuilder(this.db, table, columns);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  insert(table) {
+    const builder = new InsertQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  update(table) {
+    const builder = new UpdateQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  delete(table) {
+    const builder = new DeleteQueryBuilder(this.db, table);
+    this.applyWithClause(builder);
+    return builder;
+  }
+  applyWithClause(builder) {
+    if (this.ctes.length > 0) {
+      const cteSql = this.ctes.map((cte) => `${cte.alias} AS (${cte.query})`).join(", ");
+      builder["query"] = `WITH ${cteSql} ${builder["query"]}`;
+      builder["params"] = [
+        ...this.ctes.flatMap((cte) => cte.params),
+        ...builder["params"]
+      ];
+    }
   }
 };
 var TauriORM = class {
@@ -317,23 +553,23 @@ var TauriORM = class {
   }
   tables = /* @__PURE__ */ new Map();
   buildColumnDefinition(col, forAlterTable = false) {
-    let sql = `${col._.name} ${col.type}`;
+    let sql2 = `${col._.name} ${col.type}`;
     if (col.options.primaryKey && !forAlterTable) {
-      sql += " PRIMARY KEY";
+      sql2 += " PRIMARY KEY";
       if (col._.autoincrement) {
-        sql += " AUTOINCREMENT";
+        sql2 += " AUTOINCREMENT";
       }
     }
-    if (col._.notNull) sql += " NOT NULL";
-    if (col.options.unique) sql += " UNIQUE";
+    if (col._.notNull) sql2 += " NOT NULL";
+    if (col.options.unique) sql2 += " UNIQUE";
     if (col.options.default !== void 0) {
       const value = col.options.default;
-      sql += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
+      sql2 += ` DEFAULT ${typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value}`;
     }
     if (col.options.references) {
-      sql += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+      sql2 += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
     }
-    return sql;
+    return sql2;
   }
   async migrate() {
     for (const table of this.tables.values()) {
@@ -370,6 +606,15 @@ var TauriORM = class {
   delete(table) {
     return new DeleteQueryBuilder(this.db, table);
   }
+  $with(alias2) {
+    const withBuilder = new WithQueryBuilder(this.db);
+    return {
+      as: (query) => {
+        withBuilder.with(alias2, query);
+        return withBuilder;
+      }
+    };
+  }
   async transaction(callback) {
     await this.db.execute("BEGIN TRANSACTION");
     try {
@@ -381,6 +626,9 @@ var TauriORM = class {
       throw error;
     }
   }
+  rollback() {
+    throw new Error("Transaction rolled back");
+  }
   // --- Schema detection / signature ---
   async ensureSchemaMeta() {
     await this.db.execute(
@@ -458,6 +706,12 @@ var relations = (table, relationsCallback) => {
     })
   });
 };
+var getTableColumns = (table) => {
+  return table._.columns;
+};
+var alias = (table, alias2) => {
+  return table;
+};
 export {
   DeleteQueryBuilder,
   InsertQueryBuilder,
@@ -466,10 +720,18 @@ export {
   Table,
   TauriORM,
   UpdateQueryBuilder,
+  WithQueryBuilder,
+  alias,
   and,
+  asc,
+  avg,
   blob,
   boolean,
+  count,
+  countDistinct,
+  desc,
   eq,
+  getTableColumns,
   gt,
   gte,
   inArray,
@@ -479,9 +741,14 @@ export {
   like,
   lt,
   lte,
+  max,
+  min,
+  not,
   or,
   real,
   relations,
+  sql,
   sqliteTable,
+  sum,
   text
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@type32/tauri-sqlite-orm",
-  "version": "0.1.18-5",
+  "version": "0.1.18-6",
   "description": "A Drizzle-like ORM for Tauri v2's SQL JS API plugin.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",