kysely 0.11.4 → 0.12.0

package/dist/cjs/parser/table-parser.js

@@ -4,7 +4,7 @@ exports.parseTable = exports.parseAliasedTable = exports.parseTableExpression =
 const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 function parseTableExpressionOrList(ctx, table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
         return table.map((it) => parseTableExpression(ctx, it));
@@ -18,14 +18,8 @@ function parseTableExpression(ctx, table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return parseAliasedTable(table);
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(table)) {
-        return table.toOperationNode();
-    }
-    else if ((0, object_utils_js_1.isFunction)(table)) {
-        return table(ctx.createExpressionBuilder()).toOperationNode();
-    }
     else {
-        throw new Error(`invalid table expression ${JSON.stringify(table)}`);
+        return (0, complex_expression_parser_js_1.parseAliasedComplexExpression)(ctx, table);
     }
 }
 exports.parseTableExpression = parseTableExpression;

package/dist/cjs/parser/union-parser.d.ts

@@ -1,5 +1,5 @@
 import { UnionNode } from '../operation-node/union-node.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type UnionExpression<DB, O> = QueryBuilder<DB, any, O> | RawBuilder<O>;
+export declare type UnionExpression<DB, O> = SelectQueryBuilder<DB, any, O> | RawBuilder<O>;
 export declare function parseUnion(union: UnionExpression<any, any>, all: boolean): UnionNode;

package/dist/cjs/parser/union-parser.js

@@ -1,13 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUnion = void 0;
-const query_node_js_1 = require("../operation-node/query-node.js");
 const union_node_js_1 = require("../operation-node/union-node.js");
 function parseUnion(union, all) {
-    const node = union.toOperationNode();
-    if (query_node_js_1.QueryNode.isMutating(node)) {
-        throw new Error("can't combine insert, update or delete queries using union");
-    }
-    return union_node_js_1.UnionNode.create(node, all);
+    return union_node_js_1.UnionNode.create(union.toOperationNode(), all);
 }
 exports.parseUnion = parseUnion;

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

@@ -1,13 +1,7 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.js';
+import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]?: MutationValueExpression<DB, TB, DB[TB][C]>;
+    [C in keyof DB[TB]]?: ValueExpression<DB, TB, DB[TB][C]>;
 };
-export declare type MutationValueExpression<DB, TB extends keyof DB, T> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
 export declare function parseUpdateObject(ctx: ParseContext, row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;
-export declare function parseMutationValueExpression(ctx: ParseContext, value: MutationValueExpression<any, any, PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

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

@@ -1,34 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMutationValueExpression = exports.parseUpdateObject = void 0;
+exports.parseUpdateObject = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const column_update_node_js_1 = require("../operation-node/column-update-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
-const query_node_js_1 = require("../operation-node/query-node.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
-const object_utils_js_1 = require("../util/object-utils.js");
+const value_parser_js_1 = require("./value-parser.js");
 function parseUpdateObject(ctx, row) {
-    return Object.entries(row).map(([key, value]) => {
-        return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), parseMutationValueExpression(ctx, value));
+    return Object.entries(row)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => {
+        return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(ctx, value));
     });
 }
 exports.parseUpdateObject = parseUpdateObject;
-function parseMutationValueExpression(ctx, value) {
-    if ((0, object_utils_js_1.isPrimitive)(value)) {
-        return value_node_js_1.ValueNode.create(value);
-    }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(value)) {
-        const node = value.toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if ((0, object_utils_js_1.isFunction)(value)) {
-        const node = value(ctx.createExpressionBuilder()).toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`unsupported value for mutation object ${JSON.stringify(value)}`);
-}
-exports.parseMutationValueExpression = parseMutationValueExpression;

package/dist/cjs/parser/value-parser.d.ts

@@ -1,8 +1,11 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.js';
-export declare type ValueExpression<DB, TB extends keyof DB, RE> = ExtractTypeFromReferenceExpression<DB, TB, RE> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
-export declare type ValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, RE> | ReadonlyArray<ValueExpression<DB, TB, RE>>;
-export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, any>): ValueExpressionNode;
-export declare function parseValueExpression(ctx: ParseContext, arg: ValueExpression<any, any, any>): ValueExpressionNode;
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { ComplexExpression } from './complex-expression-parser.js';
+export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB>;
+export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
+export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, PrimitiveValue>): ValueExpressionNode;
+export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, PrimitiveValue>): ValueNode | SelectQueryNode | RawNode;

