kysely 0.11.4 → 0.12.0

package/dist/esm/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/esm/parser/update-set-parser.js

@@ -1,29 +1,10 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
-import { QueryNode } from '../operation-node/query-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { isFunction, isPrimitive, } from '../util/object-utils.js';
+import { parseValueExpression } from './value-parser.js';
 export function parseUpdateObject(ctx, row) {
-    return Object.entries(row).map(([key, value]) => {
-        return ColumnUpdateNode.create(ColumnNode.create(key), parseMutationValueExpression(ctx, value));
+    return Object.entries(row)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => {
+        return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(ctx, value));
     });
 }
-export function parseMutationValueExpression(ctx, value) {
-    if (isPrimitive(value)) {
-        return ValueNode.create(value);
-    }
-    else if (isOperationNodeSource(value)) {
-        const node = value.toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if (isFunction(value)) {
-        const node = value(ctx.createExpressionBuilder()).toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`unsupported value for mutation object ${JSON.stringify(value)}`);
-}

package/dist/esm/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/esm/parser/value-parser.js

@@ -1,49 +1,26 @@
-import { ColumnNode } from '../operation-node/column-node.js';
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { isFunction, isPrimitive } from '../util/object-utils.js';
-import { QueryNode } from '../operation-node/query-node.js';
+import { isPrimitive, isReadonlyArray, } from '../util/object-utils.js';
+import { parseComplexExpression, } from './complex-expression-parser.js';
 export function parseValueExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if (isReadonlyArray(arg)) {
         return parseValueExpressionList(ctx, arg);
     }
     else {
         return parseValueExpression(ctx, arg);
     }
 }
-export function parseValueExpression(ctx, arg) {
-    if (isPrimitive(arg)) {
-        return ValueNode.create(arg);
+export function parseValueExpression(ctx, exp) {
+    if (isPrimitive(exp)) {
+        return ValueNode.create(exp);
     }
-    else if (isOperationNodeSource(arg)) {
-        const node = arg.toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if (isFunction(arg)) {
-        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`invalid value expression ${JSON.stringify(arg)}`);
+    return parseComplexExpression(ctx, exp);
 }
 function parseValueExpressionList(ctx, arg) {
     if (arg.every(isPrimitive)) {
         // Optimization for large lists of primitive values.
         return PrimitiveValueListNode.create(arg);
     }
-    return ValueListNode.create(arg.map((it) => {
-        const node = parseValueExpression(ctx, it);
-        if (ColumnNode.is(node)) {
-            throw new Error('value lists cannot have column references');
-        }
-        if (ValueListNode.is(node) || PrimitiveValueListNode.is(node)) {
-            throw new Error('value lists cannot have nested lists');
-        }
-        return node;
-    }));
+    return ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
 }

package/dist/esm/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/esm/plugin/immediate-value.ts/immediate-value-plugin.js

@@ -12,7 +12,7 @@ export class ImmediateValuePlugin {
     transformQuery(args) {
         return this.#transformer.transformNode(args.node);
     }
-    async transformResult(args) {
-        return args.result;
+    transformResult(args) {
+        return Promise.resolve(args.result);
     }
 }

package/dist/esm/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/esm/query-builder/delete-query-builder.js

@@ -0,0 +1,181 @@
+import { parseJoin, } from '../parser/join-parser.js';
+import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
+import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
+import { QueryNode } from '../operation-node/query-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+import { NoResultError } from './no-result-error.js';
+import { DeleteResult } from './delete-result.js';
+export class DeleteQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    where(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    whereRef(lhs, op, rhs) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    orWhere(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    orWhereRef(lhs, op, rhs) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    whereExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    whereNotExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereNotExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    innerJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'InnerJoin', args)),
+        });
+    }
+    leftJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'LeftJoin', args)),
+        });
+    }
+    rightJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'RightJoin', args)),
+        });
+    }
+    fullJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'FullJoin', args)),
+        });
+    }
+    returning(selection) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
+        });
+    }
+    returningAll() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, 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 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 = NoResultError) {
+        const result = await this.executeTakeFirst();
+        if (result === undefined) {
+            throw new errorConstructor(this.toOperationNode());
+        }
+        return result;
+    }
+}
+preventAwait(DeleteQueryBuilder, "don't await DeleteQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/esm/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/esm/query-builder/expression-builder.js

@@ -1,4 +1,4 @@
-import { QueryBuilder } from './query-builder.js';
+import { SelectQueryBuilder } from './select-query-builder.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
@@ -44,8 +44,8 @@ export class ExpressionBuilder {
     get fn() {
         return new FunctionBuilder({ executor: this.#props.executor });
     }
-    subQuery(table) {
-        return new QueryBuilder({
+    selectFrom(table) {
+        return new SelectQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,

package/dist/esm/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/esm/query-builder/function-builder.js

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

package/dist/esm/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>;
+}

package/dist/esm/query-builder/having-interface.js

@@ -0,0 +1 @@
+export {};