kysely 0.26.1 → 0.26.3

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -2,11 +2,11 @@ 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, From, FromTables } from '../parser/table-parser.js';
-import { SelectExpression, SelectArg } from '../parser/select-parser.js';
-import { ReturningRow } from '../parser/returning-parser.js';
+import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
+import { 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 { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { UpdateObject, UpdateObjectFactory } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
@@ -14,7 +14,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { UpdateResult } from './update-result.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 { Selectable } from '../util/column-type.js';
@@ -23,6 +23,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 UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: UpdateQueryBuilderProps);
@@ -79,7 +80,34 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * 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
@@ -114,7 +142,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
@@ -209,7 +237,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * 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:
@@ -299,8 +327,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
-    where(factory: WhereExpressionFactory<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
-    where(expression: Expression<any>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -714,7 +741,9 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .executeTakeFirst()
      * ```
      */
-    returning<SE extends SelectExpression<DB, TB>>(selection: SelectArg<DB, TB, SE>): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<CB extends SelectCallback<DB, TB>>(callback: CB): UpdateQueryBuilder<DB, UT, TB, ReturningCallbackRow<DB, TB, O, CB>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.

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

@@ -20,13 +20,13 @@ class UpdateQueryBuilder {
     where(...args) {
         return new UpdateQueryBuilder({
             ...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 UpdateQueryBuilder({
             ...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() {

package/dist/cjs/query-builder/where-interface.d.ts

@@ -1,8 +1,7 @@
-import { Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SqlBool } from '../util/type-utils.js';
-import { ExpressionBuilder } from '../expression/expression-builder.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 export interface WhereInterface<DB, TB extends keyof DB> {
     /**
      * Adds a `where` expression to the query.
@@ -57,7 +56,34 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * 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
@@ -92,7 +118,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
@@ -187,7 +213,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * 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:
@@ -277,8 +303,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
-    where(factory: WhereExpressionFactory<DB, TB>): WhereInterface<DB, TB>;
-    where(expression: Expression<any>): WhereInterface<DB, TB>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): WhereInterface<DB, TB>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -351,4 +376,3 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      */
     clearWhere(): WhereInterface<DB, TB>;
 }
-export type WhereExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;

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

@@ -87,6 +87,7 @@ import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
 import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONPathLegNode } from '../operation-node/json-path-leg-node.js';
 import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
+import { TupleNode } from '../operation-node/tuple-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -113,6 +114,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitOr(node: OrNode): void;
     protected visitValue(node: ValueNode): void;
     protected visitValueList(node: ValueListNode): void;
+    protected visitTuple(node: TupleNode): void;
     protected visitPrimitiveValueList(node: PrimitiveValueListNode): void;
     protected visitParens(node: ParensNode): void;
     protected visitJoin(node: JoinNode): void;
@@ -194,4 +196,5 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected sanitizeIdentifier(identifier: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
+    protected sortSelectModifiers(arr: SelectModifierNode[]): ReadonlyArray<SelectModifierNode>;
 }

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

@@ -4,6 +4,7 @@ exports.DefaultQueryCompiler = void 0;
 const insert_query_node_js_1 = require("../operation-node/insert-query-node.js");
 const operation_node_visitor_js_1 = require("../operation-node/operation-node-visitor.js");
 const operator_node_js_1 = require("../operation-node/operator-node.js");
+const parens_node_js_1 = require("../operation-node/parens-node.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const create_view_node_js_1 = require("../operation-node/create-view-node.js");
@@ -29,6 +30,7 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitSelectQuery(node) {
         const wrapInParens = this.parentNode !== undefined &&
+            !parens_node_js_1.ParensNode.is(this.parentNode) &&
             !insert_query_node_js_1.InsertQueryNode.is(this.parentNode) &&
             !create_view_node_js_1.CreateViewNode.is(this.parentNode) &&
             !set_operation_node_js_1.SetOperationNode.is(this.parentNode);
@@ -43,20 +45,23 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.visitNode(node.with);
             this.append(' ');
         }
-        this.append('select ');
+        this.append('select');
         if (node.distinctOn) {
-            this.compileDistinctOn(node.distinctOn);
             this.append(' ');
+            this.compileDistinctOn(node.distinctOn);
         }
-        if (node.frontModifiers && node.frontModifiers.length > 0) {
-            this.compileList(node.frontModifiers, ' ');
+        if (node.frontModifiers?.length) {
             this.append(' ');
+            this.compileList(node.frontModifiers, ' ');
         }
         if (node.selections) {
+            this.append(' ');
             this.compileList(node.selections);
+        }
+        if (node.from) {
             this.append(' ');
+            this.visitNode(node.from);
         }
-        this.visitNode(node.from);
         if (node.joins) {
             this.append(' ');
             this.compileList(node.joins, ' ');
@@ -89,9 +94,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.offset);
         }
-        if (node.endModifiers && node.endModifiers.length > 0) {
+        if (node.endModifiers?.length) {
             this.append(' ');
-            this.compileList(node.endModifiers, ' ');
+            this.compileList(this.sortSelectModifiers([...node.endModifiers]), ' ');
         }
         if (wrapInParens) {
             this.append(')');
@@ -273,6 +278,11 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.compileList(node.values);
         this.append(')');
     }
+    visitTuple(node) {
+        this.append('(');
+        this.compileList(node.values);
+        this.append(')');
+    }
     visitPrimitiveValueList(node) {
         this.append('(');
         const { values } = node;
@@ -653,6 +663,12 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     visitCommonTableExpression(node) {
         this.visitNode(node.name);
         this.append(' as ');
+        if ((0, object_utils_js_1.isBoolean)(node.materialized)) {
+            if (!node.materialized) {
+                this.append('not ');
+            }
+            this.append('materialized ');
+        }
         this.visitNode(node.expression);
     }
     visitCommonTableExpressionName(node) {
@@ -1056,6 +1072,13 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             throw new Error(`invalid immediate value ${value}`);
         }
     }
+    sortSelectModifiers(arr) {
+        arr.sort((left, right) => left.modifier && right.modifier
+            ? SELECT_MODIFIER_PRIORITY[left.modifier] -
+                SELECT_MODIFIER_PRIORITY[right.modifier]
+            : 1);
+        return (0, object_utils_js_1.freeze)(arr);
+    }
 }
 exports.DefaultQueryCompiler = DefaultQueryCompiler;
 const SELECT_MODIFIER_SQL = (0, object_utils_js_1.freeze)({
@@ -1067,6 +1090,15 @@ const SELECT_MODIFIER_SQL = (0, object_utils_js_1.freeze)({
     SkipLocked: 'skip locked',
     Distinct: 'distinct',
 });
+const SELECT_MODIFIER_PRIORITY = (0, object_utils_js_1.freeze)({
+    ForKeyShare: 1,
+    ForNoKeyUpdate: 1,
+    ForUpdate: 1,
+    ForShare: 1,
+    NoWait: 2,
+    SkipLocked: 2,
+    Distinct: 0,
+});
 const JOIN_TYPE_SQL = (0, object_utils_js_1.freeze)({
     InnerJoin: 'inner join',
     LeftJoin: 'left join',

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

@@ -10,6 +10,8 @@ import { InsertResult } from './query-builder/insert-result.js';
 import { DeleteResult } from './query-builder/delete-result.js';
 import { UpdateResult } from './query-builder/update-result.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
+import { CTEBuilderCallback } from './query-builder/cte-builder.js';
+import { CallbackSelection, SelectCallback, SelectExpression, Selection } from './parser/select-parser.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -125,6 +127,56 @@ export declare class QueryCreator<DB> {
     selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    /**
+     * Creates a `select` query builder without a `from` clause.
+     *
+     * If you want to create a `select from` query, use the `selectFrom` method instead.
+     * This one can be used to create a plain `select` statement without a `from` clause.
+     *
+     * This method accepts the same inputs as {@link SelectQueryBuilder.select}. See its
+     * documentation for more examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = db.selectNoFrom((eb) => [
+     *   eb.selectFrom('person')
+     *     .select('id')
+     *     .where('first_name', '=', 'Jennifer')
+     *     .limit(1)
+     *     .as('jennifer_id'),
+     *
+     *   eb.selectFrom('pet')
+     *     .select('id')
+     *     .where('name', '=', 'Doggo')
+     *     .limit(1)
+     *     .as('doggo_id')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     *
+     * console.log(result.jennifer_id)
+     * console.log(result.doggo_id)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select (
+     *   select "id"
+     *   from "person"
+     *   where "first_name" = $1
+     *   limit $2
+     * ) as "jennifer_id", (
+     *   select "id"
+     *   from "pet"
+     *   where "name" = $3
+     *   limit $4
+     * ) as "doggo_id"
+     * ```
+     */
+    selectNoFrom<SE extends SelectExpression<DB, never>>(selections: ReadonlyArray<SE>): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
+    selectNoFrom<CB extends SelectCallback<DB, never>>(callback: CB): SelectQueryBuilder<DB, never, CallbackSelection<DB, never, CB>>;
+    selectNoFrom<SE extends SelectExpression<DB, never>>(selection: SE): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
     /**
      * Creates an insert query.
      *
@@ -310,14 +362,36 @@ export declare class QueryCreator<DB> {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The first argument can also be a callback. The callback is passed
+     * a `CTEBuilder` instance that can be used to configure the CTE:
+     *
+     * ```ts
+     * await db
+     *   .with(
+     *     (cte) => cte('jennifers').materialized(),
+     *     (db) => db
+     *       .selectFrom('person')
+     *       .where('first_name', '=', 'Jennifer')
+     *       .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
-    with<N extends string, E extends CommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    with<N extends string, E extends CommonTableExpression<DB, N>>(nameOrBuilder: N | CTEBuilderCallback<N>, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
     /**
      * Creates a recursive `with` query (Common Table Expression).
      *
+     * Note that recursiveness is a property of the whole `with` statement.
+     * You cannot have recursive and non-recursive CTEs in a same `with` statement.
+     * Therefore the recursiveness is determined by the **first** `with` or
+     * `withRecusive` call you make.
+     *
      * See the {@link with} method for examples and more documentation.
      */
-    withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(nameOrBuilder: N | CTEBuilderCallback<N>, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
     /**
      * Returns a copy of this query creator instance with the given plugin installed.
      */

package/dist/cjs/query-creator.js

@@ -15,16 +15,24 @@ const with_node_js_1 = require("./operation-node/with-node.js");
 const query_id_js_1 = require("./util/query-id.js");
 const with_schema_plugin_js_1 = require("./plugin/with-schema/with-schema-plugin.js");
 const object_utils_js_1 = require("./util/object-utils.js");
+const select_parser_js_1 = require("./parser/select-parser.js");
 class QueryCreator {
     #props;
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
     selectFrom(from) {
-        return new select_query_builder_js_1.SelectQueryBuilder({
+        return (0, select_query_builder_js_1.createSelectQueryBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(from), this.#props.withNode),
+            queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)(from), this.#props.withNode),
+        });
+    }
+    selectNoFrom(selection) {
+        return (0, select_query_builder_js_1.createSelectQueryBuilder)({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#props.executor,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(select_query_node_js_1.SelectQueryNode.create(this.#props.withNode), (0, select_parser_js_1.parseSelectArg)(selection)),
         });
     }
     /**
@@ -159,9 +167,26 @@ class QueryCreator {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The first argument can also be a callback. The callback is passed
+     * a `CTEBuilder` instance that can be used to configure the CTE:
+     *
+     * ```ts
+     * await db
+     *   .with(
+     *     (cte) => cte('jennifers').materialized(),
+     *     (db) => db
+     *       .selectFrom('person')
+     *       .where('first_name', '=', 'Jennifer')
+     *       .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
-    with(name, expression) {
-        const cte = (0, with_parser_js_1.parseCommonTableExpression)(name, expression);
+    with(nameOrBuilder, expression) {
+        const cte = (0, with_parser_js_1.parseCommonTableExpression)(nameOrBuilder, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -172,10 +197,15 @@ class QueryCreator {
     /**
      * Creates a recursive `with` query (Common Table Expression).
      *
+     * Note that recursiveness is a property of the whole `with` statement.
+     * You cannot have recursive and non-recursive CTEs in a same `with` statement.
+     * Therefore the recursiveness is determined by the **first** `with` or
+     * `withRecusive` call you make.
+     *
      * See the {@link with} method for examples and more documentation.
      */
-    withRecursive(name, expression) {
-        const cte = (0, with_parser_js_1.parseCommonTableExpression)(name, expression);
+    withRecursive(nameOrBuilder, expression) {
+        const cte = (0, with_parser_js_1.parseCommonTableExpression)(nameOrBuilder, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode