kysely 0.23.1 → 0.23.3

package/dist/cjs/schema/alter-table-builder.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AlterTableDropConstraintBuilder = exports.AlterTableAddForeignKeyConstraintBuilder = exports.AlterTableColumnAlteringBuilder = exports.AlterTableExecutor = exports.AlterTableBuilder = void 0;
+exports.AlterTableColumnAlteringBuilder = exports.AlterTableBuilder = void 0;
 const add_column_node_js_1 = require("../operation-node/add-column-node.js");
 const alter_column_node_js_1 = require("../operation-node/alter-column-node.js");
 const alter_table_node_js_1 = require("../operation-node/alter-table-node.js");
@@ -22,6 +22,9 @@ const column_node_js_1 = require("../operation-node/column-node.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
 const drop_constraint_node_js_1 = require("../operation-node/drop-constraint-node.js");
 const alter_column_builder_js_1 = require("./alter-column-builder.js");
+const alter_table_executor_js_1 = require("./alter-table-executor.js");
+const alter_table_add_foreign_key_constraint_builder_js_1 = require("./alter-table-add-foreign-key-constraint-builder.js");
+const alter_table_drop_constraint_builder_js_1 = require("./alter-table-drop-constraint-builder.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -31,7 +34,7 @@ class AlterTableBuilder {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
     renameTo(newTableName) {
-        return new AlterTableExecutor({
+        return new alter_table_executor_js_1.AlterTableExecutor({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
                 renameTo: (0, table_parser_js_1.parseTable)(newTableName),
@@ -39,7 +42,7 @@ class AlterTableBuilder {
         });
     }
     setSchema(newSchema) {
-        return new AlterTableExecutor({
+        return new alter_table_executor_js_1.AlterTableExecutor({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
                 setSchema: identifier_node_js_1.IdentifierNode.create(newSchema),
@@ -83,7 +86,7 @@ class AlterTableBuilder {
      * See {@link CreateTableBuilder.addUniqueConstraint}
      */
     addUniqueConstraint(constraintName, columns) {
-        return new AlterTableExecutor({
+        return new alter_table_executor_js_1.AlterTableExecutor({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
                 addConstraint: add_constraint_node_js_1.AddConstraintNode.create(unique_constraint_node_js_1.UniqueConstraintNode.create(columns, constraintName)),
@@ -94,7 +97,7 @@ class AlterTableBuilder {
      * See {@link CreateTableBuilder.addCheckConstraint}
      */
     addCheckConstraint(constraintName, checkExpression) {
-        return new AlterTableExecutor({
+        return new alter_table_executor_js_1.AlterTableExecutor({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
                 addConstraint: add_constraint_node_js_1.AddConstraintNode.create(check_constraint_node_js_1.CheckConstraintNode.create(checkExpression.toOperationNode(), constraintName)),
@@ -109,13 +112,13 @@ class AlterTableBuilder {
      * is because you can only add one column per `ALTER TABLE` query.
      */
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
-        return new AlterTableAddForeignKeyConstraintBuilder({
+        return new alter_table_add_foreign_key_constraint_builder_js_1.AlterTableAddForeignKeyConstraintBuilder({
             ...this.#props,
             constraintBuilder: new foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), (0, table_parser_js_1.parseTable)(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName)),
         });
     }
     dropConstraint(constraintName) {
-        return new AlterTableDropConstraintBuilder({
+        return new alter_table_drop_constraint_builder_js_1.AlterTableDropConstraintBuilder({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
                 dropConstraint: drop_constraint_node_js_1.DropConstraintNode.create(constraintName),
@@ -132,22 +135,6 @@ class AlterTableBuilder {
     }
 }
 exports.AlterTableBuilder = AlterTableBuilder;
-class AlterTableExecutor {
-    #props;
-    constructor(props) {
-        this.#props = (0, object_utils_js_1.freeze)(props);
-    }
-    toOperationNode() {
-        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
-    }
-    compile() {
-        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
-    }
-    async execute() {
-        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
-    }
-}
-exports.AlterTableExecutor = AlterTableExecutor;
 class AlterTableColumnAlteringBuilder {
     #props;
     constructor(props) {
@@ -197,85 +184,6 @@ class AlterTableColumnAlteringBuilder {
     }
 }
 exports.AlterTableColumnAlteringBuilder = AlterTableColumnAlteringBuilder;
-class AlterTableAddForeignKeyConstraintBuilder {
-    #props;
-    constructor(props) {
-        this.#props = (0, object_utils_js_1.freeze)(props);
-    }
-    onDelete(onDelete) {
-        return new AlterTableAddForeignKeyConstraintBuilder({
-            ...this.#props,
-            constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete),
-        });
-    }
-    onUpdate(onUpdate) {
-        return new AlterTableAddForeignKeyConstraintBuilder({
-            ...this.#props,
-            constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
-        });
-    }
-    toOperationNode() {
-        return this.#props.executor.transformQuery(alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
-            addConstraint: add_constraint_node_js_1.AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),
-        }), this.#props.queryId);
-    }
-    compile() {
-        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
-    }
-    async execute() {
-        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
-    }
-}
-exports.AlterTableAddForeignKeyConstraintBuilder = AlterTableAddForeignKeyConstraintBuilder;
-class AlterTableDropConstraintBuilder {
-    #props;
-    constructor(props) {
-        this.#props = (0, object_utils_js_1.freeze)(props);
-    }
-    ifExists() {
-        return new AlterTableDropConstraintBuilder({
-            ...this.#props,
-            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
-                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
-                    ifExists: true,
-                }),
-            }),
-        });
-    }
-    cascade() {
-        return new AlterTableDropConstraintBuilder({
-            ...this.#props,
-            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
-                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
-                    modifier: 'cascade',
-                }),
-            }),
-        });
-    }
-    restrict() {
-        return new AlterTableDropConstraintBuilder({
-            ...this.#props,
-            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
-                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
-                    modifier: 'restrict',
-                }),
-            }),
-        });
-    }
-    toOperationNode() {
-        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
-    }
-    compile() {
-        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
-    }
-    async execute() {
-        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
-    }
-}
-exports.AlterTableDropConstraintBuilder = AlterTableDropConstraintBuilder;
 (0, prevent_await_js_1.preventAwait)(AlterTableBuilder, "don't await AlterTableBuilder instances");
 (0, prevent_await_js_1.preventAwait)(alter_column_builder_js_1.AlterColumnBuilder, "don't await AlterColumnBuilder instances");
-(0, prevent_await_js_1.preventAwait)(AlterTableExecutor, "don't await AlterTableExecutor instances directly. To execute the query you need to call `execute`");
 (0, prevent_await_js_1.preventAwait)(AlterTableColumnAlteringBuilder, "don't await AlterTableColumnAlteringBuilder instances directly. To execute the query you need to call `execute`");
-(0, prevent_await_js_1.preventAwait)(AlterTableAddForeignKeyConstraintBuilder, "don't await AlterTableAddForeignKeyConstraintBuilder instances directly. To execute the query you need to call `execute`");
-(0, prevent_await_js_1.preventAwait)(AlterTableDropConstraintBuilder, "don't await AlterTableDropConstraintBuilder instances directly. To execute the query you need to call `execute`");

package/dist/cjs/schema/alter-table-drop-constraint-builder.d.ts

@@ -0,0 +1,21 @@
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryId } from '../util/query-id.js';
+export declare class AlterTableDropConstraintBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableDropConstraintBuilderProps);
+    ifExists(): AlterTableDropConstraintBuilder;
+    cascade(): AlterTableDropConstraintBuilder;
+    restrict(): AlterTableDropConstraintBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableDropConstraintBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+}

package/dist/cjs/schema/alter-table-drop-constraint-builder.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterTableDropConstraintBuilder = void 0;
+const alter_table_node_js_1 = require("../operation-node/alter-table-node.js");
+const drop_constraint_node_js_1 = require("../operation-node/drop-constraint-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+class AlterTableDropConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    ifExists() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
+                    ifExists: true,
+                }),
+            }),
+        });
+    }
+    cascade() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
+                    modifier: 'cascade',
+                }),
+            }),
+        });
+    }
+    restrict() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
+                    modifier: 'restrict',
+                }),
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+exports.AlterTableDropConstraintBuilder = AlterTableDropConstraintBuilder;
+(0, prevent_await_js_1.preventAwait)(AlterTableDropConstraintBuilder, "don't await AlterTableDropConstraintBuilder instances directly. To execute the query you need to call `execute`");

