@type32/tauri-sqlite-orm 0.2.13 → 0.3.0

package/dist/index.d.ts

@@ -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,97 @@ 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;
+    /** For one: local FK columns. For many (v2): foreign table's FK columns. */
     fields?: AnySQLiteColumn[];
+    /** For one: foreign PK columns. For many (v2): parent table's PK columns. */
     references?: AnySQLiteColumn[];
+    /** For many-to-many via through(): junction table between parent and foreign */
     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[];
+    /** Parent column -> junction column (parent PK = junction FK to parent) */
+    fromJunction?: {
+        column: AnySQLiteColumn;
+        junctionColumn: AnySQLiteColumn;
     };
-    toSQL(): {
-        sql: string;
-        params: any[];
+    /** Junction column -> foreign column (junction FK to foreign = foreign PK) */
+    toJunction?: {
+        junctionColumn: AnySQLiteColumn;
+        column: AnySQLiteColumn;
     };
+    /** When false, one relation is required (type-level: T not T | null) */
+    optional?: boolean;
+    /** Alias for the relation (e.g. for self-referential disambiguation) */
+    alias?: string;
+    /** Predefined filter for many relations: (alias) => Condition. Receives the joined table alias. */
+    where?: (alias: string) => unknown;
 }
 
+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 +157,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 +187,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 +216,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,31 +238,25 @@ 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 = {
     one: <U extends AnyTable>(table: U, config?: {
         fields: AnySQLiteColumn[];
         references: AnySQLiteColumn[];
+        optional?: boolean;
+        alias?: string;
     }) => 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 +279,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 +313,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 +352,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;
@@ -348,78 +383,71 @@ declare class OneRelation<T extends AnyTable = AnyTable> extends Relation<T> {
     config?: {
         fields: AnySQLiteColumn[];
         references: AnySQLiteColumn[];
+        optional?: boolean;
+        alias?: string;
     } | undefined;
     constructor(foreignTable: T, config?: {
         fields: AnySQLiteColumn[];
         references: AnySQLiteColumn[];
+        optional?: boolean;
+        alias?: string;
     } | undefined);
 }
 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[];
-    });
+    config?: {
+        from?: AnySQLiteColumn[];
+        to?: AnySQLiteColumn[];
+        through?: {
+            junctionTable: AnyTable;
+            fromRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+            toRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+        };
+        optional?: boolean;
+        alias?: string;
+        where?: (alias: string) => unknown;
+    } | undefined;
+    constructor(foreignTable: T, config?: {
+        from?: AnySQLiteColumn[];
+        to?: AnySQLiteColumn[];
+        through?: {
+            junctionTable: AnyTable;
+            fromRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+            toRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+        };
+        optional?: boolean;
+        alias?: string;
+        where?: (alias: string) => unknown;
+    } | undefined);
 }
 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 +470,161 @@ 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> ? R[K] extends {
+        config?: {
+            optional?: infer O;
+        };
+    } ? {
+        type: 'one';
+        foreignTable: T;
+        optional: O;
+    } : {
+        type: 'one';
+        foreignTable: T;
+        optional?: true;
+    } : 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;
+        optional?: infer O;
+    } ? T extends AnyTable ? ([O] extends [false] ? InferSelectModel<T> & InferNestedFields<T, TWith[K], TAllRelations> : (InferSelectModel<T> & InferNestedFields<T, TWith[K], TAllRelations>) | null) : 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>;
+
+/**
+ * Relations v2 API - Drizzle-style defineRelations with from/to and many-without-one.
+ * Use defineRelations() for a single place to define all relations, or defineRelationsPart() to split into parts.
+ */
+
+/** Options for one() relation - from/to replace fields/references */
+interface OneRelationOptions {
+    from: AnySQLiteColumn | AnySQLiteColumn[];
+    to: AnySQLiteColumn | AnySQLiteColumn[];
+    optional?: boolean;
+    alias?: string;
+}
+/** Reference for through() - column with junction column for many-to-many */
+interface ThroughRef {
+    column: AnySQLiteColumn;
+    junctionColumn: AnySQLiteColumn;
+    junctionTable: AnyTable;
+}
+/** Create a through reference for many-to-many: through(column, junctionColumn, junctionTable) */
+declare function through(column: AnySQLiteColumn, junctionColumn: AnySQLiteColumn, junctionTable: AnyTable): ThroughRef;
+/** Options for many() relation - optional explicit from/to for many-without-one, or through() for many-to-many */
+interface ManyRelationOptions {
+    from?: AnySQLiteColumn | AnySQLiteColumn[] | ThroughRef;
+    to?: AnySQLiteColumn | AnySQLiteColumn[] | ThroughRef;
+    optional?: boolean;
+    alias?: string;
+    /** Predefined filter: (alias) => Condition. Applied to the joined relation table. */
+    where?: (alias: string) => Condition;
+}
+/** Build the r object passed to defineRelations callback */
+declare function buildR<Tables extends Record<string, AnyTable>>(tables: Tables): {
+    [K in keyof Tables]: Record<string, AnySQLiteColumn>;
+} & {
+    one: {
+        [K in keyof Tables]: (opts: OneRelationOptions) => OneRelation<Tables[K]>;
+    };
+    many: {
+        [K in keyof Tables]: (opts?: ManyRelationOptions) => ManyRelation<Tables[K]>;
+    };
+};
+type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: ReturnType<typeof buildR>) => {
+    [K in keyof Tables]?: Record<string, OneRelation | ManyRelation>;
+};
+/**
+ * Define all relations for your schema in one place (v2 API).
+ * Uses from/to instead of fields/references, and supports many-without-one.
+ *
+ * @example
+ * ```ts
+ * import * as schema from './schema'
+ * import { defineRelations } from '@type32/tauri-sqlite-orm'
+ *
+ * export const relations = defineRelations(schema, (r) => ({
+ *   users: {
+ *     posts: r.many.posts({ from: r.users.id, to: r.posts.userId }),
+ *   },
+ *   posts: {
+ *     user: r.one.users({ from: r.posts.userId, to: r.users.id }),
+ *     postTags: r.many.postTags({ from: r.posts.id, to: r.postTags.postId }),
+ *   },
+ * }))
+ * ```
+ */
+declare function defineRelations<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<Record<string, AnyTable>>): Record<string, Record<string, OneRelation | ManyRelation>>;
+/**
+ * Define a part of relations - merge multiple parts when passing to TauriORM.
+ * Useful for splitting large schema definitions.
+ */
+declare function defineRelationsPart<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<Record<string, AnyTable>>): Record<string, Record<string, OneRelation | ManyRelation>>;
+
 declare class TauriORMError extends Error {
     constructor(message: string);
 }
@@ -473,4 +656,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, type DefineRelationsCallback, DeleteQueryBuilder, type ExtractColumnType, type InferInsertModel, type InferRelationalSelectModel, type InferRelationsMap, type InferSelectModel, InsertQueryBuilder, InsertValidationError, ManyRelation, type ManyRelationOptions, MigrationError, MissingWhereClauseError, type Mode, OneRelation, type OneRelationOptions, QueryBuilderError, Relation, type RelationConfig, RelationError, type RelationType, type RelationsBuilder, type SQLAggregate, type SQLCondition, type SQLSubquery, SQLiteColumn, SelectQueryBuilder, Table, TableNotFoundError, TauriDialect, TauriORM, TauriORMError, type ThroughRef, UpdateQueryBuilder, UpdateValidationError, ValidationError, WithQueryBuilder, alias, and, as, asc, avg, between, blob, boolean, contains, count, countDistinct, defineRelations, defineRelationsPart, 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, through };