kysely 0.26.1 → 0.26.3

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

@@ -0,0 +1,47 @@
+import { DrainOuterGeneric } from '../util/type-utils.js';
+import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import { ExtractTypeFromValueExpression } from './value-parser.js';
+export type RefTuple2<DB, TB extends keyof DB, R1, R2> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>
+]>;
+export type RefTuple3<DB, TB extends keyof DB, R1, R2, R3> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>
+]>;
+export type RefTuple4<DB, TB extends keyof DB, R1, R2, R3, R4> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>
+]>;
+export type RefTuple5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>,
+    ExtractTypeFromReferenceExpression<DB, TB, R5>
+]>;
+export type ValTuple2<V1, V2> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>
+]>;
+export type ValTuple3<V1, V2, V3> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>
+]>;
+export type ValTuple4<V1, V2, V3, V4> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>
+]>;
+export type ValTuple5<V1, V2, V3, V4, V5> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>,
+    ExtractTypeFromValueExpression<V5>
+]>;

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

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

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

@@ -1,11 +1,13 @@
+import { ValueNode } from '../operation-node/value-node.js';
 import { ExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 export type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
 export type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
 export type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
-type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilder<any, any, Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
+export type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilderExpression<Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
 export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
 export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;
-export {};
+export declare function isSafeImmediateValue(value: unknown): value is number | boolean | null;
+export declare function parseSafeImmediateValue(value: number | boolean | null): ValueNode;

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

@@ -2,7 +2,7 @@
 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 { isReadonlyArray } from '../util/object-utils.js';
+import { isBoolean, isNull, isNumber, isReadonlyArray, } from '../util/object-utils.js';
 import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 export function parseValueExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
@@ -16,6 +16,15 @@ export function parseValueExpression(exp) {
     }
     return ValueNode.create(exp);
 }
