kysely 0.7.7 → 0.8.1

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

@@ -2,12 +2,12 @@ import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]?: MutationValueExpression<DB, TB, DB[TB][C]>;
 };
-export declare type MutationValueExpression<DB, TB extends keyof DB, T extends PrimitiveValue> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type MutationValueExpression<DB, TB extends keyof DB, T> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
 export declare function parseUpdateObject(ctx: ParseContext, row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;
 export declare function parseMutationValueExpression(ctx: ParseContext, value: MutationValueExpression<any, any, PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

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

@@ -1,5 +1,5 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
 import { ParseContext } from './parse-context.js';
 export declare type ValueExpression<DB, TB extends keyof DB, RE> = ExtractTypeFromReferenceExpression<DB, TB, RE> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;

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

@@ -2,7 +2,7 @@ import { CommonTableExpressionNode } from '../operation-node/common-table-expres
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | AnyRawBuilder;
 export declare type QueryCreatorWithCommonTableExpression<DB, N extends string, E extends CommonTableExpression<DB>> = QueryCreator<DB & Record<N, ExtractRowTypeFromCommonTableExpression<E>>>;

package/dist/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -1,6 +1,7 @@
 import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
-import { AnyRow, KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import { UnknownRow } from '../../util/type-utils.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
 export interface CamelCasePluginOptions {
     /**
      * If true, camelCase is transformed into upper case SNAKE_CASE.
@@ -94,8 +95,8 @@ export declare class CamelCasePlugin implements KyselyPlugin {
     #private;
     constructor(opt?: CamelCasePluginOptions);
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
-    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<AnyRow>>;
-    protected mapRow(row: AnyRow): AnyRow;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+    protected mapRow(row: UnknownRow): UnknownRow;
     protected snakeCase(str: string): string;
     protected camelCase(str: string): string;
 }

package/dist/esm/plugin/kysely-plugin.d.ts

@@ -1,11 +1,12 @@
 import { QueryResult } from '../driver/database-connection.js';
 import { RootOperationNode } from '../query-compiler/query-compiler.js';
 import { QueryId } from '../util/query-id.js';
+import { UnknownRow } from '../util/type-utils.js';
 export interface KyselyPlugin {
     /**
      * 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}
+     * 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
@@ -22,10 +23,14 @@ export interface KyselyPlugin {
      *
      *   transformResult(args: PluginTransformResultArgs): QueryResult<AnyRow> {
      *     const data = this.data.get(args.queryId)
-     *     return data.result
+     *     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;
     /**
@@ -33,14 +38,13 @@ export interface KyselyPlugin {
      * 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<AnyRow>>;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }
 export interface PluginTransformQueryArgs {
     readonly queryId: QueryId;
     readonly node: RootOperationNode;
 }
-export declare type AnyRow = Record<string, unknown>;
 export interface PluginTransformResultArgs {
     readonly queryId: QueryId;
-    readonly result: QueryResult<AnyRow>;
+    readonly result: QueryResult<UnknownRow>;
 }

package/dist/esm/plugin/with-schema/with-schema-plugin.d.ts

@@ -1,9 +1,10 @@
 import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
-import { AnyRow, KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import { UnknownRow } from '../../util/type-utils.js';
 export declare class WithSchemaPlugin implements KyselyPlugin {
     #private;
     constructor(schema: string);
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
-    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<AnyRow>>;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }

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

@@ -1,9 +1,42 @@
 import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
 import { ParseContext } from '../parser/parse-context.js';
+import { FunctionBuilder } from './function-builder.js';
 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
+     * calls.
+     *
+     * The difference between this and {@link Kysely.fn} is that this one is more
+     * type safe. You can only refer to columns visible to the part of the query
+     * you are building. {@link Kysely.fn} allows you to refer to columns in any
+     * table of the database even if it doesn't produce valid SQL.
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select([
+     *     'person.id',
+     *     (qb) => qb.fn.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
+     * ```
+     */
+    get fn(): FunctionBuilder<DB, TB>;
     /**
      * Creates a subquery.
      *

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

@@ -4,11 +4,46 @@ 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 { freeze } from '../util/object-utils.js';
+import { FunctionBuilder } from './function-builder.js';
 export class ExpressionBuilder {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
+    /**
+     * Returns a {@link FunctionBuilder} that can be used to write type safe function
+     * calls.
+     *
+     * The difference between this and {@link Kysely.fn} is that this one is more
+     * type safe. You can only refer to columns visible to the part of the query
+     * you are building. {@link Kysely.fn} allows you to refer to columns in any
+     * table of the database even if it doesn't produce valid SQL.
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select([
+     *     'person.id',
+     *     (qb) => qb.fn.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
+     * ```
+     */
+    get fn() {
+        return new FunctionBuilder({ executor: this.#props.executor });
+    }
     subQuery(table) {
         return new QueryBuilder({
             queryId: createQueryId(),

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

@@ -0,0 +1,112 @@
+import { StringReference, ExtractTypeFromReferenceExpression } from '../parser/reference-parser.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+/**
+ * Helpers for type safe SQL function calls.
+ *
+ * @example
+ * ```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 FunctionBuilder<DB, TB extends keyof DB> {
+    #private;
+    constructor(props: FunctionBuilderProps);
+    /**
+     * Calls the `max` function for the column given as the argument.
+     */
+    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    /**
+     * Calls the `min` function for the column given as the argument.
+     */
+    max<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    /**
+     * 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'))
+     *   .execute()
+     * ```
+     */
+    avg<O extends number | string, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<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` 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'))
+     *   .execute()
+     * ```
+     */
+    sum<O extends number | string | BigInt, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    /**
+     * 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` 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>('price'))
+     *   .execute()
+     * ```
+     */
+    count<O extends number | string | BigInt, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+}
+export interface FunctionBuilderProps {
+    readonly executor: QueryExecutor;
+}

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

@@ -0,0 +1,134 @@
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { freeze } from '../util/object-utils.js';
+import { createQueryId } from '../util/query-id.js';
+/**
+ * Helpers for type safe SQL function calls.
+ *
+ * @example
+ * ```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 class FunctionBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+        this.min = this.min.bind(this);
+        this.max = this.max.bind(this);
+        this.avg = this.avg.bind(this);
+        this.sum = this.sum.bind(this);
+        this.count = this.count.bind(this);
+    }
+    /**
+     * Calls the `max` function for the column given as the argument.
+     */
+    min(column) {
+        return this.#oneArgFunction('min', column);
+    }
+    /**
+     * Calls the `min` function for the column given as the argument.
+     */
+    max(column) {
+        return this.#oneArgFunction('max', column);
+    }
+    /**
+     * 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'))
+     *   .execute()
+     * ```
+     */
+    avg(column) {
+        return this.#oneArgFunction('avg', column);
+    }
+    /**
+     * 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` 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'))
+     *   .execute()
+     * ```
+     */
+    sum(column) {
+        return this.#oneArgFunction('sum', column);
+    }
+    /**
+     * 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` 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>('price'))
+     *   .execute()
+     * ```
+     */
+    count(column) {
+        return this.#oneArgFunction('count', column);
+    }
+    #oneArgFunction(fn, column) {
+        return new RawBuilder({
+            queryId: createQueryId(),
+            executor: this.#props.executor,
+            sql: `${fn}(??)`,
+            parameters: [column],
+        });
+    }
+}

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

@@ -2,7 +2,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
-import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser.js';
+import { TableExpression, QueryBuilderWithTable, QueryBuilderWithLeftJoin, QueryBuilderWithRightJoin, QueryBuilderWithFullJoin } from '../parser/table-parser.js';
 import { SelectExpression, QueryBuilderWithSelection, SelectAllQueryBuilder } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
 import { InsertObject } from '../parser/insert-values-parser.js';
@@ -10,7 +10,7 @@ import { QueryBuilderWithReturning } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { AnyColumn, ManyResultRowType, NonEmptySingleResultRowType, SingleResultRowType } from './type-utils.js';
+import { AnyColumn, ManyResultRowType, NonEmptySingleResultRowType, SingleResultRowType } from '../util/type-utils.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
@@ -869,20 +869,20 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * Just like {@link QueryBuilder.innerJoin | innerJoin} but adds a left join
      * instead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): QueryBuilderWithTable<DB, TB, O, TE>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): QueryBuilderWithTable<DB, TB, O, TE>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): QueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): QueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Just like {@link QueryBuilder.innerJoin | innerJoin} but adds a right join
      * instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): QueryBuilderWithTable<DB, TB, O, TE>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): QueryBuilderWithTable<DB, TB, O, TE>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): QueryBuilderWithRightJoin<DB, TB, O, TE>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): QueryBuilderWithRightJoin<DB, TB, O, TE>;
     /**
      * Just like {@link QueryBuilder.innerJoin | innerJoin} but adds a full join
      * instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): QueryBuilderWithTable<DB, TB, O, TE>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): QueryBuilderWithTable<DB, TB, O, TE>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): QueryBuilderWithFullJoin<DB, TB, O, TE>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): QueryBuilderWithFullJoin<DB, TB, O, TE>;
     /**
      * Sets the values to insert for an {@link Kysely.insertInto | insert} query.
      *

package/dist/esm/query-compiler/compiled-query.d.ts

@@ -1,4 +1,4 @@
 export interface CompiledQuery {
     readonly sql: string;
-    readonly bindings: ReadonlyArray<any>;
+    readonly parameters: ReadonlyArray<any>;
 }

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -62,7 +62,7 @@ import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
-    protected get numBindings(): number;
+    protected get numParameters(): number;
     compileQuery(node: RootOperationNode): CompiledQuery;
     protected getSql(): string;
     protected visitSelectQuery(node: SelectQueryNode): void;
@@ -129,6 +129,6 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
-    protected addBinding(binding: any): void;
+    protected addParameter(parameter: any): void;
     protected appendImmediateValue(value: PrimitiveValue): void;
 }

package/dist/esm/query-compiler/default-query-compiler.js

@@ -5,17 +5,17 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sqlFragments = [];
-    #bindings = [];
-    get numBindings() {
-        return this.#bindings.length;
+    #parameters = [];
+    get numParameters() {
+        return this.#parameters.length;
     }
     compileQuery(node) {
         this.#sqlFragments = [];
-        this.#bindings = [];
+        this.#parameters = [];
         this.visitNode(node);
         return freeze({
             sql: this.getSql(),
-            bindings: this.#bindings,
+            parameters: this.#parameters,
         });
     }
     getSql() {
@@ -637,7 +637,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.#sqlFragments.push(str);
     }
     appendValue(value) {
-        this.addBinding(value);
+        this.addParameter(value);
         this.append(this.getCurrentParameterPlaceholder());
     }
     getLeftIdentifierWrapper() {
@@ -647,10 +647,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         return '"';
     }
     getCurrentParameterPlaceholder() {
-        return '$' + this.numBindings;
+        return '$' + this.numParameters;
     }
-    addBinding(binding) {
-        this.#bindings.push(binding);
+    addParameter(parameter) {
+        this.#parameters.push(parameter);
     }
     appendImmediateValue(value) {
         if (isString(value)) {

package/dist/esm/query-compiler/query-compiler.d.ts

@@ -9,6 +9,9 @@ import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from './compiled-query.js';
 export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | AlterTableNode | DropTableNode | DropIndexNode | CreateSchemaNode | DropSchemaNode | RawNode;
+/**
+ * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
+ */
 export interface QueryCompiler {
     compileQuery(node: RootOperationNode): CompiledQuery;
 }

