joist-knex 2.3.0-next.7 → 2.3.0-next.71

package/build/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/build/buildKnexQuery.cjs

@@ -0,0 +1,77 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils = require("./utils.cjs");
+let joist_core = require("joist-core");
+require("knex");
+//#region src/buildKnexQuery.ts
+/** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
+function buildKnexQuery(knex$1, parsed, settings) {
+	const { limit, offset } = settings;
+	const needsDistinct = parsed.tables.some((t) => t.join === "outer" && t.distinct !== false);
+	const asRaw = (t) => knex$1.raw(`${(0, joist_core.kq)(t.table)} as ${(0, joist_core.kq)(t.alias)}`);
+	const primary = parsed.tables.find((t) => t.join === "primary");
+	let query = knex$1.from(asRaw(primary));
+	parsed.selects.forEach((s, i) => {
+		const maybeDistinct = i === 0 && needsDistinct ? "distinct " : "";
+		if (typeof s === "string") query.select(knex$1.raw(`${maybeDistinct}${s}`));
+		else if ("sql" in s) query.select(knex$1.raw(`${maybeDistinct}${s.sql}`, s.bindings));
+	});
+	parsed.tables.forEach((t) => {
+		switch (t.join) {
+			case "inner":
+				query.join(asRaw(t), knex$1.raw(t.col1), knex$1.raw(t.col2));
+				break;
+			case "outer":
+				query.leftOuterJoin(asRaw(t), knex$1.raw(t.col1), knex$1.raw(t.col2));
+				break;
+			case "primary": break;
+			case "lateral":
+				const { sql, bindings } = buildKnexQuery(knex$1, t.query, {}).toSQL();
+				query.crossJoin(knex$1.raw(`lateral (${sql}) as ${(0, joist_core.kq)(t.alias)}`, bindings));
+				break;
+			case "cross":
+				query.crossJoin(asRaw(t));
+				break;
+			default: require_utils.assertNever(t);
+		}
+	});
+	if (parsed.condition) {
+		const subqueryRenderer = (q) => {
+			const { sql, bindings } = buildKnexQuery(knex$1, q, {}).toSQL();
+			return {
+				sql,
+				bindings
+			};
+		};
+		const where = joist_core.internals.buildWhereClause(parsed.condition, true, subqueryRenderer);
+		if (where) {
+			const [sql, bindings] = where;
+			query.whereRaw(sql, bindings);
+		}
+	}
+	parsed.orderBys && parsed.orderBys.forEach(({ alias, column, order }) => {
+		if (needsDistinct) query.select(knex$1.raw((0, joist_core.kqDot)(alias, column)));
+		query.orderBy(knex$1.raw((0, joist_core.kqDot)(alias, column)), order);
+	});
+	parsed.groupBys && parsed.groupBys.forEach((groupBy) => {
+		query.groupByRaw("expression" in groupBy ? groupBy.expression : (0, joist_core.kqDot)(groupBy.alias, groupBy.column));
+	});
+	if (parsed.ctes && parsed.ctes.length > 0) for (let i = 0; i < parsed.ctes.length; i++) {
+		const cte = parsed.ctes[i];
+		const args = [cte.alias];
+		if (cte.columns && cte.columns.length > 0) args.push(cte.columns.map((c) => c.columnName));
+		if (cte.query.kind === "raw") {
+			args.push(knex$1.raw(cte.query.sql));
+			if (cte.query.bindings) args.push(cte.query.bindings);
+		} else if (cte.query.kind === "ast") args.push(buildKnexQuery(knex$1, cte.query.query, {}));
+		else require_utils.assertNever(cte.query);
+		if (cte.recursive) query.withRecursive(...args);
+		else query.with(...args);
+	}
+	if (limit) query.limit(limit);
+	if (offset) query.offset(offset);
+	return query;
+}
+//#endregion
+exports.buildKnexQuery = buildKnexQuery;
+
+//# sourceMappingURL=buildKnexQuery.cjs.map

package/build/buildKnexQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildKnexQuery.cjs","names":["knex","kq","internals","kqDot"],"sources":["../src/buildKnexQuery.ts"],"sourcesContent":["import { type ParsedFindQuery, type ParsedTable, internals, kq, kqDot } from \"joist-core\";\nimport { type Knex } from \"knex\";\n\nimport { assertNever } from \"./utils.ts\";\n\n/** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */\nexport function buildKnexQuery(\n  knex: Knex,\n  parsed: ParsedFindQuery,\n  settings: { limit?: number; offset?: number },\n): Knex.QueryBuilder<{}, unknown[]> {\n  const { limit, offset } = settings;\n\n  // If we're doing o2m joins, add a `DISTINCT` clause to avoid duplicates\n  const needsDistinct = parsed.tables.some((t) => t.join === \"outer\" && t.distinct !== false);\n\n  // We need the `knex` param to call `knex.raw`\n  const asRaw = (t: ParsedTable) => knex.raw(`${kq(t.table)} as ${kq(t.alias)}`);\n\n  const primary = parsed.tables.find((t) => t.join === \"primary\")!;\n\n  let query: Knex.QueryBuilder<any, any> = knex.from(asRaw(primary));\n\n  parsed.selects.forEach((s, i) => {\n    const maybeDistinct = i === 0 && needsDistinct ? \"distinct \" : \"\";\n    if (typeof s === \"string\") {\n      query.select(knex.raw(`${maybeDistinct}${s}`));\n    } else if (\"sql\" in s) {\n      query.select(knex.raw(`${maybeDistinct}${s.sql}`, s.bindings));\n    }\n  });\n\n  parsed.tables.forEach((t) => {\n    switch (t.join) {\n      case \"inner\":\n        query.join(asRaw(t), knex.raw(t.col1) as any, knex.raw(t.col2));\n        break;\n      case \"outer\":\n        query.leftOuterJoin(asRaw(t), knex.raw(t.col1) as any, knex.raw(t.col2));\n        break;\n      case \"primary\":\n        // ignore\n        break;\n      case \"lateral\":\n        const { sql, bindings } = buildKnexQuery(knex, t.query, {}).toSQL();\n        query.crossJoin(knex.raw(`lateral (${sql}) as ${kq(t.alias)}`, bindings));\n        break;\n      case \"cross\":\n        query.crossJoin(asRaw(t));\n        break;\n      default:\n        assertNever(t);\n    }\n  });\n\n  if (parsed.condition) {\n    const subqueryRenderer = (q: ParsedFindQuery) => {\n      const { sql, bindings } = buildKnexQuery(knex, q, {}).toSQL();\n      return { sql, bindings };\n    };\n    const where = internals.buildWhereClause(parsed.condition, true, subqueryRenderer);\n    if (where) {\n      const [sql, bindings] = where;\n      query.whereRaw(sql, bindings);\n    }\n  }\n\n  parsed.orderBys &&\n    parsed.orderBys.forEach(({ alias, column, order }) => {\n      // If we're doing \"select distinct\" for o2m joins, then all order bys must be selects\n      if (needsDistinct) {\n        query.select(knex.raw(kqDot(alias, column)));\n      }\n      query.orderBy(knex.raw(kqDot(alias, column)) as any, order);\n    });\n\n  parsed.groupBys &&\n    parsed.groupBys.forEach((groupBy) => {\n      query.groupByRaw(\"expression\" in groupBy ? groupBy.expression : kqDot(groupBy.alias, groupBy.column));\n    });\n\n  if (parsed.ctes && parsed.ctes.length > 0) {\n    for (let i = 0; i < parsed.ctes.length; i++) {\n      const cte = parsed.ctes[i];\n      const args: Parameters<(typeof query)[\"with\"]> = [cte.alias] as any;\n      if (cte.columns && cte.columns.length > 0) args.push(cte.columns.map((c) => c.columnName) as any);\n      if (cte.query.kind === \"raw\") {\n        args.push(knex.raw(cte.query.sql) as any);\n        if (cte.query.bindings) args.push(cte.query.bindings as any);\n      } else if (cte.query.kind === \"ast\") {\n        args.push(buildKnexQuery(knex, cte.query.query, {}) as any);\n      } else {\n        assertNever(cte.query);\n      }\n      if (cte.recursive) {\n        query.withRecursive(...args);\n      } else {\n        query.with(...args);\n      }\n    }\n  }\n\n  if (limit) query.limit(limit);\n  if (offset) query.offset(offset);\n\n  return query;\n}\n"],"mappings":"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"}

package/build/buildKnexQuery.d.cts

@@ -0,0 +1,11 @@
+import { ParsedFindQuery } from "joist-core";
+import { Knex } from "knex";
+//#region src/buildKnexQuery.d.ts
+/** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
+declare function buildKnexQuery(knex: Knex, parsed: ParsedFindQuery, settings: {
+  limit?: number;
+  offset?: number;
+}): Knex.QueryBuilder<{}, unknown[]>;
+//#endregion
+export { buildKnexQuery };
+//# sourceMappingURL=buildKnexQuery.d.cts.map

package/build/buildKnexQuery.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildKnexQuery.d.cts","names":[],"sources":["../src/buildKnexQuery.ts"],"mappings":";;;;iBAMgB,eACd,MAAM,MACN,QAAQ,iBACR;EAAY;EAAgB;IAC3B,KAAK"}

package/build/buildKnexQuery.d.mts

@@ -0,0 +1,11 @@
+import { ParsedFindQuery } from "joist-core";
+import { Knex } from "knex";
+//#region src/buildKnexQuery.d.ts
+/** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
+declare function buildKnexQuery(knex: Knex, parsed: ParsedFindQuery, settings: {
+  limit?: number;
+  offset?: number;
+}): Knex.QueryBuilder<{}, unknown[]>;
+//#endregion
+export { buildKnexQuery };
+//# sourceMappingURL=buildKnexQuery.d.mts.map

package/build/buildKnexQuery.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildKnexQuery.d.mts","names":[],"sources":["../src/buildKnexQuery.ts"],"mappings":";;;;iBAMgB,eACd,MAAM,MACN,QAAQ,iBACR;EAAY;EAAgB;IAC3B,KAAK"}

package/build/buildKnexQuery.js

@@ -1,100 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildKnexQuery = buildKnexQuery;
-const joist_core_1 = require("joist-core");
-const utils_1 = require("./utils");
+import { assertNever } from "./utils.js";
+import { internals, kq, kqDot } from "joist-core";
+import "knex";
+//#region src/buildKnexQuery.ts
 /** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
 function buildKnexQuery(knex, parsed, settings) {
-    const { limit, offset } = settings;
-    // If we're doing o2m joins, add a `DISTINCT` clause to avoid duplicates
-    const needsDistinct = parsed.tables.some((t) => t.join === "outer" && t.distinct !== false);
-    // We need the `knex` param to call `knex.raw`
-    const asRaw = (t) => knex.raw(`${(0, joist_core_1.kq)(t.table)} as ${(0, joist_core_1.kq)(t.alias)}`);
-    const primary = parsed.tables.find((t) => t.join === "primary");
-    let query = knex.from(asRaw(primary));
-    parsed.selects.forEach((s, i) => {
-        const maybeDistinct = i === 0 && needsDistinct ? "distinct " : "";
-        if (typeof s === "string") {
-            query.select(knex.raw(`${maybeDistinct}${s}`));
-        }
-        else if ("sql" in s) {
-            query.select(knex.raw(`${maybeDistinct}${s.sql}`, s.bindings));
-        }
-    });
-    parsed.tables.forEach((t) => {
-        switch (t.join) {
-            case "inner":
-                query.join(asRaw(t), knex.raw(t.col1), knex.raw(t.col2));
-                break;
-            case "outer":
-                query.leftOuterJoin(asRaw(t), knex.raw(t.col1), knex.raw(t.col2));
-                break;
-            case "primary":
-                // ignore
-                break;
-            case "lateral":
-                const { sql, bindings } = buildKnexQuery(knex, t.query, {}).toSQL();
-                query.crossJoin(knex.raw(`lateral (${sql}) as ${(0, joist_core_1.kq)(t.alias)}`, bindings));
-                break;
-            case "cross":
-                query.crossJoin(asRaw(t));
-                break;
-            default:
-                (0, utils_1.assertNever)(t);
-        }
-    });
-    if (parsed.condition) {
-        const subqueryRenderer = (q) => {
-            const { sql, bindings } = buildKnexQuery(knex, q, {}).toSQL();
-            return { sql, bindings };
-        };
-        const where = joist_core_1.internals.buildWhereClause(parsed.condition, true, subqueryRenderer);
-        if (where) {
-            const [sql, bindings] = where;
-            query.whereRaw(sql, bindings);
-        }
-    }
-    parsed.orderBys &&
-        parsed.orderBys.forEach(({ alias, column, order }) => {
-            // If we're doing "select distinct" for o2m joins, then all order bys must be selects
-            if (needsDistinct) {
-                query.select(knex.raw((0, joist_core_1.kqDot)(alias, column)));
-            }
-            query.orderBy(knex.raw((0, joist_core_1.kqDot)(alias, column)), order);
-        });
-    parsed.groupBys &&
-        parsed.groupBys.forEach((groupBy) => {
-            query.groupByRaw("expression" in groupBy ? groupBy.expression : (0, joist_core_1.kqDot)(groupBy.alias, groupBy.column));
-        });
-    if (parsed.ctes && parsed.ctes.length > 0) {
-        for (let i = 0; i < parsed.ctes.length; i++) {
-            const cte = parsed.ctes[i];
-            const args = [cte.alias];
-            if (cte.columns && cte.columns.length > 0)
-                args.push(cte.columns.map((c) => c.columnName));
-            if (cte.query.kind === "raw") {
-                args.push(knex.raw(cte.query.sql));
-                if (cte.query.bindings)
-                    args.push(cte.query.bindings);
-            }
-            else if (cte.query.kind === "ast") {
-                args.push(buildKnexQuery(knex, cte.query.query, {}));
-            }
-            else {
-                (0, utils_1.assertNever)(cte.query);
-            }
-            if (cte.recursive) {
-                query.withRecursive(...args);
-            }
-            else {
-                query.with(...args);
-            }
-        }
-    }
-    if (limit)
-        query.limit(limit);
-    if (offset)
-        query.offset(offset);
-    return query;
+	const { limit, offset } = settings;
+	const needsDistinct = parsed.tables.some((t) => t.join === "outer" && t.distinct !== false);
+	const asRaw = (t) => knex.raw(`${kq(t.table)} as ${kq(t.alias)}`);
+	const primary = parsed.tables.find((t) => t.join === "primary");
+	let query = knex.from(asRaw(primary));
+	parsed.selects.forEach((s, i) => {
+		const maybeDistinct = i === 0 && needsDistinct ? "distinct " : "";
+		if (typeof s === "string") query.select(knex.raw(`${maybeDistinct}${s}`));
+		else if ("sql" in s) query.select(knex.raw(`${maybeDistinct}${s.sql}`, s.bindings));
+	});
+	parsed.tables.forEach((t) => {
+		switch (t.join) {
+			case "inner":
+				query.join(asRaw(t), knex.raw(t.col1), knex.raw(t.col2));
+				break;
+			case "outer":
+				query.leftOuterJoin(asRaw(t), knex.raw(t.col1), knex.raw(t.col2));
+				break;
+			case "primary": break;
+			case "lateral":
+				const { sql, bindings } = buildKnexQuery(knex, t.query, {}).toSQL();
+				query.crossJoin(knex.raw(`lateral (${sql}) as ${kq(t.alias)}`, bindings));
+				break;
+			case "cross":
+				query.crossJoin(asRaw(t));
+				break;
+			default: assertNever(t);
+		}
+	});
+	if (parsed.condition) {
+		const subqueryRenderer = (q) => {
+			const { sql, bindings } = buildKnexQuery(knex, q, {}).toSQL();
+			return {
+				sql,
+				bindings
+			};
+		};
+		const where = internals.buildWhereClause(parsed.condition, true, subqueryRenderer);
+		if (where) {
+			const [sql, bindings] = where;
+			query.whereRaw(sql, bindings);
+		}
+	}
+	parsed.orderBys && parsed.orderBys.forEach(({ alias, column, order }) => {
+		if (needsDistinct) query.select(knex.raw(kqDot(alias, column)));
+		query.orderBy(knex.raw(kqDot(alias, column)), order);
+	});
+	parsed.groupBys && parsed.groupBys.forEach((groupBy) => {
+		query.groupByRaw("expression" in groupBy ? groupBy.expression : kqDot(groupBy.alias, groupBy.column));
+	});
+	if (parsed.ctes && parsed.ctes.length > 0) for (let i = 0; i < parsed.ctes.length; i++) {
+		const cte = parsed.ctes[i];
+		const args = [cte.alias];
+		if (cte.columns && cte.columns.length > 0) args.push(cte.columns.map((c) => c.columnName));
+		if (cte.query.kind === "raw") {
+			args.push(knex.raw(cte.query.sql));
+			if (cte.query.bindings) args.push(cte.query.bindings);
+		} else if (cte.query.kind === "ast") args.push(buildKnexQuery(knex, cte.query.query, {}));
+		else assertNever(cte.query);
+		if (cte.recursive) query.withRecursive(...args);
+		else query.with(...args);
+	}
+	if (limit) query.limit(limit);
+	if (offset) query.offset(offset);
+	return query;
 }
+//#endregion
+export { buildKnexQuery };
+
 //# sourceMappingURL=buildKnexQuery.js.map

package/build/buildKnexQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildKnexQuery.js","sourceRoot":"","sources":["../src/buildKnexQuery.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"buildKnexQuery.js","names":[],"sources":["../src/buildKnexQuery.ts"],"sourcesContent":["import { type ParsedFindQuery, type ParsedTable, internals, kq, kqDot } from \"joist-core\";\nimport { type Knex } from \"knex\";\n\nimport { assertNever } from \"./utils.ts\";\n\n/** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */\nexport function buildKnexQuery(\n  knex: Knex,\n  parsed: ParsedFindQuery,\n  settings: { limit?: number; offset?: number },\n): Knex.QueryBuilder<{}, unknown[]> {\n  const { limit, offset } = settings;\n\n  // If we're doing o2m joins, add a `DISTINCT` clause to avoid duplicates\n  const needsDistinct = parsed.tables.some((t) => t.join === \"outer\" && t.distinct !== false);\n\n  // We need the `knex` param to call `knex.raw`\n  const asRaw = (t: ParsedTable) => knex.raw(`${kq(t.table)} as ${kq(t.alias)}`);\n\n  const primary = parsed.tables.find((t) => t.join === \"primary\")!;\n\n  let query: Knex.QueryBuilder<any, any> = knex.from(asRaw(primary));\n\n  parsed.selects.forEach((s, i) => {\n    const maybeDistinct = i === 0 && needsDistinct ? \"distinct \" : \"\";\n    if (typeof s === \"string\") {\n      query.select(knex.raw(`${maybeDistinct}${s}`));\n    } else if (\"sql\" in s) {\n      query.select(knex.raw(`${maybeDistinct}${s.sql}`, s.bindings));\n    }\n  });\n\n  parsed.tables.forEach((t) => {\n    switch (t.join) {\n      case \"inner\":\n        query.join(asRaw(t), knex.raw(t.col1) as any, knex.raw(t.col2));\n        break;\n      case \"outer\":\n        query.leftOuterJoin(asRaw(t), knex.raw(t.col1) as any, knex.raw(t.col2));\n        break;\n      case \"primary\":\n        // ignore\n        break;\n      case \"lateral\":\n        const { sql, bindings } = buildKnexQuery(knex, t.query, {}).toSQL();\n        query.crossJoin(knex.raw(`lateral (${sql}) as ${kq(t.alias)}`, bindings));\n        break;\n      case \"cross\":\n        query.crossJoin(asRaw(t));\n        break;\n      default:\n        assertNever(t);\n    }\n  });\n\n  if (parsed.condition) {\n    const subqueryRenderer = (q: ParsedFindQuery) => {\n      const { sql, bindings } = buildKnexQuery(knex, q, {}).toSQL();\n      return { sql, bindings };\n    };\n    const where = internals.buildWhereClause(parsed.condition, true, subqueryRenderer);\n    if (where) {\n      const [sql, bindings] = where;\n      query.whereRaw(sql, bindings);\n    }\n  }\n\n  parsed.orderBys &&\n    parsed.orderBys.forEach(({ alias, column, order }) => {\n      // If we're doing \"select distinct\" for o2m joins, then all order bys must be selects\n      if (needsDistinct) {\n        query.select(knex.raw(kqDot(alias, column)));\n      }\n      query.orderBy(knex.raw(kqDot(alias, column)) as any, order);\n    });\n\n  parsed.groupBys &&\n    parsed.groupBys.forEach((groupBy) => {\n      query.groupByRaw(\"expression\" in groupBy ? groupBy.expression : kqDot(groupBy.alias, groupBy.column));\n    });\n\n  if (parsed.ctes && parsed.ctes.length > 0) {\n    for (let i = 0; i < parsed.ctes.length; i++) {\n      const cte = parsed.ctes[i];\n      const args: Parameters<(typeof query)[\"with\"]> = [cte.alias] as any;\n      if (cte.columns && cte.columns.length > 0) args.push(cte.columns.map((c) => c.columnName) as any);\n      if (cte.query.kind === \"raw\") {\n        args.push(knex.raw(cte.query.sql) as any);\n        if (cte.query.bindings) args.push(cte.query.bindings as any);\n      } else if (cte.query.kind === \"ast\") {\n        args.push(buildKnexQuery(knex, cte.query.query, {}) as any);\n      } else {\n        assertNever(cte.query);\n      }\n      if (cte.recursive) {\n        query.withRecursive(...args);\n      } else {\n        query.with(...args);\n      }\n    }\n  }\n\n  if (limit) query.limit(limit);\n  if (offset) query.offset(offset);\n\n  return query;\n}\n"],"mappings":";;;;;AAMA,SAAgB,eACd,MACA,QACA,UACkC;CAClC,MAAM,EAAE,OAAO,WAAW;CAG1B,MAAM,gBAAgB,OAAO,OAAO,MAAM,MAAM,EAAE,SAAS,WAAW,EAAE,aAAa,KAAK;CAG1F,MAAM,SAAS,MAAmB,KAAK,IAAI,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,EAAE,KAAK,GAAG;CAE7E,MAAM,UAAU,OAAO,OAAO,MAAM,MAAM,EAAE,SAAS,SAAS;CAE9D,IAAI,QAAqC,KAAK,KAAK,MAAM,OAAO,CAAC;CAEjE,OAAO,QAAQ,SAAS,GAAG,MAAM;EAC/B,MAAM,gBAAgB,MAAM,KAAK,gBAAgB,cAAc;EAC/D,IAAI,OAAO,MAAM,UACf,MAAM,OAAO,KAAK,IAAI,GAAG,gBAAgB,GAAG,CAAC;OACxC,IAAI,SAAS,GAClB,MAAM,OAAO,KAAK,IAAI,GAAG,gBAAgB,EAAE,OAAO,EAAE,QAAQ,CAAC;CAEjE,CAAC;CAED,OAAO,OAAO,SAAS,MAAM;EAC3B,QAAQ,EAAE,MAAV;GACE,KAAK;IACH,MAAM,KAAK,MAAM,CAAC,GAAG,KAAK,IAAI,EAAE,IAAI,GAAU,KAAK,IAAI,EAAE,IAAI,CAAC;IAC9D;GACF,KAAK;IACH,MAAM,cAAc,MAAM,CAAC,GAAG,KAAK,IAAI,EAAE,IAAI,GAAU,KAAK,IAAI,EAAE,IAAI,CAAC;IACvE;GACF,KAAK,WAEH;GACF,KAAK;IACH,MAAM,EAAE,KAAK,aAAa,eAAe,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM;IAClE,MAAM,UAAU,KAAK,IAAI,YAAY,IAAI,OAAO,GAAG,EAAE,KAAK,KAAK,QAAQ,CAAC;IACxE;GACF,KAAK;IACH,MAAM,UAAU,MAAM,CAAC,CAAC;IACxB;GACF,SACE,YAAY,CAAC;EACjB;CACF,CAAC;CAED,IAAI,OAAO,WAAW;EACpB,MAAM,oBAAoB,MAAuB;GAC/C,MAAM,EAAE,KAAK,aAAa,eAAe,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM;GAC5D,OAAO;IAAE;IAAK;GAAS;EACzB;EACA,MAAM,QAAQ,UAAU,iBAAiB,OAAO,WAAW,MAAM,gBAAgB;EACjF,IAAI,OAAO;GACT,MAAM,CAAC,KAAK,YAAY;GACxB,MAAM,SAAS,KAAK,QAAQ;EAC9B;CACF;CAEA,OAAO,YACL,OAAO,SAAS,SAAS,EAAE,OAAO,QAAQ,YAAY;EAEpD,IAAI,eACF,MAAM,OAAO,KAAK,IAAI,MAAM,OAAO,MAAM,CAAC,CAAC;EAE7C,MAAM,QAAQ,KAAK,IAAI,MAAM,OAAO,MAAM,CAAC,GAAU,KAAK;CAC5D,CAAC;CAEH,OAAO,YACL,OAAO,SAAS,SAAS,YAAY;EACnC,MAAM,WAAW,gBAAgB,UAAU,QAAQ,aAAa,MAAM,QAAQ,OAAO,QAAQ,MAAM,CAAC;CACtG,CAAC;CAEH,IAAI,OAAO,QAAQ,OAAO,KAAK,SAAS,GACtC,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK,QAAQ,KAAK;EAC3C,MAAM,MAAM,OAAO,KAAK;EACxB,MAAM,OAA2C,CAAC,IAAI,KAAK;EAC3D,IAAI,IAAI,WAAW,IAAI,QAAQ,SAAS,GAAG,KAAK,KAAK,IAAI,QAAQ,KAAK,MAAM,EAAE,UAAU,CAAQ;EAChG,IAAI,IAAI,MAAM,SAAS,OAAO;GAC5B,KAAK,KAAK,KAAK,IAAI,IAAI,MAAM,GAAG,CAAQ;GACxC,IAAI,IAAI,MAAM,UAAU,KAAK,KAAK,IAAI,MAAM,QAAe;EAC7D,OAAO,IAAI,IAAI,MAAM,SAAS,OAC5B,KAAK,KAAK,eAAe,MAAM,IAAI,MAAM,OAAO,CAAC,CAAC,CAAQ;OAE1D,YAAY,IAAI,KAAK;EAEvB,IAAI,IAAI,WACN,MAAM,cAAc,GAAG,IAAI;OAE3B,MAAM,KAAK,GAAG,IAAI;CAEtB;CAGF,IAAI,OAAO,MAAM,MAAM,KAAK;CAC5B,IAAI,QAAQ,MAAM,OAAO,MAAM;CAE/B,OAAO;AACT"}

package/build/index.cjs

@@ -0,0 +1,90 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_buildKnexQuery = require("./buildKnexQuery.cjs");
+let joist_core = require("joist-core");
+let knex = require("knex");
+knex = require_runtime.__toESM(knex, 1);
+let pg = require("pg");
+pg = require_runtime.__toESM(pg, 1);
+//#region src/index.ts
+const { knex: baseCreateKnex } = knex.default;
+/**
+* Builds the Knex queries from `em.find`-style parameters.
+*
+* This is useful for the "last 5%" of SQL queries that require SQL features that `em.find`
+* itself doesn't support, i.e. primarily aggregation, but also complicated joins. etc.
+*
+* You can also `buildQuery` to get the regular `em.find` niceties around great join syntax,
+* join pruning, inline conditions, etc., but then take the `QueryBuilder` that it produces
+* and "muck with it". I.e. add different order bys, group bys, etc.
+*
+* The Knex API is actually well-suited for this, as it provides structure-aware methods like
+* `clearOrder`, `clearSelect`, etc. that mean you can munge the initial query without any
+* complicated string parsing.
+*
+* @param knex The Knex instance to use for building the query.
+* @param type The primary entity type that `filter` is based on.
+* @param filter[keepAliases] Marks specific aliases to keep in the query, even if they are not used
+*   by any selects or conditions, i.e. because you plan on adding your own joins/conditions
+*   against the `QueryBuilder` directly.
+* @param filter[pruneJoins] Disables removing any unused joins, i.e. because you plan on adding your
+*   own joins/conditions against the `QueryBuilder` directly.
+* @param filter[allowMultipleLeftJoins] Allows multiple fanout LEFT JOINs when Joist cannot express
+*   an alias condition as EXISTS.
+* @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because
+*   you plan on adding selects/grouping against collection aliases after Joist builds the query.
+*/
+function buildQuery(knex$2, type, filter) {
+	const meta = (0, joist_core.getMetadata)(type);
+	const { where, conditions, orderBy, limit, offset, pruneJoins = true, keepAliases = [], allowMultipleLeftJoins = false, optimizeJoinsToExists = true, softDeletes = "exclude" } = filter;
+	const parsed = (0, joist_core.parseFindQuery)(meta, where, {
+		conditions,
+		orderBy,
+		keepAliases,
+		softDeletes
+	});
+	(0, joist_core.optimizeCollectionJoins)(parsed, {
+		allowMultipleLeftJoins,
+		optimizeJoinsToExists,
+		pruneJoins,
+		keepAliases
+	});
+	return require_buildKnexQuery.buildKnexQuery(knex$2, parsed, {
+		limit,
+		offset
+	});
+}
+/**
+* Creates a Knex instance that delegates to an existing pg Pool or PoolClient
+* instead of managing its own internal connection pool.
+*
+* When given a `pg.Pool`, each knex query acquires a connection from the pool and
+* releases it when the query completes.
+*
+* When given a `pg.PoolClient`, all knex queries run on that specific client. This
+* is useful when the client has an open transaction (via `BEGIN`) — the knex queries
+* will participate in that transaction and be affected by `COMMIT`/`ROLLBACK`.
+*
+* The returned Knex instance has no internal pool, so there is no need to call
+* `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
+*/
+function createKnex(poolOrClient) {
+	const knex$3 = baseCreateKnex({
+		client: "pg",
+		connection: {},
+		pool: { max: 0 }
+	});
+	if (poolOrClient instanceof pg.default.Pool) {
+		knex$3.client.acquireConnection = () => poolOrClient.connect();
+		knex$3.client.releaseConnection = (conn) => conn.release();
+	} else {
+		knex$3.client.acquireConnection = () => poolOrClient;
+		knex$3.client.releaseConnection = () => {};
+	}
+	return knex$3;
+}
+//#endregion
+exports.buildQuery = buildQuery;
+exports.createKnex = createKnex;
+
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["getMetadata","parseFindQuery","buildKnexQuery","knex"],"sources":["../src/index.ts"],"sourcesContent":["import {\n  type Entity,\n  type FilterAndSettings,\n  type MaybeAbstractEntityConstructor,\n  getMetadata,\n  optimizeCollectionJoins,\n  parseFindQuery,\n} from \"joist-core\";\nimport knex, { type Knex } from \"knex\";\nimport pg from \"pg\";\n\nimport { buildKnexQuery } from \"./buildKnexQuery.ts\";\n\nconst { knex: baseCreateKnex } = knex;\n\n/**\n * Builds the Knex queries from `em.find`-style parameters.\n *\n * This is useful for the \"last 5%\" of SQL queries that require SQL features that `em.find`\n * itself doesn't support, i.e. primarily aggregation, but also complicated joins. etc.\n *\n * You can also `buildQuery` to get the regular `em.find` niceties around great join syntax,\n * join pruning, inline conditions, etc., but then take the `QueryBuilder` that it produces\n * and \"muck with it\". I.e. add different order bys, group bys, etc.\n *\n * The Knex API is actually well-suited for this, as it provides structure-aware methods like\n * `clearOrder`, `clearSelect`, etc. that mean you can munge the initial query without any\n * complicated string parsing.\n *\n * @param knex The Knex instance to use for building the query.\n * @param type The primary entity type that `filter` is based on.\n * @param filter[keepAliases] Marks specific aliases to keep in the query, even if they are not used\n *   by any selects or conditions, i.e. because you plan on adding your own joins/conditions\n *   against the `QueryBuilder` directly.\n * @param filter[pruneJoins] Disables removing any unused joins, i.e. because you plan on adding your\n *   own joins/conditions against the `QueryBuilder` directly.\n * @param filter[allowMultipleLeftJoins] Allows multiple fanout LEFT JOINs when Joist cannot express\n *   an alias condition as EXISTS.\n * @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because\n *   you plan on adding selects/grouping against collection aliases after Joist builds the query.\n */\nexport function buildQuery<T extends Entity>(\n  knex: Knex,\n  type: MaybeAbstractEntityConstructor<T>,\n  filter: FilterAndSettings<T> & {\n    pruneJoins?: boolean;\n    keepAliases?: string[];\n    allowMultipleLeftJoins?: boolean;\n    optimizeJoinsToExists?: boolean;\n  },\n): Knex.QueryBuilder<{}, unknown[]> {\n  const meta = getMetadata(type);\n  const {\n    where,\n    conditions,\n    orderBy,\n    limit,\n    offset,\n    pruneJoins = true,\n    keepAliases = [],\n    allowMultipleLeftJoins = false,\n    optimizeJoinsToExists = true,\n    softDeletes = \"exclude\",\n  } = filter;\n  const parsed = parseFindQuery(meta, where, {\n    conditions,\n    orderBy,\n    keepAliases,\n    softDeletes,\n  });\n  optimizeCollectionJoins(parsed, { allowMultipleLeftJoins, optimizeJoinsToExists, pruneJoins, keepAliases });\n  return buildKnexQuery(knex, parsed, { limit, offset });\n}\n\n/**\n * Creates a Knex instance that delegates to an existing pg Pool or PoolClient\n * instead of managing its own internal connection pool.\n *\n * When given a `pg.Pool`, each knex query acquires a connection from the pool and\n * releases it when the query completes.\n *\n * When given a `pg.PoolClient`, all knex queries run on that specific client. This\n * is useful when the client has an open transaction (via `BEGIN`) — the knex queries\n * will participate in that transaction and be affected by `COMMIT`/`ROLLBACK`.\n *\n * The returned Knex instance has no internal pool, so there is no need to call\n * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.\n */\nexport function createKnex(poolOrClient: pg.Pool | pg.PoolClient): Knex {\n  const knex = baseCreateKnex({ client: \"pg\", connection: {}, pool: { max: 0 } });\n  if (poolOrClient instanceof pg.Pool) {\n    knex.client.acquireConnection = () => poolOrClient.connect();\n    knex.client.releaseConnection = (conn: pg.PoolClient) => conn.release();\n  } else {\n    knex.client.acquireConnection = () => poolOrClient;\n    knex.client.releaseConnection = () => {};\n  }\n  return knex;\n}\n"],"mappings":";;;;;;;;;AAaA,MAAM,EAAE,MAAM,mBAAmB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BjC,SAAgB,WACd,QACA,MACA,QAMkC;CAClC,MAAM,QAAA,GAAOA,WAAAA,YAAAA,CAAY,IAAI;CAC7B,MAAM,EACJ,OACA,YACA,SACA,OACA,QACA,aAAa,MACb,cAAc,CAAC,GACf,yBAAyB,OACzB,wBAAwB,MACxB,cAAc,cACZ;CACJ,MAAM,UAAA,GAASC,WAAAA,eAAAA,CAAe,MAAM,OAAO;EACzC;EACA;EACA;EACA;CACF,CAAC;CACD,CAAA,GAAA,WAAA,wBAAA,CAAwB,QAAQ;EAAE;EAAwB;EAAuB;EAAY;CAAY,CAAC;CAC1G,OAAOC,uBAAAA,eAAeC,QAAM,QAAQ;EAAE;EAAO;CAAO,CAAC;AACvD;;;;;;;;;;;;;;;AAgBA,SAAgB,WAAW,cAA6C;CACtE,MAAMA,SAAO,eAAe;EAAE,QAAQ;EAAM,YAAY,CAAC;EAAG,MAAM,EAAE,KAAK,EAAE;CAAE,CAAC;CAC9E,IAAI,wBAAwB,GAAA,QAAG,MAAM;EACnC,OAAK,OAAO,0BAA0B,aAAa,QAAQ;EAC3D,OAAK,OAAO,qBAAqB,SAAwB,KAAK,QAAQ;CACxE,OAAO;EACL,OAAK,OAAO,0BAA0B;EACtC,OAAK,OAAO,0BAA0B,CAAC;CACzC;CACA,OAAOA;AACT"}

package/build/{index.d.ts → index.d.cts}

@@ -1,6 +1,7 @@
 import { Entity, FilterAndSettings, MaybeAbstractEntityConstructor } from "joist-core";
 import { Knex } from "knex";
 import pg from "pg";
+//#region src/index.d.ts
 /**
  * Builds the Knex queries from `em.find`-style parameters.
  *
@@ -27,11 +28,11 @@ import pg from "pg";
  * @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because
  *   you plan on adding selects/grouping against collection aliases after Joist builds the query.
  */
-export declare function buildQuery<T extends Entity>(knex: Knex, type: MaybeAbstractEntityConstructor<T>, filter: FilterAndSettings<T> & {
-    pruneJoins?: boolean;
-    keepAliases?: string[];
-    allowMultipleLeftJoins?: boolean;
-    optimizeJoinsToExists?: boolean;
+declare function buildQuery<T extends Entity>(knex: Knex, type: MaybeAbstractEntityConstructor<T>, filter: FilterAndSettings<T> & {
+  pruneJoins?: boolean;
+  keepAliases?: string[];
+  allowMultipleLeftJoins?: boolean;
+  optimizeJoinsToExists?: boolean;
 }): Knex.QueryBuilder<{}, unknown[]>;
 /**
  * Creates a Knex instance that delegates to an existing pg Pool or PoolClient
@@ -47,5 +48,7 @@ export declare function buildQuery<T extends Entity>(knex: Knex, type: MaybeAbst
  * The returned Knex instance has no internal pool, so there is no need to call
  * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
  */
-export declare function createKnex(poolOrClient: pg.Pool | pg.PoolClient): Knex;
-//# sourceMappingURL=index.d.ts.map
+declare function createKnex(poolOrClient: pg.Pool | pg.PoolClient): Knex;
+//#endregion
+export { buildQuery, createKnex };
+//# sourceMappingURL=index.d.cts.map

package/build/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCgB,WAAW,UAAU,QACnC,MAAM,MACN,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB;EACxB;EACA;EACA;EACA;IAED,KAAK;;;;;;;;;;;;;;;iBAsCQ,WAAW,cAAc,GAAG,OAAO,GAAG,aAAa"}

package/build/index.d.mts

@@ -0,0 +1,54 @@
+import { Entity, FilterAndSettings, MaybeAbstractEntityConstructor } from "joist-core";
+import { Knex } from "knex";
+import pg from "pg";
+//#region src/index.d.ts
+/**
+ * Builds the Knex queries from `em.find`-style parameters.
+ *
+ * This is useful for the "last 5%" of SQL queries that require SQL features that `em.find`
+ * itself doesn't support, i.e. primarily aggregation, but also complicated joins. etc.
+ *
+ * You can also `buildQuery` to get the regular `em.find` niceties around great join syntax,
+ * join pruning, inline conditions, etc., but then take the `QueryBuilder` that it produces
+ * and "muck with it". I.e. add different order bys, group bys, etc.
+ *
+ * The Knex API is actually well-suited for this, as it provides structure-aware methods like
+ * `clearOrder`, `clearSelect`, etc. that mean you can munge the initial query without any
+ * complicated string parsing.
+ *
+ * @param knex The Knex instance to use for building the query.
+ * @param type The primary entity type that `filter` is based on.
+ * @param filter[keepAliases] Marks specific aliases to keep in the query, even if they are not used
+ *   by any selects or conditions, i.e. because you plan on adding your own joins/conditions
+ *   against the `QueryBuilder` directly.
+ * @param filter[pruneJoins] Disables removing any unused joins, i.e. because you plan on adding your
+ *   own joins/conditions against the `QueryBuilder` directly.
+ * @param filter[allowMultipleLeftJoins] Allows multiple fanout LEFT JOINs when Joist cannot express
+ *   an alias condition as EXISTS.
+ * @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because
+ *   you plan on adding selects/grouping against collection aliases after Joist builds the query.
+ */
+declare function buildQuery<T extends Entity>(knex: Knex, type: MaybeAbstractEntityConstructor<T>, filter: FilterAndSettings<T> & {
+  pruneJoins?: boolean;
+  keepAliases?: string[];
+  allowMultipleLeftJoins?: boolean;
+  optimizeJoinsToExists?: boolean;
+}): Knex.QueryBuilder<{}, unknown[]>;
+/**
+ * Creates a Knex instance that delegates to an existing pg Pool or PoolClient
+ * instead of managing its own internal connection pool.
+ *
+ * When given a `pg.Pool`, each knex query acquires a connection from the pool and
+ * releases it when the query completes.
+ *
+ * When given a `pg.PoolClient`, all knex queries run on that specific client. This
+ * is useful when the client has an open transaction (via `BEGIN`) — the knex queries
+ * will participate in that transaction and be affected by `COMMIT`/`ROLLBACK`.
+ *
+ * The returned Knex instance has no internal pool, so there is no need to call
+ * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
+ */
+declare function createKnex(poolOrClient: pg.Pool | pg.PoolClient): Knex;
+//#endregion
+export { buildQuery, createKnex };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCgB,WAAW,UAAU,QACnC,MAAM,MACN,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB;EACxB;EACA;EACA;EACA;IAED,KAAK;;;;;;;;;;;;;;;iBAsCQ,WAAW,cAAc,GAAG,OAAO,GAAG,aAAa"}

package/build/index.js

@@ -1,76 +1,85 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildQuery = buildQuery;
-exports.createKnex = createKnex;
-const joist_core_1 = require("joist-core");
-const knex_1 = require("knex");
-const pg_1 = __importDefault(require("pg"));
-const buildKnexQuery_1 = require("./buildKnexQuery");
+import { buildKnexQuery } from "./buildKnexQuery.js";
+import { getMetadata, optimizeCollectionJoins, parseFindQuery } from "joist-core";
+import knex from "knex";
+import pg from "pg";
+//#region src/index.ts
+const { knex: baseCreateKnex } = knex;
 /**
- * Builds the Knex queries from `em.find`-style parameters.
- *
- * This is useful for the "last 5%" of SQL queries that require SQL features that `em.find`
- * itself doesn't support, i.e. primarily aggregation, but also complicated joins. etc.
- *
- * You can also `buildQuery` to get the regular `em.find` niceties around great join syntax,
- * join pruning, inline conditions, etc., but then take the `QueryBuilder` that it produces
- * and "muck with it". I.e. add different order bys, group bys, etc.
- *
- * The Knex API is actually well-suited for this, as it provides structure-aware methods like
- * `clearOrder`, `clearSelect`, etc. that mean you can munge the initial query without any
- * complicated string parsing.
- *
- * @param knex The Knex instance to use for building the query.
- * @param type The primary entity type that `filter` is based on.
- * @param filter[keepAliases] Marks specific aliases to keep in the query, even if they are not used
- *   by any selects or conditions, i.e. because you plan on adding your own joins/conditions
- *   against the `QueryBuilder` directly.
- * @param filter[pruneJoins] Disables removing any unused joins, i.e. because you plan on adding your
- *   own joins/conditions against the `QueryBuilder` directly.
- * @param filter[allowMultipleLeftJoins] Allows multiple fanout LEFT JOINs when Joist cannot express
- *   an alias condition as EXISTS.
- * @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because
- *   you plan on adding selects/grouping against collection aliases after Joist builds the query.
- */
+* Builds the Knex queries from `em.find`-style parameters.
+*
+* This is useful for the "last 5%" of SQL queries that require SQL features that `em.find`
+* itself doesn't support, i.e. primarily aggregation, but also complicated joins. etc.
+*
+* You can also `buildQuery` to get the regular `em.find` niceties around great join syntax,
+* join pruning, inline conditions, etc., but then take the `QueryBuilder` that it produces
+* and "muck with it". I.e. add different order bys, group bys, etc.
+*
+* The Knex API is actually well-suited for this, as it provides structure-aware methods like
+* `clearOrder`, `clearSelect`, etc. that mean you can munge the initial query without any
+* complicated string parsing.
+*
+* @param knex The Knex instance to use for building the query.
+* @param type The primary entity type that `filter` is based on.
+* @param filter[keepAliases] Marks specific aliases to keep in the query, even if they are not used
+*   by any selects or conditions, i.e. because you plan on adding your own joins/conditions
+*   against the `QueryBuilder` directly.
+* @param filter[pruneJoins] Disables removing any unused joins, i.e. because you plan on adding your
+*   own joins/conditions against the `QueryBuilder` directly.
+* @param filter[allowMultipleLeftJoins] Allows multiple fanout LEFT JOINs when Joist cannot express
+*   an alias condition as EXISTS.
+* @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because
+*   you plan on adding selects/grouping against collection aliases after Joist builds the query.
+*/
 function buildQuery(knex, type, filter) {
-    const meta = (0, joist_core_1.getMetadata)(type);
-    const { where, conditions, orderBy, limit, offset, pruneJoins = true, keepAliases = [], allowMultipleLeftJoins = false, optimizeJoinsToExists = true, softDeletes = "exclude", } = filter;
-    const parsed = (0, joist_core_1.parseFindQuery)(meta, where, {
-        conditions,
-        orderBy,
-        keepAliases,
-        softDeletes,
-    });
-    (0, joist_core_1.optimizeCollectionJoins)(parsed, { allowMultipleLeftJoins, optimizeJoinsToExists, pruneJoins, keepAliases });
-    return (0, buildKnexQuery_1.buildKnexQuery)(knex, parsed, { limit, offset });
+	const meta = getMetadata(type);
+	const { where, conditions, orderBy, limit, offset, pruneJoins = true, keepAliases = [], allowMultipleLeftJoins = false, optimizeJoinsToExists = true, softDeletes = "exclude" } = filter;
+	const parsed = parseFindQuery(meta, where, {
+		conditions,
+		orderBy,
+		keepAliases,
+		softDeletes
+	});
+	optimizeCollectionJoins(parsed, {
+		allowMultipleLeftJoins,
+		optimizeJoinsToExists,
+		pruneJoins,
+		keepAliases
+	});
+	return buildKnexQuery(knex, parsed, {
+		limit,
+		offset
+	});
 }
 /**
- * Creates a Knex instance that delegates to an existing pg Pool or PoolClient
- * instead of managing its own internal connection pool.
- *
- * When given a `pg.Pool`, each knex query acquires a connection from the pool and
- * releases it when the query completes.
- *
- * When given a `pg.PoolClient`, all knex queries run on that specific client. This
- * is useful when the client has an open transaction (via `BEGIN`) — the knex queries
- * will participate in that transaction and be affected by `COMMIT`/`ROLLBACK`.
- *
- * The returned Knex instance has no internal pool, so there is no need to call
- * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
- */
+* Creates a Knex instance that delegates to an existing pg Pool or PoolClient
+* instead of managing its own internal connection pool.
+*
+* When given a `pg.Pool`, each knex query acquires a connection from the pool and
+* releases it when the query completes.
+*
+* When given a `pg.PoolClient`, all knex queries run on that specific client. This
+* is useful when the client has an open transaction (via `BEGIN`) — the knex queries
+* will participate in that transaction and be affected by `COMMIT`/`ROLLBACK`.
+*
+* The returned Knex instance has no internal pool, so there is no need to call
+* `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
+*/
 function createKnex(poolOrClient) {
-    const knex = (0, knex_1.knex)({ client: "pg", connection: {}, pool: { max: 0 } });
-    if (poolOrClient instanceof pg_1.default.Pool) {
-        knex.client.acquireConnection = () => poolOrClient.connect();
-        knex.client.releaseConnection = (conn) => conn.release();
-    }
-    else {
-        knex.client.acquireConnection = () => poolOrClient;
-        knex.client.releaseConnection = () => { };
-    }
-    return knex;
+	const knex = baseCreateKnex({
+		client: "pg",
+		connection: {},
+		pool: { max: 0 }
+	});
+	if (poolOrClient instanceof pg.Pool) {
+		knex.client.acquireConnection = () => poolOrClient.connect();
+		knex.client.releaseConnection = (conn) => conn.release();
+	} else {
+		knex.client.acquireConnection = () => poolOrClient;
+		knex.client.releaseConnection = () => {};
+	}
+	return knex;
 }
+//#endregion
+export { buildQuery, createKnex };
+
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAsCA,gCA+BC;AAgBD,gCAUC;AA/FD,2CAOoB;AACpB,+BAAoD;AACpD,4CAAoB;AACpB,qDAAkD;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,UAAU,CACxB,IAAU,EACV,IAAuC,EACvC,MAKC;IAED,MAAM,IAAI,GAAG,IAAA,wBAAW,EAAC,IAAI,CAAC,CAAC;IAC/B,MAAM,EACJ,KAAK,EACL,UAAU,EACV,OAAO,EACP,KAAK,EACL,MAAM,EACN,UAAU,GAAG,IAAI,EACjB,WAAW,GAAG,EAAE,EAChB,sBAAsB,GAAG,KAAK,EAC9B,qBAAqB,GAAG,IAAI,EAC5B,WAAW,GAAG,SAAS,GACxB,GAAG,MAAM,CAAC;IACX,MAAM,MAAM,GAAG,IAAA,2BAAc,EAAC,IAAI,EAAE,KAAK,EAAE;QACzC,UAAU;QACV,OAAO;QACP,WAAW;QACX,WAAW;KACZ,CAAC,CAAC;IACH,IAAA,oCAAuB,EAAC,MAAM,EAAE,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IAC5G,OAAO,IAAA,+BAAc,EAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,UAAU,CAAC,YAAqC;IAC9D,MAAM,IAAI,GAAG,IAAA,WAAc,EAAC,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IAChF,IAAI,YAAY,YAAY,YAAE,CAAC,IAAI,EAAE,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC7D,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,CAAC,IAAmB,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IAC1E,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC;QACnD,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import {\n  type Entity,\n  type FilterAndSettings,\n  type MaybeAbstractEntityConstructor,\n  getMetadata,\n  optimizeCollectionJoins,\n  parseFindQuery,\n} from \"joist-core\";\nimport knex, { type Knex } from \"knex\";\nimport pg from \"pg\";\n\nimport { buildKnexQuery } from \"./buildKnexQuery.ts\";\n\nconst { knex: baseCreateKnex } = knex;\n\n/**\n * Builds the Knex queries from `em.find`-style parameters.\n *\n * This is useful for the \"last 5%\" of SQL queries that require SQL features that `em.find`\n * itself doesn't support, i.e. primarily aggregation, but also complicated joins. etc.\n *\n * You can also `buildQuery` to get the regular `em.find` niceties around great join syntax,\n * join pruning, inline conditions, etc., but then take the `QueryBuilder` that it produces\n * and \"muck with it\". I.e. add different order bys, group bys, etc.\n *\n * The Knex API is actually well-suited for this, as it provides structure-aware methods like\n * `clearOrder`, `clearSelect`, etc. that mean you can munge the initial query without any\n * complicated string parsing.\n *\n * @param knex The Knex instance to use for building the query.\n * @param type The primary entity type that `filter` is based on.\n * @param filter[keepAliases] Marks specific aliases to keep in the query, even if they are not used\n *   by any selects or conditions, i.e. because you plan on adding your own joins/conditions\n *   against the `QueryBuilder` directly.\n * @param filter[pruneJoins] Disables removing any unused joins, i.e. because you plan on adding your\n *   own joins/conditions against the `QueryBuilder` directly.\n * @param filter[allowMultipleLeftJoins] Allows multiple fanout LEFT JOINs when Joist cannot express\n *   an alias condition as EXISTS.\n * @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because\n *   you plan on adding selects/grouping against collection aliases after Joist builds the query.\n */\nexport function buildQuery<T extends Entity>(\n  knex: Knex,\n  type: MaybeAbstractEntityConstructor<T>,\n  filter: FilterAndSettings<T> & {\n    pruneJoins?: boolean;\n    keepAliases?: string[];\n    allowMultipleLeftJoins?: boolean;\n    optimizeJoinsToExists?: boolean;\n  },\n): Knex.QueryBuilder<{}, unknown[]> {\n  const meta = getMetadata(type);\n  const {\n    where,\n    conditions,\n    orderBy,\n    limit,\n    offset,\n    pruneJoins = true,\n    keepAliases = [],\n    allowMultipleLeftJoins = false,\n    optimizeJoinsToExists = true,\n    softDeletes = \"exclude\",\n  } = filter;\n  const parsed = parseFindQuery(meta, where, {\n    conditions,\n    orderBy,\n    keepAliases,\n    softDeletes,\n  });\n  optimizeCollectionJoins(parsed, { allowMultipleLeftJoins, optimizeJoinsToExists, pruneJoins, keepAliases });\n  return buildKnexQuery(knex, parsed, { limit, offset });\n}\n\n/**\n * Creates a Knex instance that delegates to an existing pg Pool or PoolClient\n * instead of managing its own internal connection pool.\n *\n * When given a `pg.Pool`, each knex query acquires a connection from the pool and\n * releases it when the query completes.\n *\n * When given a `pg.PoolClient`, all knex queries run on that specific client. This\n * is useful when the client has an open transaction (via `BEGIN`) — the knex queries\n * will participate in that transaction and be affected by `COMMIT`/`ROLLBACK`.\n *\n * The returned Knex instance has no internal pool, so there is no need to call\n * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.\n */\nexport function createKnex(poolOrClient: pg.Pool | pg.PoolClient): Knex {\n  const knex = baseCreateKnex({ client: \"pg\", connection: {}, pool: { max: 0 } });\n  if (poolOrClient instanceof pg.Pool) {\n    knex.client.acquireConnection = () => poolOrClient.connect();\n    knex.client.releaseConnection = (conn: pg.PoolClient) => conn.release();\n  } else {\n    knex.client.acquireConnection = () => poolOrClient;\n    knex.client.releaseConnection = () => {};\n  }\n  return knex;\n}\n"],"mappings":";;;;;AAaA,MAAM,EAAE,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BjC,SAAgB,WACd,MACA,MACA,QAMkC;CAClC,MAAM,OAAO,YAAY,IAAI;CAC7B,MAAM,EACJ,OACA,YACA,SACA,OACA,QACA,aAAa,MACb,cAAc,CAAC,GACf,yBAAyB,OACzB,wBAAwB,MACxB,cAAc,cACZ;CACJ,MAAM,SAAS,eAAe,MAAM,OAAO;EACzC;EACA;EACA;EACA;CACF,CAAC;CACD,wBAAwB,QAAQ;EAAE;EAAwB;EAAuB;EAAY;CAAY,CAAC;CAC1G,OAAO,eAAe,MAAM,QAAQ;EAAE;EAAO;CAAO,CAAC;AACvD;;;;;;;;;;;;;;;AAgBA,SAAgB,WAAW,cAA6C;CACtE,MAAM,OAAO,eAAe;EAAE,QAAQ;EAAM,YAAY,CAAC;EAAG,MAAM,EAAE,KAAK,EAAE;CAAE,CAAC;CAC9E,IAAI,wBAAwB,GAAG,MAAM;EACnC,KAAK,OAAO,0BAA0B,aAAa,QAAQ;EAC3D,KAAK,OAAO,qBAAqB,SAAwB,KAAK,QAAQ;CACxE,OAAO;EACL,KAAK,OAAO,0BAA0B;EACtC,KAAK,OAAO,0BAA0B,CAAC;CACzC;CACA,OAAO;AACT"}

package/build/utils.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/utils.ts
+function assertNever(x) {
+	throw new Error("Unexpected object: " + x);
+}
+//#endregion
+exports.assertNever = assertNever;
+
+//# sourceMappingURL=utils.cjs.map

package/build/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["export function assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x);\n}\n"],"mappings":";;AAAA,SAAgB,YAAY,GAAiB;CAC3C,MAAM,IAAI,MAAM,wBAAwB,CAAC;AAC3C"}

package/build/utils.d.cts

@@ -0,0 +1,5 @@
+//#region src/utils.d.ts
+declare function assertNever(x: never): never;
+//#endregion
+export { assertNever };
+//# sourceMappingURL=utils.d.cts.map

package/build/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../src/utils.ts"],"mappings":";iBAAgB,YAAY"}

package/build/utils.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils.d.ts
+declare function assertNever(x: never): never;
+//#endregion
+export { assertNever };
+//# sourceMappingURL=utils.d.mts.map

package/build/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";iBAAgB,YAAY"}

package/build/utils.js

@@ -1,7 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNever = assertNever;
+//#region src/utils.ts
 function assertNever(x) {
-    throw new Error("Unexpected object: " + x);
+	throw new Error("Unexpected object: " + x);
 }
+//#endregion
+export { assertNever };
+
 //# sourceMappingURL=utils.js.map

package/build/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;AAAA,kCAEC;AAFD,SAAgB,WAAW,CAAC,CAAQ;IAClC,MAAM,IAAI,KAAK,CAAC,qBAAqB,GAAG,CAAC,CAAC,CAAC;AAC7C,CAAC"}
+{"version":3,"file":"utils.js","names":[],"sources":["../src/utils.ts"],"sourcesContent":["export function assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x);\n}\n"],"mappings":";AAAA,SAAgB,YAAY,GAAiB;CAC3C,MAAM,IAAI,MAAM,wBAAwB,CAAC;AAC3C"}

package/package.json

@@ -1,35 +1,52 @@
 {
   "name": "joist-knex",
-  "version": "2.3.0-next.7",
+  "version": "2.3.0-next.71",
   "license": "MIT",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/joist-orm/joist-orm.git",
     "directory": "packages/knex"
   },
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
-  "scripts": {
-    "format": "prettier --ignore-path ../../.prettierignore --write '{schema,migrations,src}/**/*.{ts,js,tsx,jsx,graphql}'"
+  "main": "build/index.cjs",
+  "module": "build/index.js",
+  "types": "build/index.d.mts",
+  "exports": {
+    ".": {
+      "bun": {
+        "types": "./build/index.d.mts",
+        "default": "./build/index.js"
+      },
+      "module-sync": {
+        "types": "./build/index.d.mts",
+        "default": "./build/index.js"
+      },
+      "import": {
+        "types": "./build/index.d.mts",
+        "default": "./build/index.js"
+      },
+      "require": {
+        "types": "./build/index.d.cts",
+        "default": "./build/index.cjs"
+      },
+      "default": "./build/index.js"
+    }
   },
   "files": [
     "build"
   ],
   "peerDependencies": {
-    "joist-core": "2.3.0-next.7",
+    "joist-core": "2.3.0-next.71",
     "knex": "^3.1.0",
-    "pg": "^8.22.0"
+    "pg": "^8.23.0"
   },
   "devDependencies": {
-    "@swc/core": "^1.15.43",
+    "@swc/core": "^1.16.1",
     "@swc/jest": "^0.2.39",
     "@types/jest": "^30.0.0",
-    "@types/node": "^26.0.1",
+    "@types/node": "^26.2.0",
     "jest": "30.4.2",
-    "prettier": "^3.8.4",
-    "prettier-plugin-organize-imports": "^4.3.0",
-    "ts-node-dev": "^2.0.0",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "6.0.3"
+    "typescript": "7.0.2"
   }
 }

package/build/buildKnexQuery.d.ts

@@ -1,9 +0,0 @@
-import { ParsedFindQuery } from "joist-core";
-import { Knex } from "knex";
-import QueryBuilder = Knex.QueryBuilder;
-/** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
-export declare function buildKnexQuery(knex: Knex, parsed: ParsedFindQuery, settings: {
-    limit?: number;
-    offset?: number;
-}): QueryBuilder<{}, unknown[]>;
-//# sourceMappingURL=buildKnexQuery.d.ts.map

package/build/buildKnexQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildKnexQuery.d.ts","sourceRoot":"","sources":["../src/buildKnexQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,eAAe,EAAe,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;AAExC,mFAAmF;AACnF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5C,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,CAgG7B"}

package/build/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,iBAAiB,EAEjB,8BAA8B,EAG/B,MAAM,YAAY,CAAC;AACpB,OAAO,EAA0B,IAAI,EAAE,MAAM,MAAM,CAAC;AACpD,OAAO,EAAE,MAAM,IAAI,CAAC;AAGpB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,8BAA8B,CAAC,CAAC,CAAC,EACvC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,GACA,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,CAsBlC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,YAAY,EAAE,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,UAAU,GAAG,IAAI,CAUtE"}

package/build/utils.d.ts

@@ -1,2 +0,0 @@
-export declare function assertNever(x: never): never;
-//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAE3C"}