kysely 0.21.6 → 0.23.0

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

@@ -3,10 +3,9 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
 import { TableExpression } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
-import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
+import { MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -18,10 +17,11 @@ import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { Selectable } from '../util/column-type.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
-import { AliasedQueryBuilder } from './select-query-builder.js';
-import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
-export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable, Explainable {
+import { AliasedExpression, Expression } from '../expression/expression.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ExistsExpression } from '../parser/unary-operation-parser.js';
+export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
     /**
@@ -208,16 +208,16 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
     where(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
-    where(raw: AnyRawBuilder): DeleteQueryBuilder<DB, TB, O>;
+    where(expression: Expression<any>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
      *
      * The normal `where` method treats the right hand side argument as a
      * value by default. `whereRef` treats it as a column reference. This method is
-     * expecially useful with joins and correclated subqueries.
+     * expecially useful with joins and correlated subqueries.
      *
      * ### Examples
      *
@@ -262,7 +262,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -326,15 +326,15 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" (where "id" = 1 or "id" = 2)
      * ```
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
     orWhere(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
-    orWhere(raw: AnyRawBuilder): DeleteQueryBuilder<DB, TB, O>;
+    orWhere(expression: Expression<any>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
      *
      * Also see {@link orWhere} and {@link where}.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where exists` clause to the query.
      *
@@ -401,11 +401,11 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     whereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Just like {@link whereExists} but creates a `or exists` clause.
+     * Just like {@link whereExists} but creates an `or exists` clause.
      */
     orWhereExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
-     * Just like {@link whereExists} but creates a `or not exists` clause.
+     * Just like {@link whereExists} but creates an `or not exists` clause.
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     /**
@@ -724,7 +724,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O>;
     toOperationNode(): DeleteQueryNode;
-    compile(): CompiledQuery;
+    compile(): CompiledQuery<O>;
     /**
      * Executes the query and returns an array of rows.
      *
@@ -761,29 +761,29 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * explain format=json delete from `person` where `id` = ?
      * ```
      */
-    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<ER[]>;
 }
 export interface DeleteQueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: DeleteQueryNode;
     readonly executor: QueryExecutor;
 }
-export declare type DeleteQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? DeleteQueryBuilder<DB, TB | TE, O> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type DeleteQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? DeleteQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? DeleteQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : DeleteQueryBuilder<DB & Record<A, R>, TB | A, O>;
 declare type InnerJoinedDB<DB, A extends string, R> = {
     [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
 };
-export declare type DeleteQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type DeleteQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? DeleteQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : DeleteQueryBuilder<DB & Record<A, Nullable<R>>, TB | A, O>;
 declare type LeftJoinedDB<DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
 };
-export declare type DeleteQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type DeleteQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = DeleteQueryBuilder<RightJoinedDB<DB, TB, A, R>, TB | A, O>;
 declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 };
