kysely 0.21.5 → 0.22.0

package/dist/esm/parser/insert-values-parser.js

@@ -2,10 +2,11 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
-import { freeze } from '../util/object-utils.js';
+import { freeze, isUndefined } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { isComplexExpression } from './complex-expression-parser.js';
+import { DefaultInsertValueNode } from '../operation-node/default-insert-value-node.js';
 export function parseInsertObjectOrList(args) {
     return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
 }
@@ -30,16 +31,24 @@ function parseColumnNamesAndIndexes(rows) {
 }
 function parseRowValues(row, columns) {
     const rowColumns = Object.keys(row);
-    const rowValues = new Array(columns.size).fill(null);
+    const rowValues = Array.from({
+        length: columns.size,
+    });
+    let complexColumn = false;
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
-        const value = row[col];
         if (columnIdx !== undefined) {
+            const value = row[col];
+            if (isComplexExpression(value)) {
+                complexColumn = true;
+            }
             rowValues[columnIdx] = value;
         }
     }
-    if (rowValues.some(isComplexExpression)) {
-        return ValueListNode.create(rowValues.map((it) => parseValueExpression(it)));
+    const columnMissing = rowColumns.length < columns.size;
+    if (columnMissing || complexColumn) {
+        const defaultValue = DefaultInsertValueNode.create();
+        return ValueListNode.create(rowValues.map((it) => isUndefined(it) ? defaultValue : parseValueExpression(it)));
     }
     return PrimitiveValueListNode.create(rowValues);
 }

package/dist/esm/parser/parse-utils.d.ts

@@ -1,6 +1,7 @@
 import { JoinType } from '../operation-node/join-node.js';
 import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
+import { OverBuilder } from '../query-builder/over-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { TableExpression } from './table-parser.js';
@@ -8,3 +9,4 @@ export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, any,
 export declare function createExpressionBuilder(): ExpressionBuilder<any, any>;
 export declare function createQueryCreator(): QueryCreator<any>;
 export declare function createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+export declare function createOverBuilder(): OverBuilder<any, any>;

package/dist/esm/parser/parse-utils.js

@@ -1,8 +1,10 @@
 /// <reference types="./parse-utils.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
+import { OverNode } from '../operation-node/over-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
+import { OverBuilder } from '../query-builder/over-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
@@ -30,3 +32,8 @@ export function createJoinBuilder(joinType, table) {
         joinNode: JoinNode.create(joinType, parseTableExpression(table)),
     });
 }
+export function createOverBuilder() {
+    return new OverBuilder({
+        overNode: OverNode.create(),
+    });
+}

package/dist/esm/parser/partition-by-parser.d.ts

@@ -0,0 +1,6 @@
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
+import { StringReference } from './reference-parser.js';
+export declare type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export declare type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
+export declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

package/dist/esm/parser/partition-by-parser.js

@@ -0,0 +1,6 @@
+/// <reference types="./partition-by-parser.d.ts" />
+import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
+import { parseReferenceExpressionOrList, } from './reference-parser.js';
+export function parsePartitionBy(partitionBy) {
+    return parseReferenceExpressionOrList(partitionBy).map(PartitionByItemNode.create);
+}

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

@@ -8,10 +8,11 @@ import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { SelectType } from '../util/column-type.js';
+import { AggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : unknown;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends AggregateFunctionBuilder<any, any, infer O> ? O : RE extends (qb: any) => AggregateFunctionBuilder<any, any, infer O> ? O : unknown;
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = 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> : unknown;
 export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): ReferenceExpressionNode;

package/dist/esm/parser/select-parser.d.ts

