kysely 0.21.6 → 0.23.0

package/dist/esm/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/esm/query-builder/join-builder.js

@@ -1,7 +1,8 @@
 /// <reference types="./join-builder.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseExistFilter, parseNotExistFilter, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
+import { parseOn, parseReferentialFilter, } from '../parser/binary-operation-parser.js';
+import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class JoinBuilder {
@@ -12,13 +13,13 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOnFilter(args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOn(args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOnFilter(args)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOn(args)),
         });
     }
     /**
@@ -30,7 +31,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferenceFilter(lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -42,7 +43,7 @@ export class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferenceFilter(lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -54,7 +55,7 @@ export class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExistFilter(arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExists(arg)),
         });
     }
     /**
@@ -66,7 +67,7 @@ export class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExistFilter(arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExists(arg)),
         });
     }
     /**
@@ -78,7 +79,7 @@ export class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExistFilter(arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExists(arg)),
         });
     }
     /**
@@ -90,7 +91,7 @@ export class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExists(arg)),
         });
     }
     /**

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

@@ -1,10 +1,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 { ComplexExpression } from '../parser/complex-expression-parser.js';
-import { WhereGrouper, FilterOperator, FilterValueExpressionOrList } from '../parser/filter-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { MutationObject } from '../parser/update-set-parser.js';
-import { AnyColumn, AnyRawBuilder } from '../util/type-utils.js';
+import { AnyColumn } 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;
@@ -38,13 +39,13 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * Also see the {@link column}, {@link columns} and {@link constraint}
      * methods for alternative ways to specify the conflict target.
      */
-    expression(expression: AnyRawBuilder): OnConflictBuilder<DB, TB>;
+    expression(expression: Expression<any>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.where} for more info.
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): OnConflictBuilder<DB, TB>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictBuilder<DB, TB>;
     /**
      * Adds a `where` clause to the query.
      *
@@ -230,19 +231,19 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      */
     where(grouper: WhereGrouper<DB, TB>): OnConflictBuilder<DB, TB>;
-    where(raw: AnyRawBuilder): OnConflictBuilder<DB, TB>;
+    where(expression: Expression<any>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.whereRef} for more info.
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): OnConflictBuilder<DB, TB>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.orWhere} for more info.
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): OnConflictBuilder<DB, TB>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictBuilder<DB, TB>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -307,37 +308,37 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      */
     orWhere(grouper: WhereGrouper<DB, TB>): OnConflictBuilder<DB, TB>;
-    orWhere(raw: AnyRawBuilder): OnConflictBuilder<DB, TB>;
+    orWhere(expression: Expression<any>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.orWhereRef} for more info.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): OnConflictBuilder<DB, TB>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.whereExists} for more info.
      */
-    whereExists(arg: ComplexExpression<DB, TB>): OnConflictBuilder<DB, TB>;
+    whereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.whereNotExists} for more info.
      */
-    whereNotExists(arg: ComplexExpression<DB, TB>): OnConflictBuilder<DB, TB>;
+    whereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.orWhereExists} for more info.
      */
-    orWhereExists(arg: ComplexExpression<DB, TB>): OnConflictBuilder<DB, TB>;
+    orWhereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
      *
      * See {@link WhereInterface.orWhereNotExists} for more info.
      */
-    orWhereNotExists(arg: ComplexExpression<DB, TB>): OnConflictBuilder<DB, TB>;
+    orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
      * Adds the "do nothing" conflict action.
      *
@@ -408,7 +409,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *
      * See {@link WhereInterface.where} for more info.
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): OnConflictUpdateBuilder<DB, TB>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Adds a `where` clause to the query.
      *
@@ -594,19 +595,19 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      */
     where(grouper: WhereGrouper<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
-    where(raw: AnyRawBuilder): OnConflictUpdateBuilder<DB, TB>;
+    where(expression: Expression<any>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.whereRef} for more info.
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.orWhere} for more info.
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): OnConflictUpdateBuilder<DB, TB>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -671,36 +672,36 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      */
     orWhere(grouper: WhereGrouper<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
-    orWhere(raw: AnyRawBuilder): OnConflictUpdateBuilder<DB, TB>;
+    orWhere(expression: Expression<any>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.orWhereRef} for more info.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.whereExists} for more info.
      */
-    whereExists(arg: ComplexExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    whereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.whereNotExists} for more info.
      */
-    whereNotExists(arg: ComplexExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    whereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.orWhereExists} for more info.
      */
