kysely 0.16.1 → 0.16.5

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/operation-node/value-node.js

@@ -1,3 +1,4 @@
+/// <reference types="./value-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 /**
  * @internal

package/dist/esm/operation-node/values-node.js

@@ -1,3 +1,4 @@
+/// <reference types="./values-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 /**
  * @internal

package/dist/esm/operation-node/where-node.js

@@ -1,3 +1,4 @@
+/// <reference types="./where-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { AndNode } from './and-node.js';
 import { OrNode } from './or-node.js';

package/dist/esm/operation-node/with-node.js

@@ -1,3 +1,4 @@
+/// <reference types="./with-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 /**
  * @internal

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

@@ -1,3 +1,4 @@
+/// <reference types="./complex-expression-parser.d.ts" />
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { isFunction } from '../util/object-utils.js';
 export function parseComplexExpression(ctx, exp) {
@@ -18,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/data-type-parser.js

@@ -1,3 +1,4 @@
+/// <reference types="./data-type-parser.d.ts" />
 import { DataTypeNode, } from '../operation-node/data-type-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 export function parseDataTypeExpression(dataType) {

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,7 +1,8 @@
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+/// <reference types="./default-value-parser.d.ts" />
 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/filter-parser.js

@@ -1,3 +1,4 @@
+/// <reference types="./filter-parser.d.ts" />
 import { FilterNode } from '../operation-node/filter-node.js';
 import { freeze, isBoolean, isFunction, isNull, isString, } from '../util/object-utils.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./group-by-parser.d.ts" />
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { parseReferenceExpressionOrList, } from './reference-parser.js';
 export function parseGroupBy(ctx, orderBy) {

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

@@ -1,9 +1,11 @@
+/// <reference types="./insert-values-parser.d.ts" />
 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]);
 }
@@ -36,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/join-parser.js

@@ -1,3 +1,4 @@
+/// <reference types="./join-parser.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { parseTableExpression, } from './table-parser.js';
 import { parseReferenceFilter } from './filter-parser.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./order-by-parser.d.ts" />
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./parse-context.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';

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

@@ -1,8 +1,9 @@
+/// <reference types="./reference-parser.d.ts" />
 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/returning-parser.js

@@ -1 +1,2 @@
+/// <reference types="./returning-parser.d.ts" />
 export {};

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

@@ -1,3 +1,4 @@
+/// <reference types="./select-parser.d.ts" />
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { parseAliasedStringReference } from './reference-parser.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./table-parser.d.ts" />
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./union-parser.d.ts" />
 import { UnionNode } from '../operation-node/union-node.js';
 export function parseUnion(union, all) {
     return UnionNode.create(union.toOperationNode(), all);

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

@@ -1,3 +1,4 @@
+/// <reference types="./update-set-parser.d.ts" />
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { parseValueExpression } from './value-parser.js';

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

@@ -1,8 +1,9 @@
+/// <reference types="./value-parser.d.ts" />
 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);
@@ -12,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/parser/with-parser.js

@@ -1,3 +1,4 @@
+/// <reference types="./with-parser.d.ts" />
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
 export function parseCommonTableExpression(ctx, name, expression) {

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -1,4 +1,5 @@
-import { isObject } from '../../util/object-utils.js';
+/// <reference types="./camel-case-plugin.d.ts" />
+import { isBuffer, isDate, isObject } from '../../util/object-utils.js';
 import { SnakeCaseTransformer } from './camel-case-transformer.js';
 import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
@@ -107,5 +108,5 @@ export class CamelCasePlugin {
     }
 }
 function canMap(obj) {
-    return isObject(obj) && !(obj instanceof Date) && !Buffer.isBuffer(obj);
+    return isObject(obj) && !isDate(obj) && !isBuffer(obj);
 }

package/dist/esm/plugin/camel-case/camel-case-transformer.js

