kysely-hydrate 0.3.0 → 0.4.0

package/README.md

@@ -131,6 +131,7 @@ By design, Kysely has the following constraints:
     - [`.hasMany()`](#hasmany)
     - [`.hasOne()`](#hasone)
     - [`.hasOneOrThrow()`](#hasoneorthrow)
+    - [Hydrated lateral joins](#hydrated-lateral-joins)
   - [Application-level joins with `.attach*()`](#application-level-joins-with-attach)
     - [`.attachMany()`](#attachmany)
     - [`.attachOne()`](#attachone)
@@ -465,12 +466,86 @@ but you know the record must exist.
 
 > [!NOTE]
 > Like `hydrate()`, `hasOneOrThrow()` also accepts an optional final `keyBy` argument with the
-> same semantics (see [Keying and deduplication with `keyBy`](#keying-and-deduplication-with-keyby)).
+> same semantics (see [Keying and deduplication with
+> `keyBy`](#keying-and-deduplication-with-keyby)).
+
+#### Hydrated lateral joins
+
+Kysely supports lateral joins by passing a subquery to methods like
+`innerJoinLateral`, `leftJoinLateral`, etc.
+
+In addition to Kysely's default behavior, Kysely Hydrate also lets you pass an
+**aliased hydrated subquery** to these methods. When you do, the subquery’s
+selections are automatically added to the parent query (with the usual
+prefixing), and the nested result is hydrated according to the nested hydration
+config. This makes it possible to compose hydrated queries through lateral
+joins.
+
+Here’s an example selecting each user and their latest post (scoped per-user
+inside the lateral subquery):
+
+```ts
+const query = hydrate(db.selectFrom("users").select(["users.id", "users.username"]), "id")
+  .hasOne("latestPost", ({ innerJoinLateral }) =>
+    innerJoinLateral((db) =>
+      hydrate(
+        db
+          .selectFrom("posts")
+          .select(["posts.id", "posts.title"])
+          .whereRef("posts.user_id", "=", "users.id")
+          .orderBy("posts.id", "desc")
+          .limit(1),
+        "id",
+      ).as("latest_post_subquery"),
+      // You can omit `(join) => join.onTrue()` for the hydrated-subquery overload.
+    ),
+  );
+
+const result = await query.execute();
+// ⬇
+type Result = Array<{
+  id: number;
+  username: string;
+  latestPost: { id: number; title: string };
+}>;
+```
+
+The hydrated lateral subquery is “hoisted” into the parent select list, and its
+columns are prefixed under the relation key (e.g. `latestPost$$id`,
+`latestPost$$title`) so the hydration layer can un-flatten them.
+
+```sql
+select
+  "users"."id",
+  "users"."username",
+  "latest_post_subquery"."id" as "latestPost$$id",
+  "latest_post_subquery"."title" as "latestPost$$title"
+from "users"
+inner join lateral (
+  select "posts"."id", "posts"."title"
+  from "posts"
+  where "posts"."user_id" = "users"."id"
+  limit ?
+) as "latest_post_subquery" on true
+```
+
+> [!WARNING]
+> You cannot use `.selectAll()` in cases where Kysely Hydrate needs to resolve
+> and rewrite nested selections for prefixing. Prefer explicit `.select([...])`
+> (it will throw if selections can’t be resolved).
+
+> [!WARNING]
+> You're still writing SQL.  Lateral joins are powerful, but it’s easy to build
+> queries that don’t compose the way you expect (limits/order-by scopes,
+> correlation, etc). When in doubt, inspect the output with
+> `.toQuery().compile()`.
 
 #### SQL output
 
 Kysely Hydrate produces the SQL you tell it to with exactly one exception: it
-aliases nested selections to avoid naming collisions.
+aliases nested selections to avoid naming collisions.  (Kysely Hydrate also
+hoists selections from hydrated lateral join subqueries, as described
+[above](#hydrated-lateral-joins)—but only if you use that feature.)
 
 For example, `users.id` remains `users.id`, but `posts.id` nested under "posts"
 becomes `posts$$id`.  The hydration layer then un-flattens these aliases back

package/dist/index.d.mts

@@ -212,9 +212,10 @@ interface FullHydrator<Input, Output> extends MappedHydrator<Input, Output> {
    * Configures which fields to include in the hydrated output.
    *
    * @param fields - An object mapping field names to either `true` (include as-is)
-   *   or a transformation function
+   *   or a transformation function.  Also accepts an array of field names to include.
    * @returns A new Hydrator with the fields configuration merged
    */
+  fields<F extends readonly (keyof Input)[]>(fields: F): FullHydrator<Input, Extend<Output, Pick<Input, F[number]>>>;
   fields<F extends Fields<Input>>(fields: F): FullHydrator<Input, Extend<Output, InferFields<Input, F>>>;
   /**
    * Omits specified fields from the hydrated output.
@@ -388,10 +389,10 @@ interface MappedHydratedQueryBuilder<Prefix extends string, QueryDB, QueryTB ext
     QueryDB: QueryDB;
     QueryTB: QueryTB;
     QueryRow: QueryRow;
+    LocalDB: LocalDB;
     LocalRow: LocalRow;
     HydratedRow: HydratedRow;
     IsNullable: IsNullable;
-    NestedDB: LocalDB;
     HasJoin: HasJoin;
   } | undefined;
   /**
@@ -447,6 +448,24 @@ interface MappedHydratedQueryBuilder<Prefix extends string, QueryDB, QueryTB ext
    * @returns A MappedHydratedQueryBuilder with the transformation added
    */
   map<NewHydratedRow>(transform: (row: k$1.Simplify<HydratedRow>) => NewHydratedRow): MappedHydratedQueryBuilder<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, NewHydratedRow, IsNullable, HasJoin>;
+  /**
+   * Creates an aliased version of this query builder, suitable for use in join
+   * subqueries.
+   *
+   * **Example:**
+   * ```ts
+   * .hasMany('pets', ({ innerJoinLateral }) =>
+   *   innerJoinLateral(
+   *     (eb) => hydrate(eb.selectFrom('pet').select(['id', 'name'])).as('p'),
+   *     (join) => join.onTrue()
+   *   )
+   * )
+   * ```
+   *
+   * @param alias - The alias for this subquery
+   * @returns An AliasedHydratedExpression that can be used in lateral joins
+   */
+  as<Alias extends string>(alias: Alias): AliasedHydratedQueryBuilder<QueryRow, HydratedRow, Alias>;
 }
 /**
  * A query builder that supports both mapping and nested joins.
@@ -771,20 +790,49 @@ interface HydratedQueryBuilder<Prefix extends string, QueryDB, QueryTB extends k
   /**
    * Just like {@link innerJoin} but adds an `inner join lateral` instead of an
    * `inner join`.
+   *
+   * In addition to matching Kysely's allowed arguments, you may also pass a
+   * `HydratedQueryBuilder` as your subquery.  If you do, anything it selects
+   * will automatically be added to the parent query's selections (with
+   * prefixing).  This allows you to compose hydrated queries.
+   *
+   * @example
+   * ```ts
+   * const query = hydrate(db.selectFrom("users").select(["users.id", "users.username"]))
+   *  .hasMany("posts", ({ innerJoinLateral }) =>
+   *    innerJoinLateral(hydrate(db.selectFrom("posts").select(["posts.id", "posts.title"])))
+   *  );
+   *
+   * const result = await query.execute();
+   *
+   * // result is an array of objects with the following shape:
+   * {
+   *   id: number;
+   *   username: string;
+   *   posts: Array<{ id: number; title: string }>;
+   * }
+   * ```
+   *
+   * For the hydrated subquery case, you may omit the second "join builder" argument.
+   * By default, it will be `(join) => join.onTrue()`, which is typically what you want
+   * for a lateral join.
    */
   innerJoinLateral<TE extends k$1.TableExpression<QueryDB, QueryTB>, K1 extends k$1.JoinReferenceExpression<QueryDB, QueryTB, TE>, K2 extends k$1.JoinReferenceExpression<QueryDB, QueryTB, TE>>(table: TE, k1: K1, k2: K2): HydratedQueryBuilderWithInnerJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, TE>;
-  innerJoinLateral<TE extends k$1.TableExpression<QueryDB, QueryTB>, FN extends k$1.JoinCallbackExpression<QueryDB, QueryTB, TE>>(table: TE, callback: FN): HydratedQueryBuilderWithInnerJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, TE>;
+  innerJoinLateral<TE extends k$1.TableExpression<QueryDB, QueryTB>, FN extends k$1.JoinCallbackExpression<QueryDB, QueryTB, NoInfer<TE>>>(table: TE, callback: FN): HydratedQueryBuilderWithInnerJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, TE>;
+  innerJoinLateral<Alias extends string, NestedQueryRow, NestedHydratedRow, FN extends HydratedJoinCallbackExpression<QueryDB, QueryTB, Alias, NoInfer<NestedQueryRow>>>(hydratedTable: AliasedHydratedQueryBuilderOrFactory<QueryDB, QueryTB, Alias, NestedQueryRow, NestedHydratedRow>, callback?: FN): HydratedQueryBuilderWithHydratedInnerJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, Alias, NestedQueryRow, NestedHydratedRow>;
   /**
-   * Just like {@link leftJoin} but adds a `left join lateral` instead of a
-   * `left join`.
+   * Just like {@link innerJoinLateral} but adds a `left join lateral` instead of a
+   * `inner join lateral`.
    */
   leftJoinLateral<TE extends k$1.TableExpression<QueryDB, QueryTB>, K1 extends k$1.JoinReferenceExpression<QueryDB, QueryTB, TE>, K2 extends k$1.JoinReferenceExpression<QueryDB, QueryTB, TE>>(table: TE, k1: K1, k2: K2): HydratedQueryBuilderWithLeftJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, HasJoin, TE>;
-  leftJoinLateral<TE extends k$1.TableExpression<QueryDB, QueryTB>, FN extends k$1.JoinCallbackExpression<QueryDB, QueryTB, TE>>(table: TE, callback: FN): HydratedQueryBuilderWithLeftJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, HasJoin, TE>;
+  leftJoinLateral<TE extends k$1.TableExpression<QueryDB, QueryTB>, FN extends k$1.JoinCallbackExpression<QueryDB, QueryTB, NoInfer<TE>>>(table: TE, callback: FN): HydratedQueryBuilderWithLeftJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, HasJoin, TE>;
+  leftJoinLateral<Alias extends string, NestedQueryRow, NestedHydratedRow, FN extends HydratedJoinCallbackExpression<QueryDB, QueryTB, Alias, NoInfer<NestedQueryRow>>>(hydratedTable: AliasedHydratedQueryBuilderOrFactory<QueryDB, QueryTB, Alias, NestedQueryRow, NestedHydratedRow>, callback?: FN): HydratedQueryBuilderWithHydratedLeftJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, HasJoin, Alias, NestedQueryRow, NestedHydratedRow>;
   /**
-   * Just like {@link innerJoin} but adds a `cross join lateral` instead of an
-   * `inner join`.
+   * Just like {@link innerJoinLateral} but adds a `cross join lateral` instead of an
+   * `inner join lateral`.
    */
   crossJoinLateral<TE extends k$1.TableExpression<QueryDB, QueryTB>>(table: TE): HydratedQueryBuilderWithInnerJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, TE>;
+  crossJoinLateral<Alias extends string, NestedQueryRow, NestedHydratedRow>(hydratedTable: AliasedHydratedQueryBuilderOrFactory<QueryDB, QueryTB, Alias, NestedQueryRow, NestedHydratedRow>): HydratedQueryBuilderWithHydratedInnerJoin<Prefix, QueryDB, QueryTB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable, Alias, NestedQueryRow, NestedHydratedRow>;
   /**
    * Adds a select statement to the query.
    *
@@ -802,6 +850,36 @@ type HydratedQueryBuilderWithInnerJoin<Prefix extends string, QueryDB, QueryTB e
 type HydratedQueryBuilderWithLeftJoin<Prefix extends string, QueryDB, QueryTB extends keyof QueryDB, QueryRow, _LocalDB, LocalRow, HydratedRow, _IsNullable extends boolean, AlreadyHadJoin extends boolean, TE extends k$1.TableExpression<QueryDB, QueryTB>> = k$1.SelectQueryBuilderWithLeftJoin<QueryDB, QueryTB, QueryRow, TE> extends k$1.SelectQueryBuilder<infer JoinedDB, infer JoinedTB, infer JoinedRow> ? HydratedQueryBuilder<Prefix, JoinedDB, JoinedTB, JoinedRow, AlreadyHadJoin extends true ? JoinedDB : InferDB<k$1.SelectQueryBuilderWithInnerJoin<QueryDB, QueryTB, QueryRow, TE>>, LocalRow, HydratedRow, true,
 // Left joins always produce nullable rows.
 true> : never;
+type HydratedJoinCallbackExpression<QueryDB, QueryTB extends keyof QueryDB, Alias extends string, NestedQueryRow> = k$1.JoinCallbackExpression<QueryDB, QueryTB, AliasedHydratedQueryBuilderTableExpression<NestedQueryRow, Alias>>;
+type HydratedQueryBuilderWithHydratedInnerJoin<Prefix extends string, QueryDB, QueryTB extends keyof QueryDB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable extends boolean, Alias extends string, NestedQueryRow, NestedHydratedRow> = HydratedQueryBuilderWithInnerJoin<Prefix, QueryDB, QueryTB, Extend<QueryRow, ApplyPrefixes<Prefix, NestedQueryRow>>, LocalDB, Extend<LocalRow, NestedQueryRow>, Extend<HydratedRow, NestedHydratedRow>, IsNullable, AliasedHydratedQueryBuilderTableExpression<NestedQueryRow, Alias>>;
+type HydratedQueryBuilderWithHydratedLeftJoin<Prefix extends string, QueryDB, QueryTB extends keyof QueryDB, QueryRow, LocalDB, LocalRow, HydratedRow, IsNullable extends boolean, AlreadyHadJoin extends boolean, Alias extends string, NestedQueryRow, NestedHydratedRow> = HydratedQueryBuilderWithLeftJoin<Prefix, QueryDB, QueryTB, Extend<QueryRow, ApplyPrefixes<Prefix, NestedQueryRow>>, LocalDB, Extend<LocalRow, NestedQueryRow>, Extend<HydratedRow, NestedHydratedRow>, IsNullable, AlreadyHadJoin, AliasedHydratedQueryBuilderTableExpression<NestedQueryRow, Alias>>;
+type AliasedHydratedQueryBuilderOrFactory<QueryDB, QueryTB extends keyof QueryDB, Alias extends string, NestedQueryRow, NestedHydratedRow> = AliasedHydratedQueryBuilder<NestedQueryRow, NestedHydratedRow, Alias> | AliasedHydratedQueryBuilderFactory<QueryDB, QueryTB, Alias, NestedQueryRow, NestedHydratedRow>;
+type AliasedHydratedQueryBuilderFactory<QueryDB, QueryTB extends keyof QueryDB, Alias extends string, NestedQueryRow, NestedHydratedRow> = (eb: k$1.ExpressionBuilder<QueryDB, QueryTB>) => AliasedHydratedQueryBuilder<NestedQueryRow, NestedHydratedRow, Alias>;
+type AliasedHydratedQueryBuilderTableExpression<QueryRow, Alias extends string> = k$1.AliasedSelectQueryBuilder<QueryRow, Alias>;
+type HqbForAlias<QueryRow, HydratedRow> = MappedHydratedQueryBuilder<any, any, any, QueryRow, any, any, HydratedRow, any, any>;
+/**
+ * Represents a {@link HydratedQueryBuilder} that has been aliased with `.as()`.
+ * Analogous to {@link k.AliasedSelectQueryBuilder}.
+ */
+declare class AliasedHydratedQueryBuilder<QueryRow, HydratedRow, Alias extends string> {
+  #private;
+  readonly isAliasedHydratedQueryBuilder: true;
+  constructor(alias: Alias, hydratedQueryBuilder: HqbForAlias<QueryRow, HydratedRow>);
+  /**
+   * The alias!
+   */
+  get alias(): Alias;
+  /**
+   * The underlying {@link HydratedQueryBuilder}, which was aliased with `.as()`.
+   */
+  get hydratedQueryBuilder(): HqbForAlias<QueryRow, HydratedRow>;
+  /**
+   * Produces an {@link k.AliasedSelectQueryBuilder} for the
+   * {@link k.SelectQueryBuilder} underlying this {@link HydratedQueryBuilder}.
+   *
+   */
+  toAliasedQuery(): AliasedHydratedQueryBuilderTableExpression<QueryRow, Alias>;
+}
 /**
  * Creates a new {@link HydratedQueryBuilder} from a Kysely select query.
  * This enables nested joins and automatic hydration of flat SQL results into nested objects.

package/dist/index.mjs

@@ -275,7 +275,7 @@ var HydratorImpl = class HydratorImpl {
 	fields(fields) {
 		return new HydratorImpl({
 			...this.#props,
-			fields: addObjectToMap(this.#props.fields, fields)
+			fields: Array.isArray(fields) ? fields.reduce((map$1, field) => map$1.set(field, true), new Map(this.#props.fields)) : addObjectToMap(this.#props.fields, fields)
 		});
 	}
 	omit(keys) {
@@ -526,11 +526,27 @@ const fakeQb = k.createSelectQueryBuilder({
 function prefixSelectArg(prefix, selection) {
 	return fakeQb.select(selection).toOperationNode().selections?.map((selectionNode) => prefixSelectionNode(selectionNode, prefix)) ?? [];
 }
+/**
+* Produces selections for a parent query to select everything selected in a
+* subquery, but aliased with the given prefix.
+*/
+function hoistAndPrefixSelections(prefix, qb) {
+	const table = qb.alias;
+	if (typeof table !== "string") throw new UnexpectedComplexAliasError();
+	const node = qb.expression.toOperationNode();
+	if (!node.selections) return [];
+	const eb = k.expressionBuilder();
+	return node.selections.map((selectionNode) => {
+		const name = extractSelectionName(selectionNode);
+		return new PrefixedAliasedExpression(eb.ref(`${table}.${name}`), prefix, name);
+	});
+}
 var PrefixedAliasedExpression = class extends k.AliasedExpressionWrapper {
 	originalName;
 	constructor(node, prefix, originalName) {
 		const alias = applyPrefix(prefix, originalName);
-		super(new k.ExpressionWrapper(node), alias);
+		const expression = k.isExpression(node) ? node : new k.ExpressionWrapper(node);
+		super(expression, alias);
 		this.originalName = originalName;
 	}
 };
@@ -558,6 +574,39 @@ function extractSelectionName(selectionNode) {
 //#endregion
 //#region src/query-builder.ts
 /**
+* Represents a {@link HydratedQueryBuilder} that has been aliased with `.as()`.
+* Analogous to {@link k.AliasedSelectQueryBuilder}.
+*/
+var AliasedHydratedQueryBuilder = class {
+	isAliasedHydratedQueryBuilder = true;
+	#alias;
+	#hydratedQueryBuilder;
+	constructor(alias, hydratedQueryBuilder) {
+		this.#alias = alias;
+		this.#hydratedQueryBuilder = hydratedQueryBuilder;
+	}
+	/**
+	* The alias!
+	*/
+	get alias() {
+		return this.#alias;
+	}
+	/**
+	* The underlying {@link HydratedQueryBuilder}, which was aliased with `.as()`.
+	*/
+	get hydratedQueryBuilder() {
+		return this.#hydratedQueryBuilder;
+	}
+	/**
+	* Produces an {@link k.AliasedSelectQueryBuilder} for the
+	* {@link k.SelectQueryBuilder} underlying this {@link HydratedQueryBuilder}.
+	*
+	*/
+	toAliasedQuery() {
+		return this.#hydratedQueryBuilder.toQuery().as(this.#alias);
+	}
+};
+/**
 * Implementation of the {@link HydratedQueryBuilder} interface as well as the
 * {@link MappedHydratedQueryBuilder} interface; there is no runtime distinction.
 */
@@ -594,6 +643,9 @@ var HydratedQueryBuilderImpl = class HydratedQueryBuilderImpl {
 			hydrator: this.#props.hydrator.map(transform)
 		});
 	}
+	as(alias) {
+		return new AliasedHydratedQueryBuilder(alias, this);
+	}
 	#hydrate(rows) {
 		const isArray = Array.isArray(rows);
 		const firstRow = isArray ? rows[0] : rows;
@@ -637,7 +689,7 @@ var HydratedQueryBuilderImpl = class HydratedQueryBuilderImpl {
 			hydrator: asFullHydrator(this.#props.hydrator).extend(hydrator)
 		});
 	}
-	#addJoin(mode, key, jb, keyBy = DEFAULT_KEY_BY) {
+	#has(mode, key, jb, keyBy = DEFAULT_KEY_BY) {
 		const outputNb = jb(new HydratedQueryBuilderImpl({
 			qb: this.#props.qb,
 			prefix: makePrefix(this.#props.prefix, key),
@@ -650,13 +702,13 @@ var HydratedQueryBuilderImpl = class HydratedQueryBuilderImpl {
 		});
 	}
 	hasMany(key, jb, keyBy) {
-		return this.#addJoin("many", key, jb, keyBy);
+		return this.#has("many", key, jb, keyBy);
 	}
 	hasOne(key, jb, keyBy) {
-		return this.#addJoin("one", key, jb, keyBy);
+		return this.#has("one", key, jb, keyBy);
 	}
 	hasOneOrThrow(key, jb, keyBy) {
-		return this.#addJoin("oneOrThrow", key, jb, keyBy);
+		return this.#has("oneOrThrow", key, jb, keyBy);
 	}
 	#addAttach(mode, key, fetchFn, keys) {
 		return new HydratedQueryBuilderImpl({
@@ -678,26 +730,49 @@ var HydratedQueryBuilderImpl = class HydratedQueryBuilderImpl {
 		return new HydratedQueryBuilderImpl({
 			...this.#props,
 			qb: this.#props.qb.select(prefixedSelections),
-			hydrator: asFullHydrator(this.#props.hydrator).fields(Object.fromEntries(prefixedSelections.map((selection$1) => [selection$1.originalName, true])))
+			hydrator: asFullHydrator(this.#props.hydrator).fields(prefixedSelections.map((selection$1) => selection$1.originalName))
+		});
+	}
+	#join(method, from, ...args) {
+		if (typeof from === "function") {
+			const result = from(k.expressionBuilder());
+			if (result instanceof AliasedHydratedQueryBuilder) return this.#joinHydrated(method, result, ...args);
+		} else if (from instanceof AliasedHydratedQueryBuilder) return this.#joinHydrated(method, from, ...args);
+		return this.modify((qb) => qb[method](from, ...args));
+	}
+	#joinHydrated(method, from, ...args) {
+		if (!args.length && (method === "leftJoinLateral" || method === "innerJoinLateral")) args = [(join) => join.onTrue()];
+		const aliasedQb = from.toAliasedQuery();
+		const hoistedSelections = hoistAndPrefixSelections(this.#props.prefix, aliasedQb);
+		const nestedHydrator = from.hydratedQueryBuilder.#props.hydrator;
+		let newQb = this.#props.qb;
+		newQb = newQb[method](aliasedQb, ...args);
+		newQb = newQb.select(hoistedSelections);
+		let newHydrator = asFullHydrator(this.#props.hydrator).extend(nestedHydrator);
+		newHydrator = ensureFields(newHydrator, hoistedSelections.map((selection) => selection.originalName).filter((name) => !hasAnyPrefix(name)));
+		return new HydratedQueryBuilderImpl({
+			...this.#props,
+			qb: newQb,
+			hydrator: newHydrator
 		});
 	}
 	innerJoin(...args) {
-		return this.modify((qb) => qb.innerJoin(...args));
+		return this.#join("innerJoin", ...args);
 	}
 	leftJoin(...args) {
-		return this.modify((qb) => qb.leftJoin(...args));
+		return this.#join("leftJoin", ...args);
 	}
 	crossJoin(...args) {
-		return this.modify((qb) => qb.crossJoin(...args));
+		return this.#join("crossJoin", ...args);
 	}
 	innerJoinLateral(...args) {
-		return this.modify((qb) => qb.innerJoinLateral(...args));
+		return this.#join("innerJoinLateral", ...args);
 	}
 	leftJoinLateral(...args) {
-		return this.modify((qb) => qb.leftJoinLateral(...args));
+		return this.#join("leftJoinLateral", ...args);
 	}
 	crossJoinLateral(...args) {
-		return this.modify((qb) => qb.crossJoinLateral(...args));
+		return this.#join("crossJoinLateral", ...args);
 	}
 };
 function hydrate(qb, keyBy = DEFAULT_KEY_BY) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely-hydrate",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Explicit ORM-style queries with Kysely",
   "license": "MIT",
   "author": {
@@ -30,6 +30,7 @@
     "build": "tsdown",
     "release": "./scripts/release.sh",
     "test": "node --test",
+    "test:postgres": "RUN_POSTGRES_TESTS=1 node --test src/query-builder.postgres.test.ts",
     "typecheck": "tsgo",
     "typecheck:tsc": "tsc",
     "lint": "oxlint",
@@ -46,12 +47,14 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22",
+    "@types/pg": "^8.16.0",
     "@typescript/native-preview": "^7.0.0-dev.20251207.1",
     "better-sqlite3": "^12.4.1",
     "expect-type": "^1.3.0",
     "kysely": "^0.28.7",
     "oxfmt": "^0.16.0",
     "oxlint": "^1.31.0",
+    "pg": "^8.16.3",
     "postgres-array": "^3.0.4",
     "tsdown": "^0.17.1",
     "typescript": "^5.9.3"