kysely 0.23.5 → 0.24.0

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

@@ -2,77 +2,62 @@ 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 { From, FromTables, TableExpression } from '../parser/table-parser.js';
-import { SelectExpression } from '../parser/select-parser.js';
-import { ReturningRow } from '../parser/returning-parser.js';
+import { SelectExpression, SelectArg } from '../parser/select-parser.js';
+import { ReturningAllRow, ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
+import { QueryNode } from '../operation-node/query-node.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';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { WhereInterface } from './where-interface.js';
+import { WhereExpressionFactory, WhereInterface } from './where-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
-import { Selectable } from '../util/column-type.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 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 { ComparisonOperatorExpression, OperandValueExpressionOrList } 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 {
+import { Streamable } from '../util/streamable.js';
+export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: DeleteQueryBuilderProps);
     /**
-     * Adds a `where` clause to the query.
+     * Adds a `where` expression to the query.
      *
-     * Also see {@link orWhere}, {@link whereExists} and {@link whereRef}.
+     * Calling this method multiple times will combine the expressions using `and`.
      *
-     * ### Examples
+     * Also see {@link whereRef}
      *
-     * Find a row by column value:
+     * ### Examples
      *
      * ```ts
      * const person = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where('id', '=', 100)
+     *   .where('first_name', '=', 'Jennifer')
+     *   .where('age', '>', 40)
      *   .executeTakeFirst()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" where "id" = $1
+     * select * from "person" where "first_name" = $1 and "age" > $2
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use
+     * you can always use:
      *
      * ```ts
      * sql`your operator`
      * ```
      *
-     * The next example uses the `>` operator:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where('id', '>', 100)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where "id" > $1
-     * ```
-     *
-     * `where` methods don't change the type of the query. You can add
-     * conditional statements easily by doing something like this:
+     * You can add expressions conditionally like this:
      *
      * ```ts
      * let query = db
@@ -85,16 +70,16 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   query = query.where('first_name', '=', firstName)
      * }
      *
+     * if (lastName) {
+     *   query = query.where('last_name', '=', lastName)
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
-     * This is true for basically all methods execpt the `select` and
-     * `returning`, that __do__ change the return type of the query.
-     *
-     * Both the first and third argument can also be subqueries.
-     * A subquery is defined by passing a function and calling
-     * the `selectFrom` method of the object passed into the
-     * function:
+     * Both the first and third argument can also be arbitrary expressions like
+     * subqueries. An expression can defined by passing a function and calling
+     * the methods of the {@link ExpressionBuilder} passed to the callback:
      *
      * ```ts
      * const persons = await db
@@ -125,8 +110,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * A `where in` query can be built by using the `in` operator and an array
-     * of values. The values in the array can also be subqueries or raw
-     * {@link sql} expressions.
+     * of values. The values in the array can also be expressions:
      *
      * ```ts
      * const persons = await db
@@ -142,40 +126,53 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always use the {@link sql} tag
-     * as any of the arguments, including the operator:
+     * For complex `where` expressions you can pass in a single callback and
+     * use the {@link ExpressionBuilder} to build your expression:
      *
      * ```ts
-     * import { sql } from 'kysely'
-     *
      * const persons = await db
      *   .selectFrom('person')
-     *   .selectAll()
-     *   .where(
-     *     sql`coalesce(first_name, last_name)`,
-     *     'like',
-     *     '%' + name + '%',
-     *   )
-     *   .execute()
+     *   .selectAll('person')
+     *   .where(({ cmpr, or, and, not, exists, selectFrom, val }) => and([
+     *     or([
+     *       cmpr('first_name', '=', firstName),
+     *       cmpr('age', '<', maxAge)
+     *     ]),
+     *     not(exists(
+     *       selectFrom('pet').select('pet.id').whereRef('pet.owner_id', '=', 'person.id')
+     *     ))
+     *   ]))
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person"
-     * where coalesce(first_name, last_name) like $1
+     * select "person".*
+     * from "person"
+     * where (
+     *   (
+     *     "first_name" = $1
+     *     or "age" < $2
+     *   )
+     *   and not exists (
+     *     select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id"
+     *   )
+     * )
      * ```
      *
-     * If you only pass one function argument to this method, it can be
-     * used to create parentheses around other where statements:
+     * If everything else fails, you can always use the {@link sql} tag
+     * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where((qb) => qb
-     *     .where('id', '=', 1)
-     *     .orWhere('id', '=', 2)
+     *   .where(
+     *     sql`coalesce(first_name, last_name)`,
+     *     'like',
+     *     '%' + name + '%',
      *   )
      *   .execute()
      * ```
@@ -183,7 +180,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
+     * select * from "person"
+     * where coalesce(first_name, last_name) like $1
      * ```
      *
      * In all examples above the columns were known at compile time
@@ -205,12 +203,12 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
+     *   .where(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
-    where(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    where(factory: WhereExpressionFactory<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     where(expression: Expression<any>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
@@ -242,7 +240,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .select((qb) => qb
+     *   .select((eb) => eb
      *     .selectFrom('pet')
      *     .select('name')
      *     .whereRef('pet.owner_id', '=', 'person.id')
@@ -265,152 +263,33 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
-     *
-     * It's often necessary to wrap `or where` clauses in parentheses to control
-     * precendence. You can use the one argument version of the `where` method
-     * for that. See the examples.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where('id', '=', 1)
-     *   .orWhere('id', '=', 2)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where "id" = 1 or "id" = 2
-     * ```
-     *
-     * Grouping with parentheses:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where((qb) => qb
-     *     .where('id', '=', 1)
-     *     .orWhere('id', '=', 2)
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
-     * ```
-     *
-     * Even the first `where` can be an `orWhere`. This is useful
-     * if you are looping through a set of conditions:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where((qb) => qb
-     *     .orWhere('id', '=', 1)
-     *     .orWhere('id', '=', 2)
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
-    orWhere(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    orWhere(factory: WhereExpressionFactory<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     orWhere(expression: Expression<any>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
-     *
-     * Also see {@link orWhere} and {@link where}.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Adds a `where exists` clause to the query.
-     *
-     * You can either use a subquery or a raw {@link sql} snippet.
-     *
-     * ### Examples
-     *
-     * The query below selets all persons that own a pet named Catto:
-     *
-     * ```ts
-     * const petName = 'Catto'
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .whereExists((qb) => qb
-     *     .selectFrom('pet')
-     *     .select('pet.id')
-     *     .whereRef('person.id', '=', 'pet.owner_id')
-     *     .where('pet.name', '=', petName)
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * where exists (
-     *   select "pet"."id"
-     *   from "pet"
-     *   where "person"."id" = "pet"."owner_id"
-     *   and "pet"."name" = $1
-     * )
-     * ```
-     *
-     * The same query as in the previous example but with using raw {@link sql}:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * const petName = 'Catto'
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .whereExists(
-     *     sql`(select pet.id from pet where person.id = pet.owner_id and pet.name = ${petName})`
-     *   )
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * where exists (
-     *   select pet.id
-     *   from pet
-     *   where person.id = pet.owner_id
-     *   and pet.name = $1
-     * )
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Just like {@link whereExists} but creates a `not exists` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Just like {@link whereExists} but creates an `or exists` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Just like {@link whereExists} but creates an `or not exists` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Clears all where clauses from the query.
+     * Clears all where expressions from the query.
      *
      * ### Examples
      *
@@ -681,21 +560,114 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
-     *   .returning([
+     *   .returning(eb => [
      *     'id as id',
      *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
-     *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
+     *     eb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
      *   ])
      *   .executeTakeFirst()
      * ```
      */
