@type32/tauri-sqlite-orm 0.2.12 → 0.2.15

package/README.md

@@ -7,7 +7,7 @@ A Drizzle-like TypeScript ORM tailored for Tauri v2's `@tauri-apps/plugin-sql` (
 - **Drizzle-like Schema:** Define your database schema using a familiar, chainable API.
 - **Strict Type Inference:** Full TypeScript type safety with no `any` types - nullable columns, custom types, and required/optional fields are accurately inferred.
 - **Type-Safe Query Builder:** Build SQL queries with TypeScript, ensuring type safety and autocompletion.
-- **Relations Support:** Define and query one-to-one, one-to-many, and many-to-many relationships between tables.
+- **Relations Support:** Define and query one-to-one, one-to-many, and many-to-many (via junction tables, Drizzle-style) relationships between tables.
 - **Nested Includes:** Load relations of relations with intuitive nested syntax.
 - **Advanced Operators:** Comprehensive set of operators including `ne`, `between`, `notIn`, `ilike`, `startsWith`, `endsWith`, `contains`, and more.
 - **Subquery Support:** Use subqueries in WHERE and SELECT clauses with full type safety.
@@ -16,6 +16,7 @@ A Drizzle-like TypeScript ORM tailored for Tauri v2's `@tauri-apps/plugin-sql` (
 - **Safety Features:** Automatic WHERE clause validation for UPDATE/DELETE prevents accidental data loss.
 - **Increment/Decrement:** Atomic increment/decrement operations for safe counter updates.
 - **Better Error Handling:** Custom error classes for clear, actionable error messages.
+- **Cascade Actions:** `onDelete` and `onUpdate` (cascade, set null, set default, restrict, no action) for foreign key references.
 - **Simplified Migrations:** Keep your database schema in sync with your application's models using automatic schema detection and migration tools.
 - **Lightweight & Performant:** Designed to be a thin layer over the Tauri SQL plugin, ensuring minimal overhead.
 
@@ -33,20 +34,20 @@ Make sure the SQL plugin is registered on the Rust side (see Tauri docs).
 
 ```typescript
 import Database from '@tauri-apps/plugin-sql'
-import { TauriORM, sqliteTable, int, text, relations } from '@type32/tauri-sqlite-orm'
+import { TauriORM, sqliteTable, integer, text, relations, InferSelectModel, InferRelationalSelectModel } from '@type32/tauri-sqlite-orm'
 
 // Define tables
 const users = sqliteTable('users', {
-  id: int('id').primaryKey().autoincrement(),
+  id: integer('id').primaryKey().autoincrement(),
   name: text('name').notNull(),
   email: text('email').notNull().unique(),
 })
 
 const posts = sqliteTable('posts', {
-  id: int('id').primaryKey().autoincrement(),
+  id: integer('id').primaryKey().autoincrement(),
   title: text('title').notNull(),
   content: text('content').notNull(),
-  userId: int('user_id').notNull().references(users, 'id'),
+  userId: integer('user_id').notNull().references(users, users._.columns.id, { onDelete: 'cascade' }),
 })
 
 // Define relations
@@ -78,6 +79,11 @@ const usersWithPosts = await orm
   .select(users)
   .include({ posts: true })
   .all()
+
+// Type relational results with InferRelationalSelectModel
+type User = InferSelectModel<typeof users>
+const withPosts = { posts: true } as const
+type UserWithPosts = InferRelationalSelectModel<typeof users, typeof usersRelations, typeof withPosts>
 ```
 
 ### Documentation
@@ -88,10 +94,10 @@ const usersWithPosts = await orm
 
 ### Relations
 
-The ORM supports three types of relations:
+The ORM supports relations in a Drizzle-style pattern:
 
-1. **One-to-One / Many-to-One**: Use `one()` to define a relation where the current table references another table
+1. **One-to-One / Many-to-One**: Use `one()` with `fields` and `references` to define a relation where the current table references another table
 2. **One-to-Many**: Use `many()` to define a relation where another table references the current table
-3. **Many-to-Many**: Use `manyToMany()` to define a many-to-many relation through a junction table
+3. **Many-to-Many**: Use `many(junctionTable)` on both sides and define `one()` on the junction with `fields`/`references` to each entity. Load with nested includes: `include({ postTags: { with: { tag: true } } })`
 
 See the [many-to-many example](./docs/many-to-many-example.md) for detailed usage.

