kysely 0.26.1 → 0.26.3

package/dist/cjs/parser/set-operation-parser.d.ts

@@ -1,3 +1,5 @@
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { Expression } from '../expression/expression.js';
 import { SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
-export declare function parseSetOperation(operator: SetOperator, expression: Expression<any>, all: boolean): SetOperationNode;
+export type SetOperandExpression<DB, O> = Expression<O> | ReadonlyArray<Expression<O>> | ((eb: ExpressionBuilder<DB, never>) => Expression<O> | ReadonlyArray<Expression<O>>);
+export declare function parseSetOperations(operator: SetOperator, expression: SetOperandExpression<any, any>, all: boolean): SetOperationNode[];

package/dist/cjs/parser/set-operation-parser.js

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSetOperation = void 0;
+exports.parseSetOperations = void 0;
+const expression_builder_js_1 = require("../expression/expression-builder.js");
 const set_operation_node_js_1 = require("../operation-node/set-operation-node.js");
-function parseSetOperation(operator, expression, all) {
-    return set_operation_node_js_1.SetOperationNode.create(operator, expression.toOperationNode(), all);
+const object_utils_js_1 = require("../util/object-utils.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+function parseSetOperations(operator, expression, all) {
+    if ((0, object_utils_js_1.isFunction)(expression)) {
+        expression = expression((0, expression_builder_js_1.createExpressionBuilder)());
+    }
+    if (!(0, object_utils_js_1.isReadonlyArray)(expression)) {
+        expression = [expression];
+    }
+    return expression.map((expr) => set_operation_node_js_1.SetOperationNode.create(operator, (0, expression_parser_js_1.parseExpression)(expr), all));
 }
-exports.parseSetOperation = parseSetOperation;
+exports.parseSetOperations = parseSetOperations;

package/dist/cjs/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/cjs/parser/tuple-parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/parser/value-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
+exports.parseSafeImmediateValue = exports.isSafeImmediateValue = exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
@@ -20,6 +20,17 @@ function parseValueExpression(exp) {
     return value_node_js_1.ValueNode.create(exp);
 }
 exports.parseValueExpression = parseValueExpression;
+function isSafeImmediateValue(value) {
+    return (0, object_utils_js_1.isNumber)(value) || (0, object_utils_js_1.isBoolean)(value) || (0, object_utils_js_1.isNull)(value);
+}
+exports.isSafeImmediateValue = isSafeImmediateValue;
+function parseSafeImmediateValue(value) {
+    if (!isSafeImmediateValue(value)) {
+        throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
+    }
+    return value_node_js_1.ValueNode.createImmediate(value);
+}
+exports.parseSafeImmediateValue = parseSafeImmediateValue;
 function parseValueExpressionList(arg) {
     if (arg.some(expression_parser_js_1.isExpressionOrFactory)) {
         return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(it)));

package/dist/cjs/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/cjs/parser/with-parser.js

@@ -1,14 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCommonTableExpression = void 0;
-const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
 const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
 const parse_utils_js_1 = require("./parse-utils.js");
-function parseCommonTableExpression(name, expression) {
-    const builder = expression((0, parse_utils_js_1.createQueryCreator)());
-    return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
+const object_utils_js_1 = require("../util/object-utils.js");
+const cte_builder_js_1 = require("../query-builder/cte-builder.js");
+const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
+function parseCommonTableExpression(nameOrBuilderCallback, expression) {
+    const expressionNode = expression((0, parse_utils_js_1.createQueryCreator)()).toOperationNode();
+    if ((0, object_utils_js_1.isFunction)(nameOrBuilderCallback)) {
+        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
+    }
+    return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
 }
 exports.parseCommonTableExpression = parseCommonTableExpression;
+function cteBuilderFactory(expressionNode) {
+    return (name) => {
+        return new cte_builder_js_1.CTEBuilder({
+            node: common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode),
+        });
+    };
+}
 function parseCommonTableExpressionName(name) {
     if (name.includes('(')) {
         const parts = name.split(/[\(\)]/);

package/dist/cjs/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/cjs/plugin/camel-case/camel-case-plugin.js

@@ -46,9 +46,9 @@ const camel_case_js_1 = require("./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}.
@@ -113,9 +113,5 @@ class CamelCasePlugin {
 }
 exports.CamelCasePlugin = CamelCasePlugin;
 function canMap(obj, opt) {
-    return ((0, object_utils_js_1.isObject)(obj) &&
-        !(0, object_utils_js_1.isDate)(obj) &&
-        !(0, object_utils_js_1.isBuffer)(obj) &&
-        !(0, object_utils_js_1.isArrayBufferOrView)(obj) &&
-        !opt?.maintainNestedObjectKeys);
+    return (0, object_utils_js_1.isPlainObject)(obj) && !opt?.maintainNestedObjectKeys;
 }

package/dist/cjs/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/cjs/plugin/parse-json-results/parse-json-results-plugin.js

@@ -2,31 +2,67 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParseJSONResultsPlugin = void 0;
 const object_utils_js_1 = require("../../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()]
+ * })
+ * ```
+ */
 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),
         };
     }
 }
 exports.ParseJSONResultsPlugin = ParseJSONResultsPlugin;
-function parseRow(row) {
-    return Object.entries(row).reduce((row, [key, value]) => {
-        if ((0, object_utils_js_1.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 ((0, object_utils_js_1.isString)(obj)) {
+        return parseString(obj);
+    }
+    if (Array.isArray(obj)) {
+        return parseArray(obj);
+    }
+    if ((0, object_utils_js_1.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/cjs/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/cjs/query-builder/aggregate-function-builder.js

@@ -75,7 +75,7 @@ class AggregateFunctionBuilder {
     filterWhere(...args) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseFilter)(args)),
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
         });
     }
     /**
@@ -113,7 +113,7 @@ class AggregateFunctionBuilder {
     filterWhereRef(lhs, op, rhs) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialComparison)(lhs, op, rhs)),
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
         });
     }
     /**

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

@@ -15,7 +15,7 @@ class CaseBuilder {
     when(...args) {
         return new CaseThenBuilder({
             ...this.#props,
-            node: case_node_js_1.CaseNode.cloneWithWhen(this.#props.node, when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseFilter)(args))),
+            node: case_node_js_1.CaseNode.cloneWithWhen(this.#props.node, when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args))),
         });
     }
 }
@@ -28,7 +28,9 @@ class CaseThenBuilder {
     then(valueExpression) {
         return new CaseWhenBuilder({
             ...this.#props,
-            node: case_node_js_1.CaseNode.cloneWithThen(this.#props.node, (0, value_parser_js_1.parseValueExpression)(valueExpression)),
+            node: case_node_js_1.CaseNode.cloneWithThen(this.#props.node, (0, value_parser_js_1.isSafeImmediateValue)(valueExpression)
+                ? (0, value_parser_js_1.parseSafeImmediateValue)(valueExpression)
+                : (0, value_parser_js_1.parseValueExpression)(valueExpression)),
         });
     }
 }
@@ -41,14 +43,16 @@ class CaseWhenBuilder {
     when(...args) {
         return new CaseThenBuilder({
             ...this.#props,
-            node: case_node_js_1.CaseNode.cloneWithWhen(this.#props.node, when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseFilter)(args))),
+            node: case_node_js_1.CaseNode.cloneWithWhen(this.#props.node, when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args))),
         });
     }
     else(valueExpression) {
         return new CaseEndBuilder({
             ...this.#props,
             node: case_node_js_1.CaseNode.cloneWith(this.#props.node, {
-                else: (0, value_parser_js_1.parseValueExpression)(valueExpression),
+                else: (0, value_parser_js_1.isSafeImmediateValue)(valueExpression)
+                    ? (0, value_parser_js_1.parseSafeImmediateValue)(valueExpression)
+                    : (0, value_parser_js_1.parseValueExpression)(valueExpression),
             }),
         });
     }

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTEBuilder = void 0;
+const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class CTEBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Makes the common table expression materialized.
+     */
+    materialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: common_table_expression_node_js_1.CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: true,
+            }),
+        });
+    }
+    /**
+     * Makes the common table expression not materialized.
+     */
+    notMaterialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: common_table_expression_node_js_1.CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: false,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.node;
+    }
+}
+exports.CTEBuilder = CTEBuilder;
+(0, prevent_await_js_1.preventAwait)(CTEBuilder, "don't await CTEBuilder instances. They are never executed directly and are always just a part of a query.");

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

@@ -21,13 +21,13 @@ class DeleteQueryBuilder {
     where(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseFilter)(args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseReferentialComparison)(lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
         });
     }
     clearWhere() {
@@ -115,7 +115,7 @@ class DeleteQueryBuilder {
     orderBy(orderBy, direction) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithOrderByItem(this.#props.queryNode, (0, order_by_parser_js_1.parseOrderBy)(orderBy, direction)),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithOrderByItems(this.#props.queryNode, (0, order_by_parser_js_1.parseOrderBy)([orderBy, direction])),
         });
     }
     /**