kysely 0.23.3 → 0.23.5

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

@@ -1,11 +1,11 @@
 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 } from '../parser/table-parser.js';
+import { From, FromTables, TableExpression } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
+import { MergePartial, Nullable, SimplifyResult, SimplifySingleResult } 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';
@@ -428,6 +428,82 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     clearWhere(): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a `using` clause to the query.
+     *
+     * This clause allows adding additional tables to the query for filtering/returning
+     * only. Usually a non-standard syntactic-sugar alternative to a `where` with a sub-query.
+     *
+     * ### Examples:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .using('person')
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     *   .where('person.first_name', '=', 'Bob')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet"
+     * using "person"
+     * where "pet"."owner_id" = "person"."id"
+     *   and "person"."first_name" = $1
+     * ```
+     *
+     * On supported databases such as MySQL, this clause allows using joins, but requires
+     * at least one of the tables after the `from` keyword to be also named after
+     * the `using` keyword. See also {@link innerJoin}, {@link leftJoin}, {@link rightJoin}
+     * and {@link fullJoin}.
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .using('pet')
+     *   .leftJoin('person', 'person.id', 'pet.owner_id')
+     *   .where('person.first_name', '=', 'Bob')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `pet`
+     * using `pet`
+     * left join `person` on `person`.`id` = `pet`.`owner_id`
+     * where `person`.`first_name` = ?
+     * ```
+     *
+     * You can also chain multiple invocations of this method, or pass an array to
+     * a single invocation to name multiple tables.
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('toy')
+     *   .using(['pet', 'person'])
+     *   .whereRef('toy.pet_id', '=', 'pet.id')
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     *   .where('person.first_name', '=', 'Bob')
+     *   .returning('pet.name')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "toy"
+     * using "pet", "person"
+     * where "toy"."pet_id" = "pet"."id"
+     *   and "pet"."owner_id" = "person"."id"
+     *   and "person"."first_name" = $1
+     * returning "pet"."name"
+     * ```
+     */
+    using<TE extends TableExpression<DB, keyof DB>>(tables: TE[]): DeleteQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, O>;
+    using<TE extends TableExpression<DB, keyof DB>>(table: TE): DeleteQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -678,7 +754,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Simply calls the given function passing `this` as the only argument.
      *
      * If you want to conditionally call a method on `this`, see
-     * the {@link if} method.
+     * the {@link $if} method.
      *
      * ### Examples
      *
@@ -691,10 +767,14 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      *
      * db.deleteFrom('person')
-     *   .call(log)
+     *   .$call(log)
      *   .execute()
      * ```
      */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * @deprecated Use `$call` instead
+     */
     call<T>(func: (qb: this) => T): T;
     /**
      * Call `func(this)` if `condition` is true.
@@ -714,7 +794,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     .deleteFrom('person')
      *     .where('id', '=', id)
      *     .returning(['id', 'first_name'])
-     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .$if(returnLastName, (qb) => qb.returning('last_name'))
      *     .executeTakeFirstOrThrow()
      * }
      * ```
@@ -731,6 +811,10 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      * ```
      */
+    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<DB, TB, O2>): DeleteQueryBuilder<DB, TB, O2 extends DeleteResult ? DeleteResult : O extends DeleteResult ? Partial<O2> : MergePartial<O, O2>>;
+    /**
+     * @deprecated Use `$if` instead
+     */
     if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<DB, TB, O2>): DeleteQueryBuilder<DB, TB, O2 extends DeleteResult ? DeleteResult : O extends DeleteResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
@@ -738,6 +822,10 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * 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>;
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
     castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
     /**
      * Asserts that query's output row type equals the given type `T`.
@@ -767,37 +855,41 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     .deleteFrom('person')
      *     .where('id', '=', person.id)
      *     .returning('first_name')
-     *     .assertType<{ first_name: string }>()
+     *     .$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 }>()
+     *     .$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.`>;
+    /**
+     * @deprecated Use `$assertType` instead.
+     */
     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.
      */
     withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O>;
     toOperationNode(): DeleteQueryNode;
