kysely 0.21.6 → 0.23.0

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

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionModule = void 0;
+const aggregate_function_node_js_1 = require("../operation-node/aggregate-function-node.js");
+const coalesce_parser_js_1 = require("../parser/coalesce-parser.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
+const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
+const query_id_js_1 = require("../util/query-id.js");
+const aggregate_function_builder_js_1 = require("./aggregate-function-builder.js");
+/**
+ * Helpers for type safe SQL function calls.
+ *
+ * You can always use the {@link sql} tag to call functions and build arbitrary
+ * expressions. This module simply has shortcuts for most common function calls.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const { count } = db.fn
+ *
+ * await db.selectFrom('person')
+ *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+ *   .select([
+ *     'person.id',
+ *     count('pet.id').as('pet_count')
+ *   ])
+ *   .groupBy('person.id')
+ *   .having(count('pet.id'), '>', 10)
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "person"."id", count("pet"."id") as "pet_count"
+ * from "person"
+ * inner join "pet" on "pet"."owner_id" = "person"."id"
+ * group by "person"."id"
+ * having count("pet"."id") > $1
+ * ```
+ */
+class FunctionModule {
+    constructor() {
+        this.avg = this.avg.bind(this);
+        this.coalesce = this.coalesce.bind(this);
+        this.count = this.count.bind(this);
+        this.max = this.max.bind(this);
+        this.min = this.min.bind(this);
+        this.sum = this.sum.bind(this);
+    }
+    /**
+     * Calls the `avg` function for the column given as the argument.
+     *
+     * If this is used in a `select` statement the type of the selected expression
+     * will be `number | string` by default. This is because Kysely can't know the
+     * type the db driver outputs. Sometimes the output can be larger than the largest
+     * javascript number and a string is returned instead. Most drivers allow you
+     * to configure the output type of large numbers and Kysely can't know if you've
+     * done so.
+     *
+     * You can specify the output type of the expression by providing the type as
+     * the first type argument:
+     *
+     * ```ts
+     * const { avg } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(avg<number>('price').as('avg_price'))
+     *   .execute()
+     * ```
+     *
+     * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+     * was used. It is highly recommended to include null in the output type union
+     * and handle null values in post-execute code, or wrap the function with a `coalesce`
+     * function.
+     *
+     * ```ts
+     * const { avg } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(avg<number | null>('price').as('avg_price'))
+     *   .execute()
+     * ```
+     */
+    avg(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('avg', (0, reference_parser_js_1.parseSimpleReferenceExpression)(column)),
+        });
+    }
+    /**
+     * Calls the `coalesce` function for given arguments.
+     *
+     * This function returns the first non-null value from left to right, commonly
+     * used to provide a default scalar for nullable columns or functions.
+     *
+     * ```ts
+     * const { coalesce, max } = db.fn
+     *
+     * db.selectFrom('person')
+     *   .select(coalesce(max('age'), sql<number>`0`).as('max_age'))
+     *   .where('first_name', '=', 'Jennifer')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (postgres):
+     *
+     * ```sql
+     * select coalesce(max("age"), 0) as "max_age" from "person" where "first_name" = $1
+     * ```
+     *
+     * If this is used in a `select` statement the type of the selected expression
+     * is inferred in the same manner that the function computes. A union of arguments'
+     * types - if a non-nullable argument exists, it stops there (ignoring any further
+     * arguments' types) and exludes null from the final union type.
+     *
+     * Examples:
+     *
+     * `(string | null, number | null)` is inferred as `string | number | null`.
+     *
+     * `(string | null, number, Date | null)` is inferred as `string | number`.
+     *
+     * `(number, string | null)` is inferred as `number`.
+     */
+    coalesce(value, ...otherValues) {
+        return new raw_builder_js_1.RawBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            rawNode: (0, coalesce_parser_js_1.parseCoalesce)([value, ...otherValues]),
+        });
+    }
+    /**
+     * Calls the `count` function for the column given as the argument.
+     *
+     * If this is used in a `select` statement the type of the selected expression
+     * will be `number | string | bigint` by default. This is because Kysely
+     * can't know the type the db driver outputs. Sometimes the output can be larger
+     * than the largest javascript number and a string is returned instead. Most
+     * drivers allow you to configure the output type of large numbers and Kysely
+     * can't know if you've done so.
+     *
+     * You can specify the output type of the expression by providing
+     * the type as the first type argument:
+     *
+     * ```ts
+     * const { count } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(count<number>('id').as('num_toys'))
+     *   .execute()
+     * ```
+     *
+     * You can limit column range:
+     *
+     * ```ts
+     * db.selectFrom('toy')
+     *   .select(qb => qb.fn.count<number>('id').as('num_toys'))
+     *   .execute()
+     * ```
+     */
+    count(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('count', (0, reference_parser_js_1.parseSimpleReferenceExpression)(column)),
+        });
+    }
+    max(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('max', (0, reference_parser_js_1.parseSimpleReferenceExpression)(column)),
+        });
+    }
+    min(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('min', (0, reference_parser_js_1.parseSimpleReferenceExpression)(column)),
+        });
+    }
+    /**
+     * Calls the `sum` function for the column given as the argument.
+     *
+     * If this is used in a `select` statement the type of the selected expression
+     * will be `number | string | bigint` by default. This is because Kysely
+     * can't know the type the db driver outputs. Sometimes the output can be larger
+     * than the largest javascript number and a string is returned instead. Most
+     * drivers allow you to configure the output type of large numbers and Kysely
+     * can't know if you've done so.
+     *
+     * You can specify the output type of the expression by providing
+     * the type as the first type argument:
+     *
+     * ```ts
+     * const { sum } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(sum<number>('price').as('total_price'))
+     *   .execute()
+     * ```
+     *
+     * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+     * was used. It is highly recommended to include null in the output type union
+     * and handle null values in post-execute code, or wrap the function with a `coalesce`
+     * function.
+     *
+     * ```ts
+     * const { sum } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(sum<number | null>('price').as('total_price'))
+     *   .execute()
+     * ```
+     */
+    sum(column) {
+        return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('sum', (0, reference_parser_js_1.parseSimpleReferenceExpression)(column)),
+        });
+    }
+}
+exports.FunctionModule = FunctionModule;

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