package/dist/index.d.mts

@@ -1,4 +1,26 @@
-import Database from '@tauri-apps/plugin-sql';
+import { Dialect, DialectAdapter, Driver, Kysely, DatabaseIntrospector, QueryCompiler, Expression, SqlBool } from 'kysely';
+export { Expression, sql } from 'kysely';
+
+/**
+ * Minimal interface that any SQLite-over-Tauri (or compatible mock) database must satisfy.
+ * Using this instead of the concrete `@tauri-apps/plugin-sql` type keeps the dialect
+ * portable and testable outside a Tauri runtime.
+ */
+interface DatabaseLike {
+    select<T>(query: string, params?: any[]): Promise<T>;
+    execute(query: string, params?: any[]): Promise<{
+        lastInsertId: number;
+        rowsAffected: number;
+    }>;
+}
+declare class TauriDialect implements Dialect {
+    private readonly db;
+    constructor(db: DatabaseLike);
+    createAdapter(): DialectAdapter;
+    createDriver(): Driver;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+    createQueryCompiler(): QueryCompiler;
+}
 
 type ColumnDataType = 'TEXT' | 'INTEGER' | 'REAL' | 'BLOB' | 'BOOLEAN' | 'NUMERIC';
 type Mode = 'default' | 'timestamp' | 'timestamp_ms' | 'json' | 'boolean' | 'bigint';
@@ -13,6 +35,8 @@ interface ColumnOptions<TData, TEnum extends readonly string[] = readonly string
     references?: {
         table: AnyTable;
         column: AnySQLiteColumn;
+        onDelete?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
+        onUpdate?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
     };
     mode?: Mode;
     $onUpdateFn?: () => TData;
@@ -28,69 +52,77 @@ type AnyTable = Table<Record<string, AnySQLiteColumn>, string>;
 type InferSelectModel<T extends AnyTable> = {
     [K in keyof T['_']['columns']]: ExtractColumnType<T['_']['columns'][K]>;
 };
-type RelationType = 'one' | 'many' | 'manyToMany';
+type RelationType = 'one' | 'many';
 interface RelationConfig {
     type: RelationType;
     foreignTable: AnyTable;
     fields?: AnySQLiteColumn[];
     references?: AnySQLiteColumn[];
-    junctionTable?: AnyTable;
-    junctionFields?: AnySQLiteColumn[];
-    junctionReferences?: AnySQLiteColumn[];
 }
 
-declare class BaseQueryBuilder {
-    protected db: Database;
-    protected query: string;
-    protected params: any[];
-    constructor(db: Database);
-    where(condition: SQLCondition): this;
-    orderBy(column: AnySQLiteColumn | {
-        sql: string;
-        params: any[];
-    }, direction?: "ASC" | "DESC"): this;
-    limit(count: number): this;
-    offset(count: number): this;
-    build(): {
-        sql: string;
-        params: any[];
-    };
-    toSQL(): {
-        sql: string;
-        params: any[];
-    };
-}
+type Condition = Expression<SqlBool>;
+declare const eq: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => Condition;
+declare const ne: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => Condition;
+declare const and: (...conditions: Condition[]) => Condition;
+declare const or: (...conditions: Condition[]) => Condition;
+declare const not: (condition: Condition) => Condition;
+declare const gt: <T>(column: AnySQLiteColumn, value: T) => Condition;
+declare const gte: <T>(column: AnySQLiteColumn, value: T) => Condition;
+declare const lt: <T>(column: AnySQLiteColumn, value: T) => Condition;
+declare const lte: <T>(column: AnySQLiteColumn, value: T) => Condition;
+declare const like: (column: AnySQLiteColumn, pattern: string) => Condition;
+declare const ilike: (column: AnySQLiteColumn, pattern: string) => Condition;
+declare const startsWith: (column: AnySQLiteColumn, value: string) => Condition;
+declare const endsWith: (column: AnySQLiteColumn, value: string) => Condition;
+declare const contains: (column: AnySQLiteColumn, value: string) => Condition;
+declare const isNull: (column: AnySQLiteColumn) => Condition;
+declare const isNotNull: (column: AnySQLiteColumn) => Condition;
+declare const exists: (subquery: Expression<any>) => Condition;
+declare const notExists: (subquery: Expression<any>) => Condition;
+declare const eqSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+declare const neSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+declare const gtSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+declare const gteSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+declare const ltSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+declare const lteSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+declare const inArray: <T>(column: AnySQLiteColumn, values: T[] | Expression<any>) => Condition;
+declare const notIn: <T>(column: AnySQLiteColumn, values: T[] | Expression<any>) => Condition;
+declare const between: <T>(column: AnySQLiteColumn, min: T, max: T) => Condition;
 
 type NestedInclude = boolean | {
+    columns?: string[] | Record<string, boolean>;
     with?: Record<string, NestedInclude>;
 };
 type ExtractRelationNames<T extends AnyTable> = T['relations'] extends Record<string, any> ? keyof T['relations'] & string : never;
 type IncludeRelations<T extends AnyTable> = T['relations'] extends Record<string, any> ? Partial<Record<ExtractRelationNames<T>, NestedInclude>> : Record<string, never>;