-    compile(): CompiledQuery<O>;
+    compile(): CompiledQuery<SimplifyResult<O>>;
     /**
      * Executes the query and returns an array of rows.
      *
      * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
      */
-    execute(): Promise<O[]>;
+    execute(): Promise<SimplifyResult<O>[]>;
     /**
      * Executes the query and returns the first result or undefined if
      * the query returned no result.
      */
-    executeTakeFirst(): Promise<SingleResultType<O>>;
+    executeTakeFirst(): Promise<SimplifySingleResult<O>>;
     /**
      * Executes the query and returns the first result or throws if
      * the query returned no result.
@@ -806,7 +898,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * provide a custom error class as the only argument to throw a different
      * error.
      */
-    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<SimplifyResult<O>>;
     /**
      * Executes query with `explain` statement before `delete` keyword.
      *

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

@@ -1,5 +1,6 @@
 /// <reference types="./delete-query-builder.d.ts" />
 import { parseJoin, } from '../parser/join-parser.js';
+import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -71,6 +72,12 @@ export class DeleteQueryBuilder {
             queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
         });
     }
+    using(tables) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: DeleteQueryNode.cloneWithUsing(this.#props.queryNode, parseTableExpressionOrList(tables)),
+        });
+    }
     innerJoin(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
@@ -175,7 +182,7 @@ export class DeleteQueryBuilder {
      * Simply calls the given function passing `this` as the only argument.
      *
      * If you want to conditionally call a method on `this`, see
-     * the {@link if} method.
+     * the {@link $if} method.
      *
      * ### Examples
      *
@@ -188,13 +195,19 @@ export class DeleteQueryBuilder {
      * }
      *
      * db.deleteFrom('person')
-     *   .call(log)
+     *   .$call(log)
      *   .execute()
      * ```
      */
-    call(func) {
+    $call(func) {
         return func(this);
     }
+    /**
+     * @deprecated Use `$call` instead
+     */
+    call(func) {
+        return this.$call(func);
+    }
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -213,7 +226,7 @@ export class DeleteQueryBuilder {
      *     .deleteFrom('person')
      *     .where('id', '=', id)
      *     .returning(['id', 'first_name'])
-     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .$if(returnLastName, (qb) => qb.returning('last_name'))
      *     .executeTakeFirstOrThrow()
      * }
      * ```
@@ -230,7 +243,7 @@ export class DeleteQueryBuilder {
      * }
      * ```
      */
-    if(condition, func) {
+    $if(condition, func) {
         if (condition) {
             return func(this);
         }
@@ -238,15 +251,27 @@ export class DeleteQueryBuilder {
             ...this.#props,
         });
     }
+    /**
+     * @deprecated Use `$if` instead
+     */
+    if(condition, func) {
+        return this.$if(condition, func);
+    }
     /**
      * 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() {
+    $castTo() {
         return new DeleteQueryBuilder(this.#props);
     }
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
+    castTo() {
+        return this.$castTo();
+    }
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
@@ -275,19 +300,25 @@ export class DeleteQueryBuilder {
      *     .deleteFrom('person')
      *     .where('id', '=', person.id)
      *     .returning('first_name')
-     *     .assertType<{ first_name: string }>()
+     *     .$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 }>()
+     *     .$assertType<{ pet_name: string, species: Species }>()
      *   )
      *   .selectFrom(['deleted_person', 'deleted_pet'])
      *   .selectAll()
      *   .executeTakeFirstOrThrow()
      * ```
      */
+    $assertType() {
+        return new DeleteQueryBuilder(this.#props);
+    }
+    /**
+     * @deprecated Use `$assertType` instead.
+     */
     assertType() {
         return new DeleteQueryBuilder(this.#props);
     }
@@ -321,7 +352,7 @@ export class DeleteQueryBuilder {
         return [
             new DeleteResult(
             // TODO: remove numUpdatedOrDeletedRows.
-            (result.numAffectedRows ?? result.numUpdatedOrDeletedRows)),
+            result.numAffectedRows ?? result.numUpdatedOrDeletedRows ?? 0n),
         ];
     }
     /**