@@ -1,31 +1,32 @@
-import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, HavingGrouper } from '../parser/filter-parser.js';
+import { Expression } from '../expression/expression.js';
+import { ComparisonOperatorExpression, HavingGrouper, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { ExistsExpression } from '../parser/unary-operation-parser.js';
 export interface HavingInterface<DB, TB extends keyof DB> {
     /**
      * Just like {@link WhereInterface.where | where} but adds a `having` statement
      * instead of a `where` statement.
      */
-    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
+    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
     having(grouper: HavingGrouper<DB, TB>): HavingInterface<DB, TB>;
-    having(raw: AnyRawBuilder): HavingInterface<DB, TB>;
+    having(expression: Expression<any>): HavingInterface<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereRef | whereRef} but adds a `having` statement
      * instead of a `where` statement.
      */
-    havingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
+    havingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
     /**
      * Just like {@link WhereInterface.orWhere | orWhere} but adds a `having` statement
      * instead of a `where` statement.
      */
-    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
+    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
     orHaving(grouper: HavingGrouper<DB, TB>): HavingInterface<DB, TB>;
-    orHaving(raw: AnyRawBuilder): HavingInterface<DB, TB>;
+    orHaving(expression: Expression<any>): HavingInterface<DB, TB>;
     /**
      * Just like {@link WhereInterface.orWhereRef | orWhereRef} but adds a `having` statement
      * instead of a `where` statement.
      */
-    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
+    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereExists | whereExists} but adds a `having` statement
      * instead of a `where` statement.

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -3,7 +3,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { InsertObject } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
-import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
+import { MergePartial, SingleResultType } from '../util/type-utils.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -12,12 +12,13 @@ import { InsertResult } from './insert-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
-import { ComplexExpression } from '../parser/complex-expression-parser.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
 import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder } from './on-conflict-builder.js';
 import { Selectable } from '../util/column-type.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
