kysely 0.26.0 → 0.26.2

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

@@ -1,6 +1,5 @@
-import { ExpressionBuilder } from '../expression/expression-builder.js';
-import { Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SqlBool } from '../util/type-utils.js';
 export interface HavingInterface<DB, TB extends keyof DB> {
@@ -9,12 +8,10 @@ export interface HavingInterface<DB, TB extends keyof DB> {
      * instead of a `where` statement.
      */
     having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
-    having(factory: HavingExpressionFactory<DB, TB>): HavingInterface<DB, TB>;
-    having(expression: Expression<any>): HavingInterface<DB, TB>;
+    having(expression: ExpressionOrFactory<DB, TB, SqlBool>): 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: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
 }
-export type HavingExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;

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

@@ -539,7 +539,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * }
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): O2 extends InsertResult ? InsertQueryBuilder<DB, TB, InsertResult> : O2 extends O & infer E ? InsertQueryBuilder<DB, TB, O & Partial<E>> : InsertQueryBuilder<DB, TB, Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<any, any, O2>): O2 extends InsertResult ? InsertQueryBuilder<DB, TB, InsertResult> : O2 extends O & infer E ? InsertQueryBuilder<DB, TB, O & Partial<E>> : InsertQueryBuilder<DB, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *

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

@@ -1,8 +1,7 @@
-import { ExpressionBuilder } from '../expression/expression-builder.js';
-import { Expression } from '../expression/expression.js';
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SqlBool } from '../util/type-utils.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
@@ -15,8 +14,7 @@ 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: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
-    on(factory: OnExpressionFactory<DB, TB>): JoinBuilder<DB, TB>;
-    on(expression: Expression<any>): JoinBuilder<DB, TB>;
+    on(expression: ExpressionOrFactory<DB, TB, SqlBool>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereRef} but adds an item to the join's
      * `on` clause instead.
@@ -38,5 +36,3 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
 export interface JoinBuilderProps {
     readonly joinNode: JoinNode;
 }
-type OnExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;
-export {};

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

@@ -14,7 +14,7 @@ class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseFilter)(args)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
         });
     }
     /**
@@ -26,7 +26,7 @@ class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseReferentialComparison)(lhs, op, rhs)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
         });
     }
     /**

package/dist/cjs/query-builder/json-path-builder.d.ts

@@ -1,4 +1,4 @@
-import { AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
 import { OperationNode } from '../operation-node/operation-node.js';
@@ -119,9 +119,9 @@ export declare class JSONPathBuilder<S, O = S> {
      * select "profile"->'addresses'->0->'city' as "city" from "person"
      * ```
      */
-    key<K extends any[] extends O ? never : O extends object ? keyof NonNullable<O> & string : never, O2 = undefined extends O ? null | NonNullable<NonNullable<O>[K]> : null extends O ? null | NonNullable<NonNullable<O>[K]> : NonNullable<O>[K]>(key: K): TraversedJSONPathBuilder<S, O2>;
+    key<K extends any[] extends O ? never : O extends object ? keyof NonNullable<O> & string : never, O2 = undefined extends O ? null | NonNullable<NonNullable<O>[K]> : null extends O ? null | NonNullable<NonNullable<O>[K]> : string extends keyof NonNullable<O> ? null | NonNullable<NonNullable<O>[K]> : NonNullable<O>[K]>(key: K): TraversedJSONPathBuilder<S, O2>;
 }
