kysely-hydrate 0.10.0 → 0.10.2

package/README.md

@@ -1182,29 +1182,32 @@ In Postgres, this is done with data-modifying CTEs: a `SELECT` whose `WITH`
 clause contains `INSERT`, `UPDATE`, or `DELETE` statements. Kysely supports this
 natively with `.with()`.
 
-`writeAs()` initializes a query set from such a query. Any CTEs on the provided
-`SELECT` are hoisted to the top level of the generated SQL—which is where
-Postgres requires data-modifying CTEs to live.
+`writeAs()` takes two callbacks. The first builds CTEs and returns a query
+creator. The second builds the SELECT that references CTE names. The CTEs are
+placed at the top level of the generated SQL—which is where Postgres requires
+data-modifying CTEs to live—while the SELECT becomes a derived table with no
+CTEs to strip.
 
 ```ts
 const result = await querySet(db)
-	.writeAs("updated", (db) =>
-		db
-			// Data-modifying CTE: update the user
-			.with("updated", (qb) =>
-				qb
-					.updateTable("users")
-					.set({ email: "new@example.com" })
-					.where("id", "=", userId)
-					.returningAll(),
-			)
-			// Data-modifying CTE: insert an audit log entry
-			.with("audit", (qb) =>
-				qb.insertInto("audit_log").values({ userId, action: "email_changed" }).returning(["id"]),
-			)
-			// Select from the update result
-			.selectFrom("updated")
-			.select(["id", "username", "email"]),
+	.writeAs(
+		"updated",
+		(db) =>
+			db
+				// Data-modifying CTE: update the user
+				.with("updated", (qb) =>
+					qb
+						.updateTable("users")
+						.set({ email: "new@example.com" })
+						.where("id", "=", userId)
+						.returningAll(),
+				)
+				// Data-modifying CTE: insert an audit log entry
+				.with("audit", (qb) =>
+					qb.insertInto("audit_log").values({ userId, action: "email_changed" }).returning(["id"]),
+				),
+		// Select from the update result
+		(qc) => qc.selectFrom("updated").select(["id", "username", "email"]),
 	)
 	.executeTakeFirstOrThrow();
 // ⬇
@@ -1238,17 +1241,16 @@ const usersQuerySet = querySet(db)
 
 // Reuse the canonical query set for a select query with data-modifying CTE.
 const result = await usersQuerySet
-	.write((db) =>
-		db
-			.with("updated", (qb) =>
+	.write(
+		(db) =>
+			db.with("updated", (qb) =>
 				qb
 					.updateTable("users")
 					.set({ email: "new@example.com" })
 					.where("id", "=", userId)
 					.returningAll(),
-			)
-			.selectFrom("updated")
-			.select(["id", "username", "email"]),
+			),
+		(qc) => qc.selectFrom("updated").select(["id", "username", "email"]),
 	)
 	.executeTakeFirstOrThrow();
 // ⬇ Result includes posts and gravatarUrl!

package/dist/index.d.mts

@@ -1369,22 +1369,15 @@ interface MappedQuerySet<in out T extends TQuerySet> extends k.Compilable, k.Ope
   /**
    * Switches the base query to a `SELECT` that may contain data-modifying CTEs.
    *
-   * Any CTEs on the provided query will be hoisted to the top level of the
-   * generated SQL, which is required by Postgres for data-modifying CTEs.
-   * The stripped `SELECT` is inlined as a derived table, just like
-   * {@link selectAs}.
-   *
-   * This enables multi-write CTE orchestration patterns like:
-   * ```sql
-   * WITH "updated" AS (UPDATE ... RETURNING *),
-   *      "audit" AS (INSERT INTO audit_log ... RETURNING *)
-   * SELECT * FROM "updated"
-   * ```
+   * Callback 1 receives `db`, builds CTEs, and returns a query creator.
+   * Callback 2 receives a query creator typed with the CTE names and builds
+   * the SELECT.
    *
-   * @param sqb - A select query builder (possibly with CTEs) or factory function.
+   * @param cteFn - Builds CTEs; returns a query creator.
+   * @param selectFn - Builds the SELECT referencing CTE names.
    * @returns A new QuerySet with the write query as the base.
    */
-  write<SQB extends k.SelectQueryBuilder<any, any, T["BaseQuery"]["O"]>>(sqb: WriteQueryBuilderOrFactory<T["DB"], SQB>): MaybeMappedQuerySet<TWithBaseQuery<T, InferTSelectQuery<SQB>>>;
+  write<NewDB, SQB extends k.SelectQueryBuilder<any, any, T["BaseQuery"]["O"]>>(cteFn: (db: k.Kysely<T["DB"]>) => k.QueryCreator<NewDB>, selectFn: (qc: k.QueryCreator<NewDB>) => SQB): MaybeMappedQuerySet<TWithBaseQuery<T, InferTSelectQuery<SQB>>>;
 }
 /**
  * A query set that supports nested joins and automatic hydration.
@@ -2484,8 +2477,6 @@ type UpdateQueryBuilderFactory<InitialDB, UQB extends AnyUpdateQueryBuilder> = (
 type UpdateQueryBuilderOrFactory<InitialDB, UQB extends AnyUpdateQueryBuilder> = UQB | UpdateQueryBuilderFactory<InitialDB, UQB>;
 type DeleteQueryBuilderFactory<InitialDB, DQB extends AnyDeleteQueryBuilder> = (db: DeleteCreator<InitialDB>) => DQB;
 type DeleteQueryBuilderOrFactory<InitialDB, DQB extends AnyDeleteQueryBuilder> = DQB | DeleteQueryBuilderFactory<InitialDB, DQB>;
-type WriteQueryBuilderFactory<InitialDB, SQB extends AnySelectQueryBuilder> = (db: k.Kysely<InitialDB>) => SQB;
-type WriteQueryBuilderOrFactory<InitialDB, SQB extends AnySelectQueryBuilder> = SQB | WriteQueryBuilderFactory<InitialDB, SQB>;
 interface NestedQuerySetFn<in out DB$1, in out Alias extends string> {
   <SQB extends k.SelectQueryBuilder<any, any, InputWithDefaultKey>>(query: SQB): InitialQuerySet<DB$1, Alias, InferTSelectQuery<SQB>>;
   <SQB extends AnySelectQueryBuilder>(query: SQB, keyBy: KeyBy<InferO<NoInfer<SQB>>>): InitialQuerySet<DB$1, Alias, InferTSelectQuery<SQB>>;
@@ -2604,27 +2595,26 @@ declare class QuerySetCreator<in out DB$1> {
    * This enables multi-write CTE orchestration patterns like:
    * ```ts
    * const result = await querySet(db)