package/dist/cjs/schema/alter-table-executor.d.ts

@@ -0,0 +1,18 @@
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryId } from '../util/query-id.js';
+export declare class AlterTableExecutor implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableExecutorProps);
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableExecutorProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+}

package/dist/cjs/schema/alter-table-executor.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterTableExecutor = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+class AlterTableExecutor {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+exports.AlterTableExecutor = AlterTableExecutor;
+(0, prevent_await_js_1.preventAwait)(AlterTableExecutor, "don't await AlterTableExecutor instances directly. To execute the query you need to call `execute`");

package/dist/cjs/util/type-error.d.ts

@@ -0,0 +1,3 @@
+export interface KyselyTypeError<E extends string> {
+    readonly __kyselyTypeError__: E;
+}

package/dist/cjs/util/type-error.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/dialect/mysql/mysql-introspector.js

@@ -29,7 +29,7 @@ export class MysqlIntrospector {
         ])
             .where('table_schema', '=', sql `database()`)
             .orderBy('table_name')
-            .orderBy('column_name')
+            .orderBy('ordinal_position')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -55,7 +55,7 @@ export class PostgresIntrospector {
             .where('a.attisdropped', '!=', true)
             .orderBy('ns.nspname')
             .orderBy('c.relname')
-            .orderBy('a.attname')
+            .orderBy('a.attnum')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -50,7 +50,7 @@ export class SqliteIntrospector {
         const columns = await db
             .selectFrom(sql `pragma_table_info(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull', 'dflt_value'])
-            .orderBy('name')
+            .orderBy('cid')
             .execute();
         return {
             name: table,

package/dist/esm/index.d.ts

@@ -172,7 +172,7 @@ export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.j
 export { TableExpression, TableExpressionOrList, } from './parser/table-parser.js';
 export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-parser.js';
 export { InsertObject } from './parser/insert-values-parser.js';
-export { MutationObject } from './parser/update-set-parser.js';
+export { UpdateObject } from './parser/update-set-parser.js';
 export { OrderByExpression, OrderByDirectionExpression, } from './parser/order-by-parser.js';
 export { ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList, } from './parser/binary-operation-parser.js';
 export { ExistsExpression } from './parser/unary-operation-parser.js';

package/dist/esm/operation-node/on-conflict-node.d.ts

@@ -25,4 +25,6 @@ export declare const OnConflictNode: Readonly<{
     cloneWithIndexOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
     cloneWithUpdateWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
     cloneWithUpdateOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithoutIndexWhere(node: OnConflictNode): OnConflictNode;
+    cloneWithoutUpdateWhere(node: OnConflictNode): OnConflictNode;
 }>;

package/dist/esm/operation-node/on-conflict-node.js

@@ -51,4 +51,16 @@ export const OnConflictNode = freeze({
                 : WhereNode.create(operation),
         });
     },
+    cloneWithoutIndexWhere(node) {
+        return freeze({
+            ...node,
+            indexWhere: undefined,
+        });
+    },
+    cloneWithoutUpdateWhere(node) {
+        return freeze({
+            ...node,
+            updateWhere: undefined,
+        });
+    },
 });

package/dist/esm/operation-node/query-node.d.ts

@@ -17,4 +17,5 @@ export declare const QueryNode: Readonly<{
     cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, operation: OperationNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
     cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
+    cloneWithoutWhere<T_4 extends FilterableQueryNode>(node: T_4): T_4;
 }>;

package/dist/esm/operation-node/query-node.js

@@ -46,4 +46,10 @@ export const QueryNode = freeze({
                 : ReturningNode.create(selections),
         });
     },
+    cloneWithoutWhere(node) {
+        return freeze({
+            ...node,
+            where: undefined,
+        });
+    },
 });

package/dist/esm/operation-node/select-query-node.d.ts

@@ -50,4 +50,8 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
     cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
+    cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -108,4 +108,28 @@ export const SelectQueryNode = freeze({
             explain,
         });
     },
+    cloneWithoutSelections(select) {
+        return freeze({
+            ...select,
+            selections: [],
+        });
+    },
+    cloneWithoutLimit(select) {
+        return freeze({
+            ...select,
+            limit: undefined,
+        });
+    },
+    cloneWithoutOffset(select) {
+        return freeze({
+            ...select,
+            offset: undefined,
+        });
+    },
+    cloneWithoutOrderBy(select) {
+        return freeze({
+            ...select,
+            orderBy: undefined,
+        });
+    },
 });

package/dist/esm/parser/binary-operation-parser.d.ts

@@ -7,7 +7,7 @@ import { HavingInterface } from '../query-builder/having-interface.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
 export declare type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
-export declare type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export declare type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE> | null>;
 export declare type WhereGrouper<DB, TB extends keyof DB> = (qb: WhereInterface<DB, TB>) => WhereInterface<DB, TB>;
 export declare type HavingGrouper<DB, TB extends keyof DB> = (qb: HavingInterface<DB, TB>) => HavingInterface<DB, TB>;
 export declare type ComparisonOperatorExpression = ComparisonOperator | Expression<any>;

package/dist/esm/parser/update-set-parser.d.ts

@@ -1,7 +1,7 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
-export declare type MutationObject<DB, TB extends keyof DB, TM extends keyof DB> = {
-    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>> | undefined;
+export declare type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB> = {
+    [C in UpdateKeys<DB[UT]>]?: ValueExpression<DB, TB, UpdateType<DB[UT][C]>> | undefined;
 };
-export declare function parseUpdateObject(row: MutationObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObject(update: UpdateObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/update-set-parser.js

@@ -2,8 +2,8 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { parseValueExpression } from './value-parser.js';
-export function parseUpdateObject(row) {
-    return Object.entries(row)
+export function parseUpdateObject(update) {
+    return Object.entries(update)
         .filter(([_, value]) => value !== undefined)
         .map(([key, value]) => {
         return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(value));

package/dist/esm/query-builder/delete-query-builder.d.ts

@@ -21,6 +21,7 @@ import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
 import { ExistsExpression } from '../parser/unary-operation-parser.js';
+import { KyselyTypeError } from '../util/type-error.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -408,6 +409,25 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Just like {@link whereExists} but creates an `or not exists` clause.
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -662,7 +682,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -719,6 +739,48 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    /**
+     * Asserts that query's output row type equals the given type `T`.
+     *
+     * This method can be used to simplify excessively complex types to make typescript happy
+     * and much faster.
+     *
+     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
+     * for typescript and you get errors like this:
+     *
+     * ```
+     * error TS2589: Type instantiation is excessively deep and possibly infinite.
+     * ```
+     *
+     * In these case you can often use this method to help typescript a little bit. When you use this
+     * method to assert the output type of a query, Kysely can drop the complex output type that
+     * consists of multiple nested helper types and replace it with the simple asserted type.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('deleted_person', (qb) => qb
+     *     .deleteFrom('person')
+     *     .where('id', '=', person.id)
+     *     .returning('first_name')
+     *     .assertType<{ first_name: string }>()
+     *   )
+     *   .with('deleted_pet', (qb) => qb
+     *     .deleteFrom('pet')
+     *     .where('owner_id', '=', person.id)
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['deleted_person', 'deleted_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType<T extends O>(): O extends T ? DeleteQueryBuilder<DB, TB, T> : KyselyTypeError<`assertType() call failed: The type passed in is not equal to the output type of the query.`>;
     /**
      * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
      */

package/dist/esm/query-builder/delete-query-builder.js

@@ -65,6 +65,12 @@ export class DeleteQueryBuilder {
             queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExists(arg)),
         });
     }
+    clearWhere() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
+        });
+    }
     innerJoin(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
@@ -173,7 +179,7 @@ export class DeleteQueryBuilder {
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -241,6 +247,50 @@ export class DeleteQueryBuilder {
     castTo() {
         return new DeleteQueryBuilder(this.#props);
     }
+    /**
+     * Asserts that query's output row type equals the given type `T`.
+     *
+     * This method can be used to simplify excessively complex types to make typescript happy
+     * and much faster.
+     *
+     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
+     * for typescript and you get errors like this:
+     *
+     * ```
+     * error TS2589: Type instantiation is excessively deep and possibly infinite.
+     * ```
+     *
+     * In these case you can often use this method to help typescript a little bit. When you use this
+     * method to assert the output type of a query, Kysely can drop the complex output type that
+     * consists of multiple nested helper types and replace it with the simple asserted type.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('deleted_person', (qb) => qb
+     *     .deleteFrom('person')
+     *     .where('id', '=', person.id)
+     *     .returning('first_name')
+     *     .assertType<{ first_name: string }>()
+     *   )
+     *   .with('deleted_pet', (qb) => qb
+     *     .deleteFrom('pet')
+     *     .where('owner_id', '=', person.id)
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['deleted_person', 'deleted_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType() {
+        return new DeleteQueryBuilder(this.#props);
+    }
     /**
      * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
      */