-    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>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SelectArg<DB, TB, SE>): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    /**
+     * Adds `returning *` or `returning table.*` clause to the query.
+     *
+     * ### Examples
+     *
+     * Return all columns.
+     *
+     * ```ts
+     * const pets = await db
+     *   .deleteFrom('pet')
+     *   .returningAll()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL)
+     *
+     * ```sql
+     * delete from "pet" returning *
+     * ```
+     *
+     * Return all columns from all tables
+     *
+     * ```ts
+     * const result = ctx.db
+     *   .deleteFrom('toy')
+     *   .using(['pet', 'person'])
+     *   .whereRef('toy.pet_id', '=', 'pet.id')
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     *   .where('person.first_name', '=', 'Zoro')
+     *   .returningAll()
+     *   .execute()
+     * ```
+     *
+     * 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 *
+     * ```
+     *
+     * Return all columns from a single table.
+     *
+     * ```ts
+     * const result = ctx.db
+     *   .deleteFrom('toy')
+     *   .using(['pet', 'person'])
+     *   .whereRef('toy.pet_id', '=', 'pet.id')
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     *   .where('person.first_name', '=', 'Itachi')
+     *   .returningAll('pet')
+     *   .execute()
+     * ```
+     *
+     * 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".*
+     * ```
+     *
+     * Return all columns from multiple tables.
+     *
+     * ```ts
+     * const result = ctx.db
+     *   .deleteFrom('toy')
+     *   .using(['pet', 'person'])
+     *   .whereRef('toy.pet_id', '=', 'pet.id')
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     *   .where('person.first_name', '=', 'Luffy')
+     *   .returningAll(['toy', 'pet'])
+     *   .execute()
+     * ```
+     *
+     * 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 "toy".*, "pet".*
+     * ```
+     */
+    returningAll<T extends TB>(tables: ReadonlyArray<T>): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, T, O>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): DeleteQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    returningAll<T extends TB>(table: T): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, T, O>>;
+    returningAll(): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, TB, O>>;
     /**
      * Adds an `order by` clause to the query.
      *
@@ -751,7 +723,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     limit(limit: number): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Simply calls the given function passing `this` as the only argument.
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
      *
      * If you want to conditionally call a method on `this`, see
      * the {@link $if} method.
@@ -895,24 +868,70 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * 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
+     * provide a custom error class, or callback as the only argument to throw a different
      * error.
      */
-    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<SimplifyResult<O>>;
+    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor | ((node: QueryNode) => Error)): Promise<SimplifyResult<O>>;
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db.
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    stream(chunkSize?: number): AsyncIterableIterator<O>;
     /**
-     * Executes query with `explain` statement before `delete` keyword.
+     * Executes query with `explain` statement before the main query.
      *
      * ```ts
      * const explained = await db
-     *  .deleteFrom('person')
-     *  .where('id', '=', 123)
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
      *  .explain('json')
      * ```
      *
      * The generated SQL (MySQL):
      *
      * ```sql
-     * explain format=json delete from `person` where `id` = ?
+     * explain format=json select * from `person` where `gender` = ?
+     * ```
+     *
+     * You can also execute `explain analyze` statements.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json', sql`analyze`)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * explain (analyze, format json) select * from "person" where "gender" = $1
      * ```
      */
     explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<ER[]>;