-   *   .writeAs("updated", (db) =>
-   *     db
-   *       .with("updated", (qb) =>
-   *         qb.updateTable("users")
-   *           .set({ email: "new@example.com" })
-   *           .where("id", "=", 1)
-   *           .returningAll()
-   *       )
-   *       .selectFrom("updated")
-   *       .selectAll()
+   *   .writeAs("updated",
+   *     (db) => db.with("updated", (qb) =>
+   *       qb.updateTable("users")
+   *         .set({ email: "new@example.com" })
+   *         .where("id", "=", 1)
+   *         .returningAll()
+   *     ),
+   *     (qc) => qc.selectFrom("updated").selectAll()
    *   )
    *   .executeTakeFirst();
    * ```
    *
    * @param alias - The alias for the base query.
-   * @param query - A Kysely select query builder (possibly with CTEs) or factory function.
+   * @param cteFn - A callback that receives `db` and builds the CTEs, returning a query creator.
+   * @param selectFn - A callback that receives the query creator and builds the SELECT referencing CTE names.
    * @param keyBy - The key(s) to uniquely identify rows. Defaults to `"id"`.
    * @returns A new QuerySet.
    */
-  writeAs<Alias extends string, SQB extends k.SelectQueryBuilder<any, any, InputWithDefaultKey>>(alias: Alias, query: WriteQueryBuilderOrFactory<DB$1, SQB>): InitialQuerySet<DB$1, Alias, InferTSelectQuery<SQB>>;
-  writeAs<Alias extends string, SQB extends AnySelectQueryBuilder>(alias: Alias, query: WriteQueryBuilderOrFactory<DB$1, SQB>, keyBy: KeyBy<InferO<NoInfer<SQB>>>): InitialQuerySet<DB$1, Alias, InferTSelectQuery<SQB>>;
+  writeAs<Alias extends string, NewDB, SQB extends k.SelectQueryBuilder<any, any, InputWithDefaultKey>>(alias: Alias, cteFn: (db: k.Kysely<DB$1>) => k.QueryCreator<NewDB>, selectFn: (qc: k.QueryCreator<NewDB>) => SQB): InitialQuerySet<DB$1, Alias, InferTSelectQuery<SQB>>;
+  writeAs<Alias extends string, NewDB, SQB extends AnySelectQueryBuilder>(alias: Alias, cteFn: (db: k.Kysely<DB$1>) => k.QueryCreator<NewDB>, selectFn: (qc: k.QueryCreator<NewDB>) => SQB, keyBy: KeyBy<InferO<NoInfer<SQB>>>): InitialQuerySet<DB$1, Alias, InferTSelectQuery<SQB>>;
 }
 /**
  * Creates a new {@link QuerySetCreator} for building query sets with nested joins

package/dist/index.mjs

@@ -609,56 +609,6 @@ function groupByKey(prefix, inputs, keyBy) {
 	return map;
 }
 
-//#endregion
-//#region src/helpers/cte-hoisting.ts
-/**
-* Extracts the CTE expressions from a query builder's operation node.
-*/
-function extractCTEs(qb) {
-	return qb.toOperationNode().with?.expressions;
-}
-/**
-* A Kysely plugin that strips the WITH clause from a SelectQueryNode,
-* effectively removing all CTEs from the query.
-*/
-var StripWithPlugin = class {
-	transformQuery(args) {
-		const node = args.node;
-		if (node.kind === "SelectQueryNode" && node.with) return {
-			...node,
-			with: void 0
-		};
-		return node;
-	}
-	async transformResult(args) {
-		return args.result;
-	}
-};
-/**
-* A Kysely plugin that prepends CTE expressions to the outer query's WithNode.
-*/
-var AddCTEsPlugin = class {
-	#expressions;
-	constructor(expressions) {
-		this.#expressions = expressions;
-	}
-	transformQuery(args) {
-		const node = args.node;
-		if (node.kind !== "SelectQueryNode") return node;
-		const existing = node.with?.expressions ?? [];
-		const merged = [...this.#expressions, ...existing];
-		let withNode = k.WithNode.create(merged[0]);
-		for (let i = 1; i < merged.length; i++) withNode = k.WithNode.cloneWithExpression(withNode, merged[i]);
-		return {
-			...node,
-			with: withNode
-		};
-	}
-	async transformResult(args) {
-		return args.result;
-	}
-};
-
 //#endregion
 //#region src/helpers/select-renamer.ts
 const fakeQb = k.createSelectQueryBuilder({
@@ -741,6 +691,25 @@ function extractSelectionName(selectionNode) {
 * @see {@link QuerySet} - Query builder interface
 * @see {@link MappedQuerySet} - Mapped query builder interface
 */
+/**
+* A stateless Kysely plugin that strips the WITH clause from a
+* SelectQueryNode.  Used to remove CTEs that the query creator
+* attaches to queries built via `selectFn` in `.write()` / `.writeAs()`.
+* The CTEs are already captured separately in `writeQueryCreator`.
+*/
+const stripWithPlugin = {
+	transformQuery(args) {
+		const node = args.node;
+		if (node.kind === "SelectQueryNode" && node.with) return {
+			...node,
+			with: void 0
+		};
+		return node;
+	},
+	async transformResult(args) {
+		return args.result;
+	}
+};
 const filteringJoins = new Set([
 	"innerJoin",
 	"innerJoinLateral",
@@ -783,17 +752,13 @@ var QuerySetImpl = class QuerySetImpl {
 		return this.#props.baseQuery;
 	}
 	#getSelectFromBase(isNested, isLocalSubquery) {
-		const { db, baseQuery, baseAlias, hoistCTEs } = this.#props;
+		const { db, baseQuery, baseAlias, writeQueryCreator } = this.#props;
 		if (isSelectQueryBuilder(baseQuery)) {
-			if (hoistCTEs) {
+			if (writeQueryCreator) {
 				if (isNested) throw new InvalidJoinedQuerySetError(baseAlias);
-				const ctes = extractCTEs(baseQuery);
-				if (ctes?.length) {
-					const stripped = baseQuery.withPlugin(new StripWithPlugin());
-					let qb$1 = db.selectFrom(stripped.as(baseAlias));
-					qb$1 = applyHoistedSelections(qb$1, baseQuery, baseAlias);
-					return qb$1.withPlugin(new AddCTEsPlugin(ctes));
-				}
+				let qb$1 = writeQueryCreator.selectFrom(baseQuery.as(baseAlias));
+				qb$1 = applyHoistedSelections(qb$1, baseQuery, baseAlias);
+				return qb$1;
 			}
 			return applyHoistedSelections(db.selectFrom(baseQuery.as(baseAlias)), baseQuery, baseAlias);
 		}
@@ -842,12 +807,16 @@ var QuerySetImpl = class QuerySetImpl {
 		if (offset !== null) qb = qb.offset(offset);
 		return qb;
 	}
-	#applyOrderBy(qb) {
+	#applyOrderBy(qb, isOuter = false) {
 		const { baseAlias, keyBy, orderBy } = this.#props;
+		const eb = k.expressionBuilder(qb);
 		let keyByArray = typeof keyBy === "string" ? [keyBy] : keyBy;
 		for (const { expr, modifiers } of orderBy) {
-			const sqlExpr = expr.includes(SEP) ? expr.replace(SEP, ".") : `${baseAlias}.${expr}`;
-			qb = qb.orderBy(sqlExpr, modifiers);
+			let orderExpr;
+			if (expr.includes(SEP)) if (isOuter) orderExpr = eb.ref(`${baseAlias}.${expr}`);
+			else orderExpr = expr.replace(SEP, ".");
+			else orderExpr = `${baseAlias}.${expr}`;
+			qb = qb.orderBy(orderExpr, modifiers);
 			keyByArray = keyByArray.filter((k$1) => k$1 !== expr);
 		}
 		if (this.#props.orderByKeys) for (const key of keyByArray) qb = qb.orderBy(`${baseAlias}.${key}`, "asc");
@@ -873,7 +842,7 @@ var QuerySetImpl = class QuerySetImpl {
 		const { joinCollections } = this.#props;
 		let qb = this.#getSelectFromBase(isNested, isLocalSubquery);
 		for (const [key, collection] of joinCollections) qb = this.#addCollectionAsJoin(qb, key, collection);
-		if (!(isNested || isLocalSubquery)) qb = this.#applyOrderBy(qb);
+		if (!(isNested || isLocalSubquery)) qb = this.#applyOrderBy(qb, false);
 		return qb;
 	}
 	toJoinedQuery() {
@@ -893,12 +862,12 @@ var QuerySetImpl = class QuerySetImpl {
 		if (this.#isCardinalityOne()) return this.#applyLimitAndOffset(this.#toJoinedQuery(isNested, isLocalSubquery));
 		let cardinalityOneQuery = this.#toCardinalityOneQuery(isNested, isLocalSubquery);
 		cardinalityOneQuery = this.#applyLimitAndOffset(cardinalityOneQuery);
-		if (limit || offset) cardinalityOneQuery = this.#applyOrderBy(cardinalityOneQuery);
+		if (limit || offset) cardinalityOneQuery = this.#applyOrderBy(cardinalityOneQuery, false);
 		const aliasedCardinalityOneQuery = cardinalityOneQuery.as(baseAlias);
 		let qb = db.selectFrom(aliasedCardinalityOneQuery);
 		qb = applyHoistedSelections(qb, cardinalityOneQuery, baseAlias);
 		for (const [key, collection] of joinCollections) if (!this.#isCollectionCardinalityOne(collection)) qb = this.#addCollectionAsJoin(qb, key, collection);
-		if (!(isNested || isLocalSubquery)) qb = this.#applyOrderBy(qb);
+		if (!(isNested || isLocalSubquery)) qb = this.#applyOrderBy(qb, true);
 		for (const modifier of this.#props.frontModifiers) qb = qb.modifyFront(modifier);
 		for (const modifier of this.#props.endModifiers) qb = qb.modifyEnd(modifier);
 		return qb;
@@ -1114,10 +1083,12 @@ var QuerySetImpl = class QuerySetImpl {
 	delete(iqb) {
 		return this.#asWrite(iqb);
 	}
-	write(sqb) {
+	write(cteFn, selectFn) {
+		const qc = cteFn(this.#props.db);
+		const baseQuery = selectFn(qc).withPlugin(stripWithPlugin);
 		return this.#clone({
-			baseQuery: typeof sqb === "function" ? sqb(this.#props.db) : sqb,
-			hoistCTEs: true
+			baseQuery,
+			writeQueryCreator: qc
 		});
 	}
 };
@@ -1147,7 +1118,7 @@ var QuerySetCreator = class {
 			orderByKeys: true,
 			frontModifiers: [],
 			endModifiers: [],
-			hoistCTEs: false
+			writeQueryCreator: null
 		});
 	}
 	selectAs(alias, query, keyBy = DEFAULT_KEY_BY) {
@@ -1162,13 +1133,14 @@ var QuerySetCreator = class {
 	deleteAs(alias, query, keyBy = DEFAULT_KEY_BY) {
 		return this.#createQuerySet(alias, query, keyBy);
 	}
-	writeAs(alias, query, keyBy = DEFAULT_KEY_BY) {
-		const baseQuery = typeof query === "function" ? query(this.#db) : query;
+	writeAs(alias, cteFn, selectFn, keyBy) {
+		const qc = cteFn(this.#db);
+		const baseQuery = selectFn(qc).withPlugin(stripWithPlugin);
 		return new QuerySetImpl({
 			db: this.#db,
 			baseAlias: alias,
 			baseQuery,
-			keyBy,
+			keyBy: keyBy ?? DEFAULT_KEY_BY,
 			hydrator: createHydrator().orderByKeys(),
 			joinCollections: /* @__PURE__ */ new Map(),
 			attachCollections: /* @__PURE__ */ new Map(),
@@ -1178,7 +1150,7 @@ var QuerySetCreator = class {
 			orderByKeys: true,
 			frontModifiers: [],
 			endModifiers: [],
-			hoistCTEs: true
+			writeQueryCreator: qc
 		});
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "kysely-hydrate",
-	"version": "0.10.0",
+	"version": "0.10.2",
 	"description": "Explicit ORM-style queries with Kysely",
 	"homepage": "https://github.com/GiacoCorsiglia/kysely-hydrate#readme",
 	"bugs": {