-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;
-    private joins;
-    private includeRelations;
-    private selectedTableAlias;
-    private selectedColumns;
-    constructor(db: Database, table: TTable, columns?: TSelectedColumns | undefined);
+declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable['_']['columns'])[] | undefined = undefined> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _columns?;
+    private _includeRelations;
+    private _manualJoins;
+    private _isDistinct;
+    private _includedColumnAliases;
+    constructor(kysely: Kysely<any>, table: TTable, columns?: TSelectedColumns);
     distinct(): this;
+    where(condition: Condition): this;
+    orderBy(column: AnySQLiteColumn | Expression<any>, direction?: 'asc' | 'desc'): this;
+    limit(count: number): this;
+    offset(count: number): this;
     groupBy(...columns: AnySQLiteColumn[]): this;
-    having(condition: SQLCondition): this;
-    leftJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias: string): this;
-    innerJoin<T extends AnyTable>(table: T, condition: SQLCondition, alias: string): this;
+    having(condition: Condition): this;
+    leftJoin<T extends AnyTable>(table: T, condition: Expression<SqlBool>, alias: string): this;
+    innerJoin<T extends AnyTable>(table: T, condition: Expression<SqlBool>, alias: string): this;
     include(relations: IncludeRelations<TTable>): this;
-    private buildJoins;
+    private applyIncludes;
     execute(): Promise<InferSelectModel<TTable>[]>;
     private processRelationResults;
     all(): Promise<InferSelectModel<TTable>[]>;
     get(): Promise<InferSelectModel<TTable> | undefined>;
+    first(): Promise<InferSelectModel<TTable> | undefined>;
     exists(): Promise<boolean>;
     count(): Promise<number>;
-    first(): Promise<InferSelectModel<TTable> | undefined>;
     pluck<K extends keyof TTable['_']['columns']>(column: K): Promise<InferSelectModel<TTable>[K][]>;
     paginate(page?: number, pageSize?: number): Promise<{
         data: InferSelectModel<TTable>[];
@@ -105,23 +137,27 @@ declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns exten
         sql: string;
         params: any[];
     };
+    toKyselyExpression(): Expression<any>;
 }
 
-declare class UpdateQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
-    private table;
-    private updateData;
-    private returningColumns;
-    private hasWhereClause;
-    private allowGlobal;
-    private incrementDecrementOps;
-    constructor(db: Database, table: T);
+declare class UpdateQueryBuilder<T extends AnyTable> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _updateData;
+    private _returningColumns;
+    private _hasWhereClause;
+    private _allowGlobal;
+    private _incrementDecrementOps;
+    constructor(kysely: Kysely<any>, table: T);
     set(data: Partial<InferInsertModel<T>>): this;
-    where(condition: any): this;
-    increment(column: keyof T["_"]["columns"], value?: number): this;
-    decrement(column: keyof T["_"]["columns"], value?: number): this;
+    where(condition: Condition): this;
+    increment(column: keyof T['_']['columns'], value?: number): this;
+    decrement(column: keyof T['_']['columns'], value?: number): this;
     allowGlobalOperation(): this;