-export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable, Explainable {
+import { Expression } from '../expression/expression.js';
+export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable {
     #private;
     constructor(props: InsertQueryBuilderProps);
     /**
@@ -189,7 +190,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * select "pet"."name" from "pet"
      * ```
      */
-    expression(expression: ComplexExpression<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    expression(expression: ExpressionOrFactory<DB, TB, any>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Changes an `insert into` query to an `insert ignore into` query.
      *
@@ -521,7 +522,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      */
     withPlugin(plugin: KyselyPlugin): InsertQueryBuilder<DB, TB, O>;
     toOperationNode(): InsertQueryNode;
-    compile(): CompiledQuery;
+    compile(): CompiledQuery<O>;
     /**
      * Executes the query and returns an array of rows.
      *
@@ -558,7 +559,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * explain format=json insert into `person` (`id`, `first_name`, `last_name`) values (?, ?, ?) (?, ?, ?)
      * ```
      */
-    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<ER[]>;
 }
 export interface InsertQueryBuilderProps {
     readonly queryId: QueryId;

package/dist/cjs/query-builder/insert-query-builder.js

@@ -11,7 +11,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const on_duplicate_key_node_js_1 = require("../operation-node/on-duplicate-key-node.js");
 const insert_result_js_1 = require("./insert-result.js");
 const no_result_error_js_1 = require("./no-result-error.js");
-const complex_expression_parser_js_1 = require("../parser/complex-expression-parser.js");
+const expression_parser_js_1 = require("../parser/expression-parser.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
 const on_conflict_builder_js_1 = require("./on-conflict-builder.js");
 const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
@@ -83,7 +83,7 @@ class InsertQueryBuilder {
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
-                values: (0, complex_expression_parser_js_1.parseComplexExpression)(expression),
+                values: (0, expression_parser_js_1.parseExpression)(expression),
             }),
         });
     }
@@ -414,15 +414,17 @@ class InsertQueryBuilder {
      * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
      */
     async execute() {
-        const compildQuery = this.compile();
-        const query = compildQuery.query;
-        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
+        const compiledQuery = this.compile();
+        const query = compiledQuery.query;
+        const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
         if (this.#props.executor.adapter.supportsReturning && query.returning) {
             return result.rows;
         }
-        else {
-            return [new insert_result_js_1.InsertResult(result.insertId)];
-        }
+        return [
+            new insert_result_js_1.InsertResult(result.insertId, 
+            // TODO: remove numUpdatedOrDeletedRows.
+            result.numAffectedRows ?? result.numUpdatedOrDeletedRows),
+        ];
     }
     /**
      * Executes the query and returns the first result or undefined if
@@ -467,7 +469,7 @@ class InsertQueryBuilder {
         const builder = new InsertQueryBuilder({
             ...this.#props,
             queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
-                explain: explain_node_js_1.ExplainNode.create(format, options),
+                explain: explain_node_js_1.ExplainNode.create(format, options?.toOperationNode()),
             }),
         });
         return await builder.execute();

package/dist/cjs/query-builder/insert-result.d.ts

@@ -7,6 +7,9 @@
  * need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}
  * to get out the inserted id.
  *
+ * {@link numInsertedOrUpdatedRows} holds the number of (actually) inserted rows.
+ * On MySQL, updated rows are counted twice when using `on duplicate key update`.
+ *
  * ### Examples
  *
  * ```ts
@@ -20,9 +23,13 @@
  */
 export declare class InsertResult {
     #private;
-    constructor(insertId: bigint | undefined);
+    constructor(insertId: bigint | undefined, numInsertedOrUpdatedRows: bigint | undefined);
     /**
      * The auto incrementing primary key
      */
     get insertId(): bigint | undefined;
+    /**
+     * Affected rows count.
+     */
+    get numInsertedOrUpdatedRows(): bigint | undefined;
 }

package/dist/cjs/query-builder/insert-result.js

@@ -10,6 +10,9 @@ exports.InsertResult = void 0;
  * need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}
  * to get out the inserted id.
  *
+ * {@link numInsertedOrUpdatedRows} holds the number of (actually) inserted rows.
+ * On MySQL, updated rows are counted twice when using `on duplicate key update`.
+ *
  * ### Examples
  *
  * ```ts
@@ -23,8 +26,10 @@ exports.InsertResult = void 0;
  */
 class InsertResult {
     #insertId;
-    constructor(insertId) {
+    #numInsertedOrUpdatedRows;
+    constructor(insertId, numInsertedOrUpdatedRows) {
         this.#insertId = insertId;
+        this.#numInsertedOrUpdatedRows = numInsertedOrUpdatedRows;
     }
     /**
      * The auto incrementing primary key
@@ -32,5 +37,11 @@ class InsertResult {
     get insertId() {
         return this.#insertId;
     }
+    /**
+     * Affected rows count.
+     */
+    get numInsertedOrUpdatedRows() {
+        return this.#numInsertedOrUpdatedRows;
+    }
 }
 exports.InsertResult = InsertResult;

package/dist/cjs/query-builder/join-builder.d.ts

@@ -1,8 +1,9 @@
+import { Expression } from '../expression/expression.js';
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { ExistsExpression, FilterOperator, FilterValueExpressionOrList } from '../parser/filter-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { ExistsExpression } from '../parser/unary-operation-parser.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: JoinBuilderProps);
@@ -12,32 +13,32 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      *
      * See {@link WhereInterface.where} for documentation and examples.
      */
-    on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
+    on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     on(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
-    on(raw: AnyRawBuilder): JoinBuilder<DB, TB>;
+    on(expression: Expression<any>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.orWhere} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link WhereInterface.orWhere} for documentation and examples.
      */
-    orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
+    orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     orOn(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
-    orOn(raw: AnyRawBuilder): JoinBuilder<DB, TB>;
+    orOn(expression: Expression<any>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereRef} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link WhereInterface.whereRef} for documentation and examples.
      */
-    onRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
+    onRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.orWhereRef} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link WhereInterface.orWhereRef} for documentation and examples.
      */
-    orOnRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
+    orOnRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereExists} but adds an item to the join's
      * `on` clause instead.

package/dist/cjs/query-builder/join-builder.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinBuilder = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
-const filter_parser_js_1 = require("../parser/filter-parser.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const unary_operation_parser_js_1 = require("../parser/unary-operation-parser.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 class JoinBuilder {
@@ -14,13 +15,13 @@ class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseOnFilter)(args)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseOn)(args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseOnFilter)(args)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseOn)(args)),
         });
     }
     /**
@@ -32,7 +33,7 @@ class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseReferenceFilter)(lhs, op, rhs)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
         });
     }
     /**
@@ -44,7 +45,7 @@ class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseReferenceFilter)(lhs, op, rhs)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
         });
     }
     /**
@@ -56,7 +57,7 @@ class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseExistFilter)(arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, unary_operation_parser_js_1.parseExists)(arg)),
         });
     }
     /**
@@ -68,7 +69,7 @@ class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, unary_operation_parser_js_1.parseNotExists)(arg)),
         });
     }
     /**
@@ -80,7 +81,7 @@ class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseExistFilter)(arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, unary_operation_parser_js_1.parseExists)(arg)),
         });
     }
     /**
@@ -92,7 +93,7 @@ class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, unary_operation_parser_js_1.parseNotExists)(arg)),
         });
     }
     /**