+export function isSafeImmediateValue(value) {
+    return isNumber(value) || isBoolean(value) || isNull(value);
+}
+export function parseSafeImmediateValue(value) {
+    if (!isSafeImmediateValue(value)) {
+        throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
+    }
+    return ValueNode.createImmediate(value);
+}
 function parseValueExpressionList(arg) {
     if (arg.some(isExpressionOrFactory)) {
         return ValueListNode.create(arg.map((it) => parseValueExpression(it)));

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

@@ -1,10 +1,11 @@
 import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
 import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
 import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
-import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { QueryCreator } from '../query-creator.js';
 import { Expression } from '../expression/expression.js';
 import { ShallowRecord } from '../util/type-utils.js';
+import { CTEBuilderCallback } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 export type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & {
     [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
@@ -40,5 +41,5 @@ type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${
  * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
  */
 type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
-export declare function parseCommonTableExpression(name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
+export declare function parseCommonTableExpression(nameOrBuilderCallback: string | CTEBuilderCallback<string>, expression: CommonTableExpression<any, string>): CommonTableExpressionNode;
 export {};

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

@@ -1,10 +1,22 @@
 /// <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';
 import { createQueryCreator } from './parse-utils.js';
-export function parseCommonTableExpression(name, expression) {
-    const builder = expression(createQueryCreator());
-    return CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
+import { isFunction } from '../util/object-utils.js';
+import { CTEBuilder } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export function parseCommonTableExpression(nameOrBuilderCallback, expression) {
+    const expressionNode = expression(createQueryCreator()).toOperationNode();
+    if (isFunction(nameOrBuilderCallback)) {
+        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
+    }
+    return CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
+}
+function cteBuilderFactory(expressionNode) {
+    return (name) => {
+        return new CTEBuilder({
+            node: CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode),
+        });
+    };
 }
 function parseCommonTableExpressionName(name) {
     if (name.includes('(')) {

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

@@ -75,9 +75,9 @@ export interface CamelCasePluginOptions {
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: the table names, the columns,
- * schemas, __everything__. When using the `CamelCasePlugin` Kysely
- * works as if the database was defined in camelCase.
+ * in camelCase in the typescript code: table names, columns, schemas,
+ * __everything__. When using the `CamelCasePlugin` Kysely works as if
+ * the database was defined in camelCase.
  *
  * There are various options you can give to the plugin to modify
  * the way identifiers are converted. See {@link CamelCasePluginOptions}.

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

@@ -1,5 +1,5 @@
 /// <reference types="./camel-case-plugin.d.ts" />
-import { isArrayBufferOrView, isBuffer, isDate, isObject, } from '../../util/object-utils.js';
+import { isPlainObject } from '../../util/object-utils.js';
 import { SnakeCaseTransformer } from './camel-case-transformer.js';
 import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
@@ -44,9 +44,9 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: the table names, the columns,
- * schemas, __everything__. When using the `CamelCasePlugin` Kysely
- * works as if the database was defined in camelCase.
+ * in camelCase in the typescript code: table names, columns, schemas,
+ * __everything__. When using the `CamelCasePlugin` Kysely works as if
+ * the database was defined in camelCase.
  *
  * There are various options you can give to the plugin to modify
  * the way identifiers are converted. See {@link CamelCasePluginOptions}.
@@ -110,9 +110,5 @@ export class CamelCasePlugin {
     }
 }
 function canMap(obj, opt) {
-    return (isObject(obj) &&
-        !isDate(obj) &&
-        !isBuffer(obj) &&
-        !isArrayBufferOrView(obj) &&
-        !opt?.maintainNestedObjectKeys);
+    return isPlainObject(obj) && !opt?.maintainNestedObjectKeys;
 }

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.d.ts

@@ -2,6 +2,19 @@ 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';
+/**
+ * Parses JSON strings in query results into JSON objects.
+ *
+ * This plugin can be useful with dialects that don't automatically parse
+ * JSON into objects and arrays but return JSON strings instead.
+ *
+ * ```ts
+ * const db = new Kysely<DB>({
+ *   ...
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ */
 export declare class ParseJSONResultsPlugin implements KyselyPlugin {
     /**
      * This is called for each query before it is executed. You can modify the query by

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.js

@@ -1,29 +1,65 @@
 /// <reference types="./parse-json-results-plugin.d.ts" />
-import { isString } from '../../util/object-utils.js';
+import { isPlainObject, isString } from '../../util/object-utils.js';
+/**
+ * Parses JSON strings in query results into JSON objects.
+ *
+ * This plugin can be useful with dialects that don't automatically parse
+ * JSON into objects and arrays but return JSON strings instead.
+ *
+ * ```ts
+ * const db = new Kysely<DB>({
+ *   ...
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ */
 export class ParseJSONResultsPlugin {
     // noop
     transformQuery(args) {
         return args.node;
     }
     async transformResult(args) {
-        const { result } = args;
         return {
             ...args.result,
-            rows: result.rows.map(parseRow),
+            rows: parseArray(args.result.rows),
         };
     }
 }
-function parseRow(row) {
-    return Object.entries(row).reduce((row, [key, value]) => {
-        if (isString(value) && value.match(/^[\[\{]/) != null) {
-            try {
-                value = JSON.parse(value);
-            }
-            catch (err) {
-                // this catch block is intentionally empty.
-            }
+function parseArray(arr) {
+    for (let i = 0; i < arr.length; ++i) {
+        arr[i] = parse(arr[i]);
+    }
+    return arr;
+}
+function parse(obj) {
+    if (isString(obj)) {
+        return parseString(obj);
+    }
+    if (Array.isArray(obj)) {
+        return parseArray(obj);
+    }
+    if (isPlainObject(obj)) {
+        return parseObject(obj);
+    }
+    return obj;
+}
+function parseString(str) {
+    if (maybeJson(str)) {
+        try {
+            return parse(JSON.parse(str));
         }
-        row[key] = value;
-        return row;
-    }, {});
+        catch (err) {
+            // this catch block is intentionally empty.
+        }
+    }
+    return str;
+}
+function maybeJson(value) {
+    return value.match(/^[\[\{]/) != null;
+}
+function parseObject(obj) {
+    for (const key in obj) {
+        obj[key] = parse(obj[key]);
+    }
+    return obj;
 }

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

@@ -1,11 +1,12 @@
 import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OverBuilder } from './over-builder.js';
-import { AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
-import { WhereExpressionFactory } from './where-interface.js';
-export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements Expression<O> {
+import { SqlBool } from '../util/type-utils.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements AliasableExpression<O> {
     #private;
     constructor(props: AggregateFunctionBuilderProps);
     /** @private */
@@ -116,8 +117,7 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    filterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
-    filterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(expression: ExpressionOrFactory<DB, TB, SqlBool>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Adds a `filter` clause with a nested `where` clause after the function, where
      * both sides of the operator are references to columns.

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

@@ -5,7 +5,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { createOverBuilder } from '../parser/parse-utils.js';
-import { parseReferentialComparison, parseFilter, } from '../parser/binary-operation-parser.js';
+import { parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
 export class AggregateFunctionBuilder {
     #props;
     constructor(props) {
@@ -73,7 +73,7 @@ export class AggregateFunctionBuilder {
     filterWhere(...args) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseFilter(args)),
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     /**
@@ -111,7 +111,7 @@ export class AggregateFunctionBuilder {
     filterWhereRef(lhs, op, rhs) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialComparison(lhs, op, rhs)),
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     /**

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

@@ -3,8 +3,8 @@ import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { freeze } from '../util/object-utils.js';
 import { CaseNode } from '../operation-node/case-node.js';
 import { WhenNode } from '../operation-node/when-node.js';
-import { parseFilter, } from '../parser/binary-operation-parser.js';
-import { parseValueExpression } from '../parser/value-parser.js';
+import { parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
+import { isSafeImmediateValue, parseSafeImmediateValue, parseValueExpression, } from '../parser/value-parser.js';
 export class CaseBuilder {
     #props;
     constructor(props) {
@@ -13,7 +13,7 @@ export class CaseBuilder {
     when(...args) {
         return new CaseThenBuilder({
             ...this.#props,
-            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseFilter(args))),
+            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args))),
         });
     }
 }
@@ -25,7 +25,9 @@ export class CaseThenBuilder {
     then(valueExpression) {
         return new CaseWhenBuilder({
             ...this.#props,
-            node: CaseNode.cloneWithThen(this.#props.node, parseValueExpression(valueExpression)),
+            node: CaseNode.cloneWithThen(this.#props.node, isSafeImmediateValue(valueExpression)
+                ? parseSafeImmediateValue(valueExpression)
+                : parseValueExpression(valueExpression)),
         });
     }
 }
@@ -37,14 +39,16 @@ export class CaseWhenBuilder {
     when(...args) {
         return new CaseThenBuilder({
             ...this.#props,
-            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseFilter(args))),
+            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args))),
         });
     }
     else(valueExpression) {
         return new CaseEndBuilder({
             ...this.#props,
             node: CaseNode.cloneWith(this.#props.node, {
-                else: parseValueExpression(valueExpression),
+                else: isSafeImmediateValue(valueExpression)
+                    ? parseSafeImmediateValue(valueExpression)
+                    : parseValueExpression(valueExpression),
             }),
         });
     }

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

@@ -0,0 +1,20 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export declare class CTEBuilder<N extends string> implements OperationNodeSource {
+    #private;
+    constructor(props: CTEBuilderProps);
+    /**
+     * Makes the common table expression materialized.
+     */
+    materialized(): CTEBuilder<N>;
+    /**
+     * Makes the common table expression not materialized.
+     */
+    notMaterialized(): CTEBuilder<N>;
+    toOperationNode(): CommonTableExpressionNode;
+}
+interface CTEBuilderProps {
+    readonly node: CommonTableExpressionNode;
+}
+export type CTEBuilderCallback<N extends string> = (cte: <N2 extends string>(name: N2) => CTEBuilder<N2>) => CTEBuilder<N>;
+export {};

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

@@ -0,0 +1,36 @@
+/// <reference types="./cte-builder.d.ts" />
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+export class CTEBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    /**
+     * Makes the common table expression materialized.
+     */
+    materialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: true,
+            }),
+        });
+    }
+    /**
+     * Makes the common table expression not materialized.
+     */
+    notMaterialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: false,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.node;
+    }
+}
+preventAwait(CTEBuilder, "don't await CTEBuilder instances. They are never executed directly and are always just a part of a query.");

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

@@ -2,16 +2,16 @@ 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 { From, FromTables, TableExpression } from '../parser/table-parser.js';
-import { SelectExpression, SelectArg } from '../parser/select-parser.js';
-import { ReturningAllRow, ReturningRow } from '../parser/returning-parser.js';
+import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
+import { ReturningAllRow, ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
+import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } 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';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { WhereExpressionFactory, WhereInterface } from './where-interface.js';
+import { WhereInterface } from './where-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
@@ -22,6 +22,7 @@ import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -78,7 +79,34 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "OR where", 30) -->
+     * <!-- siteExample("where", "Object filter", 30) -->
+     *
+     * You can use the `and` function to create a simple equality
+     * filter using an object
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where((eb) => eb.and({
+     *     first_name: 'Jennifer',
+     *     last_name: eb.ref('first_name')
+     *   }))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = "first_name"
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 40) -->
      *
      * To combine conditions using `OR`, you can use the expression builder.
      * There are two ways to create `OR` expressions. Both are shown in this
@@ -113,7 +141,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
@@ -208,7 +236,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "Complex where clause", 50) -->
+     * <!-- siteExample("where", "Complex where clause", 60) -->
      *
      * For complex `where` expressions you can pass in a single callback and
      * use the `ExpressionBuilder` to build your expression:
@@ -298,8 +326,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
-    where(factory: WhereExpressionFactory<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
-    where(expression: Expression<any>): DeleteQueryBuilder<DB, TB, O>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -632,7 +659,9 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .executeTakeFirst()
      * ```
      */
-    returning<SE extends SelectExpression<DB, TB>>(selection: SelectArg<DB, TB, SE>): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<CB extends SelectCallback<DB, TB>>(callback: CB): DeleteQueryBuilder<DB, TB, ReturningCallbackRow<DB, TB, O, CB>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds `returning *` or `returning table.*` clause to the query.
      *

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

@@ -10,7 +10,7 @@ import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { parseOrderBy, } from '../parser/order-by-parser.js';
-import { parseFilter, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
 export class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -19,13 +19,13 @@ export class DeleteQueryBuilder {
     where(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseFilter(args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     clearWhere() {
@@ -113,7 +113,7 @@ export class DeleteQueryBuilder {
     orderBy(orderBy, direction) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: DeleteQueryNode.cloneWithOrderByItem(this.#props.queryNode, parseOrderBy(orderBy, direction)),
+            queryNode: DeleteQueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy([orderBy, direction])),
         });
     }
     /**