-    returning(...columns: (keyof T["_"]["columns"])[]): this;
-    private buildUpdateClause;
+    returning(...columns: (keyof T['_']['columns'])[]): this;
+    private mapReturningRows;
+    private buildSetClause;
     execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
     returningAll(): Promise<InferSelectModel<T>[]>;
     returningFirst(): Promise<InferSelectModel<T> | undefined>;
@@ -131,23 +167,26 @@ declare class UpdateQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     };
 }
 
-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);
+declare class InsertQueryBuilder<T extends AnyTable> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _dataSets;
+    private _returningColumns;
+    private _onConflictAction;
+    private _conflictTarget;
+    private _updateSet;
+    constructor(kysely: Kysely<any>, table: T);
     values(data: InferInsertModel<T> | InferInsertModel<T>[]): this;
-    returning(...columns: (keyof T["_"]["columns"])[]): this;
+    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;
+    private processDefaults;
+    private mapReturningRows;
+    private serializeDataSet;
     execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
     returningAll(): Promise<InferSelectModel<T>[]>;
     returningFirst(): Promise<InferSelectModel<T> | undefined>;
@@ -157,13 +196,16 @@ declare class InsertQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
     };
 }
 
-declare class DeleteQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
-    private table;
-    private returningColumns;
-    private hasWhereClause;
-    private allowGlobal;
-    constructor(db: Database, table: T);
-    where(condition: any): this;
+declare class DeleteQueryBuilder<T extends AnyTable> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _returningColumns;
+    private _hasWhereClause;
+    private _allowGlobal;
+    constructor(kysely: Kysely<any>, table: T);
+    private mapReturningRows;
+    where(condition: Condition): this;
     allowGlobalOperation(): this;
     returning(...columns: (keyof T['_']['columns'])[]): this;
     execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
@@ -176,18 +218,15 @@ declare class DeleteQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
 }
 
 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>;
+    private readonly kysely;
+    private _ctes;
+    constructor(kysely: Kysely<any>);
+    with(alias: string, query: SelectQueryBuilder<any, any>): this;
+    private applyWith;
+    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;
 }
 
 type RelationsBuilder = {
@@ -196,11 +235,6 @@ type RelationsBuilder = {
         references: AnySQLiteColumn[];
     }) => OneRelation<U>;
     many: <U extends AnyTable>(table: U) => ManyRelation<U>;
