drizzle-orm 0.28.3 → 0.28.4

package/sqlite-core/query-builders/select.d.mts

@@ -0,0 +1,94 @@
+import { entityKind } from '../../entity.js';
+import { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import { type Placeholder, type Query, SQL } from '../../sql/index.js';
+import type { SQLiteColumn } from '../columns/index.js';
+import type { SQLiteDialect } from '../dialect.js';
+import type { PreparedQuery, SQLiteSession } from '../session.js';
+import type { SubqueryWithSelection } from '../subquery.js';
+import type { SQLiteTable } from '../table.js';
+import { Subquery } from '../../subquery.js';
+import { type ValueOrArray } from '../../utils.js';
+import { type ColumnsSelection } from '../../view.js';
+import { SQLiteViewBase } from '../view.js';
+import type { JoinFn, SelectedFields, SQLiteSelectConfig, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectQueryBuilderHKT } from './select.types.js';
+type CreateSQLiteSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? SQLiteSelect<TTableName, TResultType, TRunResult, TSelection, TSelectMode> : SQLiteSelectQueryBuilder<SQLiteSelectQueryBuilderHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode>;
+export declare class SQLiteSelectBuilder<TSelection extends SelectedFields | undefined, TResultType extends 'sync' | 'async', TRunResult, TBuilderMode extends 'db' | 'qb' = 'db'> {
+    static readonly [entityKind]: string;
+    private fields;
+    private session;
+    private dialect;
+    private withList;
+    private distinct;
+    constructor(config: {
+        fields: TSelection;
+        session: SQLiteSession<any, any, any, any> | undefined;
+        dialect: SQLiteDialect;
+        withList?: Subquery[];
+        distinct?: boolean;
+    });
+    from<TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL>(source: TFrom): CreateSQLiteSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, TResultType, TRunResult, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial'>;
+}
+export declare abstract class SQLiteSelectQueryBuilder<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends TypedQueryBuilder<BuildSubquerySelection<TSelection, TNullabilityMap>, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly selectMode: TSelectMode;
+        readonly selection: TSelection;
+        readonly result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+        readonly selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+    };
+    protected config: SQLiteSelectConfig;
+    protected joinsNotNullableMap: Record<string, boolean>;
+    private tableName;
+    private isPartialSelect;
+    protected session: SQLiteSession<any, any, any, any> | undefined;
+    protected dialect: SQLiteDialect;
+    constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
+        table: SQLiteSelectConfig['table'];
+        fields: SQLiteSelectConfig['fields'];
+        isPartialSelect: boolean;
+        session: SQLiteSession<any, any, any, any> | undefined;
+        dialect: SQLiteDialect;
+        withList: Subquery[] | undefined;
+        distinct: boolean | undefined;
+    });
+    private createJoin;
+    leftJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "left", TSelection, TNullabilityMap>;
+    rightJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "right", TSelection, TNullabilityMap>;
+    innerJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "inner", TSelection, TNullabilityMap>;
+    fullJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "full", TSelection, TNullabilityMap>;
+    where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    groupBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
+    groupBy(...columns: (SQLiteColumn | SQL)[]): this;
+    orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
+    orderBy(...columns: (SQLiteColumn | SQL)[]): this;
+    limit(limit: number | Placeholder): this;
+    offset(offset: number | Placeholder): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+    getSelectedFields(): BuildSubquerySelection<TSelection, TNullabilityMap>;
+}
+export interface SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName | undefined, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>, QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+}
+export declare class SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+    static readonly [entityKind]: string;
+    prepare(isOneTimeQuery?: boolean): PreparedQuery<{
+        type: TResultType;
+        run: TRunResult;
+        all: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+        get: SelectResult<TSelection, TSelectMode, TNullabilityMap> | undefined;
+        values: any[][];
+        execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+    }>;
+    run: ReturnType<this['prepare']>['run'];
+    all: ReturnType<this['prepare']>['all'];
+    get: ReturnType<this['prepare']>['get'];
+    values: ReturnType<this['prepare']>['values'];
+    execute(): Promise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>;
+}
+export {};

package/sqlite-core/query-builders/select.d.ts

