joist-knex 2.5.0-next.2 → 2.5.0-next.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,4 +1,4 @@
1
- //#region \0rolldown/runtime.js
1
+ // \0rolldown/runtime.js
2
2
  var __create = Object.create;
3
3
  var __defProp = Object.defineProperty;
4
4
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -19,5 +19,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
19
19
  value: mod,
20
20
  enumerable: true
21
21
  }) : target, mod));
22
- //#endregion
23
22
  exports.__toESM = __toESM;
@@ -2,31 +2,31 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
2
2
  const require_utils = require("./utils.cjs");
3
3
  let joist_core = require("joist-core");
4
4
  require("knex");
5
- //#region src/buildKnexQuery.ts
5
+ // src/buildKnexQuery.ts
6
6
  /** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
7
- function buildKnexQuery(knex$1, parsed, settings) {
7
+ function buildKnexQuery(knex, parsed, settings) {
8
8
  const { limit, offset } = settings;
9
9
  const needsDistinct = parsed.tables.some((t) => t.join === "outer" && t.distinct !== false);
10
- const asRaw = (t) => knex$1.raw(`${(0, joist_core.kq)(t.table)} as ${(0, joist_core.kq)(t.alias)}`);
10
+ const asRaw = (t) => knex.raw(`${(0, joist_core.kq)(t.table)} as ${(0, joist_core.kq)(t.alias)}`);
11
11
  const primary = parsed.tables.find((t) => t.join === "primary");
12
- let query = knex$1.from(asRaw(primary));
12
+ let query = knex.from(asRaw(primary));
13
13
  parsed.selects.forEach((s, i) => {
14
14
  const maybeDistinct = i === 0 && needsDistinct ? "distinct " : "";
15
- if (typeof s === "string") query.select(knex$1.raw(`${maybeDistinct}${s}`));
16
- else if ("sql" in s) query.select(knex$1.raw(`${maybeDistinct}${s.sql}`, s.bindings));
15
+ if (typeof s === "string") query.select(knex.raw(`${maybeDistinct}${s}`));
16
+ else if ("sql" in s) query.select(knex.raw(`${maybeDistinct}${s.sql}`, s.bindings));
17
17
  });
18
18
  parsed.tables.forEach((t) => {
19
19
  switch (t.join) {
20
20
  case "inner":
21
- query.join(asRaw(t), knex$1.raw(t.col1), knex$1.raw(t.col2));
21
+ query.join(asRaw(t), knex.raw(t.col1), knex.raw(t.col2));
22
22
  break;
23
23
  case "outer":
24
- query.leftOuterJoin(asRaw(t), knex$1.raw(t.col1), knex$1.raw(t.col2));
24
+ query.leftOuterJoin(asRaw(t), knex.raw(t.col1), knex.raw(t.col2));
25
25
  break;
26
26
  case "primary": break;
27
27
  case "lateral":
28
- const { sql, bindings } = buildKnexQuery(knex$1, t.query, {}).toSQL();
29
- query.crossJoin(knex$1.raw(`lateral (${sql}) as ${(0, joist_core.kq)(t.alias)}`, bindings));
28
+ const { sql, bindings } = buildKnexQuery(knex, t.query, {}).toSQL();
29
+ query.crossJoin(knex.raw(`lateral (${sql}) as ${(0, joist_core.kq)(t.alias)}`, bindings));
30
30
  break;
31
31
  case "cross":
32
32
  query.crossJoin(asRaw(t));
@@ -36,7 +36,7 @@ function buildKnexQuery(knex$1, parsed, settings) {
36
36
  });
37
37
  if (parsed.condition) {
38
38
  const subqueryRenderer = (q) => {
39
- const { sql, bindings } = buildKnexQuery(knex$1, q, {}).toSQL();
39
+ const { sql, bindings } = buildKnexQuery(knex, q, {}).toSQL();
40
40
  return {
41
41
  sql,
42
42
  bindings
@@ -49,8 +49,8 @@ function buildKnexQuery(knex$1, parsed, settings) {
49
49
  }
50
50
  }
51
51
  parsed.orderBys && parsed.orderBys.forEach(({ alias, column, order }) => {
52
- if (needsDistinct) query.select(knex$1.raw((0, joist_core.kqDot)(alias, column)));
53
- query.orderBy(knex$1.raw((0, joist_core.kqDot)(alias, column)), order);
52
+ if (needsDistinct) query.select(knex.raw((0, joist_core.kqDot)(alias, column)));
53
+ query.orderBy(knex.raw((0, joist_core.kqDot)(alias, column)), order);
54
54
  });
55
55
  parsed.groupBys && parsed.groupBys.forEach((groupBy) => {
56
56
  query.groupByRaw("expression" in groupBy ? groupBy.expression : (0, joist_core.kqDot)(groupBy.alias, groupBy.column));
@@ -60,18 +60,18 @@ function buildKnexQuery(knex$1, parsed, settings) {
60
60
  const args = [cte.alias];
61
61
  if (cte.columns && cte.columns.length > 0) args.push(cte.columns.map((c) => c.columnName));
62
62
  if (cte.query.kind === "raw") {
63
- args.push(knex$1.raw(cte.query.sql));
63
+ args.push(knex.raw(cte.query.sql));
64
64
  if (cte.query.bindings) args.push(cte.query.bindings);
65
- } else if (cte.query.kind === "ast") args.push(buildKnexQuery(knex$1, cte.query.query, {}));
65
+ } else if (cte.query.kind === "ast") args.push(buildKnexQuery(knex, cte.query.query, {}));
66
66
  else require_utils.assertNever(cte.query);
67
67
  if (cte.recursive) query.withRecursive(...args);
68
+ else if (cte.materialized) query.withMaterialized(...args);
68
69
  else query.with(...args);
69
70
  }
70
71
  if (limit) query.limit(limit);
71
72
  if (offset) query.offset(offset);
72
73
  return query;
73
74
  }
74
- //#endregion
75
75
  exports.buildKnexQuery = buildKnexQuery;
76
76
 
77
77
  //# sourceMappingURL=buildKnexQuery.cjs.map
@@ -1 +1 @@
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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"}
1
+ {"version":3,"file":"buildKnexQuery.cjs","names":["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 if (cte.materialized) {\n query.withMaterialized(...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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"}
@@ -1,10 +1,8 @@
1
1
  import { ParsedFindQuery } from "joist-core";
2
2
  import { Knex } from "knex";
3
- //#region src/buildKnexQuery.d.ts
4
3
  /** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
5
4
  export declare function buildKnexQuery(knex: Knex, parsed: ParsedFindQuery, settings: {
6
5
  limit?: number;
7
6
  offset?: number;
8
7
  }): Knex.QueryBuilder<{}, unknown[]>;
9
- //#endregion
10
8
  //# sourceMappingURL=buildKnexQuery.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"buildKnexQuery.d.cts","names":[],"sources":["../src/buildKnexQuery.ts"],"mappings":";;;;wBAMgB,eACd,MAAM,MACN,QAAQ,iBACR;EAAY;EAAgB;IAC3B,KAAK"}
1
+ {"version":3,"file":"buildKnexQuery.d.cts","names":[],"sources":["../src/buildKnexQuery.ts"],"mappings":";;;wBAMgB,eACd,MAAM,MACN,QAAQ,iBACR;EAAY;EAAgB;IAC3B,KAAK"}
@@ -1,10 +1,8 @@
1
1
  import { ParsedFindQuery } from "joist-core";
2
2
  import { Knex } from "knex";
3
- //#region src/buildKnexQuery.d.ts
4
3
  /** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
5
4
  export declare function buildKnexQuery(knex: Knex, parsed: ParsedFindQuery, settings: {
6
5
  limit?: number;
7
6
  offset?: number;
8
7
  }): Knex.QueryBuilder<{}, unknown[]>;
9
- //#endregion
10
8
  //# sourceMappingURL=buildKnexQuery.d.mts.map
@@ -1 +1 @@
1
- {"version":3,"file":"buildKnexQuery.d.mts","names":[],"sources":["../src/buildKnexQuery.ts"],"mappings":";;;;wBAMgB,eACd,MAAM,MACN,QAAQ,iBACR;EAAY;EAAgB;IAC3B,KAAK"}
1
+ {"version":3,"file":"buildKnexQuery.d.mts","names":[],"sources":["../src/buildKnexQuery.ts"],"mappings":";;;wBAMgB,eACd,MAAM,MACN,QAAQ,iBACR;EAAY;EAAgB;IAC3B,KAAK"}
@@ -1,7 +1,7 @@
1
1
  import { assertNever } from "./utils.js";
2
2
  import { internals, kq, kqDot } from "joist-core";
3
3
  import "knex";
4
- //#region src/buildKnexQuery.ts
4
+ // src/buildKnexQuery.ts
5
5
  /** Transforms Joist's internal `ParsedFindQuery` AST into a Knex query builder. */