-    manyToMany: <U extends AnyTable>(table: U, config: {
-        junctionTable: AnyTable;
-        junctionFields: AnySQLiteColumn[];
-        junctionReferences: AnySQLiteColumn[];
-    }) => ManyToManyRelation<U>;
 };
 
 declare class SQLiteColumn<TName extends string = string, TType extends ColumnDataType = ColumnDataType, TMode extends Mode = 'default', TNotNull extends boolean = false, THasDefault extends boolean = false, TAutoincrement extends boolean = false, TEnum extends readonly string[] = never, TCustomType = never> {
@@ -223,7 +257,10 @@ declare class SQLiteColumn<TName extends string = string, TType extends ColumnDa
     primaryKey(): SQLiteColumn<TName, TType, TMode, true, THasDefault, TAutoincrement, TEnum, TCustomType>;
     autoincrement(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, true, TEnum, TCustomType>;
     unique(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
-    references<T extends AnyTable, K extends keyof T['_']['columns'] & string>(ref: T, column: K | T['_']['columns'][K]): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
+    references<T extends AnyTable, K extends keyof T['_']['columns'] & string>(ref: T, column: K | T['_']['columns'][K], options?: {
+        onDelete?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
+        onUpdate?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
+    }): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
     $onUpdateFn(fn: () => ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
     $type<T>(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, T>;
     as(alias: string): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
@@ -254,37 +291,16 @@ declare class Table<TColumns extends Record<string, AnySQLiteColumn>, TTableName
     constructor(name: TTableName, columns: TColumns);
 }
 declare const sqliteTable: <TTableName extends string, TColumns extends Record<string, AnySQLiteColumn>>(tableName: TTableName, columns: TColumns) => Table<TColumns, TTableName>;
-type SQLCondition = {
-    sql: string;
-    params: any[];
-};
-type SQLAggregate<T = number> = {
-    sql: string;
-    params: any[];
-    _type?: T;
-};
-type SQLSubquery = {
-    sql: string;
-    params: any[];
-    _isSubquery: true;
-};
-declare const asc: (column: AnySQLiteColumn) => {
-    sql: string;
-    params: never[];
-};
-declare const desc: (column: AnySQLiteColumn) => {
-    sql: string;
-    params: never[];
-};
-declare const sql: <T = unknown>(strings: TemplateStringsArray, ...values: any[]) => {
-    sql: string;
-    params: any[];
-    mapWith?: (value: any) => T;
-};
+type SQLCondition = Expression<SqlBool>;
+type SQLAggregate<T = number> = Expression<T>;
+type SQLSubquery = Expression<any>;
+declare const asc: (column: AnySQLiteColumn) => Expression<any>;
+declare const desc: (column: AnySQLiteColumn) => Expression<any>;
 declare class TauriORM {
     private db;
     private tables;
-    constructor(db: Database, schema?: Record<string, AnyTable | Record<string, Relation>> | undefined);
+    private kysely;
+    constructor(db: DatabaseLike, schema?: Record<string, AnyTable | Record<string, Relation>> | undefined);
     private buildColumnDefinition;
     checkMigration(): Promise<{
         safe: boolean;
@@ -314,10 +330,7 @@ declare class TauriORM {
         rowsAffected: number;
     }[] : never>;
     $with(alias: string): {
-        as: (query: {
-            sql: string;
-            params: any[];
-        }) => WithQueryBuilder;
+        as: (query: SelectQueryBuilder<any, any>) => WithQueryBuilder;
     };
     transaction<T>(callback: (tx: TauriORM) => Promise<T>): Promise<T>;
     rollback(): never;
@@ -357,69 +370,23 @@ declare class OneRelation<T extends AnyTable = AnyTable> extends Relation<T> {
 declare class ManyRelation<T extends AnyTable = AnyTable> extends Relation<T> {
     constructor(foreignTable: T);
 }
-declare class ManyToManyRelation<T extends AnyTable = AnyTable> extends Relation<T> {
-    config: {
-        junctionTable: AnyTable;
-        junctionFields: AnySQLiteColumn[];
-        junctionReferences: AnySQLiteColumn[];
-    };
-    constructor(foreignTable: T, config: {
-        junctionTable: AnyTable;
-        junctionFields: AnySQLiteColumn[];
-        junctionReferences: AnySQLiteColumn[];
-    });
-}
 declare const relations: <T extends AnyTable, R extends Record<string, Relation>>(table: T, relationsCallback: (helpers: RelationsBuilder) => 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"]>;
 
-declare const eq: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => SQLCondition;
-declare const ne: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => 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;
-declare const lte: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
-declare const like: (column: AnySQLiteColumn, pattern: string) => SQLCondition;
-declare const ilike: (column: AnySQLiteColumn, pattern: string) => SQLCondition;
-declare const startsWith: (column: AnySQLiteColumn, value: string) => SQLCondition;
-declare const endsWith: (column: AnySQLiteColumn, value: string) => SQLCondition;
-declare const contains: (column: AnySQLiteColumn, value: string) => SQLCondition;
-declare const isNull: (column: AnySQLiteColumn) => SQLCondition;
-declare const isNotNull: (column: AnySQLiteColumn) => SQLCondition;
-declare const exists: (subquery: {
-    sql: string;
-    params: any[];
-}) => SQLCondition;
-declare const notExists: (subquery: {
-    sql: string;
-    params: any[];
-}) => SQLCondition;
-declare const eqSubquery: (column: AnySQLiteColumn, subquery: SQLSubquery) => SQLCondition;
-declare const neSubquery: (column: AnySQLiteColumn, subquery: SQLSubquery) => SQLCondition;
-declare const gtSubquery: (column: AnySQLiteColumn, subquery: SQLSubquery) => SQLCondition;
-declare const gteSubquery: (column: AnySQLiteColumn, subquery: SQLSubquery) => SQLCondition;
-declare const ltSubquery: (column: AnySQLiteColumn, subquery: SQLSubquery) => SQLCondition;
-declare const lteSubquery: (column: AnySQLiteColumn, subquery: SQLSubquery) => SQLCondition;
-declare const inArray: <T>(column: AnySQLiteColumn, values: T[] | SQLSubquery) => SQLCondition;
-declare const notIn: <T>(column: AnySQLiteColumn, values: T[] | SQLSubquery) => SQLCondition;
-declare const between: <T>(column: AnySQLiteColumn, min: T, max: T) => SQLCondition;
-
-declare const count: (column?: AnySQLiteColumn) => SQLAggregate<number>;
-declare const countDistinct: (column: AnySQLiteColumn) => SQLAggregate<number>;
-declare const sum: (column: AnySQLiteColumn) => SQLAggregate<number>;
-declare const avg: (column: AnySQLiteColumn) => SQLAggregate<number>;
-declare const max: <T = any>(column: AnySQLiteColumn) => SQLAggregate<T>;
-declare const min: <T = any>(column: AnySQLiteColumn) => SQLAggregate<T>;
-declare const groupConcat: (column: AnySQLiteColumn, separator?: string) => SQLAggregate<string>;
-declare const as: <T>(aggregate: SQLAggregate<T>, alias: string) => SQLAggregate<T> & {
+declare const count: (column?: AnySQLiteColumn) => Expression<number>;
+declare const countDistinct: (column: AnySQLiteColumn) => Expression<number>;
+declare const sum: (column: AnySQLiteColumn) => Expression<number>;
+declare const avg: (column: AnySQLiteColumn) => Expression<number>;
+declare const max: <T = any>(column: AnySQLiteColumn) => Expression<T>;
+declare const min: <T = any>(column: AnySQLiteColumn) => Expression<T>;
+declare const groupConcat: (column: AnySQLiteColumn, separator?: string) => Expression<string>;
+declare const as: <T>(aggregate: Expression<T>, alias: string) => Expression<T> & {
     alias: string;
 };
 
-declare const subquery: <T extends AnyTable>(query: SelectQueryBuilder<T, any>) => SQLSubquery;
-declare const scalarSubquery: <T extends AnyTable>(query: SelectQueryBuilder<T, any>) => SQLSubquery;
+declare const subquery: <T extends AnyTable>(query: SelectQueryBuilder<T, any>) => Expression<any>;
+declare const scalarSubquery: <T extends AnyTable>(query: SelectQueryBuilder<T, any>) => Expression<any>;
 
 declare function text<TName extends string>(name: TName): SQLiteColumn<TName, 'TEXT', 'default', false, false, false, never, never>;
 declare function text<TName extends string, const TConfig extends {
@@ -442,6 +409,81 @@ declare function numeric<TName extends string, const TConfig extends {
 }>(name: TName, config: TConfig): SQLiteColumn<TName, 'NUMERIC', TConfig['mode'], false, false, false, never, never>;
 declare const enumType: <TName extends string, TValues extends readonly [string, ...string[]]>(name: TName, values: TValues) => SQLiteColumn<TName, "TEXT", "default", false, false, false, TValues extends readonly string[] ? TValues : never, never>;
 
+/** Maps relations() return type to typed relation configs with foreign table preserved */
+type InferRelationsMap<R extends Record<string, OneRelation | ManyRelation>> = {
+    [K in keyof R]: R[K] extends OneRelation<infer T> ? {
+        type: 'one';
+        foreignTable: T;
+    } : R[K] extends ManyRelation<infer T> ? {
+        type: 'many';
+        foreignTable: T;
+    } : never;
+};
+/** With/include object shape - matches NestedInclude from select builder */
+type WithShape = boolean | {
+    columns?: string[] | Record<string, boolean>;
+    with?: Record<string, WithShape>;
+};
+/** Map of table name -> relations() return type, for nested with support */
+type RelationsByTable = Record<string, Record<string, OneRelation | ManyRelation>>;
+/** Get relations for a table from the all-relations map */
+type GetRelationsForTable<TTable extends AnyTable, TAllRelations extends RelationsByTable> = TAllRelations[TTable['_']['name']] extends Record<string, OneRelation | ManyRelation> ? InferRelationsMap<TAllRelations[TTable['_']['name']]> : Record<string, never>;
+/** Infer nested relation fields when TWith has a nested `with` */
+type InferNestedFields<TForeignTable extends AnyTable, TWith extends WithShape, TAllRelations extends RelationsByTable> = TWith extends {
+    with?: infer TW;
+} ? TW extends Record<string, WithShape> ? InferRelationFields<TForeignTable, GetRelationsForTable<TForeignTable, TAllRelations>, TAllRelations, TW> : unknown : unknown;
+/** Recursively build relation fields from a with object */
+type InferRelationFields<TTable extends AnyTable, TRelationsMap extends Record<string, {
+    type: 'one' | 'many';
+    foreignTable: AnyTable;
+}>, TAllRelations extends RelationsByTable, TWith extends Record<string, WithShape>> = {
+    [K in keyof TWith & keyof TRelationsMap]: TWith[K] extends false | undefined ? never : TRelationsMap[K] extends {
+        type: 'one';
+        foreignTable: infer T;
+    } ? T extends AnyTable ? InferSelectModel<T> & InferNestedFields<T, TWith[K], TAllRelations> : never : TRelationsMap[K] extends {
+        type: 'many';
+        foreignTable: infer T;
+    } ? T extends AnyTable ? (InferSelectModel<T> & InferNestedFields<T, TWith[K], TAllRelations>)[] : never : never;
+};
+/**
+ * Infer the result type of a select query that includes relations via `.include(with)`.
+ *
+ * Use this to type variables that hold results from relational queries, e.g.:
+ *
+ * @example
+ * ```ts
+ * export type User = InferSelectModel<typeof schema.user>
+ *
+ * const withRelationalObject = { sessions: true, accounts: true } as const
+ * export type UserWithRelations = InferRelationalSelectModel<
+ *   typeof schema.user,
+ *   typeof schema.userRelations,
+ *   typeof withRelationalObject
+ * >
+ * ```
+ *
+ * For nested includes, pass a map of table name -> relations as the fourth parameter:
+ *
+ * @example
+ * ```ts
+ * const withNested = { sessions: { with: { user: true } } } as const
+ * type UserWithSessionsAndUser = InferRelationalSelectModel<
+ *   typeof schema.user,
+ *   typeof schema.userRelations,
+ *   typeof withNested,
+ *   { user: typeof userRelations; session: typeof sessionRelations }
+ * >
+ * ```
+ *
+ * @param TTable - The table type (e.g. typeof schema.user)
+ * @param TRelations - The relations for this table (e.g. typeof schema.userRelations)
+ * @param TWith - The with/include object shape (use `as const` for literal inference)
+ * @param TAllRelations - Optional map of table name -> relations for nested `with` support
+ */
+type InferRelationalSelectModel<TTable extends AnyTable, TRelations extends Record<string, OneRelation | ManyRelation>, TWith extends Record<string, WithShape>, TAllRelations extends RelationsByTable = {
+    [K in TTable['_']['name']]: TRelations;
+}> = InferSelectModel<TTable> & InferRelationFields<TTable, InferRelationsMap<TRelations>, TAllRelations, TWith>;
+
 declare class TauriORMError extends Error {
     constructor(message: string);
 }
@@ -473,4 +515,4 @@ declare class TableNotFoundError extends TauriORMError {
     constructor(tableName: string);
 }
 
-export { type AnySQLiteColumn, type AnyTable, BaseQueryBuilder, type ColumnDataType, ColumnNotFoundError, type ColumnOptions, type ColumnValueTypes, DeleteQueryBuilder, type ExtractColumnType, type InferInsertModel, type InferSelectModel, InsertQueryBuilder, InsertValidationError, ManyRelation, ManyToManyRelation, MigrationError, MissingWhereClauseError, type Mode, OneRelation, QueryBuilderError, Relation, type RelationConfig, RelationError, type RelationType, type RelationsBuilder, type SQLAggregate, type SQLCondition, type SQLSubquery, 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 };
+export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, ColumnNotFoundError, type ColumnOptions, type ColumnValueTypes, type Condition, type DatabaseLike, DeleteQueryBuilder, type ExtractColumnType, type InferInsertModel, type InferRelationalSelectModel, type InferRelationsMap, type InferSelectModel, InsertQueryBuilder, InsertValidationError, ManyRelation, MigrationError, MissingWhereClauseError, type Mode, OneRelation, QueryBuilderError, Relation, type RelationConfig, RelationError, type RelationType, type RelationsBuilder, type SQLAggregate, type SQLCondition, type SQLSubquery, SQLiteColumn, SelectQueryBuilder, Table, TableNotFoundError, TauriDialect, 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, sqliteTable, startsWith, subquery, sum, text };