@@ -1,18 +1,18 @@
-import { entityKind } from '../../entity';
-import { type Placeholder, type Query, SQL } from '../../sql';
-import type { SQLiteColumn } from '../columns';
-import type { SQLiteDialect } from '../dialect';
-import type { PreparedQuery, SQLiteSession } from '../session';
-import type { SQLiteTable } from '../table';
-import { TypedQueryBuilder } from '../../query-builders/query-builder';
-import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types';
-import { QueryPromise } from '../../query-promise';
-import type { SubqueryWithSelection } from '../subquery';
-import { Subquery } from '../../subquery';
-import { type ValueOrArray } from '../../utils';
-import { type ColumnsSelection } from '../../view';
-import { SQLiteViewBase } from '../view';
-import type { JoinFn, SelectedFields, SQLiteSelectConfig, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectQueryBuilderHKT } from './select.types';
+import { entityKind } from '../../entity.js';
+import { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import { type Placeholder, type Query, SQL } from '../../sql/index.js';
+import type { SQLiteColumn } from '../columns/index.js';
+import type { SQLiteDialect } from '../dialect.js';
+import type { PreparedQuery, SQLiteSession } from '../session.js';
+import type { SubqueryWithSelection } from '../subquery.js';
+import type { SQLiteTable } from '../table.js';
+import { Subquery } from '../../subquery.js';
+import { type ValueOrArray } from '../../utils.js';
+import { type ColumnsSelection } from '../../view.js';
+import { SQLiteViewBase } from '../view.js';
+import type { JoinFn, SelectedFields, SQLiteSelectConfig, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectQueryBuilderHKT } from './select.types.js';
 type CreateSQLiteSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? SQLiteSelect<TTableName, TResultType, TRunResult, TSelection, TSelectMode> : SQLiteSelectQueryBuilder<SQLiteSelectQueryBuilderHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode>;
 export declare class SQLiteSelectBuilder<TSelection extends SelectedFields | undefined, TResultType extends 'sync' | 'async', TRunResult, TBuilderMode extends 'db' | 'qb' = 'db'> {
     static readonly [entityKind]: string;

package/sqlite-core/query-builders/select.types.d.cts

@@ -0,0 +1,63 @@
+import type { Placeholder, SQL } from '../../sql/index.js';
+import type { Assume } from '../../utils.js';
+import type { SQLiteColumn } from '../columns/index.js';
+import type { SQLiteTable, SQLiteTableWithColumns } from '../table.js';
+import type { SelectedFields as SelectFieldsBase, SelectedFieldsFlat as SelectFieldsFlatBase, SelectedFieldsOrdered as SelectFieldsOrderedBase } from '../../operations.js';
+import type { AppendToNullabilityMap, AppendToResult, GetSelectTableName, JoinNullability, JoinType, MapColumnsToTableAlias, SelectMode } from '../../query-builders/select.types.js';
+import type { Subquery } from '../../subquery.js';
+import type { Table, UpdateTableConfig } from '../../table.js';
+import { type ColumnsSelection, type View } from '../../view.js';
+import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.js';
+import type { SQLiteSelect, SQLiteSelectQueryBuilder } from './select.js';
+export interface Join {
+    on: SQL | undefined;
+    table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
+    alias: string | undefined;
+    joinType: JoinType;
+}
+export type AnySQLiteSelect = SQLiteSelect<any, any, any, any, any, any>;
+export type BuildAliasTable<TTable extends SQLiteTable | View, TAlias extends string> = TTable extends Table ? SQLiteTableWithColumns<UpdateTableConfig<TTable['_']['config'], {
+    name: TAlias;
+    columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'sqlite'>;
+}>> : TTable extends View ? SQLiteViewWithSelection<TAlias, TTable['_']['existing'], MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'sqlite'>> : never;
+export interface SQLiteSelectConfig {
+    withList?: Subquery[];
+    fields: Record<string, unknown>;
+    fieldsFlat?: SelectedFieldsOrdered;
+    where?: SQL;
+    having?: SQL;
+    table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
+    limit?: number | Placeholder;
+    offset?: number | Placeholder;
+    joins?: Join[];
+    orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+    groupBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+    distinct?: boolean;
+}
+export type JoinFn<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelectMode extends SelectMode, TJoinType extends JoinType, TSelection, TNullabilityMap extends Record<string, JoinNullability>> = <TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL, TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>>(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => SQLiteSelectKind<THKT, TTableName, TResultType, TRunResult, AppendToResult<TTableName, TSelection, TJoinedName, TJoinedTable extends SQLiteTable ? TJoinedTable['_']['columns'] : TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields> : never, TSelectMode>, TSelectMode extends 'partial' ? TSelectMode : 'multiple', AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>>;
+export type SelectedFieldsFlat = SelectFieldsFlatBase<SQLiteColumn>;
+export type SelectedFields = SelectFieldsBase<SQLiteColumn, SQLiteTable>;
+export type SelectedFieldsOrdered = SelectFieldsOrderedBase<SQLiteColumn>;
+export interface SQLiteSelectHKTBase {
+    tableName: string | undefined;
+    resultType: 'sync' | 'async';
+    runResult: unknown;
+    selection: unknown;
+    selectMode: SelectMode;
+    nullabilityMap: unknown;
+    _type: unknown;
+}
+export type SQLiteSelectKind<T extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = (T & {
+    tableName: TTableName;
+    resultType: TResultType;
+    runResult: TRunResult;
+    selection: TSelection;
+    selectMode: TSelectMode;
+    nullabilityMap: TNullabilityMap;
+})['_type'];
+export interface SQLiteSelectQueryBuilderHKT extends SQLiteSelectHKTBase {
+    _type: SQLiteSelectQueryBuilder<this, this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+}
+export interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
+    _type: SQLiteSelect<this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+}

package/sqlite-core/query-builders/select.types.d.mts

@@ -0,0 +1,63 @@
+import type { Placeholder, SQL } from '../../sql/index.js';
+import type { Assume } from '../../utils.js';
+import type { SQLiteColumn } from '../columns/index.js';
+import type { SQLiteTable, SQLiteTableWithColumns } from '../table.js';
+import type { SelectedFields as SelectFieldsBase, SelectedFieldsFlat as SelectFieldsFlatBase, SelectedFieldsOrdered as SelectFieldsOrderedBase } from '../../operations.js';
+import type { AppendToNullabilityMap, AppendToResult, GetSelectTableName, JoinNullability, JoinType, MapColumnsToTableAlias, SelectMode } from '../../query-builders/select.types.js';
+import type { Subquery } from '../../subquery.js';
+import type { Table, UpdateTableConfig } from '../../table.js';
+import { type ColumnsSelection, type View } from '../../view.js';
+import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.js';
+import type { SQLiteSelect, SQLiteSelectQueryBuilder } from './select.js';
+export interface Join {
+    on: SQL | undefined;
+    table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
+    alias: string | undefined;
+    joinType: JoinType;
+}
+export type AnySQLiteSelect = SQLiteSelect<any, any, any, any, any, any>;
+export type BuildAliasTable<TTable extends SQLiteTable | View, TAlias extends string> = TTable extends Table ? SQLiteTableWithColumns<UpdateTableConfig<TTable['_']['config'], {
+    name: TAlias;
+    columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'sqlite'>;
+}>> : TTable extends View ? SQLiteViewWithSelection<TAlias, TTable['_']['existing'], MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'sqlite'>> : never;
+export interface SQLiteSelectConfig {
+    withList?: Subquery[];
+    fields: Record<string, unknown>;
+    fieldsFlat?: SelectedFieldsOrdered;
+    where?: SQL;
+    having?: SQL;
+    table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
+    limit?: number | Placeholder;
+    offset?: number | Placeholder;
+    joins?: Join[];
+    orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+    groupBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+    distinct?: boolean;
+}
+export type JoinFn<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelectMode extends SelectMode, TJoinType extends JoinType, TSelection, TNullabilityMap extends Record<string, JoinNullability>> = <TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL, TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>>(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => SQLiteSelectKind<THKT, TTableName, TResultType, TRunResult, AppendToResult<TTableName, TSelection, TJoinedName, TJoinedTable extends SQLiteTable ? TJoinedTable['_']['columns'] : TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields> : never, TSelectMode>, TSelectMode extends 'partial' ? TSelectMode : 'multiple', AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>>;
+export type SelectedFieldsFlat = SelectFieldsFlatBase<SQLiteColumn>;
+export type SelectedFields = SelectFieldsBase<SQLiteColumn, SQLiteTable>;
+export type SelectedFieldsOrdered = SelectFieldsOrderedBase<SQLiteColumn>;
+export interface SQLiteSelectHKTBase {
+    tableName: string | undefined;
+    resultType: 'sync' | 'async';
+    runResult: unknown;
+    selection: unknown;
+    selectMode: SelectMode;
+    nullabilityMap: unknown;
+    _type: unknown;
+}
+export type SQLiteSelectKind<T extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = (T & {
+    tableName: TTableName;
+    resultType: TResultType;
+    runResult: TRunResult;
+    selection: TSelection;
+    selectMode: TSelectMode;
+    nullabilityMap: TNullabilityMap;
+})['_type'];
+export interface SQLiteSelectQueryBuilderHKT extends SQLiteSelectHKTBase {
+    _type: SQLiteSelectQueryBuilder<this, this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+}
+export interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
+    _type: SQLiteSelect<this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+}

package/sqlite-core/query-builders/select.types.d.ts

@@ -1,14 +1,14 @@
-import type { Placeholder, SQL } from '../../sql';
-import type { Assume } from '../../utils';
-import type { SQLiteColumn } from '../columns';
-import type { SQLiteTable, SQLiteTableWithColumns } from '../table';
-import type { SelectedFields as SelectFieldsBase, SelectedFieldsFlat as SelectFieldsFlatBase, SelectedFieldsOrdered as SelectFieldsOrderedBase } from '../../operations';
-import type { AppendToNullabilityMap, AppendToResult, GetSelectTableName, JoinNullability, JoinType, MapColumnsToTableAlias, SelectMode } from '../../query-builders/select.types';
-import type { Subquery } from '../../subquery';
-import type { Table, UpdateTableConfig } from '../../table';
-import { type ColumnsSelection, type View } from '../../view';
-import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view';
-import type { SQLiteSelect, SQLiteSelectQueryBuilder } from './select';
+import type { Placeholder, SQL } from '../../sql/index.js';
+import type { Assume } from '../../utils.js';
+import type { SQLiteColumn } from '../columns/index.js';
+import type { SQLiteTable, SQLiteTableWithColumns } from '../table.js';
+import type { SelectedFields as SelectFieldsBase, SelectedFieldsFlat as SelectFieldsFlatBase, SelectedFieldsOrdered as SelectFieldsOrderedBase } from '../../operations.js';
+import type { AppendToNullabilityMap, AppendToResult, GetSelectTableName, JoinNullability, JoinType, MapColumnsToTableAlias, SelectMode } from '../../query-builders/select.types.js';
+import type { Subquery } from '../../subquery.js';
+import type { Table, UpdateTableConfig } from '../../table.js';
+import { type ColumnsSelection, type View } from '../../view.js';
+import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.js';
+import type { SQLiteSelect, SQLiteSelectQueryBuilder } from './select.js';
 export interface Join {
     on: SQL | undefined;
     table: SQLiteTable | Subquery | SQLiteViewBase | SQL;

package/sqlite-core/query-builders/update.d.cts

@@ -0,0 +1,63 @@
+import type { GetColumnData } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { SelectResultFields } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query, SQL, SQLWrapper } from '../../sql/index.js';
+import type { SQLiteDialect } from '../dialect.js';
+import type { PreparedQuery, SQLiteSession } from '../session.js';
+import { SQLiteTable } from '../table.js';
+import type { InferModel } from '../../table.js';
+import { type DrizzleTypeError, type UpdateSet } from '../../utils.js';
+import type { SelectedFields, SelectedFieldsOrdered } from './select.types.js';
+export interface SQLiteUpdateConfig {
+    where?: SQL | undefined;
+    set: UpdateSet;
+    table: SQLiteTable;
+    returning?: SelectedFieldsOrdered;
+}
+export type SQLiteUpdateSetSource<TTable extends SQLiteTable> = {
+    [Key in keyof TTable['_']['columns']]?: GetColumnData<TTable['_']['columns'][Key], 'query'> | SQL;
+} & {};
+export declare class SQLiteUpdateBuilder<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult> {
+    protected table: TTable;
+    protected session: SQLiteSession<any, any, any, any>;
+    protected dialect: SQLiteDialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    constructor(table: TTable, session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
+    set(values: SQLiteUpdateSetSource<TTable>): SQLiteUpdate<TTable, TResultType, TRunResult>;
+}
+export interface SQLiteUpdate<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {
+}
+export declare class SQLiteUpdate<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    private config;
+    constructor(table: TTable, set: UpdateSet, session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
+    where(where: SQL | undefined): Omit<this, 'where'>;
+    returning(): SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): SQLiteUpdate<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    prepare(isOneTimeQuery?: boolean): PreparedQuery<{
+        type: TResultType;
+        run: TRunResult;
+        all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
+        get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'> : TReturning;
+        values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'> : any[][];
+        execute: TReturning extends undefined ? TRunResult : TReturning[];
+    }>;
+    run: ReturnType<this['prepare']>['run'];
+    all: ReturnType<this['prepare']>['all'];
+    get: ReturnType<this['prepare']>['get'];
+    values: ReturnType<this['prepare']>['values'];
+    execute(): Promise<TReturning extends undefined ? TRunResult : TReturning[]>;
+}

package/sqlite-core/query-builders/update.d.mts

@@ -0,0 +1,63 @@
+import type { GetColumnData } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { SelectResultFields } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query, SQL, SQLWrapper } from '../../sql/index.js';
+import type { SQLiteDialect } from '../dialect.js';
+import type { PreparedQuery, SQLiteSession } from '../session.js';
+import { SQLiteTable } from '../table.js';
+import type { InferModel } from '../../table.js';
+import { type DrizzleTypeError, type UpdateSet } from '../../utils.js';
+import type { SelectedFields, SelectedFieldsOrdered } from './select.types.js';
+export interface SQLiteUpdateConfig {
+    where?: SQL | undefined;
+    set: UpdateSet;
+    table: SQLiteTable;
+    returning?: SelectedFieldsOrdered;
+}
+export type SQLiteUpdateSetSource<TTable extends SQLiteTable> = {
+    [Key in keyof TTable['_']['columns']]?: GetColumnData<TTable['_']['columns'][Key], 'query'> | SQL;
+} & {};
+export declare class SQLiteUpdateBuilder<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult> {
+    protected table: TTable;
+    protected session: SQLiteSession<any, any, any, any>;
+    protected dialect: SQLiteDialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    constructor(table: TTable, session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
+    set(values: SQLiteUpdateSetSource<TTable>): SQLiteUpdate<TTable, TResultType, TRunResult>;
+}
+export interface SQLiteUpdate<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {
+}
+export declare class SQLiteUpdate<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    private config;
+    constructor(table: TTable, set: UpdateSet, session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
+    where(where: SQL | undefined): Omit<this, 'where'>;
+    returning(): SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): SQLiteUpdate<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    prepare(isOneTimeQuery?: boolean): PreparedQuery<{
+        type: TResultType;
+        run: TRunResult;
+        all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
+        get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'> : TReturning;
+        values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'> : any[][];
+        execute: TReturning extends undefined ? TRunResult : TReturning[];
+    }>;
+    run: ReturnType<this['prepare']>['run'];
+    all: ReturnType<this['prepare']>['all'];
+    get: ReturnType<this['prepare']>['get'];
+    values: ReturnType<this['prepare']>['values'];
+    execute(): Promise<TReturning extends undefined ? TRunResult : TReturning[]>;
+}

package/sqlite-core/query-builders/update.d.ts

@@ -1,14 +1,14 @@
-import type { GetColumnData } from '../../column';
-import { entityKind } from '../../entity';
-import type { SelectResultFields } from '../../query-builders/select.types';
-import { QueryPromise } from '../../query-promise';
-import type { Query, SQL, SQLWrapper } from '../../sql';
-import type { SQLiteDialect } from '../dialect';
-import type { PreparedQuery, SQLiteSession } from '../session';
-import { SQLiteTable } from '../table';
-import type { InferModel } from '../../table';
-import { type DrizzleTypeError, type UpdateSet } from '../../utils';
-import type { SelectedFields, SelectedFieldsOrdered } from './select.types';
+import type { GetColumnData } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { SelectResultFields } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query, SQL, SQLWrapper } from '../../sql/index.js';
+import type { SQLiteDialect } from '../dialect.js';
+import type { PreparedQuery, SQLiteSession } from '../session.js';
+import { SQLiteTable } from '../table.js';
+import type { InferModel } from '../../table.js';
+import { type DrizzleTypeError, type UpdateSet } from '../../utils.js';
+import type { SelectedFields, SelectedFieldsOrdered } from './select.types.js';
 export interface SQLiteUpdateConfig {
     where?: SQL | undefined;
     set: UpdateSet;

package/sqlite-core/session.d.cts

@@ -0,0 +1,91 @@
+import { entityKind } from '../entity.js';
+import { type TablesRelationalConfig } from '../relations.js';
+import type { Query, SQL } from '../sql/index.js';
+import type { SQLiteAsyncDialect, SQLiteSyncDialect } from './dialect.js';
+import { QueryPromise } from '../index.js';
+import { BaseSQLiteDatabase } from './db.js';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.js';
+export interface PreparedQueryConfig {
+    type: 'sync' | 'async';
+    run: unknown;
+    all: unknown;
+    get: unknown;
+    values: unknown;
+    execute: unknown;
+}
+export declare class ExecuteResultSync<T> extends QueryPromise<T> {
+    private resultCb;
+    static readonly [entityKind]: string;
+    constructor(resultCb: () => T);
+    execute(): Promise<T>;
+    sync(): T;
+}
+export type ExecuteResult<TType extends 'sync' | 'async', TResult> = TType extends 'async' ? Promise<TResult> : ExecuteResultSync<TResult>;
+export declare abstract class PreparedQuery<T extends PreparedQueryConfig> {
+    private mode;
+    private executeMethod;
+    static readonly [entityKind]: string;
+    constructor(mode: 'sync' | 'async', executeMethod: SQLiteExecuteMethod);
+    abstract run(placeholderValues?: Record<string, unknown>): Result<T['type'], T['run']>;
+    abstract all(placeholderValues?: Record<string, unknown>): Result<T['type'], T['all']>;
+    abstract get(placeholderValues?: Record<string, unknown>): Result<T['type'], T['get']>;
+    abstract values(placeholderValues?: Record<string, unknown>): Result<T['type'], T['values']>;
+    execute(placeholderValues?: Record<string, unknown>): ExecuteResult<T['type'], T['execute']>;
+}
+export interface SQLiteTransactionConfig {
+    behavior?: 'deferred' | 'immediate' | 'exclusive';
+}
+export type SQLiteExecuteMethod = 'run' | 'all' | 'get';
+export declare abstract class SQLiteSession<TResultKind extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> {
+    static readonly [entityKind]: string;
+    constructor(
+    /** @internal */
+    dialect: {
+        sync: SQLiteSyncDialect;
+        async: SQLiteAsyncDialect;
+    }[TResultKind]);
+    abstract prepareQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown): PreparedQuery<PreparedQueryConfig & {
+        type: TResultKind;
+    }>;
+    prepareOneTimeQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod): PreparedQuery<PreparedQueryConfig & {
+        type: TResultKind;
+    }>;
+    abstract transaction<T>(transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>, config?: SQLiteTransactionConfig): Result<TResultKind, T>;
+    run(query: SQL): Result<TResultKind, TRunResult>;
+    all<T = unknown>(query: SQL): Result<TResultKind, T[]>;
+    get<T = unknown>(query: SQL): Result<TResultKind, T>;
+    values<T extends any[] = unknown[]>(query: SQL): Result<TResultKind, T[]>;
+}
+interface ResultHKT {
+    readonly $brand: 'SQLiteResultHKT';
+    readonly config: unknown;
+    readonly type: unknown;
+}
+interface SyncResultHKT extends ResultHKT {
+    readonly type: this['config'];
+}
+interface AsyncResultHKT extends ResultHKT {
+    readonly type: Promise<this['config']>;
+}
+export type Result<TKind extends 'sync' | 'async', TResult> = (('sync' extends TKind ? SyncResultHKT : AsyncResultHKT) & {
+    readonly config: TResult;
+})['type'];
+export declare abstract class SQLiteTransaction<TResultType extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends BaseSQLiteDatabase<TResultType, TRunResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(resultType: TResultType, dialect: {
+        sync: SQLiteSyncDialect;
+        async: SQLiteAsyncDialect;
+    }[TResultType], session: SQLiteSession<TResultType, TRunResult, TFullSchema, TSchema>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+}
+export {};

