kysely 0.26.3 → 0.27.1

package/dist/cjs/operation-node/select-modifier-node.js

@@ -9,10 +9,11 @@ exports.SelectModifierNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'SelectModifierNode';
     },
-    create(modifier) {
+    create(modifier, of) {
         return (0, object_utils_js_1.freeze)({
             kind: 'SelectModifierNode',
             modifier,
+            of,
         });
     },
     createWithExpression(modifier) {

package/dist/cjs/operation-node/unique-constraint-node.d.ts

@@ -5,11 +5,14 @@ export interface UniqueConstraintNode extends OperationNode {
     readonly kind: 'UniqueConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly name?: IdentifierNode;
+    readonly nullsNotDistinct?: boolean;
 }
+export type UniqueConstraintNodeProps = Omit<Partial<UniqueConstraintNode>, 'kind'>;
 /**
  * @internal
  */
 export declare const UniqueConstraintNode: Readonly<{
     is(node: OperationNode): node is UniqueConstraintNode;
-    create(columns: string[], constraintName?: string): UniqueConstraintNode;
+    create(columns: string[], constraintName?: string, nullsNotDistinct?: boolean): UniqueConstraintNode;
+    cloneWith(node: UniqueConstraintNode, props: UniqueConstraintNodeProps): UniqueConstraintNode;
 }>;

package/dist/cjs/operation-node/unique-constraint-node.js

@@ -11,11 +11,18 @@ exports.UniqueConstraintNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'UniqueConstraintNode';
     },
-    create(columns, constraintName) {
+    create(columns, constraintName, nullsNotDistinct) {
         return (0, object_utils_js_1.freeze)({
             kind: 'UniqueConstraintNode',
             columns: (0, object_utils_js_1.freeze)(columns.map(column_node_js_1.ColumnNode.create)),
             name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
+            nullsNotDistinct,
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
         });
     },
 });

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

