kysely 0.16.3 → 0.16.7

package/dist/esm/kysely.js

@@ -24,22 +24,24 @@ import { PRIVATE_ADAPTER } from './util/private-symbols.js';
  * This example assumes your database has tables `person` and `pet`:
  *
  * ```ts
- * interface Person {
- *   id: number
+ * import { Kysely, Generated, PostgresDialect } from 'kysely'
+ *
+ * interface PersonTable {
+ *   id: Generated<number>
  *   first_name: string
  *   last_name: string
  * }
  *
- * interface Pet {
- *   id: number
+ * interface PetTable {
+ *   id: Generated<number>
  *   owner_id: number
  *   name: string
  *   species 'cat' | 'dog'
  * }
  *
  * interface Database {
- *   person: Person,
- *   pet: Pet
+ *   person: PersonTable,
+ *   pet: PetTable
  * }
  *
  * const db = new Kysely<Database>({

package/dist/esm/migration/migrator.d.ts

@@ -144,8 +144,8 @@ export interface MigratorProps {
     readonly provider: MigrationProvider;
 }
 /**
- * All migration methods ({@link MigrationModule.migrateTo | migrateTo},
- * {@link MigrationModule.migrateToLatest | migrateToLatest} etc.) never
+ * All migration methods ({@link Migrator.migrateTo | migrateTo},
+ * {@link Migrator.migrateToLatest | migrateToLatest} etc.) never
  * throw but return this object instead.
  */
 export interface MigrationResultSet {

package/dist/esm/operation-node/primitive-value-list-node.d.ts

@@ -1,4 +1,3 @@
-import { PrimitiveValue } from '../util/object-utils.js';
 import { OperationNode } from './operation-node.js';
 /**
  * This node is basically just a performance optimization over the normal ValueListNode.
@@ -7,12 +6,12 @@ import { OperationNode } from './operation-node.js';
  */
 export interface PrimitiveValueListNode extends OperationNode {
     readonly kind: 'PrimitiveValueListNode';
-    readonly values: ReadonlyArray<PrimitiveValue>;
+    readonly values: ReadonlyArray<unknown>;
 }
 /**
  * @internal
  */
 export declare const PrimitiveValueListNode: Readonly<{
     is(node: OperationNode): node is PrimitiveValueListNode;
-    create(values: ReadonlyArray<PrimitiveValue>): PrimitiveValueListNode;
+    create(values: ReadonlyArray<unknown>): PrimitiveValueListNode;
 }>;

package/dist/esm/operation-node/value-node.d.ts

@@ -1,8 +1,7 @@
-import { PrimitiveValue } from '../util/object-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface ValueNode extends OperationNode {
     readonly kind: 'ValueNode';
-    readonly value: PrimitiveValue;
+    readonly value: unknown;
     readonly immediate?: boolean;
 }
 /**
@@ -10,6 +9,6 @@ export interface ValueNode extends OperationNode {
  */
 export declare const ValueNode: Readonly<{
     is(node: OperationNode): node is ValueNode;
-    create(value: PrimitiveValue): ValueNode;
-    createImmediate(value: PrimitiveValue): ValueNode;
+    create(value: unknown): ValueNode;
+    createImmediate(value: unknown): ValueNode;
 }>;

package/dist/esm/parser/complex-expression-parser.d.ts

@@ -7,3 +7,4 @@ export declare type ComplexExpression<DB, TB extends keyof DB> = AnySelectQueryB
 export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
 export declare function parseComplexExpression(ctx: ParseContext, exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
 export declare function parseAliasedComplexExpression(ctx: ParseContext, exp: AliasedComplexExpression<any, any>): AliasNode;
+export declare function isComplexExpression(obj: unknown): obj is ComplexExpression<any, any>;

package/dist/esm/parser/complex-expression-parser.js

@@ -19,3 +19,6 @@ export function parseAliasedComplexExpression(ctx, exp) {
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
+export function isComplexExpression(obj) {
+    return isOperationNodeSource(obj) || isFunction(obj);
+}

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

@@ -1,6 +1,5 @@
 import { RawNode } from '../operation-node/raw-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
-export declare type DefaultValueExpression = PrimitiveValue | AnyRawBuilder;
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+export declare type DefaultValueExpression = unknown | RawBuilder;
 export declare function parseDefaultValueExpression(value: DefaultValueExpression): ValueNode | RawNode;

package/dist/esm/parser/default-value-parser.js

@@ -1,8 +1,8 @@
 /// <reference types="./default-value-parser.d.ts" />
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ValueNode } from '../operation-node/value-node.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 export function parseDefaultValueExpression(value) {
-    return isOperationNodeSource(value)
+    return value instanceof RawBuilder
         ? value.toOperationNode()
         : ValueNode.createImmediate(value);
 }

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

@@ -2,9 +2,10 @@
 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, isPrimitive } from '../util/object-utils.js';
+import { freeze } 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';
 export function parseInsertObjectOrList(ctx, args) {
     return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
 }
@@ -37,8 +38,8 @@ function parseRowValues(ctx, row, columns) {
             rowValues[columnIdx] = value;
         }
     }
-    if (rowValues.every(isPrimitive)) {
-        return PrimitiveValueListNode.create(rowValues);
+    if (rowValues.some(isComplexExpression)) {
+        return ValueListNode.create(rowValues.map((it) => parseValueExpression(ctx, it)));
     }
-    return ValueListNode.create(rowValues.map((it) => parseValueExpression(ctx, it)));
+    return PrimitiveValueListNode.create(rowValues);
 }

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

@@ -2,7 +2,6 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
@@ -13,8 +12,8 @@ import { SelectType } from '../util/column-type.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> : PrimitiveValue;
-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> : PrimitiveValue;
+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;
+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(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;

package/dist/esm/parser/reference-parser.js

@@ -3,7 +3,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { isReadonlyArray, isString, } from '../util/object-utils.js';
+import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseComplexExpression, } from './complex-expression-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
 export function parseReferenceExpressionOrList(ctx, arg) {

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

@@ -1,11 +1,10 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.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';
 export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, PrimitiveValue>): ValueExpressionNode;
-export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, PrimitiveValue>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
+export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;

package/dist/esm/parser/value-parser.js

@@ -2,8 +2,8 @@
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { isPrimitive, isReadonlyArray, } from '../util/object-utils.js';
-import { parseComplexExpression, } from './complex-expression-parser.js';
+import { isReadonlyArray } from '../util/object-utils.js';
+import { parseComplexExpression, isComplexExpression, } from './complex-expression-parser.js';
 export function parseValueExpressionOrList(ctx, arg) {
     if (isReadonlyArray(arg)) {
         return parseValueExpressionList(ctx, arg);
@@ -13,15 +13,14 @@ export function parseValueExpressionOrList(ctx, arg) {
     }
 }
 export function parseValueExpression(ctx, exp) {
-    if (isPrimitive(exp)) {
-        return ValueNode.create(exp);
+    if (isComplexExpression(exp)) {
+        return parseComplexExpression(ctx, exp);
     }
-    return parseComplexExpression(ctx, exp);
+    return ValueNode.create(exp);
 }
 function parseValueExpressionList(ctx, arg) {
-    if (arg.every(isPrimitive)) {
-        // Optimization for large lists of primitive values.
-        return PrimitiveValueListNode.create(arg);
+    if (arg.some(isComplexExpression)) {
+        return ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
     }
-    return ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
+    return PrimitiveValueListNode.create(arg);
 }

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -0,0 +1,48 @@
+import { QueryResult } from '../../driver/database-connection.js';
+import { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import { UnknownRow } from '../../util/type-utils.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+/**
+ * Plugin that removes duplicate joins from queries.
+ *
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ */
+export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
+    #private;
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.js

@@ -0,0 +1,16 @@
+/// <reference types="./deduplicate-joins-plugin.d.ts" />
+import { DeduplicateJoinsTransformer } from './deduplicate-joins-transformer.js';
+/**
+ * Plugin that removes duplicate joins from queries.
+ *
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ */
+export class DeduplicateJoinsPlugin {
+    #transformer = new DeduplicateJoinsTransformer();
+    transformQuery(args) {
+        return this.#transformer.transformNode(args.node);
+    }
+    transformResult(args) {
+        return Promise.resolve(args.result);
+    }
+}

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-transformer.d.ts

@@ -0,0 +1,9 @@
+import { DeleteQueryNode, UpdateQueryNode } from '../../index-nodeless.js';
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { SelectQueryNode } from '../../operation-node/select-query-node.js';
+export declare class DeduplicateJoinsTransformer extends OperationNodeTransformer {
+    #private;
+    protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;
+    protected transformUpdateQuery(node: UpdateQueryNode): UpdateQueryNode;
+    protected transformDeleteQuery(node: DeleteQueryNode): DeleteQueryNode;
+}

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-transformer.js

@@ -0,0 +1,39 @@
+/// <reference types="./deduplicate-joins-transformer.d.ts" />
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { compare, freeze } from '../../util/object-utils.js';
+export class DeduplicateJoinsTransformer extends OperationNodeTransformer {
+    transformSelectQuery(node) {
+        return this.#transformQuery(super.transformSelectQuery(node));
+    }
+    transformUpdateQuery(node) {
+        return this.#transformQuery(super.transformUpdateQuery(node));
+    }
+    transformDeleteQuery(node) {
+        return this.#transformQuery(super.transformDeleteQuery(node));
+    }
+    #transformQuery(node) {
+        if (!node.joins || node.joins.length === 0) {
+            return node;
+        }
+        return freeze({
+            ...node,
+            joins: this.#deduplicateJoins(node.joins),
+        });
+    }
+    #deduplicateJoins(joins) {
+        const out = [];
+        for (let i = 0; i < joins.length; ++i) {
+            let foundDuplicate = false;
+            for (let j = i + 1; j < joins.length; ++j) {
+                if (compare(joins[i], joins[j])) {
+                    foundDuplicate = true;
+                    break;
+                }
+            }
+            if (!foundDuplicate) {
+                out.push(joins[i]);
+            }
+        }
+        return freeze(out);
+    }
+}

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

@@ -6,7 +6,7 @@ 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, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, 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';
@@ -16,6 +16,7 @@ import { WhereInterface } from './where-interface.js';
 import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
+import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { Selectable } from '../util/column-type.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
@@ -589,23 +590,61 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.deleteFrom('person')
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function deletePerson(id: number, returnLastName: boolean) {
+     *   return await db
+     *     .deleteFrom('person')
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `deletePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<DB, TB, O2>): DeleteQueryBuilder<DB, TB, O2 extends DeleteResult ? DeleteResult : O extends DeleteResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
@@ -613,6 +652,9 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O>;
     toOperationNode(): DeleteQueryNode;
     compile(): CompiledQuery;

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

