kysely 0.25.0 → 0.26.1

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

@@ -10,8 +10,7 @@ import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { parseOrderBy, } from '../parser/order-by-parser.js';
-import { parseReferentialComparison, parseWhere, } from '../parser/binary-operation-parser.js';
-import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
+import { parseFilter, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
 export class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -20,7 +19,7 @@ export class DeleteQueryBuilder {
     where(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhere(args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseFilter(args)),
         });
     }
     whereRef(lhs, op, rhs) {
@@ -29,42 +28,6 @@ export class DeleteQueryBuilder {
             queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
-    orWhere(...args) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhere(args)),
-        });
-    }
-    orWhereRef(lhs, op, rhs) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
-        });
-    }
-    whereExists(arg) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExists(arg)),
-        });
-    }
-    whereNotExists(arg) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExists(arg)),
-        });
-    }
-    orWhereExists(arg) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExists(arg)),
-        });
-    }
-    orWhereNotExists(arg) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExists(arg)),
-        });
-    }
     clearWhere() {
         return new DeleteQueryBuilder({
             ...this.#props,
@@ -202,12 +165,6 @@ export class DeleteQueryBuilder {
     $call(func) {
         return func(this);
     }
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call(func) {
-        return this.$call(func);
-    }
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -251,12 +208,6 @@ export class DeleteQueryBuilder {
             ...this.#props,
         });
     }
-    /**
-     * @deprecated Use `$if` instead
-     */
-    if(condition, func) {
-        return this.$if(condition, func);
-    }
     /**
      * Change the output type of the query.
      *
@@ -266,12 +217,6 @@ export class DeleteQueryBuilder {
     $castTo() {
         return new DeleteQueryBuilder(this.#props);
     }
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo() {
-        return this.$castTo();
-    }
     /**
      * Narrows (parts of) the output type of the query.
      *
@@ -360,12 +305,6 @@ export class DeleteQueryBuilder {
     $assertType() {
         return new DeleteQueryBuilder(this.#props);
     }
-    /**
-     * @deprecated Use `$assertType` instead.
-     */
-    assertType() {
-        return new DeleteQueryBuilder(this.#props);
-    }
     /**
      * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
      */

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

@@ -1,5 +1,4 @@
 export declare class DeleteResult {
-    #private;
+    readonly numDeletedRows: bigint;
     constructor(numDeletedRows: bigint);
-    get numDeletedRows(): bigint;
 }

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

@@ -1,13 +1,7 @@
 /// <reference types="./delete-result.d.ts" />
 export class DeleteResult {
-    #numDeletedRows;
+    numDeletedRows;
     constructor(numDeletedRows) {
-        this.#numDeletedRows = numDeletedRows;
-    }
-    get numDeletedRows() {
-        return this.#numDeletedRows;
+        this.numDeletedRows = numDeletedRows;
     }
 }
-Object.defineProperty(DeleteResult.prototype, 'numDeletedRows', {
-    enumerable: true,
-});

package/dist/esm/query-builder/function-module.d.ts

@@ -1,7 +1,7 @@
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { CoalesceReferenceExpressionList } from '../parser/coalesce-parser.js';
-import { ExtractTypeFromReferenceExpression, SimpleReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { Equals, IsAny } from '../util/type-utils.js';
 import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
 /**
@@ -12,24 +12,36 @@ import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
  *
  * ### Examples
  *
- * ```ts
- * const { count } = db.fn
+ * <!-- siteExample("select", "Function calls", 60) -->
+ *
+ * This example uses the `fn` module to select some aggregates:
  *
- * await db.selectFrom('person')
+ * ```ts
+ * const result = await db.selectFrom('person')
  *   .innerJoin('pet', 'pet.owner_id', 'person.id')
- *   .select([
+ *   .select(({ fn }) => [
  *     'person.id',
- *     count('pet.id').as('pet_count')
+ *
+ *     // The `fn` module contains the most common
+ *     // functions.
+ *     fn.count<number>('pet.id').as('pet_count'),
+ *
+ *     // You can call any function using the
+ *     // `agg` method
+ *     fn.agg<string[]>('array_agg', ['pet.name']).as('pet_names')
  *   ])
  *   .groupBy('person.id')
- *   .having(count('pet.id'), '>', 10)
+ *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
  *   .execute()
  * ```
  *
  * The generated SQL (PostgreSQL):
  *
  * ```sql
- * select "person"."id", count("pet"."id") as "pet_count"
+ * select
+ *   "person"."id",
+ *   count("pet"."id") as "pet_count",
+ *   array_agg("pet"."name") as "pet_names"
  * from "person"
  * inner join "pet" on "pet"."owner_id" = "person"."id"
  * group by "person"."id"
@@ -66,7 +78,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .where(sql`upper(first_name)`, '=', 'JENNIFER')
      * ```
      */
-    <T>(name: string, args: ReadonlyArray<ReferenceExpression<DB, TB>>): ExpressionWrapper<T>;
+    <T>(name: string, args: ReadonlyArray<ReferenceExpression<DB, TB>>): ExpressionWrapper<DB, TB, T>;
     /**
      * Creates an aggregate function call.
      *
@@ -108,10 +120,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { avg } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(avg('price').as('avg_price'))
+     *   .select((eb) => eb.fn.avg('price').as('avg_price'))
      *   .execute()
      * ```
      *
@@ -140,10 +150,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the first type argument:
      *
      * ```ts
-     * const { avg } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(avg<number>('price').as('avg_price'))
+     *   .select((eb) => eb.fn.avg<number>('price').as('avg_price'))
      *   .execute()
      * ```
      *
@@ -153,14 +161,12 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { avg } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(avg<number | null>('price').as('avg_price'))
+     *   .select((eb) => eb.fn.avg<number | null>('price').as('avg_price'))
      *   .execute()
      * ```
      */
-    avg<O extends number | string | null = number | string, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    avg<O extends number | string | null = number | string, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `coalesce` function for given arguments.
      *
@@ -182,10 +188,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { coalesce } = db.fn
-     *
      * db.selectFrom('participant')
-     *   .select(coalesce('nickname', sql<string>`'<anonymous>'`).as('nickname'))
+     *   .select((eb) => eb.fn.coalesce('nickname', sql<string>`'<anonymous>'`).as('nickname'))
      *   .where('room_id', '=', roomId)
      *   .execute()
      * ```
@@ -211,10 +215,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * You can combine this function with other helpers in this module:
      *
      * ```ts
-     * const { avg, coalesce } = db.fn
-     *
      * db.selectFrom('person')
-     *   .select(coalesce(avg<number | null>('age'), sql<number>`0`).as('avg_age'))
+     *   .select((eb) => eb.fn.coalesce(eb.fn.avg<number | null>('age'), sql<number>`0`).as('avg_age'))
      *   .where('first_name', '=', 'Jennifer')
      *   .execute()
      * ```
@@ -225,7 +227,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * select coalesce(avg("age"), 0) as "avg_age" from "person" where "first_name" = $1
      * ```
      */
-    coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): ExpressionWrapper<CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
+    coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): ExpressionWrapper<DB, TB, CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
     /**
      * Calls the `count` function for the column given as the argument.
      *
@@ -241,10 +243,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { count } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(count('id').as('num_toys'))
+     *   .select((eb) => eb.fn.count('id').as('num_toys'))
      *   .execute()
      * ```
      *
@@ -265,10 +265,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { count } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(count<number>('id').as('num_toys'))
+     *   .select((eb) => eb.fn.count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      *
@@ -280,7 +278,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    count<O extends number | string | bigint, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    count<O extends number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `count` function with `*` or `table.*` as argument.
      *
@@ -297,10 +295,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { countAll } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(countAll().as('num_toys'))
+     *   .select((eb) => eb.fn.countAll().as('num_toys'))
      *   .execute()
      * ```
      *
@@ -321,10 +317,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { countAll } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(countAll<number>().as('num_toys'))
+     *   .select((eb) => eb.fn.countAll<number>().as('num_toys'))
      *   .execute()
      * ```
      *
@@ -332,11 +326,9 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * table:
      *
      * ```ts
-     * const { countAll } = db.fn
-     *
      * db.selectFrom('toy')
      *   .innerJoin('pet', 'pet.id', 'toy.pet_id')
-     *   .select(countAll('toy').as('num_toys'))
+     *   .select((eb) => eb.fn.countAll('toy').as('num_toys'))
      *   .execute()
      * ```
      *
@@ -374,10 +366,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { max } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(max('price').as('max_price'))
+     *   .select((eb) => eb.fn.max('price').as('max_price'))
      *   .execute()
      * ```
      *
@@ -401,10 +391,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { max } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(max<number | null, 'price'>('price').as('max_price'))
+     *   .select((eb) => eb.fn.max<number | null, 'price'>('price').as('max_price'))
      *   .execute()
      * ```
      */
@@ -426,10 +414,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { min } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(min('price').as('min_price'))
+     *   .select((eb) => eb.fn.min('price').as('min_price'))
      *   .execute()
      * ```
      *
@@ -453,10 +439,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { min } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(min<number | null, 'price'>('price').as('min_price'))
+     *   .select((eb) => eb.fn.min<number | null, 'price'>('price').as('min_price'))
      *   .execute()
      * ```
      */
@@ -474,10 +458,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { sum } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(sum('price').as('total_price'))
+     *   .select((eb) => eb.fn.sum('price').as('total_price'))
      *   .execute()
      * ```
      *
@@ -506,10 +488,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the first type argument:
      *
      * ```ts
-     * const { sum } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price').as('total_price'))
+     *   .select((eb) => eb.fn.sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      *
@@ -519,16 +499,14 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { sum } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(sum<number | null>('price').as('total_price'))
+     *   .select((eb) => eb.fn.sum<number | null>('price').as('total_price'))
      *   .execute()
      * ```
      */
-    sum<O extends number | string | bigint | null = number | string | bigint, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    sum<O extends number | string | bigint | null = number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
 }
 export declare function createFunctionModule<DB, TB extends keyof DB>(): FunctionModule<DB, TB>;
-declare type OutputBoundStringReference<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = IsAny<O> extends true ? C : Equals<ExtractTypeFromReferenceExpression<DB, TB, C> | null, O | null> extends true ? C : never;
-declare type StringReferenceBoundAggregateFunctionBuilder<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C> | (IsAny<O> extends true ? never : null extends O ? null : never)>;
+type OutputBoundStringReference<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = IsAny<O> extends true ? C : Equals<ExtractTypeFromReferenceExpression<DB, TB, C> | null, O | null> extends true ? C : never;
+type StringReferenceBoundAggregateFunctionBuilder<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C> | (IsAny<O> extends true ? never : null extends O ? null : never)>;
 export {};

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

@@ -1,9 +1,8 @@
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { ExistsExpression } from '../parser/unary-operation-parser.js';
 import { SqlBool } from '../util/type-utils.js';
-import { HavingExpressionBuilder } from './deprecated-having-expression-builder.js';
 export interface HavingInterface<DB, TB extends keyof DB> {
     /**
      * Just like {@link WhereInterface.where | where} but adds a `having` statement
@@ -17,37 +16,5 @@ export interface HavingInterface<DB, TB extends keyof DB> {
      * instead of a `where` statement.
      */
     havingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHaving(factory: HavingExpressionFactory<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHaving(expression: Expression<any>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    havingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    havingNotExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingNotExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
 }
-export declare type HavingExpressionFactory<DB, TB extends keyof DB> = (eb: HavingExpressionBuilder<DB, TB>) => Expression<SqlBool> | HavingExpressionBuilder<DB, TB>;
+export type HavingExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;