kysely 0.26.1 → 0.26.3

package/dist/esm/query-builder/function-module.d.ts

@@ -1,9 +1,12 @@
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { Expression } from '../expression/expression.js';
 import { CoalesceReferenceExpressionList } from '../parser/coalesce-parser.js';
-import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference, ExtractTypeFromStringReference } from '../parser/reference-parser.js';
+import { KyselyTypeError } from '../util/type-error.js';
 import { Equals, IsAny } from '../util/type-utils.js';
 import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 /**
  * Helpers for type safe SQL function calls.
  *
@@ -109,7 +112,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      */
     agg<O>(name: string, args?: ReadonlyArray<ReferenceExpression<DB, TB>>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `avg` function for the column given as the argument.
+     * Calls the `avg` function for the column or expression given as the argument.
      *
      * This sql function calculates the average value for a given column.
      *
@@ -229,7 +232,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      */
     coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): ExpressionWrapper<DB, TB, CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
     /**
-     * Calls the `count` function for the column given as the argument.
+     * Calls the `count` function for the column or expression given as the argument.
      *
      * When called with a column as argument, this sql function counts the number of rows where there
      * is a non-null value in that column.
@@ -351,7 +354,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     countAll<O extends number | string | bigint, T extends TB = TB>(table: T): AggregateFunctionBuilder<DB, TB, O>;
     countAll<O extends number | string | bigint>(): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `max` function for the column given as the argument.
+     * Calls the `max` function for the column or expression given as the argument.
      *
      * This sql function calculates the maximum value for a given column.
      *
@@ -399,7 +402,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     max<O extends number | string | bigint | null = any, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: OutputBoundStringReference<DB, TB, C, O>): StringReferenceBoundAggregateFunctionBuilder<DB, TB, C, O>;
     max<O extends number | string | bigint | null = number | string | bigint>(column: DynamicReferenceBuilder): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `min` function for the column given as the argument.
+     * Calls the `min` function for the column or expression given as the argument.
      *
      * This sql function calculates the minimum value for a given column.
      *
@@ -447,7 +450,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     min<O extends number | string | bigint | null = any, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: OutputBoundStringReference<DB, TB, C, O>): StringReferenceBoundAggregateFunctionBuilder<DB, TB, C, O>;
     min<O extends number | string | bigint | null = number | string | bigint>(column: DynamicReferenceBuilder): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `sum` function for the column given as the argument.
+     * Calls the `sum` function for the column or expression given as the argument.
      *
      * This sql function sums the values of a given column.
      *
@@ -505,6 +508,38 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ```
      */
     sum<O extends number | string | bigint | null = number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Calls the `any` function for the column or expression given as the argument.
+     *
+     * The argument must be a subquery or evaluate to an array.
+     *
+     * ### Examples
+     *
+     * In the following example, `nicknames` is assumed to be a column of type `string[]`:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where((eb) => eb(
+     *     eb.val('Jen'), '=', eb.fn.any('person.nicknames')
+     *   ))
+     * ```
+     *
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   "person".*
+     * from
+     *   "person"
+     * where
+     *  $1 = any("person"."nicknames")
+     * ```
+     */
+    any<RE extends StringReference<DB, TB>>(expr: RE): Exclude<ExtractTypeFromStringReference<DB, TB, RE>, null> extends ReadonlyArray<infer I> ? ExpressionWrapper<DB, TB, I> : KyselyTypeError<'any(expr) call failed: expr must be an array'>;
+    any<T>(subquery: SelectQueryBuilderExpression<Record<string, T>>): ExpressionWrapper<DB, TB, T>;
+    any<T>(expr: Expression<ReadonlyArray<T>>): ExpressionWrapper<DB, TB, T>;
 }
 export declare function createFunctionModule<DB, TB extends keyof DB>(): FunctionModule<DB, TB>;
 type OutputBoundStringReference<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = IsAny<O> extends true ? C : Equals<ExtractTypeFromReferenceExpression<DB, TB, C> | null, O | null> extends true ? C : never;

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

@@ -39,5 +39,8 @@ export function createFunctionModule() {
         sum(column) {
             return agg('sum', [column]);
         },
+        any(column) {
+            return fn('any', [column]);
+        },
     });
 }

package/dist/esm/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/esm/query-builder/insert-query-builder.d.ts

@@ -1,6 +1,6 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
-import { SelectExpression, SelectArg } from '../parser/select-parser.js';
+import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
 import { InsertObjectOrList, InsertObjectOrListFactory } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
@@ -11,7 +11,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { InsertResult } from './insert-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { ReturningRow } from '../parser/returning-parser.js';
+import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
@@ -474,7 +474,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .executeTakeFirst()
      * ```
      */
-    returning<SE extends SelectExpression<DB, TB>>(selection: SelectArg<DB, TB, SE>): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<CB extends SelectCallback<DB, TB>>(callback: CB): InsertQueryBuilder<DB, TB, ReturningCallbackRow<DB, TB, O, CB>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.

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

@@ -1,7 +1,7 @@
 /// <reference types="./join-builder.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseFilter, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class JoinBuilder {
@@ -12,7 +12,7 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseFilter(args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     /**
@@ -24,7 +24,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialComparison(lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     /**

package/dist/esm/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 */
@@ -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/esm/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,7 +99,34 @@ 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) -->
+     *
+     * You can use the `and` function to create a simple equality
+     * filter using an object
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .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
@@ -133,7 +161,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
@@ -228,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:
@@ -317,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.
      *
@@ -489,7 +516,34 @@ 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) -->
+     *
+     * You can use the `and` function to create a simple equality
+     * filter using an object
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .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
@@ -524,7 +578,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
@@ -619,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:
@@ -708,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/esm/query-builder/on-conflict-builder.js

@@ -2,7 +2,7 @@
 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 { parseFilter, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
 import { parseUpdateExpression, } from '../parser/update-set-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -78,7 +78,7 @@ export class OnConflictBuilder {
     where(...args) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseFilter(args)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     /**
@@ -89,7 +89,7 @@ export class OnConflictBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferentialComparison(lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     clearWhere() {
@@ -204,7 +204,7 @@ export class OnConflictUpdateBuilder {
     where(...args) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseFilter(args)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     /**
@@ -215,7 +215,7 @@ export class OnConflictUpdateBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferentialComparison(lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     clearWhere() {

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

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

package/dist/esm/query-builder/returning-interface.d.ts

@@ -1,5 +1,5 @@
-import { ReturningRow } from '../parser/returning-parser.js';
-import { SelectExpression } from '../parser/select-parser.js';
+import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import { SelectCallback, SelectExpression } from '../parser/select-parser.js';
 import { Selectable } from '../util/column-type.js';
 export interface ReturningInterface<DB, TB extends keyof DB, O> {
     /**
@@ -62,6 +62,7 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      * ```
      */
     returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): ReturningInterface<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<CB extends SelectCallback<DB, TB>>(callback: CB): ReturningInterface<DB, TB, ReturningCallbackRow<DB, TB, O, CB>>;
     returning<SE extends SelectExpression<DB, TB>>(selection: SE): ReturningInterface<DB, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases

package/dist/esm/query-builder/select-query-builder-expression.d.ts

@@ -0,0 +1,20 @@
+import { AliasableExpression } from '../expression/expression.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+export interface SelectQueryBuilderExpression<O> extends AliasableExpression<O> {
+    get isSelectQueryBuilder(): true;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): SelectQueryNode;
+}

package/dist/esm/query-builder/select-query-builder-expression.js

@@ -0,0 +1,2 @@
+/// <reference types="./select-query-builder-expression.d.ts" />
+export {};