6
6
  function buildKnexQuery(knex, parsed, settings) {
7
7
  const { limit, offset } = settings;
@@ -64,13 +64,13 @@ function buildKnexQuery(knex, parsed, settings) {
64
64
  } else if (cte.query.kind === "ast") args.push(buildKnexQuery(knex, cte.query.query, {}));
65
65
  else assertNever(cte.query);
66
66
  if (cte.recursive) query.withRecursive(...args);
67
+ else if (cte.materialized) query.withMaterialized(...args);
67
68
  else query.with(...args);
68
69
  }
69
70
  if (limit) query.limit(limit);
70
71
  if (offset) query.offset(offset);
71
72
  return query;
72
73
  }
73
- //#endregion
74
74
  export { buildKnexQuery };
75
75
 
76
76
  //# sourceMappingURL=buildKnexQuery.js.map
@@ -1 +1 @@
1
- {"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":"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"}
1
+ {"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 if (cte.materialized) {\n query.withMaterialized(...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/index.cjs CHANGED
@@ -6,7 +6,7 @@ let knex = require("knex");
6
6
  knex = require_runtime.__toESM(knex, 1);
7
7
  let pg = require("pg");
8
8
  pg = require_runtime.__toESM(pg, 1);
9
- //#region src/index.ts
9
+ // src/index.ts
10
10
  const { knex: baseCreateKnex } = knex.default;
11
11
  /**
12
12
  * Builds the Knex queries from `em.find`-style parameters.
@@ -34,7 +34,7 @@ const { knex: baseCreateKnex } = knex.default;
34
34
  * @param filter[optimizeJoinsToExists] Disables rewriting collection joins into EXISTS, i.e. because
35
35
  * you plan on adding selects/grouping against collection aliases after Joist builds the query.
36
36
  */
37
- function buildQuery(knex$2, type, filter) {
37
+ function buildQuery(knex, type, filter) {
38
38
  const meta = (0, joist_core.getMetadata)(type);
39
39
  const { where, conditions, orderBy, limit, offset, pruneJoins = true, keepAliases = [], allowMultipleLeftJoins = false, optimizeJoinsToExists = true, softDeletes = "exclude" } = filter;
40
40
  const parsed = (0, joist_core.parseFindQuery)(meta, where, {
@@ -49,7 +49,7 @@ function buildQuery(knex$2, type, filter) {
49
49
  pruneJoins,
50
50
  keepAliases
51
51
  });
52
- return require_buildKnexQuery.buildKnexQuery(knex$2, parsed, {
52
+ return require_buildKnexQuery.buildKnexQuery(knex, parsed, {
53
53
  limit,
54
54
  offset
55
55
  });
@@ -69,21 +69,20 @@ function buildQuery(knex$2, type, filter) {
69
69
  * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
70
70
  */
71
71
  function createKnex(poolOrClient) {
72
- const knex$3 = baseCreateKnex({
72
+ const knex = baseCreateKnex({
73
73
  client: "pg",
74
74
  connection: {},
75
75
  pool: { max: 0 }
76
76
  });
77
77
  if (poolOrClient instanceof pg.default.Pool) {
78
- knex$3.client.acquireConnection = () => poolOrClient.connect();
79
- knex$3.client.releaseConnection = (conn) => conn.release();
78
+ knex.client.acquireConnection = () => poolOrClient.connect();
79
+ knex.client.releaseConnection = (conn) => conn.release();
80
80
  } else {
81
- knex$3.client.acquireConnection = () => poolOrClient;
82
- knex$3.client.releaseConnection = () => {};
81
+ knex.client.acquireConnection = () => poolOrClient;
82
+ knex.client.releaseConnection = () => {};
83
83
  }
84
- return knex$3;
84
+ return knex;
85
85
  }
86
- //#endregion
87
86
  exports.buildQuery = buildQuery;
88
87
  exports.createKnex = createKnex;
89
88
 
@@ -1 +1 @@
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"}
1
+ {"version":3,"file":"index.cjs","names":["getMetadata","parseFindQuery","buildKnexQuery"],"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,MACA,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,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,GAAA,QAAG,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/index.d.cts CHANGED
@@ -1,7 +1,6 @@
1
1
  import { Entity, FilterAndSettings, MaybeAbstractEntityConstructor } from "joist-core";
2
2
  import { Knex } from "knex";
3
3
  import pg from "pg";
4
- //#region src/index.d.ts
5
4
  /**
6
5
  * Builds the Knex queries from `em.find`-style parameters.
7
6
  *
@@ -49,5 +48,4 @@ export declare function buildQuery<T extends Entity>(knex: Knex, type: MaybeAbst
49
48
  * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
50
49
  */
51
50
  export declare function createKnex(poolOrClient: pg.Pool | pg.PoolClient): Knex;
52
- //#endregion
53
51
  //# sourceMappingURL=index.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyCgB,WAAW,UAAU,QACnC,MAAM,MACN,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB;EACxB;EACA;EACA;EACA;IAED,KAAK;;;;;;;;;;;;;;;wBAsCQ,WAAW,cAAc,GAAG,OAAO,GAAG,aAAa"}
1
+ {"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyCgB,WAAW,UAAU,QACnC,MAAM,MACN,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB;EACxB;EACA;EACA;EACA;IAED,KAAK;;;;;;;;;;;;;;;wBAsCQ,WAAW,cAAc,GAAG,OAAO,GAAG,aAAa"}
package/build/index.d.mts CHANGED
@@ -1,7 +1,6 @@
1
1
  import { Entity, FilterAndSettings, MaybeAbstractEntityConstructor } from "joist-core";
2
2
  import { Knex } from "knex";
3
3
  import pg from "pg";
4
- //#region src/index.d.ts
5
4
  /**
6
5
  * Builds the Knex queries from `em.find`-style parameters.
7
6
  *
@@ -49,5 +48,4 @@ export declare function buildQuery<T extends Entity>(knex: Knex, type: MaybeAbst
49
48
  * `.destroy()` on it — the caller owns the Pool/PoolClient lifecycle.
50
49
  */
51
50
  export declare function createKnex(poolOrClient: pg.Pool | pg.PoolClient): Knex;
52
- //#endregion
53
51
  //# sourceMappingURL=index.d.mts.map
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyCgB,WAAW,UAAU,QACnC,MAAM,MACN,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB;EACxB;EACA;EACA;EACA;IAED,KAAK;;;;;;;;;;;;;;;wBAsCQ,WAAW,cAAc,GAAG,OAAO,GAAG,aAAa"}
1
+ {"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyCgB,WAAW,UAAU,QACnC,MAAM,MACN,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB;EACxB;EACA;EACA;EACA;IAED,KAAK;;;;;;;;;;;;;;;wBAsCQ,WAAW,cAAc,GAAG,OAAO,GAAG,aAAa"}
package/build/index.js CHANGED
@@ -2,7 +2,7 @@ import { buildKnexQuery } from "./buildKnexQuery.js";
2
2
  import { getMetadata, optimizeCollectionJoins, parseFindQuery } from "joist-core";
3
3
  import knex from "knex";
4
4
  import pg from "pg";
5
- //#region src/index.ts
5
+ // src/index.ts
6
6
  const { knex: baseCreateKnex } = knex;
7
7
  /**
8
8
  * Builds the Knex queries from `em.find`-style parameters.
@@ -79,7 +79,6 @@ function createKnex(poolOrClient) {
79
79
  }
80
80
  return knex;
81
81
  }
82
- //#endregion
83
82
  export { buildQuery, createKnex };
84
83
 
85
84
  //# sourceMappingURL=index.js.map
package/build/utils.cjs CHANGED
@@ -1,9 +1,8 @@
1
1
  Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
2
- //#region src/utils.ts
2
+ // src/utils.ts
3
3
  function assertNever(x) {
4
4
  throw new Error("Unexpected object: " + x);
5
5
  }
6
- //#endregion
7
6
  exports.assertNever = assertNever;
8
7
 
9
8
  //# sourceMappingURL=utils.cjs.map
package/build/utils.d.cts CHANGED
@@ -1,4 +1,2 @@
1
- //#region src/utils.d.ts
2
1
  export declare function assertNever(x: never): never;
3
- //#endregion
4
2
  //# sourceMappingURL=utils.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"utils.d.cts","names":[],"sources":["../src/utils.ts"],"mappings":";wBAAgB,YAAY"}
1
+ {"version":3,"file":"utils.d.cts","names":[],"sources":["../src/utils.ts"],"mappings":"A,wBAAgB,YAAY"}
package/build/utils.d.mts CHANGED
@@ -1,4 +1,2 @@
1
- //#region src/utils.d.ts
2
1
  export declare function assertNever(x: never): never;
3
- //#endregion
4
2
  //# sourceMappingURL=utils.d.mts.map
@@ -1 +1 @@
1
- {"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";wBAAgB,YAAY"}
1
+ {"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":"A,wBAAgB,YAAY"}
package/build/utils.js CHANGED
@@ -1,8 +1,7 @@
1
- //#region src/utils.ts
1
+ // src/utils.ts
2
2
  function assertNever(x) {
3
3
  throw new Error("Unexpected object: " + x);
4
4
  }
5
- //#endregion
6
5
  export { assertNever };
7
6
 
8
7
  //# sourceMappingURL=utils.js.map
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "joist-knex",
3
- "version": "2.5.0-next.2",
3
+ "version": "2.5.0-next.20",
4
4
  "license": "MIT",
5
5
  "type": "module",
6
6
  "repository": {
@@ -36,15 +36,15 @@
36
36
  "build"
37
37
  ],
38
38
  "peerDependencies": {
39
- "joist-core": "2.5.0-next.2",
39
+ "joist-core": "2.5.0-next.20",
40
40
  "knex": "^3.1.0",
41
41
  "pg": "^8.23.0"
42
42
  },
43
43
  "devDependencies": {
44
- "@swc/core": "1.16.18",
44
+ "@swc/core": "1.16.21",
45
45
  "@swc/jest": "^0.2.39",
46
46
  "@types/jest": "^30.0.0",
47
- "@types/node": "^26.6.5",
47
+ "@types/node": "^26.6.6",
48
48
  "jest": "30.4.2",
49
49
  "tsconfig-paths": "^4.2.0",
50
50
  "typescript": "7.0.2"