package/dist/cjs/parser/value-parser.js

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
-const column_node_js_1 = require("../operation-node/column-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const query_node_js_1 = require("../operation-node/query-node.js");
+const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 function parseValueExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return parseValueExpressionList(ctx, arg);
     }
     else {
@@ -17,23 +15,11 @@ function parseValueExpressionOrList(ctx, arg) {
     }
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
-function parseValueExpression(ctx, arg) {
-    if ((0, object_utils_js_1.isPrimitive)(arg)) {
-        return value_node_js_1.ValueNode.create(arg);
+function parseValueExpression(ctx, exp) {
+    if ((0, object_utils_js_1.isPrimitive)(exp)) {
+        return value_node_js_1.ValueNode.create(exp);
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        const node = arg.toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if ((0, object_utils_js_1.isFunction)(arg)) {
-        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`invalid value expression ${JSON.stringify(arg)}`);
+    return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
 }
 exports.parseValueExpression = parseValueExpression;
 function parseValueExpressionList(ctx, arg) {
@@ -41,14 +27,5 @@ function parseValueExpressionList(ctx, arg) {
         // Optimization for large lists of primitive values.
         return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
     }
-    return value_list_node_js_1.ValueListNode.create(arg.map((it) => {
-        const node = parseValueExpression(ctx, it);
-        if (column_node_js_1.ColumnNode.is(node)) {
-            throw new Error('value lists cannot have column references');
-        }
-        if (value_list_node_js_1.ValueListNode.is(node) || primitive_value_list_node_js_1.PrimitiveValueListNode.is(node)) {
-            throw new Error('value lists cannot have nested lists');
-        }
-        return node;
-    }));
+    return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
 }

package/dist/cjs/parser/with-parser.d.ts

@@ -1,11 +1,14 @@
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
-export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | AnyRawBuilder;
+export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => SelectQueryBuilder<DB, any, any> | InsertQueryBuilder<DB, any, any> | UpdateQueryBuilder<DB, any, any> | DeleteQueryBuilder<DB, any, any> | AnyRawBuilder;
 export declare type QueryCreatorWithCommonTableExpression<DB, N extends string, E extends CommonTableExpression<DB>> = QueryCreator<DB & Record<N, ExtractRowTypeFromCommonTableExpression<E>>>;
-declare type ExtractRowTypeFromCommonTableExpression<E> = E extends (creator: QueryCreator<any>) => infer Q ? Q extends QueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowTypeFromCommonTableExpression<E> = E extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 export declare function parseCommonTableExpression(ctx: ParseContext, name: string, expression: CommonTableExpression<any>): CommonTableExpressionNode;
 export {};

package/dist/cjs/plugin/immediate-value.ts/immediate-value-plugin.js

@@ -15,8 +15,8 @@ class ImmediateValuePlugin {
     transformQuery(args) {
         return this.#transformer.transformNode(args.node);
     }
-    async transformResult(args) {
-        return args.result;
+    transformResult(args) {
+        return Promise.resolve(args.result);
     }
 }
 exports.ImmediateValuePlugin = ImmediateValuePlugin;

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

@@ -0,0 +1,102 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
+import { TableExpression, TableExpressionDatabase, TableExpressionTables, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, FullJoinTableExpressionDatabase } from '../parser/table-parser.js';
+import { SelectExpression } from '../parser/select-parser.js';
+import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
+import { ReturningRow } from '../parser/returning-parser.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { AnyRawBuilder, SingleResultType } from '../util/type-utils.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+import { ParseContext } from '../parser/parse-context.js';
+import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { WhereInterface } from './where-interface.js';
+import { JoinInterface } from './join-interface.js';
+import { ReturningInterface } from './returning-interface.js';
+import { NoResultErrorConstructor } from './no-result-error.js';
+import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
+export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+    #private;
+    constructor(props: DeleteQueryBuilderProps);
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
+    where(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    where(raw: AnyRawBuilder): DeleteQueryBuilder<DB, TB, O>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
+    orWhere(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    orWhere(raw: AnyRawBuilder): DeleteQueryBuilder<DB, TB, O>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    whereExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    whereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    orWhereExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    orWhereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returningAll(): DeleteQueryBuilder<DB, TB, DB[TB]>;
+    /**
+     * Simply calls the given function passing `this` as the only argument.
+     *
+     * This method can be useful when adding optional method calls:
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('person')
+     *   .call((qb) => {
+     *     if (something) {
+     *       return qb.where('something', '=', something)
+     *     } else {
+     *       return qb.where('somethingElse', '=', somethingElse)
+     *     }
+     *   })
+     *   .execute()
+     * ```
+     */
+    call<T>(func: (qb: this) => T): T;
+    /**
+     * Change the output type of the query.
+     *
+     * You should only use this method as the last resort if the types
+     * don't support your use case.
+     */
+    castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O>;
+    toOperationNode(): DeleteQueryNode;
+    compile(): CompiledQuery;
+    /**
+     * Executes the query and returns an array of rows.
+     *
+     * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
+     */
+    execute(): Promise<O[]>;
+    /**
+     * Executes the query and returns the first result or undefined if
+     * the query returned no result.
+     */
+    executeTakeFirst(): Promise<SingleResultType<O>>;
+    /**
+     * Executes the query and returns the first result or throws if
+     * the query returned no result.
+     *
+     * By default an instance of {@link NoResultError} is thrown, but you can
+     * provide a custom error class as the only argument to throw a different
+     * error.
+     */
+    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+}
+export interface DeleteQueryBuilderProps {
+    readonly queryId: QueryId;
+    readonly queryNode: DeleteQueryNode;
+    readonly executor: QueryExecutor;
+    readonly parseContext: ParseContext;
+}

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

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteQueryBuilder = void 0;
+const join_parser_js_1 = require("../parser/join-parser.js");
+const select_parser_js_1 = require("../parser/select-parser.js");
+const filter_parser_js_1 = require("../parser/filter-parser.js");
+const query_node_js_1 = require("../operation-node/query-node.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const no_result_error_js_1 = require("./no-result-error.js");
+const delete_result_js_1 = require("./delete-result.js");
+class DeleteQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    where(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+        });
+    }
+    whereRef(lhs, op, rhs) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    orWhere(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+        });
+    }
+    orWhereRef(lhs, op, rhs) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    whereExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    whereNotExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereNotExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    innerJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'InnerJoin', args)),
+        });
+    }
+    leftJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'LeftJoin', args)),
+        });
+    }
+    rightJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'RightJoin', args)),
+        });
+    }
+    fullJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'FullJoin', args)),
+        });
+    }
+    returning(selection) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
+        });
+    }
+    returningAll() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)()),
+        });
+    }
+    /**
+     * Simply calls the given function passing `this` as the only argument.
+     *
+     * This method can be useful when adding optional method calls:
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('person')
+     *   .call((qb) => {
+     *     if (something) {
+     *       return qb.where('something', '=', something)
+     *     } else {
+     *       return qb.where('somethingElse', '=', somethingElse)
+     *     }
+     *   })
+     *   .execute()
+     * ```
+     */
+    call(func) {
+        return func(this);
+    }
+    /**
+     * Change the output type of the query.
+     *
+     * You should only use this method as the last resort if the types
+     * don't support your use case.
+     */
+    castTo() {
+        return new DeleteQueryBuilder(this.#props);
+    }
+    withPlugin(plugin) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    /**
+     * Executes the query and returns an array of rows.
+     *
+     * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
+     */
+    async execute() {
+        const compildQuery = this.compile();
+        const query = compildQuery.query;
+        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
+        if (this.#props.parseContext.adapter.supportsReturning && query.returning) {
+            return result.rows;
+        }
+        else {
+            return [new delete_result_js_1.DeleteResult(result.numUpdatedOrDeletedRows)];
+        }
+    }
+    /**
+     * Executes the query and returns the first result or undefined if
+     * the query returned no result.
+     */
+    async executeTakeFirst() {
+        const [result] = await this.execute();
+        return result;
+    }
+    /**
+     * Executes the query and returns the first result or throws if
+     * the query returned no result.
+     *
+     * By default an instance of {@link NoResultError} is thrown, but you can
+     * provide a custom error class as the only argument to throw a different
+     * error.
+     */
+    async executeTakeFirstOrThrow(errorConstructor = no_result_error_js_1.NoResultError) {
+        const result = await this.executeTakeFirst();
+        if (result === undefined) {
+            throw new errorConstructor(this.toOperationNode());
+        }
+        return result;
+    }
+}
+exports.DeleteQueryBuilder = DeleteQueryBuilder;
+(0, prevent_await_js_1.preventAwait)(DeleteQueryBuilder, "don't await DeleteQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/cjs/query-builder/expression-builder.d.ts

@@ -1,4 +1,5 @@
-import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser.js';
+import { SelectQueryBuilder } from './select-query-builder.js';
+import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { FunctionBuilder } from './function-builder.js';
@@ -43,7 +44,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * The query builder returned by this method is typed in a way that you can refer to
      * all tables of the parent query in addition to the subquery's tables.
      *
-     * @example
+     * ### Examples
+     *
      * This example shows that you can refer to both `pet.owner_id` and `person.id`
      * columns from the subquery. This is needed to be able to create correlated
      * subqueries:
@@ -52,7 +54,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * const result = await db.selectFrom('pet')
      *   .select([
      *     'pet.name',
-     *     (qb) => qb.subQuery('person')
+     *     (qb) => qb.selectFrom('person')
      *       .whereRef('person.id', '=', 'pet.owner_id')
      *       .select('person.first_name')
      *       .as('owner_name')
@@ -74,12 +76,12 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * from "pet"
      * ```
      *
-     * You can use a normal query in place of `(qb) => qb.subQuery(...)` but in
+     * You can use a normal query in place of `(qb) => qb.selectFrom(...)` but in
      * that case Kysely typings wouldn't allow you to reference `pet.owner_id`
      * because `pet` is not joined to that query.
      */
-    subQuery<F extends TableExpression<DB, TB>>(from: F[]): QueryBuilderWithTable<DB, TB, {}, F>;
-    subQuery<F extends TableExpression<DB, TB>>(from: F): QueryBuilderWithTable<DB, TB, {}, F>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
     /**
      * See {@link QueryCreator.withSchema}
      */

package/dist/cjs/query-builder/expression-builder.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressionBuilder = void 0;
-const query_builder_js_1 = require("./query-builder.js");
+const select_query_builder_js_1 = require("./select-query-builder.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
 const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
@@ -47,8 +47,8 @@ class ExpressionBuilder {
     get fn() {
         return new function_builder_js_1.FunctionBuilder({ executor: this.#props.executor });
     }
-    subQuery(table) {
-        return new query_builder_js_1.QueryBuilder({
+    selectFrom(table) {
+        return new select_query_builder_js_1.SelectQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,

package/dist/cjs/query-builder/function-builder.d.ts

@@ -4,7 +4,8 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
- * @example
+ * ### Examples
+ *
  * ```ts
  * const { count } = db.fn
  *

package/dist/cjs/query-builder/function-builder.js

@@ -7,7 +7,8 @@ const query_id_js_1 = require("../util/query-id.js");
 /**
  * Helpers for type safe SQL function calls.
  *
- * @example
+ * ### Examples
+ *
  * ```ts
  * const { count } = db.fn
  *

package/dist/cjs/query-builder/having-interface.d.ts

@@ -0,0 +1,49 @@
+import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, HavingGrouper } from '../parser/filter-parser.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
+export interface HavingInterface<DB, TB extends keyof DB> {
+    /**
+     * Just like {@link WhereInterface.where | where} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
+    having(grouper: HavingGrouper<DB, TB>): HavingInterface<DB, TB>;
+    having(raw: AnyRawBuilder): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.whereRef | whereRef} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    havingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhere | orWhere} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
+    orHaving(grouper: HavingGrouper<DB, TB>): HavingInterface<DB, TB>;
+    orHaving(raw: AnyRawBuilder): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhereRef | orWhereRef} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.whereExists | whereExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    havingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.whereNotExists | whereNotExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    havingNotExist(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhereExists | orWhereExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHavingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhereNotExists | orWhereNotExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHavingNotExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+}