@@ -1,3 +1,4 @@
+/// <reference types="./camel-case-transformer.d.ts" />
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 export class SnakeCaseTransformer extends OperationNodeTransformer {
     #snakeCase;

package/dist/esm/plugin/camel-case/camel-case.js

@@ -1,3 +1,4 @@
+/// <reference types="./camel-case.d.ts" />
 /**
  * Creates a function that transforms camel case strings to snake case.
  */

package/dist/esm/plugin/immediate-value.ts/immediate-value-plugin.js

@@ -1,3 +1,4 @@
+/// <reference types="./immediate-value-plugin.d.ts" />
 import { ImmediateValueTransformer } from './immediate-value-transformer.js';
 /**
  * Transforms all ValueNodes to immediate.

package/dist/esm/plugin/immediate-value.ts/immediate-value-transformer.js

@@ -1,3 +1,4 @@
+/// <reference types="./immediate-value-transformer.d.ts" />
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 /**
  * Transforms all ValueNodes to immediate.

package/dist/esm/plugin/kysely-plugin.js

@@ -1 +1,2 @@
+/// <reference types="./kysely-plugin.d.ts" />
 export {};

package/dist/esm/plugin/with-schema/with-schema-plugin.js

@@ -1,3 +1,4 @@
+/// <reference types="./with-schema-plugin.d.ts" />
 import { WithSchemaTransformer } from './with-schema-transformer.js';
 export class WithSchemaPlugin {
     #transformer;

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -1,3 +1,4 @@
+/// <reference types="./with-schema-transformer.d.ts" />
 import { AliasNode } from '../../operation-node/alias-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 import { TableNode } from '../../operation-node/table-node.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./delete-query-builder.d.ts" />
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseNotExistFilter, } from '../parser/filter-parser.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./delete-result.d.ts" />
 export class DeleteResult {
     #numDeletedRows;
     constructor(numDeletedRows) {

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

@@ -3,6 +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 { 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);
@@ -44,6 +46,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * The query builder returned by this method is typed in a way that you can refer to
      * all tables of the parent query in addition to the subquery's tables.
      *
+     * This method accepts all the same inputs as {@link QueryCreator.selectFrom}.
+     *
      * ### Examples
      *
      * This example shows that you can refer to both `pet.owner_id` and `person.id`
@@ -86,6 +90,44 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * See {@link QueryCreator.withSchema}
      */
     withSchema(schema: string): ExpressionBuilder<DB, TB>;
+    /**
+     * See {@link QueryCreator.raw}.
+     */
+    raw<T = unknown>(sql: string, parameters?: unknown[]): RawBuilder<T>;
+    /**
+     * This can be used to reference columns.
+     *
+     * ### Examples
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
+     *
+     * In the next example we use `ref` in a raw expression. Unless you
+     * want to be as type-safe as possible, this is probably overkill:
+     *
+     * ```ts
+     * db.update('pet').set({
+     *   name: (eb) => eb.raw('concat(?, ?)', [
+     *     eb.ref('pet.name'),
+     *     suffix,
+     *   ])
+     * })
+     * ```
+     */
+    ref<RE extends StringReference<DB, TB>>(reference: RE): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 }
 export interface ExpressionBuilderProps {
     readonly executor: NoopQueryExecutor;

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

@@ -1,3 +1,4 @@
+/// <reference types="./expression-builder.d.ts" />
 import { SelectQueryBuilder } from './select-query-builder.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
@@ -5,6 +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 '../raw-builder/raw-builder.js';
 export class ExpressionBuilder {
     #props;
     constructor(props) {
@@ -61,4 +63,51 @@ export class ExpressionBuilder {
             executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
         });
     }
+    /**
+     * See {@link QueryCreator.raw}.
+     */
+    raw(sql, parameters) {
+        return new RawBuilder({
+            queryId: createQueryId(),
+            executor: this.#props.executor,
+            sql,
+            parameters,
+        });
+    }
+    /**
+     * This can be used to reference columns.
+     *
+     * ### Examples
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
+     *
+     * In the next example we use `ref` in a raw expression. Unless you
+     * want to be as type-safe as possible, this is probably overkill:
+     *
+     * ```ts
+     * db.update('pet').set({
+     *   name: (eb) => eb.raw('concat(?, ?)', [
+     *     eb.ref('pet.name'),
+     *     suffix,
+     *   ])
+     * })
+     * ```
+     */
+    ref(reference) {
+        return this.raw('??', [reference]);
+    }
 }

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