-export declare type DeleteQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type DeleteQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = DeleteQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, TB | A, O>;
 declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleteQueryBuilder = void 0;
 const join_parser_js_1 = require("../parser/join-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
-const filter_parser_js_1 = require("../parser/filter-parser.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
@@ -13,6 +12,8 @@ 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 explain_node_js_1 = require("../operation-node/explain-node.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const unary_operation_parser_js_1 = require("../parser/unary-operation-parser.js");
 class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -21,49 +22,49 @@ class DeleteQueryBuilder {
     where(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseWhere)(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseWhere)(args)),
         });
     }
     orWhereRef(lhs, op, rhs) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
         });
     }
     whereExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, unary_operation_parser_js_1.parseExists)(arg)),
         });
     }
     whereNotExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, unary_operation_parser_js_1.parseNotExists)(arg)),
         });
     }
     orWhereExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, unary_operation_parser_js_1.parseExists)(arg)),
         });
     }
     orWhereNotExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, unary_operation_parser_js_1.parseNotExists)(arg)),
         });
     }
     innerJoin(...args) {
@@ -263,15 +264,17 @@ class DeleteQueryBuilder {
      * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
      */
     async execute() {
-        const compildQuery = this.compile();
-        const query = compildQuery.query;
-        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
+        const compiledQuery = this.compile();
+        const query = compiledQuery.query;
+        const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
         if (this.#props.executor.adapter.supportsReturning && query.returning) {
             return result.rows;
         }
-        else {
-            return [new delete_result_js_1.DeleteResult(result.numUpdatedOrDeletedRows)];
-        }
+        return [
+            new delete_result_js_1.DeleteResult(
+            // TODO: remove numUpdatedOrDeletedRows.
+            (result.numAffectedRows ?? result.numUpdatedOrDeletedRows)),
+        ];
     }
     /**
      * Executes the query and returns the first result or undefined if
@@ -315,7 +318,7 @@ class DeleteQueryBuilder {
     async explain(format, options) {
         const builder = new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithExplain(this.#props.queryNode, explain_node_js_1.ExplainNode.create(format, options)),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithExplain(this.#props.queryNode, explain_node_js_1.ExplainNode.create(format, options?.toOperationNode())),
         });
         return await builder.execute();
     }

package/dist/cjs/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/cjs/query-builder/expression-builder.js

@@ -6,7 +6,7 @@ const select_query_node_js_1 = require("../operation-node/select-query-node.js")
 const table_parser_js_1 = require("../parser/table-parser.js");
 const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
 const query_id_js_1 = require("../util/query-id.js");
-const function_builder_js_1 = require("./function-builder.js");
+const function_module_js_1 = require("./function-module.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
@@ -17,7 +17,7 @@ class ExpressionBuilder {
         this.#props = (0, object_utils_js_1.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
@@ -48,7 +48,7 @@ class ExpressionBuilder {
      * ```
      */
     get fn() {
-        return new function_builder_js_1.FunctionBuilder();
+        return new function_module_js_1.FunctionModule();
     }
     selectFrom(table) {
         return new select_query_builder_js_1.SelectQueryBuilder({

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

@@ -0,0 +1,241 @@
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { CoalesceReferenceExpressionList } from '../parser/coalesce-parser.js';
+import { ExtractTypeFromReferenceExpression, SimpleReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Equals, IsNever } from '../util/type-utils.js';
+import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
+/**
+ * Helpers for type safe SQL function calls.
+ *
+ * You can always use the {@link sql} tag to call functions and build arbitrary
+ * expressions. This module simply has shortcuts for most common function calls.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const { count } = db.fn
+ *
+ * await db.selectFrom('person')
+ *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+ *   .select([
+ *     'person.id',
+ *     count('pet.id').as('pet_count')
+ *   ])
+ *   .groupBy('person.id')
+ *   .having(count('pet.id'), '>', 10)
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "person"."id", count("pet"."id") as "pet_count"
+ * from "person"
+ * inner join "pet" on "pet"."owner_id" = "person"."id"
+ * group by "person"."id"
+ * having count("pet"."id") > $1
+ * ```
+ */
+export declare class FunctionModule<DB, TB extends keyof DB> {
+    constructor();
+    /**
+     * Calls the `avg` 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` 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 know if you've
+     * done so.
+     *
+     * You can specify the output type of the expression by providing the type as
+     * the first type argument:
+     *
+     * ```ts
+     * const { avg } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(avg<number>('price').as('avg_price'))
+     *   .execute()
+     * ```
+     *
+     * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+     * was used. It is highly recommended to include null in the output type union
+     * and handle null values in post-execute code, or wrap the function with a `coalesce`
+     * function.
+     *
+     * ```ts
+     * const { avg } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(avg<number | null>('price').as('avg_price'))
+     *   .execute()
+     * ```
+     */
+    avg<O extends number | string | null = number | string, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Calls the `coalesce` function for given arguments.
+     *
+     * This function returns the first non-null value from left to right, commonly
+     * used to provide a default scalar for nullable columns or functions.
+     *
+     * ```ts
+     * const { coalesce, max } = db.fn
+     *
+     * db.selectFrom('person')
+     *   .select(coalesce(max('age'), sql<number>`0`).as('max_age'))
+     *   .where('first_name', '=', 'Jennifer')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (postgres):
+     *
+     * ```sql
+     * select coalesce(max("age"), 0) as "max_age" from "person" where "first_name" = $1
+     * ```
+     *
+     * If this is used in a `select` statement the type of the selected expression
+     * is inferred in the same manner that the function computes. A union of arguments'
+     * types - if a non-nullable argument exists, it stops there (ignoring any further
+     * arguments' types) and exludes null from the final union type.
+     *
+     * Examples:
+     *
+     * `(string | null, number | null)` is inferred as `string | number | null`.
+     *
+     * `(string | null, number, Date | null)` is inferred as `string | number`.
+     *
+     * `(number, string | null)` is inferred as `number`.
+     */
+    coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): RawBuilder<CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
+    /**
+     * 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 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 know if you've done so.
+     *
+     * You can specify the output type of the expression by providing
+     * the type as the first type argument:
+     *
+     * ```ts
+     * const { count } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .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()
+     * ```
+     */
+    count<O extends number | string | bigint, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Calls the `max` function for the column given as the argument.
+     *
+     * If this is used in a `select` statement the type of the selected expression
+     * will be the referenced column's type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { max } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(max('price').as('max_price'))
+     *   .execute()
+     * ```
+     *
+     * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+     * was used. It is highly recommended to include null in the output type union
+     * and handle null values in post-execute code, or wrap the function with a `coalesce`
+     * function.
+     *
+     * ```ts
+     * const { max } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(max<number | null, 'price'>('price').as('max_price'))
+     *   .execute()
+     * ```
+     */
+    max<O extends number | string | bigint | null = never, 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.
+     *
+     * If this is used in a `select` statement the type of the selected expression
+     * will be the referenced column's type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { min } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(min('price').as('min_price'))
+     *   .execute()
+     * ```
+     *
+     * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+     * was used. It is highly recommended to include null in the output type union
+     * and handle null values in post-execute code, or wrap the function with a `coalesce`
+     * function.
+     *
+     * ```ts
+     * const { min } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(min<number | null, 'price'>('price').as('min_price'))
+     *   .execute()
+     * ```
+     */
+    min<O extends number | string | bigint | null = never, 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.
+     *
+     * 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 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 know if you've done so.
+     *
+     * You can specify the output type of the expression by providing
+     * the type as the first type argument:
+     *
+     * ```ts
+     * const { sum } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(sum<number>('price').as('total_price'))
+     *   .execute()
+     * ```
+     *
+     * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+     * was used. It is highly recommended to include null in the output type union
+     * and handle null values in post-execute code, or wrap the function with a `coalesce`
+     * function.
+     *
+     * ```ts
+     * const { sum } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(sum<number | null>('price').as('total_price'))
+     *   .execute()
+     * ```
+     */
+    sum<O extends number | string | bigint | null = number | string | bigint, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+}
+declare type OutputBoundStringReference<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = IsNever<O> extends true ? C : Equals<ExtractTypeFromReferenceExpression<DB, TB, C> | null, O | null> extends true ? C : never;
+declare type StringReferenceBoundAggregateFunctionBuilder<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C> | (null extends O ? null : never)>;
+export {};