package/dist/esm/query-creator.d.ts

@@ -1,6 +1,6 @@
 import { QueryBuilder } from './query-builder/query-builder.js';
 import { QueryBuilderWithTable, TableExpression, TableReference } from './parser/table-parser.js';
-import { InsertResultTypeTag, DeleteResultTypeTag, UpdateResultTypeTag } from './query-builder/type-utils.js';
+import { InsertResultTypeTag, DeleteResultTypeTag, UpdateResultTypeTag } from './util/type-utils.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { RawBuilder } from './raw-builder/raw-builder.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';
@@ -276,11 +276,11 @@ export declare class QueryCreator<DB> {
      * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
      * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
      *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used to provide
-     *    parameter bindings. `?` for values and `??` for identifiers such as column names
+     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
+     *    placeholders. `?` for values and `??` for identifiers such as column names
      *    or `column.table` references.
      *
-     * @param params - The parameters that will be bound to the `?` and `??` bindings in
+     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
      *    the sql string.
      *
      * @example
@@ -318,7 +318,7 @@ export declare class QueryCreator<DB> {
      *     the output type. In this case you need to use the `castTo` method on the query
      *     to specify a return type for the query.
      *
-     * We could've also used `??` bindings to provide `first_name` and `last_name` like
+     * We could've also used a `??` placeholder to provide `first_name` and `last_name` like
      * this:
      *
      * ```ts
@@ -333,9 +333,9 @@ export declare class QueryCreator<DB> {
      *
      * But it's often cleaner to just write the column names in the SQL. Again remember to
      * never concatenate column names or any other untrusted user input to the SQL string or you
-     * are going to create an injection vulnerability. All user input should go to the bindings
+     * are going to create an injection vulnerability. All user input should go to the parameters
      * array, never to the SQL string directly. But if the column names or values are trusted
-     * and known at compile time, there is no reason to use bindings.
+     * and known at compile time, there is no reason to use parameters.
      *
      * @example
      * Example of using `raw` in `where`:
@@ -361,7 +361,7 @@ export declare class QueryCreator<DB> {
      *
      * The function in the above example returns people that are older than the given number of
      * years. The number of years in this example is an untrusted user input, and therefore we use
-     * a `?` binding for it.
+     * a `?` placeholder for it.
      *
      * @example
      * Example of creating a completely raw query from scratch:
@@ -375,7 +375,7 @@ export declare class QueryCreator<DB> {
      * The result of `execute()` method is always an array. In this case the type of
      * the `persons` variable is `Person[]`.
      */
-    raw<T = unknown>(sql: string, params?: any[]): RawBuilder<T>;
+    raw<T = unknown>(sql: string, parameters?: any[]): RawBuilder<T>;
 }
 export interface QueryCreatorProps {
     readonly executor: QueryExecutor;