-export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O> implements Expression<O> {
+export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O> implements AliasableExpression<O> {
     #private;
     constructor(node: JSONReferenceNode);
     /** @private */
@@ -152,7 +152,7 @@ export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O
      * const result = await db
      *   .selectFrom('person')
      *   .select(eb =>
-     *     eb.cmpr('first_name', '=', 'Jennifer').as('is_jennifer')
+     *     eb('first_name', '=', 'Jennifer').as('is_jennifer')
      *   )
      *   .executeTakeFirstOrThrow()
      *
@@ -168,6 +168,62 @@ export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O
      * ```
      */
     as<A extends string>(alias: A): AliasedExpression<O, A>;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name' eb.val(' '), 'last_name']).as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select
+     *   concat("first_name", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
+     */
     as<A extends string>(alias: Expression<unknown>): AliasedExpression<O, A>;
     /**
      * Change the output type of the json path.

package/dist/cjs/query-builder/on-conflict-builder.d.ts

@@ -2,10 +2,11 @@ import { Expression } from '../expression/expression.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { UpdateExpression } from '../parser/update-set-parser.js';
-import { AnyColumn } from '../util/type-utils.js';
-import { WhereExpressionFactory, WhereInterface } from './where-interface.js';
+import { AnyColumn, SqlBool } from '../util/type-utils.js';
+import { WhereInterface } from './where-interface.js';
 export declare class OnConflictBuilder<DB, TB extends keyof DB> implements WhereInterface<DB, TB> {
     #private;
     constructor(props: OnConflictBuilderProps);
@@ -98,24 +99,53 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "OR where", 30) -->
+     * <!-- siteExample("where", "Object filter", 30) -->
      *
-     * To combine conditions using `OR`, you can use the expression builder:
+     * You can use the `and` function to create a simple equality
+     * filter using an object
      *
      * ```ts
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where(({ or, and, cmpr }) => or([
-     *     and([
-     *       cmpr('first_name', '=', 'Jennifer'),
-     *       cmpr('last_name', '=', 'Aniston')
-     *     ]),
-     *     and([
-     *       cmpr('first_name', '=', 'Sylvester'),
-     *       cmpr('last_name', '=', 'Stallone')
-     *     ])
+     *   .where((eb) => eb.and({
+     *     first_name: 'Jennifer',
+     *     last_name: eb.ref('first_name')
+     *   }))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = "first_name"
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 40) -->
+     *
+     * To combine conditions using `OR`, you can use the expression builder.
+     * There are two ways to create `OR` expressions. Both are shown in this
+     * example:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   // 1. Using the `or` method on the expression builder:
+     *   .where((eb) => eb.or([
+     *     eb('first_name', '=', 'Jennifer'),
+     *     eb('first_name', '=', 'Sylvester')
      *   ]))
+     *   // 2. Chaining expressions using the `or` method on the
+     *   // created expressions:
+     *   .where((eb) =>
+     *     eb('last_name', '=', 'Aniston').or('last_name', '=', 'Stallone')
+     *   )
      *   .execute()
      * ```
      *
@@ -125,19 +155,23 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * select *
      * from "person"
      * where (
-     *   ("first_name" = $1 AND "last_name" = $2)
-     *   OR
-     *   ("first_name" = $3 AND "last_name" = $4)
+     *   ("first_name" = $1 or "first_name" = $2)
+     *   and
+     *   ("last_name" = $3 or "last_name" = $4)
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
      * ```ts
+     * import { Expression, SqlBool } from 'kysely'
+     *
      * const firstName: string | undefined = 'Jennifer'
      * const lastName: string | undefined = 'Aniston'
+     * const under18 = true
+     * const over60 = true
      *
      * let query = db
      *   .selectFrom('person')
@@ -153,6 +187,23 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   query = query.where('last_name', '=', lastName)
      * }
      *
+     * if (under18 || over60) {
+     *   // Conditional OR expressions can be added like this.
+     *   query = query.where((eb) => {
+     *     const ors: Expression<SqlBool>[] = []
+     *
+     *     if (under18) {
+     *       ors.push(eb('age', '<', 18))
+     *     }
+     *
+     *     if (over60) {
+     *       ors.push(eb('age', '>', 60))
+     *     }
+     *
+     *     return eb.or(ors)
+     *   })
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
@@ -205,7 +256,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "Complex where clause", 50) -->
+     * <!-- siteExample("where", "Complex where clause", 60) -->
      *
      * For complex `where` expressions you can pass in a single callback and
      * use the `ExpressionBuilder` to build your expression:
@@ -217,10 +268,10 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .where(({ cmpr, or, and, not, exists, selectFrom }) => and([
+     *   .where(({ eb, or, and, not, exists, selectFrom }) => and([
      *     or([
-     *       cmpr('first_name', '=', firstName),
-     *       cmpr('age', '<', maxAge)
+     *       eb('first_name', '=', firstName),
+     *       eb('age', '<', maxAge)
      *     ]),
      *     not(exists(
      *       selectFrom('pet')
@@ -294,8 +345,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   .execute()
      * ```
      */
-    where(factory: WhereExpressionFactory<DB, TB>): OnConflictBuilder<DB, TB>;
-    where(expression: Expression<any>): OnConflictBuilder<DB, TB>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
@@ -466,24 +516,53 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "OR where", 30) -->
+     * <!-- siteExample("where", "Object filter", 30) -->
      *
-     * To combine conditions using `OR`, you can use the expression builder:
+     * You can use the `and` function to create a simple equality
+     * filter using an object
      *
      * ```ts
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where(({ or, and, cmpr }) => or([
-     *     and([
-     *       cmpr('first_name', '=', 'Jennifer'),
-     *       cmpr('last_name', '=', 'Aniston')
-     *     ]),
-     *     and([
-     *       cmpr('first_name', '=', 'Sylvester'),
-     *       cmpr('last_name', '=', 'Stallone')
-     *     ])
+     *   .where((eb) => eb.and({
+     *     first_name: 'Jennifer',
+     *     last_name: eb.ref('first_name')
+     *   }))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = "first_name"
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 40) -->
+     *
+     * To combine conditions using `OR`, you can use the expression builder.
+     * There are two ways to create `OR` expressions. Both are shown in this
+     * example:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   // 1. Using the `or` method on the expression builder:
+     *   .where((eb) => eb.or([
+     *     eb('first_name', '=', 'Jennifer'),
+     *     eb('first_name', '=', 'Sylvester')
      *   ]))
+     *   // 2. Chaining expressions using the `or` method on the
+     *   // created expressions:
+     *   .where((eb) =>
+     *     eb('last_name', '=', 'Aniston').or('last_name', '=', 'Stallone')
+     *   )
      *   .execute()
      * ```
      *
@@ -493,19 +572,23 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * select *
      * from "person"
      * where (
-     *   ("first_name" = $1 AND "last_name" = $2)
-     *   OR
-     *   ("first_name" = $3 AND "last_name" = $4)
+     *   ("first_name" = $1 or "first_name" = $2)
+     *   and
+     *   ("last_name" = $3 or "last_name" = $4)
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
      * ```ts
+     * import { Expression, SqlBool } from 'kysely'
+     *
      * const firstName: string | undefined = 'Jennifer'
      * const lastName: string | undefined = 'Aniston'
+     * const under18 = true
+     * const over60 = true
      *
      * let query = db
      *   .selectFrom('person')
@@ -521,6 +604,23 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   query = query.where('last_name', '=', lastName)
      * }
      *
+     * if (under18 || over60) {
+     *   // Conditional OR expressions can be added like this.
+     *   query = query.where((eb) => {
+     *     const ors: Expression<SqlBool>[] = []
+     *
+     *     if (under18) {
+     *       ors.push(eb('age', '<', 18))
+     *     }
+     *
+     *     if (over60) {
+     *       ors.push(eb('age', '>', 60))
+     *     }
+     *
+     *     return eb.or(ors)
+     *   })
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
@@ -573,7 +673,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "Complex where clause", 50) -->
+     * <!-- siteExample("where", "Complex where clause", 60) -->
      *
      * For complex `where` expressions you can pass in a single callback and
      * use the `ExpressionBuilder` to build your expression:
@@ -585,10 +685,10 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .where(({ cmpr, or, and, not, exists, selectFrom }) => and([
+     *   .where(({ eb, or, and, not, exists, selectFrom }) => and([
      *     or([
-     *       cmpr('first_name', '=', firstName),
-     *       cmpr('age', '<', maxAge)
+     *       eb('first_name', '=', firstName),
+     *       eb('age', '<', maxAge)
      *     ]),
      *     not(exists(
      *       selectFrom('pet')
@@ -662,8 +762,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   .execute()
      * ```
      */
-    where(factory: WhereExpressionFactory<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
-    where(expression: Expression<any>): OnConflictUpdateBuilder<DB, TB>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *

package/dist/cjs/query-builder/on-conflict-builder.js

@@ -80,7 +80,7 @@ class OnConflictBuilder {
     where(...args) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseFilter)(args)),
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
         });
     }
     /**
@@ -91,7 +91,7 @@ class OnConflictBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseReferentialComparison)(lhs, op, rhs)),
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
         });
     }
     clearWhere() {
@@ -208,7 +208,7 @@ class OnConflictUpdateBuilder {
     where(...args) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseFilter)(args)),
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
         });
     }
     /**
@@ -219,7 +219,7 @@ class OnConflictUpdateBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseReferentialComparison)(lhs, op, rhs)),
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
         });
     }
     clearWhere() {

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

@@ -34,7 +34,7 @@ class OverBuilder {
      */
     orderBy(orderBy, direction) {
         return new OverBuilder({
-            overNode: over_node_js_1.OverNode.cloneWithOrderByItem(this.#props.overNode, (0, order_by_parser_js_1.parseOrderBy)(orderBy, direction)),
+            overNode: over_node_js_1.OverNode.cloneWithOrderByItems(this.#props.overNode, (0, order_by_parser_js_1.parseOrderBy)([orderBy, direction])),
         });
     }
     partitionBy(partitionBy) {