kysely 0.23.5 → 0.24.1

package/dist/esm/query-builder/aggregate-function-builder.js

@@ -5,7 +5,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { createOverBuilder } from '../parser/parse-utils.js';
-import { parseReferentialFilter, parseWhere, } from '../parser/binary-operation-parser.js';
+import { parseReferentialComparison, parseWhere, } from '../parser/binary-operation-parser.js';
 import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 export class AggregateFunctionBuilder {
     #props;
@@ -78,44 +78,7 @@ export class AggregateFunctionBuilder {
         });
     }
     /**
-     * Adds a `filter` clause with a nested `where exists` clause after the function.
-     *
-     * Similar to {@link WhereInterface}'s `whereExists` method.
-     *
-     * ### Examples
-     *
-     * Count pet owners versus general public:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('person.id')
-     *         .filterWhereExists((qb) =>
-     *           qb
-     *             .selectFrom('pet')
-     *             .select('pet.id')
-     *             .whereRef('pet.owner_id', '=', 'person.id')
-     *         )
-     *         .as('pet_owner_count'),
-     *     (eb) => eb.fn.count<number>('person.id').as('total_count'),
-     *   ])
-     *   .executeTakeFirstOrThrow()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select count("person"."id") filter(where exists (
-     *   select "pet"."id"
-     *   from "pet"
-     *   where "pet"."owner_id" = "person"."id"
-     * )) as "pet_ower_count",
-     *   count("person"."id") as "total_count"
-     * from "person"
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     filterWhereExists(arg) {
         return new AggregateFunctionBuilder({
@@ -124,8 +87,7 @@ export class AggregateFunctionBuilder {
         });
     }
     /**
-     * Just like {@link filterWhereExists} but creates a `not exists` clause inside
-     * the `filter` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     filterWhereNotExists(arg) {
         return new AggregateFunctionBuilder({
@@ -146,13 +108,12 @@ export class AggregateFunctionBuilder {
      * ```ts
      * const result = await db
      *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhereRef('first_name', '=', 'last_name')
-     *         .as('repeat_name_count'),
-     *     (eb) => eb.fn.count<number>('id').as('total_count'),
+     *   .select((eb) => [
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhereRef('first_name', '=', 'last_name')
+     *       .as('repeat_name_count'),
+     *     eb.fn.count<number>('id').as('total_count'),
      *   ])
      *   .executeTakeFirstOrThrow()
      * ```
@@ -169,9 +130,12 @@ export class AggregateFunctionBuilder {
     filterWhereRef(lhs, op, rhs) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialFilter(lhs, op, rhs)),
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
     orFilterWhere(...args) {
         return new AggregateFunctionBuilder({
             ...this.#props,
@@ -179,10 +143,7 @@ export class AggregateFunctionBuilder {
         });
     }
     /**
-     * Just like {@link filterWhereExists} but creates an `or exists` clause inside
-     * the `filter` clause.
-     *
-     * Similar to {@link WhereInterface}'s `orWhereExists` method.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhereExists(arg) {
         return new AggregateFunctionBuilder({
@@ -191,10 +152,7 @@ export class AggregateFunctionBuilder {
         });
     }
     /**
-     * Just like {@link filterWhereExists} but creates an `or not exists` clause inside
-     * the `filter` clause.
-     *
-     * Similar to {@link WhereInterface}'s `orWhereNotExists` method.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhereNotExists(arg) {
         return new AggregateFunctionBuilder({
@@ -203,17 +161,12 @@ export class AggregateFunctionBuilder {
         });
     }
     /**
-     * Adds an `or where` clause inside the `filter` clause. Otherwise works just
-     * like {@link filterWhereRef}.
-     *
-     * Also see {@link orFilterWhere} and {@link filterWhere}.
-     *
-     * Similar to {@link WhereInterface}'s `orWhereRef` method.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhereRef(lhs, op, rhs) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, parseReferentialFilter(lhs, op, rhs)),
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
     /**
@@ -265,6 +218,13 @@ export class AggregateFunctionBuilder {
             aggregateFunctionNode: AggregateFunctionNode.cloneWithOver(this.#props.aggregateFunctionNode, (over ? over(builder) : builder).toOperationNode()),
         });
     }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.aggregateFunctionNode;
     }