@@ -41,7 +41,7 @@ exports.parseFilterObject = parseFilterObject;
 function parseFilterList(list, combinator) {
     const combine = combinator === 'and' ? and_node_js_1.AndNode.create : or_node_js_1.OrNode.create;
     if (list.length === 0) {
-        return value_node_js_1.ValueNode.createImmediate(combinator === 'and');
+        return binary_operation_node_js_1.BinaryOperationNode.create(value_node_js_1.ValueNode.createImmediate(1), operator_node_js_1.OperatorNode.create('='), value_node_js_1.ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
     }
     let node = toOperationNode(list[0]);
     for (let i = 1; i < list.length; ++i) {

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

@@ -1,2 +1,12 @@
-import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
-export type CoalesceReferenceExpressionList<DB, TB extends keyof DB, RE extends unknown[], O = never> = RE extends [] ? O : RE extends [infer L, ...infer R] ? L extends ReferenceExpression<any, any> ? null extends ExtractTypeFromReferenceExpression<DB, TB, L> ? CoalesceReferenceExpressionList<DB, TB, R extends ReferenceExpression<any, any>[] ? R : never, O | ExtractTypeFromReferenceExpression<DB, TB, L>> : Exclude<O, null> | ExtractTypeFromReferenceExpression<DB, TB, L> : never : never;
+import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+export type ExtractTypeFromCoalesce1<DB, TB extends keyof DB, R1> = ExtractTypeFromReferenceExpression<DB, TB, R1>;
+export type ExtractTypeFromCoalesce2<DB, TB extends keyof DB, R1, R2> = ExtractTypeFromCoalesceValues2<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>>;
+type ExtractTypeFromCoalesceValues2<V1, V2> = null extends V1 ? null extends V2 ? V1 | V2 : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce3<DB, TB extends keyof DB, R1, R2, R3> = ExtractTypeFromCoalesceValues3<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>>;
+type ExtractTypeFromCoalesceValues3<V1, V2, V3> = null extends V1 ? null extends V2 ? null extends V3 ? V1 | V2 | V3 : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce4<DB, TB extends keyof DB, R1, R2, R3, R4> = ExtractTypeFromCoalesceValues4<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>>;
+type ExtractTypeFromCoalesceValues4<V1, V2, V3, V4> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? V1 | V2 | V3 | V4 : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = ExtractTypeFromCoalesceValues5<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>, ExtractTypeFromReferenceExpression<DB, TB, R5>>;
+type ExtractTypeFromCoalesceValues5<V1, V2, V3, V4, V5> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? null extends V5 ? V1 | V2 | V3 | V4 | V5 : NotNull<V1 | V2 | V3 | V4 | V5> : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+type NotNull<T> = Exclude<T, null>;
+export {};

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

@@ -16,7 +16,8 @@ export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyCo
 export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
 export type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
 export type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
-export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
+export type ExtractRawTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
 export type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
 export type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
 export type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;

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

@@ -2,9 +2,12 @@ import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
+import { ExtractRawTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
 export type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
     [C in UpdateKeys<DB[UT]>]?: ValueExpression<DB, TB, UpdateType<DB[UT][C]>> | undefined;
 };
 export type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
-export type UpdateExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
-export declare function parseUpdateExpression(update: UpdateExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;
+export type UpdateObjectExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
+export type ExtractUpdateTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = UpdateType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
+export declare function parseUpdate(...args: [UpdateObjectExpression<any, any, any>] | [ReferenceExpression<any, any>, ValueExpression<any, any, any>]): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObjectExpression(update: UpdateObjectExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

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

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

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

@@ -116,8 +116,8 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * from "person"
      * ```
      */
-    filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    filterWhere(expression: ExpressionOrFactory<DB, TB, SqlBool>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Adds a `filter` clause with a nested `where` clause after the function, where
      * both sides of the operator are references to columns.
@@ -150,7 +150,7 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * from "person"
      * ```
      */
-    filterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Adds an `over` clause (window functions) after the function.
      *
@@ -199,6 +199,23 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * what the provided function returns.
      */
     $call<T>(func: (qb: this) => T): T;
+    /**
+     * Casts the expression to the given type.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AggregateFunctionBuilder` with a new output type.
+     */
+    $castTo<C>(): AggregateFunctionBuilder<DB, TB, C>;
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull(): AggregateFunctionBuilder<DB, TB, Exclude<O, null>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -239,4 +256,4 @@ export declare class AliasedAggregateFunctionBuilder<DB, TB extends keyof DB, O
 export interface AggregateFunctionBuilderProps {
     aggregateFunctionNode: AggregateFunctionNode;
 }
-export type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<DB, TB>;
+export type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<any, any>;

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

@@ -172,6 +172,27 @@ class AggregateFunctionBuilder {
     $call(func) {
         return func(this);
     }
+    /**
+     * Casts the expression to the given type.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AggregateFunctionBuilder` with a new output type.
+     */
+    $castTo() {
+        return new AggregateFunctionBuilder(this.#props);
+    }
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull() {
+        return new AggregateFunctionBuilder(this.#props);
+    }
     toOperationNode() {
         return this.#props.aggregateFunctionNode;
     }

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

@@ -3,6 +3,7 @@ import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { CaseNode } from '../operation-node/case-node.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { ExtractTypeFromValueExpression } from '../parser/value-parser.js';
 import { KyselyTypeError } from '../util/type-error.js';
 export declare class CaseBuilder<DB, TB extends keyof DB, W = unknown, O = never> implements Whenable<DB, TB, W, O> {
     #private;
@@ -12,7 +13,7 @@ export declare class CaseBuilder<DB, TB extends keyof DB, W = unknown, O = never
      *
      * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
      */
-    when<RE extends ReferenceExpression<DB, TB>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): CaseThenBuilder<DB, TB, W, O>;
+    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
     when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
     when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
 }
@@ -28,7 +29,7 @@ export declare class CaseThenBuilder<DB, TB extends keyof DB, W, O> {
      * A `then` call can be followed by {@link Whenable.when}, {@link CaseWhenBuilder.else},
      * {@link CaseWhenBuilder.end} or {@link CaseWhenBuilder.endCase} call.
      */
-    then<O2>(expression: Expression<O2>): CaseWhenBuilder<DB, TB, W, O | O2>;
+    then<E extends Expression<unknown>>(expression: E): CaseWhenBuilder<DB, TB, W, O | ExtractTypeFromValueExpression<E>>;
     then<V>(value: V): CaseWhenBuilder<DB, TB, W, O | V>;
 }
 export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements Whenable<DB, TB, W, O>, Endable<DB, TB, O | null> {
@@ -39,7 +40,7 @@ export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements W
      *
      * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
      */
-    when<RE extends ReferenceExpression<DB, TB>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): CaseThenBuilder<DB, TB, W, O>;
+    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
     when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
     when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
     /**
@@ -47,7 +48,7 @@ export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements W
      *
      * An `else` call must be followed by an {@link Endable.end} or {@link Endable.endCase} call.
      */
-    else<O2>(expression: Expression<O2>): CaseEndBuilder<DB, TB, O | O2>;
+    else<E extends Expression<unknown>>(expression: E): CaseEndBuilder<DB, TB, O | ExtractTypeFromValueExpression<E>>;
     else<V>(value: V): CaseEndBuilder<DB, TB, O | V>;
     /**
      * Adds an `end` keyword to the case operator.
@@ -88,7 +89,7 @@ interface Whenable<DB, TB extends keyof DB, W, O> {
      *
      * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
      */
-    when<RE extends ReferenceExpression<DB, TB>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): CaseThenBuilder<DB, TB, W, O>;
+    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
     when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
     when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
 }

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

@@ -23,6 +23,7 @@ import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../p
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
+import { ValueExpression } from '../parser/value-parser.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -325,8 +326,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): DeleteQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): DeleteQueryBuilder<DB, TB, O>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -378,7 +379,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Clears all where expressions from the query.
      *
@@ -814,7 +815,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    limit(limit: number): DeleteQueryBuilder<DB, TB, O>;
+    limit(limit: ValueExpression<DB, TB, number>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -877,10 +878,10 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `DeleteQueryBuilder` with a new output type.
      */
-    $castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    $castTo<C>(): DeleteQueryBuilder<DB, TB, C>;
     /**
      * Narrows (parts of) the output type of the query.
      *

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

@@ -13,6 +13,7 @@ const delete_query_node_js_1 = require("../operation-node/delete-query-node.js")
 const limit_node_js_1 = require("../operation-node/limit-node.js");
 const order_by_parser_js_1 = require("../parser/order-by-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
 class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -139,7 +140,7 @@ class DeleteQueryBuilder {
     limit(limit) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create(limit)),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create((0, value_parser_js_1.parseValueExpression)(limit))),
         });
     }
     /**
@@ -213,8 +214,8 @@ class DeleteQueryBuilder {
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `DeleteQueryBuilder` with a new output type.
      */
     $castTo() {
         return new DeleteQueryBuilder(this.#props);

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

@@ -1,12 +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 { ExtractTypeFromCoalesce1, ExtractTypeFromCoalesce3, ExtractTypeFromCoalesce2, ExtractTypeFromCoalesce4, ExtractTypeFromCoalesce5 } from '../parser/coalesce-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 { IsNever } from '../util/type-utils.js';
 import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
 import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+import { Selectable } from '../util/column-type.js';
 /**
  * Helpers for type safe SQL function calls.
  *
@@ -17,21 +17,47 @@ import { SelectQueryBuilderExpression } from '../query-builder/select-query-buil
  *
  * <!-- siteExample("select", "Function calls", 60) -->
  *
- * This example uses the `fn` module to select some aggregates:
+ * This example shows how to create function calls. These examples also work in any
+ * other place (`where` calls, updates, inserts etc.). The only difference is that you
+ * leave out the alias (the `as` call) if you use these in any other place than `select`.
  *
  * ```ts
+ * import { sql } from 'kysely'
+ *
  * const result = await db.selectFrom('person')
  *   .innerJoin('pet', 'pet.owner_id', 'person.id')
- *   .select(({ fn }) => [
+ *   .select(({ fn, val, ref }) => [
  *     'person.id',
  *
  *     // The `fn` module contains the most common
  *     // functions.
  *     fn.count<number>('pet.id').as('pet_count'),
  *
- *     // You can call any function using the
- *     // `agg` method
- *     fn.agg<string[]>('array_agg', ['pet.name']).as('pet_names')
+ *     // You can call any function by calling `fn`
+ *     // directly. The arguments are treated as column
+ *     // references by default. If you want  to pass in
+ *     // values, use the `val` function.
+ *     fn<string>('concat', [
+ *       val('Ms. '),
+ *       'first_name',
+ *       val(' '),
+ *       'last_name'
+ *     ]).as('full_name_with_title'),
+ *
+ *     // You can call any aggregate function using the
+ *     // `fn.agg` function.
+ *     fn.agg<string[]>('array_agg', ['pet.name']).as('pet_names'),
+ *
+ *     // And once again, you can use the `sql`
+ *     // template tag. The template tag substitutions
+ *     // are treated as values by default. If you want
+ *     // to reference columns, you can use the `ref`
+ *     // function.
+ *     sql<string>`concat(
+ *       ${ref('first_name')},
+ *       ' ',
+ *       ${ref('last_name')}
+ *     )`.as('full_name')
  *   ])
  *   .groupBy('person.id')
  *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
@@ -44,11 +70,13 @@ import { SelectQueryBuilderExpression } from '../query-builder/select-query-buil
  * select
  *   "person"."id",
  *   count("pet"."id") as "pet_count",
- *   array_agg("pet"."name") as "pet_names"
+ *   concat($1, "first_name", $2, "last_name") as "full_name_with_title",
+ *   array_agg("pet"."name") as "pet_names",
+ *   concat("first_name", ' ', "last_name") as "full_name"
  * from "person"
  * inner join "pet" on "pet"."owner_id" = "person"."id"
  * group by "person"."id"
- * having count("pet"."id") > $1
+ * having count("pet"."id") > $3
  * ```
  */
 export interface FunctionModule<DB, TB extends keyof DB> {
@@ -81,7 +109,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .where(sql`upper(first_name)`, '=', 'JENNIFER')
      * ```
      */
-    <T>(name: string, args: ReadonlyArray<ReferenceExpression<DB, TB>>): ExpressionWrapper<DB, TB, T>;
+    <O, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): ExpressionWrapper<DB, TB, O>;
     /**
      * Creates an aggregate function call.
      *
@@ -110,7 +138,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * from "person"
      * ```
      */
-    agg<O>(name: string, args?: ReadonlyArray<ReferenceExpression<DB, TB>>): AggregateFunctionBuilder<DB, TB, O>;
+    agg<O, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `avg` function for the column or expression given as the argument.
      *
@@ -169,7 +197,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    avg<O extends number | string | null = number | string, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    avg<O extends number | string | null = number | string, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `coalesce` function for given arguments.
      *
@@ -230,7 +258,11 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * select coalesce(avg("age"), 0) as "avg_age" from "person" where "first_name" = $1
      * ```
      */
-    coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): ExpressionWrapper<DB, TB, CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
+    coalesce<V1 extends ReferenceExpression<DB, TB>>(v1: V1): ExpressionWrapper<DB, TB, ExtractTypeFromCoalesce1<DB, TB, V1>>;
+    coalesce<V1 extends ReferenceExpression<DB, TB>, V2 extends ReferenceExpression<DB, TB>>(v1: V1, v2: V2): ExpressionWrapper<DB, TB, ExtractTypeFromCoalesce2<DB, TB, V1, V2>>;
+    coalesce<V1 extends ReferenceExpression<DB, TB>, V2 extends ReferenceExpression<DB, TB>, V3 extends ReferenceExpression<DB, TB>>(v1: V1, v2: V2, v3: V3): ExpressionWrapper<DB, TB, ExtractTypeFromCoalesce3<DB, TB, V1, V2, V3>>;
+    coalesce<V1 extends ReferenceExpression<DB, TB>, V2 extends ReferenceExpression<DB, TB>, V3 extends ReferenceExpression<DB, TB>, V4 extends ReferenceExpression<DB, TB>>(v1: V1, v2: V2, v3: V3, v4: V4): ExpressionWrapper<DB, TB, ExtractTypeFromCoalesce4<DB, TB, V1, V2, V3, V4>>;
+    coalesce<V1 extends ReferenceExpression<DB, TB>, V2 extends ReferenceExpression<DB, TB>, V3 extends ReferenceExpression<DB, TB>, V4 extends ReferenceExpression<DB, TB>, V5 extends ReferenceExpression<DB, TB>>(v1: V1, v2: V2, v3: V3, v4: V4, v5: V5): ExpressionWrapper<DB, TB, ExtractTypeFromCoalesce5<DB, TB, V1, V2, V3, V4, V5>>;
     /**
      * Calls the `count` function for the column or expression given as the argument.
      *
@@ -281,7 +313,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    count<O extends number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    count<O extends number | string | bigint, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `count` function with `*` or `table.*` as argument.
      *
@@ -395,12 +427,11 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *
      * ```ts
      * db.selectFrom('toy')
-     *   .select((eb) => eb.fn.max<number | null, 'price'>('price').as('max_price'))
+     *   .select((eb) => eb.fn.max<number | null>('price').as('max_price'))
      *   .execute()
      * ```
      */
-    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>;
+    max<O extends number | string | bigint | null = never, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, IsNever<O> extends true ? ExtractTypeFromReferenceExpression<DB, TB, RE, number | string | bigint> : O>;
     /**
      * Calls the `min` function for the column or expression given as the argument.
      *
@@ -443,12 +474,11 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *
      * ```ts
      * db.selectFrom('toy')
-     *   .select((eb) => eb.fn.min<number | null, 'price'>('price').as('min_price'))
+     *   .select((eb) => eb.fn.min<number | null>('price').as('min_price'))
      *   .execute()
      * ```
      */
-    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>;
+    min<O extends number | string | bigint | null = never, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, IsNever<O> extends true ? ExtractTypeFromReferenceExpression<DB, TB, RE, number | string | bigint> : O>;
     /**
      * Calls the `sum` function for the column or expression given as the argument.
      *
@@ -507,7 +537,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    sum<O extends number | string | bigint | null = number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    sum<O extends number | string | bigint | null = number | string | bigint, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `any` function for the column or expression given as the argument.
      *
@@ -540,8 +570,49 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     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>;
+    /**
+     * Creates a json_agg function call.
+     *
+     * This function is only available on PostgreSQL.
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select((eb) => ['first_name', eb.fn.jsonAgg('pet').as('pets')])
+     *   .groupBy('person.first_name')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name", json_agg("pet") as "pets"
+     * from "person"
+     * inner join "pet" on "pet"."owner_id" = "person"."id"
+     * group by "person"."first_name"
+     * ```
+     */
+    jsonAgg<T extends (TB & string) | Expression<unknown>>(table: T): AggregateFunctionBuilder<DB, TB, T extends TB ? Selectable<DB[T]>[] : T extends Expression<infer O> ? O[] : never>;
+    /**
+     * Creates a to_json function call.
+     *
+     * This function is only available on PostgreSQL.
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select((eb) => ['first_name', eb.fn.toJson('pet').as('pet')])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name", to_json("pet") as "pet"
+     * from "person"
+     * inner join "pet" on "pet"."owner_id" = "person"."id"
+     * ```
+     */
+    toJson<T extends (TB & string) | Expression<unknown>>(table: T): ExpressionWrapper<DB, TB, T extends TB ? Selectable<DB[T]> : T extends Expression<infer O> ? O : never>;
 }
 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;
-type StringReferenceBoundAggregateFunctionBuilder<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C> | (IsAny<O> extends true ? never : null extends O ? null : never)>;
-export {};

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

@@ -7,9 +7,11 @@ const function_node_js_1 = require("../operation-node/function-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
 const aggregate_function_builder_js_1 = require("./aggregate-function-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
 function createFunctionModule() {
     const fn = (name, args) => {
-        return new expression_wrapper_js_1.ExpressionWrapper(function_node_js_1.FunctionNode.create(name, (0, reference_parser_js_1.parseReferenceExpressionOrList)(args)));
+        return new expression_wrapper_js_1.ExpressionWrapper(function_node_js_1.FunctionNode.create(name, (0, reference_parser_js_1.parseReferenceExpressionOrList)(args ?? [])));
     };
     const agg = (name, args) => {
         return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
@@ -21,8 +23,8 @@ function createFunctionModule() {
         avg(column) {
             return agg('avg', [column]);
         },
-        coalesce(value, ...otherValues) {
-            return fn('coalesce', [value, ...otherValues]);
+        coalesce(...values) {
+            return fn('coalesce', values);
         },
         count(column) {
             return agg('count', [column]);
@@ -44,6 +46,18 @@ function createFunctionModule() {
         any(column) {
             return fn('any', [column]);
         },
+        jsonAgg(table) {
+            return new aggregate_function_builder_js_1.AggregateFunctionBuilder({
+                aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.create('json_agg', [
+                    (0, object_utils_js_1.isString)(table) ? (0, table_parser_js_1.parseTable)(table) : table.toOperationNode(),
+                ]),
+            });
+        },
+        toJson(table) {
+            return new expression_wrapper_js_1.ExpressionWrapper(function_node_js_1.FunctionNode.create('to_json', [
+                (0, object_utils_js_1.isString)(table) ? (0, table_parser_js_1.parseTable)(table) : table.toOperationNode(),
+            ]));
+        },
     });
 }
 exports.createFunctionModule = createFunctionModule;