package/sqlite-core/session.d.mts

@@ -0,0 +1,91 @@
+import { entityKind } from '../entity.js';
+import { type TablesRelationalConfig } from '../relations.js';
+import type { Query, SQL } from '../sql/index.js';
+import type { SQLiteAsyncDialect, SQLiteSyncDialect } from './dialect.js';
+import { QueryPromise } from '../index.js';
+import { BaseSQLiteDatabase } from './db.js';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.js';
+export interface PreparedQueryConfig {
+    type: 'sync' | 'async';
+    run: unknown;
+    all: unknown;
+    get: unknown;
+    values: unknown;
+    execute: unknown;
+}
+export declare class ExecuteResultSync<T> extends QueryPromise<T> {
+    private resultCb;
+    static readonly [entityKind]: string;
+    constructor(resultCb: () => T);
+    execute(): Promise<T>;
+    sync(): T;
+}
+export type ExecuteResult<TType extends 'sync' | 'async', TResult> = TType extends 'async' ? Promise<TResult> : ExecuteResultSync<TResult>;
+export declare abstract class PreparedQuery<T extends PreparedQueryConfig> {
+    private mode;
+    private executeMethod;
+    static readonly [entityKind]: string;
+    constructor(mode: 'sync' | 'async', executeMethod: SQLiteExecuteMethod);
+    abstract run(placeholderValues?: Record<string, unknown>): Result<T['type'], T['run']>;
+    abstract all(placeholderValues?: Record<string, unknown>): Result<T['type'], T['all']>;
+    abstract get(placeholderValues?: Record<string, unknown>): Result<T['type'], T['get']>;
+    abstract values(placeholderValues?: Record<string, unknown>): Result<T['type'], T['values']>;
+    execute(placeholderValues?: Record<string, unknown>): ExecuteResult<T['type'], T['execute']>;
+}
+export interface SQLiteTransactionConfig {
+    behavior?: 'deferred' | 'immediate' | 'exclusive';
+}
+export type SQLiteExecuteMethod = 'run' | 'all' | 'get';
+export declare abstract class SQLiteSession<TResultKind extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> {
+    static readonly [entityKind]: string;
+    constructor(
+    /** @internal */
+    dialect: {
+        sync: SQLiteSyncDialect;
+        async: SQLiteAsyncDialect;
+    }[TResultKind]);
+    abstract prepareQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown): PreparedQuery<PreparedQueryConfig & {
+        type: TResultKind;
+    }>;
+    prepareOneTimeQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod): PreparedQuery<PreparedQueryConfig & {
+        type: TResultKind;
+    }>;
+    abstract transaction<T>(transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>, config?: SQLiteTransactionConfig): Result<TResultKind, T>;
+    run(query: SQL): Result<TResultKind, TRunResult>;
+    all<T = unknown>(query: SQL): Result<TResultKind, T[]>;
+    get<T = unknown>(query: SQL): Result<TResultKind, T>;
+    values<T extends any[] = unknown[]>(query: SQL): Result<TResultKind, T[]>;
+}
+interface ResultHKT {
+    readonly $brand: 'SQLiteResultHKT';
+    readonly config: unknown;
+    readonly type: unknown;
+}
+interface SyncResultHKT extends ResultHKT {
+    readonly type: this['config'];
+}
+interface AsyncResultHKT extends ResultHKT {
+    readonly type: Promise<this['config']>;
+}
+export type Result<TKind extends 'sync' | 'async', TResult> = (('sync' extends TKind ? SyncResultHKT : AsyncResultHKT) & {
+    readonly config: TResult;
+})['type'];
+export declare abstract class SQLiteTransaction<TResultType extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends BaseSQLiteDatabase<TResultType, TRunResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(resultType: TResultType, dialect: {
+        sync: SQLiteSyncDialect;
+        async: SQLiteAsyncDialect;
+    }[TResultType], session: SQLiteSession<TResultType, TRunResult, TFullSchema, TSchema>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+}
+export {};