@@ -1,3 +1,4 @@
+/// <reference types="./function-builder.d.ts" />
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { freeze } from '../util/object-utils.js';
 import { createQueryId } from '../util/query-id.js';

package/dist/esm/query-builder/having-interface.js

@@ -1 +1,2 @@
+/// <reference types="./having-interface.d.ts" />
 export {};

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

@@ -342,6 +342,22 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * values ($1, $2)
      * on conflict ("name") do nothing
      * ```
+     *
+     * You can refer to the columns of the virtual `excluded` table
+     * in a type-safe way using a callback and the `ref` method of
+     * `ExpressionBuilder`:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
      */
     onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictDoNothingBuilder<DB, TB> | OnConflictUpdateBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**

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

@@ -1,3 +1,4 @@
+/// <reference types="./insert-query-builder.d.ts" />
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseInsertObjectOrList, } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
@@ -245,6 +246,22 @@ export class InsertQueryBuilder {
      * values ($1, $2)
      * on conflict ("name") do nothing
      * ```
+     *
+     * You can refer to the columns of the virtual `excluded` table
+     * in a type-safe way using a callback and the `ref` method of
+     * `ExpressionBuilder`:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
      */
     onConflict(callback) {
         return new InsertQueryBuilder({

package/dist/esm/query-builder/insert-result.js

@@ -1,3 +1,4 @@
+/// <reference types="./insert-result.d.ts" />
 /**
  * The result of an insert query.
  *

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

@@ -1,3 +1,4 @@
+/// <reference types="./join-builder.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { parseExistFilter, parseNotExistFilter, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
 import { freeze } from '../util/object-utils.js';

package/dist/esm/query-builder/join-interface.js

@@ -1 +1,2 @@
+/// <reference types="./join-interface.d.ts" />
 export {};

package/dist/esm/query-builder/no-result-error.js

@@ -1,3 +1,4 @@
+/// <reference types="./no-result-error.d.ts" />
 export class NoResultError extends Error {
     /**
      * The operation node tree of the query that was executed.

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

@@ -377,14 +377,16 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<DB, TB>): OnConflictUpdateBuilder<{
-        [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
-    }, TB | 'excluded'>;
+    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
     readonly parseContext: ParseContext;
 }
+export declare type OnConflictDatabase<DB, TB extends keyof DB> = {
+    [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
+};
+export declare type OnConflictTables<TB> = TB | 'excluded';
 export declare class OnConflictDoNothingBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: OnConflictBuilderProps);

package/dist/esm/query-builder/on-conflict-builder.js

@@ -1,3 +1,4 @@
+/// <reference types="./on-conflict-builder.d.ts" />
 import { ColumnNode } from '../operation-node/column-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';

package/dist/esm/query-builder/returning-interface.js

@@ -1 +1,2 @@
+/// <reference types="./returning-interface.d.ts" />
 export {};

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

@@ -1,3 +1,4 @@
+/// <reference types="./select-query-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';

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

@@ -1,3 +1,4 @@
+/// <reference types="./update-query-builder.d.ts" />
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseNotExistFilter, } from '../parser/filter-parser.js';

package/dist/esm/query-builder/update-result.js

@@ -1,3 +1,4 @@
+/// <reference types="./update-result.d.ts" />
 export class UpdateResult {
     #numUpdatedRows;
     constructor(numUpdatedRows) {

package/dist/esm/query-builder/where-interface.js

@@ -1 +1,2 @@
+/// <reference types="./where-interface.d.ts" />
 export {};

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

@@ -1,3 +1,4 @@
+/// <reference types="./compiled-query.d.ts" />
 import { RawNode } from '../operation-node/raw-node.js';
 import { freeze } from '../util/object-utils.js';
 export const CompiledQuery = freeze({