-    orWhereExists(arg: ComplexExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    orWhereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
      *
      * See {@link WhereInterface.orWhereNotExists} for more info.
      */
-    orWhereNotExists(arg: ComplexExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     toOperationNode(): OnConflictNode;
 }

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

@@ -2,7 +2,8 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { parseWhereFilter, parseReferenceFilter, parseExistFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
+import { parseReferentialFilter, parseWhere, } from '../parser/binary-operation-parser.js';
+import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 import { parseUpdateObject, } from '../parser/update-set-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -78,7 +79,7 @@ export class OnConflictBuilder {
     where(...args) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseWhereFilter(args)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseWhere(args)),
         });
     }
     /**
@@ -89,13 +90,13 @@ export class OnConflictBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseWhereFilter(args)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseWhere(args)),
         });
     }
     /**
@@ -106,7 +107,7 @@ export class OnConflictBuilder {
     orWhereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -117,7 +118,7 @@ export class OnConflictBuilder {
     whereExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseExists(arg)),
         });
     }
     /**
@@ -128,7 +129,7 @@ export class OnConflictBuilder {
     whereNotExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
     /**
@@ -139,7 +140,7 @@ export class OnConflictBuilder {
     orWhereExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseExists(arg)),
         });
     }
     /**
@@ -150,7 +151,7 @@ export class OnConflictBuilder {
     orWhereNotExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
     /**
@@ -236,7 +237,7 @@ export class OnConflictUpdateBuilder {
     where(...args) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseWhereFilter(args)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseWhere(args)),
         });
     }
     /**
@@ -247,13 +248,13 @@ export class OnConflictUpdateBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseWhereFilter(args)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseWhere(args)),
         });
     }
     /**
@@ -264,7 +265,7 @@ export class OnConflictUpdateBuilder {
     orWhereRef(lhs, op, rhs) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -275,7 +276,7 @@ export class OnConflictUpdateBuilder {
     whereExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseExists(arg)),
         });
     }
     /**
@@ -286,7 +287,7 @@ export class OnConflictUpdateBuilder {
     whereNotExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
     /**
@@ -297,7 +298,7 @@ export class OnConflictUpdateBuilder {
     orWhereExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseExists(arg)),
         });
     }
     /**
@@ -308,7 +309,7 @@ export class OnConflictUpdateBuilder {
     orWhereNotExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
     toOperationNode() {

package/dist/esm/query-builder/over-builder.d.ts

@@ -0,0 +1,59 @@
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OverNode } from '../operation-node/over-node.js';
+import { OrderByDirectionExpression } from '../parser/order-by-parser.js';
+import { PartitionByExpression } from '../parser/partition-by-parser.js';
+import { StringReference } from '../parser/reference-parser.js';
+export declare class OverBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
+    #private;
+    constructor(props: OverBuilderProps);
+    /**
+     * Adds an order by clause item inside the over function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.orderBy('first_name', 'asc').orderBy('last_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(order by "first_name" asc, "last_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    orderBy(orderBy: StringReference<DB, TB> | DynamicReferenceBuilder<any>, direction?: OrderByDirectionExpression): OverBuilder<DB, TB>;
+    /**
+     * Adds partition by clause item/s inside the over function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy(['last_name', 'first_name'])
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name", "first_name") as "average_age"
+     * from "person"
+     * ```
+     */
+    partitionBy(partitionBy: ReadonlyArray<PartitionByExpression<DB, TB>>): OverBuilder<DB, TB>;
+    partitionBy(partitionBy: PartitionByExpression<DB, TB>): OverBuilder<DB, TB>;
+    toOperationNode(): OverNode;
+}
+export interface OverBuilderProps {
+    readonly overNode: OverNode;
+}

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

@@ -0,0 +1,47 @@
+/// <reference types="./over-builder.d.ts" />
+import { OverNode } from '../operation-node/over-node.js';
+import { parseOrderBy, } from '../parser/order-by-parser.js';
+import { parsePartitionBy, } from '../parser/partition-by-parser.js';
+import { freeze } from '../util/object-utils.js';
+import { preventAwait } from '../util/prevent-await.js';
+export class OverBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    /**
+     * Adds an order by clause item inside the over function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.orderBy('first_name', 'asc').orderBy('last_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(order by "first_name" asc, "last_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    orderBy(orderBy, direction) {
+        return new OverBuilder({
+            overNode: OverNode.cloneWithOrderByItem(this.#props.overNode, parseOrderBy(orderBy, direction)),
+        });
+    }
+    partitionBy(partitionBy) {
+        return new OverBuilder({
+            overNode: OverNode.cloneWithPartitionByItems(this.#props.overNode, parsePartitionBy(partitionBy)),
+        });
+    }
+    toOperationNode() {
+        return this.#props.overNode;
+    }
+}
+preventAwait(OverBuilder, "don't await OverBuilder instances. They are never executed directly and are always just a part of a query.");