@@ -99,25 +99,70 @@ export class DeleteQueryBuilder {
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.deleteFrom('person')
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call(func) {
         return func(this);
     }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function deletePerson(id: number, returnLastName: boolean) {
+     *   return await db
+     *     .deleteFrom('person')
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `deletePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new DeleteQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Change the output type of the query.
      *
@@ -127,6 +172,9 @@ export class DeleteQueryBuilder {
     castTo() {
         return new DeleteQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new DeleteQueryBuilder({
             ...this.#props,

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

@@ -3,8 +3,8 @@ import { TableExpression, TableExpressionDatabase, TableExpressionTables } from
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { FunctionBuilder } from './function-builder.js';
-import { RawBuilder } from '../index-nodeless.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);

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

@@ -6,7 +6,7 @@ import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
 import { freeze } from '../util/object-utils.js';
 import { FunctionBuilder } from './function-builder.js';
-import { RawBuilder } from '../index-nodeless.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 export class ExpressionBuilder {
     #props;
     constructor(props) {

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

@@ -4,6 +4,9 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
+ * You can always use {@link Kysely.raw} to call functions and build arbitrary
+ * expressions. This module simply has shortcuts for most common function calls.
+ *
  * ### Examples
  *
  * ```ts
@@ -35,12 +38,33 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
     constructor(props: FunctionBuilderProps);
     /**
      * 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()
+     * ```
      */
-    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    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()
+     * ```
+     *
      */
-    max<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
     /**
      * Calls the `avg` function for the column given as the argument.
      *
@@ -58,7 +82,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * const { avg } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(avg<number>('price'))
+     *   .select(avg<number>('price').as('avg_price'))
      *   .execute()
      * ```
      */
@@ -80,7 +104,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * const { sum } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price'))
+     *   .select(sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      */
@@ -102,7 +126,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * const { count } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(count<number>('price'))
+     *   .select(count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      */