kysely 0.23.5 → 0.24.1

package/dist/cjs/parser/unary-operation-parser.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNotExists = exports.parseExists = void 0;
+exports.parseUnaryOperation = exports.parseNotExists = exports.parseExists = void 0;
 const operator_node_js_1 = require("../operation-node/operator-node.js");
 const unary_operation_node_js_1 = require("../operation-node/unary-operation-node.js");
-const value_parser_js_1 = require("./value-parser.js");
-function parseExists(arg) {
-    return parseUnaryOperation('exists', arg);
+const reference_parser_js_1 = require("./reference-parser.js");
+function parseExists(operand) {
+    return parseUnaryOperation('exists', operand);
 }
 exports.parseExists = parseExists;
-function parseNotExists(arg) {
-    return parseUnaryOperation('not exists', arg);
+function parseNotExists(operand) {
+    return parseUnaryOperation('not exists', operand);
 }
 exports.parseNotExists = parseNotExists;
-function parseUnaryOperation(type, arg) {
-    return unary_operation_node_js_1.UnaryOperationNode.create(operator_node_js_1.OperatorNode.create(type), (0, value_parser_js_1.parseValueExpressionOrList)(arg));
+function parseUnaryOperation(operator, operand) {
+    return unary_operation_node_js_1.UnaryOperationNode.create(operator_node_js_1.OperatorNode.create(operator), (0, reference_parser_js_1.parseReferenceExpression)(operand));
 }
+exports.parseUnaryOperation = parseUnaryOperation;

package/dist/cjs/parser/update-set-parser.d.ts

@@ -1,7 +1,10 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
 export declare type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
     [C in UpdateKeys<DB[UT]>]?: ValueExpression<DB, TB, UpdateType<DB[UT][C]>> | undefined;
 };
-export declare function parseUpdateObject(update: UpdateObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;
+export declare type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
+export declare type UpdateExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
+export declare function parseUpdateExpression(update: UpdateExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/cjs/parser/update-set-parser.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUpdateObject = void 0;
+exports.parseUpdateExpression = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const column_update_node_js_1 = require("../operation-node/column-update-node.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
-function parseUpdateObject(update) {
-    return Object.entries(update)
+function parseUpdateExpression(update) {
+    const updateObj = (0, object_utils_js_1.isFunction)(update)
+        ? update((0, expression_builder_js_1.expressionBuilder)())
+        : update;
+    return Object.entries(updateObj)
         .filter(([_, value]) => value !== undefined)
         .map(([key, value]) => {
         return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(value));
     });
 }
-exports.parseUpdateObject = parseUpdateObject;
+exports.parseUpdateExpression = parseUpdateExpression;

package/dist/cjs/parser/value-parser.d.ts

@@ -1,6 +1,11 @@
 import { ExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
+import { Expression } from '../expression/expression.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
+export declare type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
+declare type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilder<any, any, Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
 export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
 export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;
+export {};

package/dist/cjs/parser/value-parser.js

@@ -10,9 +10,7 @@ function parseValueExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return parseValueExpressionList(arg);
     }
-    else {
-        return parseValueExpression(arg);
-    }
+    return parseValueExpression(arg);
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
 function parseValueExpression(exp) {

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -5,7 +5,7 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
 /**
  * Plugin that removes duplicate joins from queries.
  *
- * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
  */
 export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
     #private;

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js

@@ -5,7 +5,7 @@ const deduplicate_joins_transformer_js_1 = require("./deduplicate-joins-transfor
 /**
  * Plugin that removes duplicate joins from queries.
  *
- * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
  */
 class DeduplicateJoinsPlugin {
     #transformer = new deduplicate_joins_transformer_js_1.DeduplicateJoinsTransformer();

package/dist/cjs/query-builder/aggregate-function-builder.d.ts

@@ -3,8 +3,9 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { OverBuilder } from './over-builder.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ReferenceExpression } from '../parser/reference-parser.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 { WhereExpressionFactory } from './where-interface.js';
 export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements Expression<O> {
     #private;
     constructor(props: AggregateFunctionBuilderProps);
@@ -88,22 +89,19 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```ts
      * const result = await db
      *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('gender', '=', 'female')
-     *         .as('female_count'),
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('gender', '=', 'male')
-     *         .as('male_count'),
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('gender', '=', 'other')
-     *         .as('other_count'),
+     *   .select((eb) => [
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhere('gender', '=', 'female')
+     *       .as('female_count'),
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhere('gender', '=', 'male')
+     *       .as('male_count'),
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhere('gender', '=', 'other')
+     *       .as('other_count'),
      *   ])
      *   .executeTakeFirstOrThrow()
      * ```
@@ -119,52 +117,14 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    filterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     filterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * 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: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * 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: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
@@ -180,13 +140,12 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```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()
      * ```
@@ -202,64 +161,27 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      */
     filterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Adds a `filter` clause with a nested `or where` clause after the function.
-     * Otherwise works just like {@link filterWhere}.
-     *
-     * Similar to {@link WhereInterface}'s `orWhere` method.
-     *
-     * ### Examples
-     *
-     * For some reason you're tasked with counting adults (18+) or people called
-     * "Bob" versus general public:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('age', '>=', '18')
-     *         .orFilterWhere('first_name', '=', 'Bob')
-     *         .as('adult_or_bob_count'),
-     *     (eb) => eb.fn.count<number>('id').as('total_count'),
-     *   ])
-     *   .executeTakeFirstOrThrow()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select
-     *   count("id") filter(where "age" >= $1 or "first_name" = $2) as "adult_or_bob_count",
-     *   count("id") as "total_count"
-     * from "person"
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    orFilterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
+    orFilterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
     orFilterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * 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: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * 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: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * 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: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
@@ -305,6 +227,11 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     over(over?: OverBuilderCallback<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

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

@@ -80,44 +80,7 @@ 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({
@@ -126,8 +89,7 @@ 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({
@@ -148,13 +110,12 @@ 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()
      * ```
@@ -171,9 +132,12 @@ class AggregateFunctionBuilder {
     filterWhereRef(lhs, op, rhs) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.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,
@@ -181,10 +145,7 @@ 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({
@@ -193,10 +154,7 @@ 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({
@@ -205,17 +163,12 @@ 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: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialComparison)(lhs, op, rhs)),
         });
     }
     /**
@@ -267,6 +220,13 @@ class AggregateFunctionBuilder {
             aggregateFunctionNode: aggregate_function_node_js_1.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;
     }