@@ -5,7 +5,8 @@ import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTa
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
-export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB>;
+import { AliasedAggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
+export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB> | AliasedAggregateFunctionBuilder<DB, TB>;
 export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
  * Given a selection expression returns a query builder type that
@@ -19,9 +20,9 @@ export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends
 export declare type Selection<DB, TB extends keyof DB, SE> = {
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
-declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
+declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : SE extends AliasedAggregateFunctionBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedAggregateFunctionBuilder<any, any, any, infer QA> ? QA : never;
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
-declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
+declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : SE extends AliasedAggregateFunctionBuilder<any, any, infer O, infer FA> ? FA extends A ? O : never : SE extends (qb: any) => AliasedAggregateFunctionBuilder<any, any, infer O, infer FA> ? FA extends A ? O : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
 declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {

package/dist/esm/parser/set-operation-parser.d.ts

@@ -0,0 +1,5 @@
+import { SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+export declare type SetOperationExpression<DB, O> = SelectQueryBuilder<DB, any, O> | RawBuilder<O>;
+export declare function parseSetOperation(operator: SetOperator, expression: SetOperationExpression<any, any>, all: boolean): SetOperationNode;

package/dist/esm/parser/set-operation-parser.js

@@ -0,0 +1,5 @@
+/// <reference types="./set-operation-parser.d.ts" />
+import { SetOperationNode, } from '../operation-node/set-operation-node.js';
+export function parseSetOperation(operator, expression, all) {
+    return SetOperationNode.create(operator, expression.toOperationNode(), all);
+}

package/dist/esm/parser/value-parser.d.ts

@@ -3,7 +3,8 @@ import { ValueNode } from '../operation-node/value-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { ComplexExpression } from './complex-expression-parser.js';
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
 export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
 export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
-export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode | AggregateFunctionNode;

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

@@ -0,0 +1,117 @@
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OverBuilder } from './over-builder.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements OperationNodeSource {
+    #private;
+    constructor(props: AggregateFunctionBuilderProps);
+    /**
+     * Returns an aliased version of the function.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.count<number>('id').as('person_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `person_count: number` field exists in the result type.
+     * console.log(result.person_count)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("id") as "person_count"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedAggregateFunctionBuilder<DB, TB, O, A>;
+    /**
+     * Adds a distinct clause inside the function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.count<number>('first_name').distinct().as('first_name_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count(distinct "first_name") as "first_name_count"
+     * from "person"
+     * ```
+     */
+    distinct(): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an over clause (window functions) after the function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over().as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over() as "average_age"
+     * from "person"
+     * ```
+     *
+     * Also supports passing a callback that returns an over builder,
+     * allowing to add partition by and sort by clauses inside over.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy('last_name').orderBy('first_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name" order by "first_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    over(over?: OverBuilderCallback<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    toOperationNode(): AggregateFunctionNode;
+}
+/**
+ * {@link AggregateFunctionBuilder} with an alias. The result of calling {@link AggregateFunctionBuilder.as}.
+ */
+export declare class AliasedAggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown, A extends string = never> implements OperationNodeSource {
+    #private;
+    constructor(aggregateFunctionBuilder: AggregateFunctionBuilder<DB, TB, O>, alias: A);
+    /**
+     * @private
+     *
+     * This needs to be here just so that the typings work. Without this
+     * the generated .d.ts file contains no reference to the type param A
+     * which causes this type to be equal to AliasedAggregateFunctionBuilder with any A
+     * as long as O is the same.
+     */
+    protected get alias(): A;
+    toOperationNode(): AliasNode;
+}
+export interface AggregateFunctionBuilderProps {
+    aggregateFunctionNode: AggregateFunctionNode;
+}
+export declare type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<DB, TB>;

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

@@ -0,0 +1,142 @@
+/// <reference types="./aggregate-function-builder.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+import { createOverBuilder } from '../parser/parse-utils.js';
+export class AggregateFunctionBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    /**
+     * Returns an aliased version of the function.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.count<number>('id').as('person_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `person_count: number` field exists in the result type.
+     * console.log(result.person_count)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("id") as "person_count"
+     * from "person"
+     * ```
+     */
+    as(alias) {
+        return new AliasedAggregateFunctionBuilder(this, alias);
+    }
+    /**
+     * Adds a distinct clause inside the function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.count<number>('first_name').distinct().as('first_name_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count(distinct "first_name") as "first_name_count"
+     * from "person"
+     * ```
+     */
+    distinct() {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithDistinct(this.#props.aggregateFunctionNode),
+        });
+    }
+    /**
+     * Adds an over clause (window functions) after the function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over().as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over() as "average_age"
+     * from "person"
+     * ```
+     *
+     * Also supports passing a callback that returns an over builder,
+     * allowing to add partition by and sort by clauses inside over.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy('last_name').orderBy('first_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name" order by "first_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    over(over) {
+        const builder = createOverBuilder();
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithOver(this.#props.aggregateFunctionNode, (over ? over(builder) : builder).toOperationNode()),
+        });
+    }
+    toOperationNode() {
+        return this.#props.aggregateFunctionNode;
+    }
+}
+preventAwait(AggregateFunctionBuilder, "don't await AggregateFunctionBuilder instances. They are never executed directly and are always just a part of a query.");
+/**
+ * {@link AggregateFunctionBuilder} with an alias. The result of calling {@link AggregateFunctionBuilder.as}.
+ */
+export class AliasedAggregateFunctionBuilder {
+    #aggregateFunctionBuilder;
+    #alias;
+    constructor(aggregateFunctionBuilder, alias) {
+        this.#aggregateFunctionBuilder = aggregateFunctionBuilder;
+        this.#alias = alias;
+    }
+    /**
+     * @private
+     *
+     * This needs to be here just so that the typings work. Without this
+     * the generated .d.ts file contains no reference to the type param A
+     * which causes this type to be equal to AliasedAggregateFunctionBuilder with any A
+     * as long as O is the same.
+     */
+    get alias() {
+        return this.#alias;
+    }
+    toOperationNode() {
+        return AliasNode.create(this.#aggregateFunctionBuilder.toOperationNode(), IdentifierNode.create(this.#alias));
+    }
+}

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

@@ -1,6 +1,6 @@
 import { SelectQueryBuilder } from './select-query-builder.js';
 import { TableExpression, From, FromTables } from '../parser/table-parser.js';
-import { FunctionBuilder } from './function-builder.js';
+import { FunctionModule } from './function-module.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -8,7 +8,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);
     /**
-     * Returns a {@link FunctionBuilder} that can be used to write type safe function
+     * Returns a {@link FunctionModule} that can be used to write type safe function
      * calls.
      *
      * The difference between this and {@link Kysely.fn} is that this one is more
@@ -38,7 +38,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * having count("pet"."id") > $1
      * ```
      */
-    get fn(): FunctionBuilder<DB, TB>;
+    get fn(): FunctionModule<DB, TB>;
     /**
      * Creates a subquery.
      *

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

@@ -4,7 +4,7 @@ import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
-import { FunctionBuilder } from './function-builder.js';
+import { FunctionModule } from './function-module.js';
 import { parseStringReference, } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { freeze } from '../util/object-utils.js';
@@ -15,7 +15,7 @@ export class ExpressionBuilder {
         this.#props = freeze(props);
     }
     /**
-     * Returns a {@link FunctionBuilder} that can be used to write type safe function
+     * Returns a {@link FunctionModule} that can be used to write type safe function
      * calls.
      *
      * The difference between this and {@link Kysely.fn} is that this one is more
@@ -46,7 +46,7 @@ export class ExpressionBuilder {
      * ```
      */
     get fn() {
-        return new FunctionBuilder();
+        return new FunctionModule();
     }
     selectFrom(table) {
         return new SelectQueryBuilder({

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

@@ -1,5 +1,5 @@
 import { StringReference, ExtractTypeFromReferenceExpression } from '../parser/reference-parser.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
@@ -32,38 +32,8 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
  * having count("pet"."id") > $1
  * ```
  */
-export declare class FunctionBuilder<DB, TB extends keyof DB> {
-    #private;
+export declare class FunctionModule<DB, TB extends keyof DB> {
     constructor();
-    /**
-     * Calls the `max` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { max } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(max('price').as('max_price'))
-     *   .execute()
-     * ```
-     */
-    max<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
-    /**
-     * Calls the `min` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { min } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(min('price').as('min_price'))
-     *   .execute()
-     * ```
-     *
-     */
-    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
     /**
      * Calls the `avg` function for the column given as the argument.
      *
@@ -85,9 +55,9 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    avg<O extends number | string, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
+    avg<O extends number | string, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `sum` function for the column given as the argument.
+     * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
      * will be `number | string | bigint` by default. This is because Kysely can't
@@ -100,19 +70,56 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { sum } = db.fn
+     * const { count } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price').as('total_price'))
+     *   .select(count<number>('id').as('num_toys'))
+     *   .execute()
+     * ```
+     *
+     * You can limit column range:
+     *
+     * ```ts
+     * db.selectFrom('toy')
+     *   .select(qb => qb.fn.count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      */
-    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
+    count<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Calls the `count` function for the column given as the argument.
+     * Calls the `max` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { max } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(max('price').as('max_price'))
+     *   .execute()
+     * ```
+     */
+    max<C extends StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    /**
+     * Calls the `min` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { min } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(min('price').as('min_price'))
+     *   .execute()
+     * ```
+     *
+     */
+    min<C extends StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    /**
+     * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string |bigint` by default. This is because Kysely can't
+     * will be `number | string | bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -122,12 +129,12 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { count } = db.fn
+     * const { sum } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(count<number>('id').as('num_toys'))
+     *   .select(sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      */
-    count<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
+    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
 }