joist-core 2.3.0 → 2.4.0-next.10

package/build/queries/ConditionBuilder.js

@@ -0,0 +1,105 @@
+import { skipCondition } from "./skipCondition.js";
+import { mapToDb } from "./valueFilters.js";
+import { fail, partition } from "../utils.js";
+import { isDefined } from "../EntityManager.js";
+//#region src/queries/ConditionBuilder.ts
+/** Converts domain-level values like string ids/enums into their db equivalent. */
+var ConditionBuilder = class {
+	/** Simple, single-column conditions, which will be AND-d together. */
+	conditions = [];
+	/** Complex expressions, which will also be AND-d together with `conditions`. */
+	expressions = [];
+	/** Accepts a raw user-facing DSL filter, and parses it into a `ParsedExpressionFilter`. */
+	maybeAddExpression(expression) {
+		const parsed = parseExpression(expression);
+		if (parsed) this.expressions.push(parsed);
+	}
+	/** Adds an already-db-level condition to the simple conditions list. */
+	addSimpleCondition(condition) {
+		this.conditions.push(condition);
+	}
+	/** Adds an already-db-level condition to the simple conditions list. */
+	addRawCondition(condition) {
+		this.conditions.push({
+			kind: "raw",
+			bindings: [],
+			...condition
+		});
+	}
+	/** Adds an already-db-level expression to the expressions list. */
+	addParsedExpression(parsed) {
+		this.expressions.push(parsed);
+	}
+	/**
+	* Adds a user-facing `ParsedValueFilter` to the inline conditions.
+	*
+	* Unless it's something like `in: [a1, null]`, in which case we split it into two `is-null` and `in` conditions.
+	*/
+	addValueFilter(alias, column, filter) {
+		if (filter.kind === "in" && filter.value.includes(null)) {
+			const isNull = {
+				kind: "column",
+				alias,
+				column: column.columnName,
+				dbType: column.dbType,
+				cond: { kind: "is-null" }
+			};
+			const inValues = {
+				kind: "column",
+				alias,
+				column: column.columnName,
+				dbType: column.dbType,
+				cond: {
+					kind: "in",
+					value: filter.value.filter((v) => v !== null).map((v) => column.mapToDb(v))
+				}
+			};
+			this.expressions.push({
+				kind: "exp",
+				op: "or",
+				conditions: [isNull, inValues]
+			});
+		} else {
+			const cond = {
+				kind: "column",
+				alias,
+				column: column.columnName,
+				dbType: column.dbType,
+				cond: mapToDb(column, filter)
+			};
+			this.conditions.push(cond);
+		}
+	}
+	/** Combines our collected `conditions` and `expressions` into a single `ParsedExpressionFilter`. */
+	toExpressionFilter() {
+		const { expressions, conditions } = this;
+		const allSimple = [...conditions];
+		if (allSimple.length === 0 && expressions.length === 1) return expressions[0];
+		else if (expressions.length === 1 && expressions[0].op === "and") return {
+			kind: "exp",
+			op: "and",
+			conditions: [...allSimple, ...expressions[0].conditions]
+		};
+		else if (allSimple.length > 0 || expressions.length > 0) return {
+			kind: "exp",
+			op: "and",
+			conditions: [...allSimple, ...expressions]
+		};
+	}
+};
+/** Parses user-facing `{ and: ... }` or `{ or: ... }` into a `ParsedExpressionFilter`. */
+function parseExpression(expression) {
+	const [op, expressions] = "and" in expression && expression.and ? ["and", expression.and] : "or" in expression && expression.or ? ["or", expression.or] : fail(`Invalid expression ${expression}`);
+	const conditions = expressions.map((exp) => exp && ("and" in exp || "or" in exp) ? parseExpression(exp) : exp);
+	const [skip, valid] = partition(conditions, (cond) => cond === void 0 || cond === skipCondition);
+	if (skip.length > 0 && expression.pruneIfUndefined === "any" || valid.length === 0) return;
+	return {
+		kind: "exp",
+		op,
+		conditions: valid.filter(isDefined)
+	};
+}
+//#endregion
+export { ConditionBuilder };
+
+//# sourceMappingURL=ConditionBuilder.js.map

package/build/queries/ConditionBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBuilder.js","names":[],"sources":["../../src/queries/ConditionBuilder.ts"],"sourcesContent":["import { isDefined } from \"src/EntityManager.ts\";\nimport type { ConditionGroup, ConditionInput } from \"src/queries/conditions.ts\";\nimport type {\n  ColumnCondition,\n  ParsedExpressionCondition,\n  ParsedExpressionFilter,\n  ParsedValueFilter,\n  RawCondition,\n} from \"src/queries/parsedConditions.ts\";\nimport { skipCondition } from \"src/queries/skipCondition.ts\";\nimport { mapToDb } from \"src/queries/valueFilters.ts\";\nimport type { Column } from \"src/serde/columns.ts\";\nimport { fail, partition } from \"src/utils.ts\";\n\ntype PartialSome<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\n\n/** Converts domain-level values like string ids/enums into their db equivalent. */\nexport class ConditionBuilder {\n  /** Simple, single-column conditions, which will be AND-d together. */\n  private conditions: (ColumnCondition | RawCondition)[] = [];\n  /** Complex expressions, which will also be AND-d together with `conditions`. */\n  private expressions: ParsedExpressionFilter[] = [];\n\n  /** Accepts a raw user-facing DSL filter, and parses it into a `ParsedExpressionFilter`. */\n  maybeAddExpression(expression: ConditionGroup<ConditionInput>): void {\n    const parsed = parseExpression(expression);\n    if (parsed) this.expressions.push(parsed);\n  }\n\n  /** Adds an already-db-level condition to the simple conditions list. */\n  addSimpleCondition(condition: ColumnCondition): void {\n    this.conditions.push(condition);\n  }\n\n  /** Adds an already-db-level condition to the simple conditions list. */\n  addRawCondition(condition: PartialSome<RawCondition, \"kind\" | \"bindings\">): void {\n    this.conditions.push({\n      kind: \"raw\",\n      bindings: [],\n      ...condition,\n    });\n  }\n\n  /** Adds an already-db-level expression to the expressions list. */\n  addParsedExpression(parsed: ParsedExpressionFilter): void {\n    this.expressions.push(parsed);\n  }\n\n  /**\n   * Adds a user-facing `ParsedValueFilter` to the inline conditions.\n   *\n   * Unless it's something like `in: [a1, null]`, in which case we split it into two `is-null` and `in` conditions.\n   */\n  addValueFilter(alias: string, column: Column, filter: ParsedValueFilter<any>): void {\n    if (filter.kind === \"in\" && filter.value.includes(null)) {\n      // If the filter contains a null, we need to split it into an `is-null` and `in` condition\n      const isNull = {\n        kind: \"column\",\n        alias,\n        column: column.columnName,\n        dbType: column.dbType,\n        cond: { kind: \"is-null\" },\n      } satisfies ColumnCondition;\n      const inValues = {\n        kind: \"column\",\n        alias,\n        column: column.columnName,\n        dbType: column.dbType,\n        cond: {\n          kind: \"in\",\n          // Filter out the nulls from the in condition\n          value: filter.value.filter((v) => v !== null).map((v) => column.mapToDb(v)),\n        },\n      } satisfies ColumnCondition;\n      // Now OR them back together\n      this.expressions.push({ kind: \"exp\", op: \"or\", conditions: [isNull, inValues] });\n    } else {\n      const cond = {\n        kind: \"column\",\n        alias,\n        column: column.columnName,\n        dbType: column.dbType,\n        // Rewrite the user-facing domain values to db values\n        cond: mapToDb(column, filter),\n      } satisfies ColumnCondition;\n      this.conditions.push(cond);\n    }\n  }\n\n  /** Combines our collected `conditions` and `expressions` into a single `ParsedExpressionFilter`. */\n  toExpressionFilter(): ParsedExpressionFilter | undefined {\n    const { expressions, conditions } = this;\n    const allSimple: ParsedExpressionCondition[] = [...conditions];\n    if (allSimple.length === 0 && expressions.length === 1) {\n      // If no inline conditions, and just 1 opt expression, just use that\n      return expressions[0];\n    } else if (expressions.length === 1 && expressions[0].op === \"and\") {\n      // Merge the 1 `AND` expression with the other simple conditions\n      return { kind: \"exp\", op: \"and\", conditions: [...allSimple, ...expressions[0].conditions] };\n    } else if (allSimple.length > 0 || expressions.length > 0) {\n      // Combine the conditions within the `em.find` join literal & the `conditions` as ANDs\n      return { kind: \"exp\", op: \"and\", conditions: [...allSimple, ...expressions] };\n    }\n    return undefined;\n  }\n}\n\n/** Parses user-facing `{ and: ... }` or `{ or: ... }` into a `ParsedExpressionFilter`. */\nfunction parseExpression(expression: ConditionGroup<ConditionInput>): ParsedExpressionFilter | undefined {\n  // Look for `{ and: [...] }` or `{ or: [...] }`\n  const [op, expressions] =\n    \"and\" in expression && expression.and\n      ? [\"and\" as const, expression.and]\n      : \"or\" in expression && expression.or\n        ? [\"or\" as const, expression.or]\n        : fail(`Invalid expression ${expression}`);\n  // Potentially recurse into nested expressions\n  const conditions = expressions.map((exp) => (exp && (\"and\" in exp || \"or\" in exp) ? parseExpression(exp) : exp));\n  const [skip, valid] = partition(conditions, (cond) => cond === undefined || cond === skipCondition);\n  if ((skip.length > 0 && expression.pruneIfUndefined === \"any\") || valid.length === 0) {\n    return undefined;\n  }\n  return { kind: \"exp\", op, conditions: valid.filter(isDefined) };\n}\n"],"mappings":";;;;;;AAiBA,IAAa,mBAAb,MAA8B;;CAE5B,aAAyD,CAAC;;CAE1D,cAAgD,CAAC;;CAGjD,mBAAmB,YAAkD;EACnE,MAAM,SAAS,gBAAgB,UAAU;EACzC,IAAI,QAAQ,KAAK,YAAY,KAAK,MAAM;CAC1C;;CAGA,mBAAmB,WAAkC;EACnD,KAAK,WAAW,KAAK,SAAS;CAChC;;CAGA,gBAAgB,WAAiE;EAC/E,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,UAAU,CAAC;GACX,GAAG;EACL,CAAC;CACH;;CAGA,oBAAoB,QAAsC;EACxD,KAAK,YAAY,KAAK,MAAM;CAC9B;;;;;;CAOA,eAAe,OAAe,QAAgB,QAAsC;EAClF,IAAI,OAAO,SAAS,QAAQ,OAAO,MAAM,SAAS,IAAI,GAAG;GAEvD,MAAM,SAAS;IACb,MAAM;IACN;IACA,QAAQ,OAAO;IACf,QAAQ,OAAO;IACf,MAAM,EAAE,MAAM,UAAU;GAC1B;GACA,MAAM,WAAW;IACf,MAAM;IACN;IACA,QAAQ,OAAO;IACf,QAAQ,OAAO;IACf,MAAM;KACJ,MAAM;KAEN,OAAO,OAAO,MAAM,QAAQ,MAAM,MAAM,IAAI,CAAC,CAAC,KAAK,MAAM,OAAO,QAAQ,CAAC,CAAC;IAC5E;GACF;GAEA,KAAK,YAAY,KAAK;IAAE,MAAM;IAAO,IAAI;IAAM,YAAY,CAAC,QAAQ,QAAQ;GAAE,CAAC;EACjF,OAAO;GACL,MAAM,OAAO;IACX,MAAM;IACN;IACA,QAAQ,OAAO;IACf,QAAQ,OAAO;IAEf,MAAM,QAAQ,QAAQ,MAAM;GAC9B;GACA,KAAK,WAAW,KAAK,IAAI;EAC3B;CACF;;CAGA,qBAAyD;EACvD,MAAM,EAAE,aAAa,eAAe;EACpC,MAAM,YAAyC,CAAC,GAAG,UAAU;EAC7D,IAAI,UAAU,WAAW,KAAK,YAAY,WAAW,GAEnD,OAAO,YAAY;OACd,IAAI,YAAY,WAAW,KAAK,YAAY,EAAE,CAAC,OAAO,OAE3D,OAAO;GAAE,MAAM;GAAO,IAAI;GAAO,YAAY,CAAC,GAAG,WAAW,GAAG,YAAY,EAAE,CAAC,UAAU;EAAE;OACrF,IAAI,UAAU,SAAS,KAAK,YAAY,SAAS,GAEtD,OAAO;GAAE,MAAM;GAAO,IAAI;GAAO,YAAY,CAAC,GAAG,WAAW,GAAG,WAAW;EAAE;CAGhF;AACF;;AAGA,SAAS,gBAAgB,YAAgF;CAEvG,MAAM,CAAC,IAAI,eACT,SAAS,cAAc,WAAW,MAC9B,CAAC,OAAgB,WAAW,GAAG,IAC/B,QAAQ,cAAc,WAAW,KAC/B,CAAC,MAAe,WAAW,EAAE,IAC7B,KAAK,sBAAsB,YAAY;CAE/C,MAAM,aAAa,YAAY,KAAK,QAAS,QAAQ,SAAS,OAAO,QAAQ,OAAO,gBAAgB,GAAG,IAAI,GAAI;CAC/G,MAAM,CAAC,MAAM,SAAS,UAAU,aAAa,SAAS,SAAS,KAAA,KAAa,SAAS,aAAa;CAClG,IAAK,KAAK,SAAS,KAAK,WAAW,qBAAqB,SAAU,MAAM,WAAW,GACjF;CAEF,OAAO;EAAE,MAAM;EAAO;EAAI,YAAY,MAAM,OAAO,SAAS;CAAE;AAChE"}

package/build/queries/conditions.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/queries/conditions.ts
+const predicateBrand = Symbol("joist.predicate");
+/** Marks a newly created predicate without changing its enumerable SQL representation. */
+function brandPredicate(cond, kind) {
+	return Object.defineProperty(cond, predicateBrand, {
+		value: kind,
+		enumerable: false
+	});
+}
+//#endregion
+exports.brandPredicate = brandPredicate;
+exports.predicateBrand = predicateBrand;
+
+//# sourceMappingURL=conditions.cjs.map

package/build/queries/conditions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.cjs","names":[],"sources":["../../src/queries/conditions.ts"],"sourcesContent":["import type { ColumnCondition, RawCondition } from \"src/queries/parsedConditions.ts\";\n\nexport const predicateBrand: unique symbol = Symbol(\"joist.predicate\");\n\n/** Combines conditions without tying AND/OR or optional-filter pruning to either public API. */\nexport type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;\n\n/** Requires every surviving condition to match. */\nexport interface AndCondition<C> {\n  and: Array<C | undefined>;\n  or?: never;\n  pruneIfUndefined?: \"any\" | \"all\";\n}\n\n/** Requires at least one surviving condition to match. */\nexport interface OrCondition<C> {\n  or: Array<C | undefined>;\n  and?: never;\n  pruneIfUndefined?: \"any\" | \"all\";\n}\n\n/** Identifies which API can resolve a predicate's aliases. */\nexport interface PredicateBrand<K extends \"domain\" | \"sql\"> {\n  readonly [predicateBrand]: K;\n}\n\n/** A predicate built from alias(...) for em.find and scopes. */\nexport type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<\"domain\">;\n\n/** A predicate built from table(...), an SQL expression, or sql.condition. */\nexport type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<\"sql\">;\n\n/** Existing hand-written conditions remain an escape hatch, but cannot accept a foreign branded predicate. */\nexport type UnbrandedPredicate = (ColumnCondition | RawCondition) & { readonly [predicateBrand]?: never };\n\n/** SQL predicates and nested AND/OR groups, before query-specific clauses such as EXISTS are added. */\nexport type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;\n\n/** Unbranded compiler input shared by domain filtering and SQL queries after public API validation. */\nexport type ConditionInput =\n  | AndCondition<ConditionInput>\n  | OrCondition<ConditionInput>\n  | ColumnCondition\n  | RawCondition;\n\n/** Marks a newly created predicate without changing its enumerable SQL representation. */\nexport function brandPredicate<C extends object, K extends \"domain\" | \"sql\">(cond: C, kind: K): C & PredicateBrand<K> {\n  return Object.defineProperty(cond, predicateBrand, { value: kind, enumerable: false }) as C & PredicateBrand<K>;\n}\n"],"mappings":";;AAEA,MAAa,iBAAgC,OAAO,iBAAiB;;AA4CrE,SAAgB,eAA6D,MAAS,MAAgC;CACpH,OAAO,OAAO,eAAe,MAAM,gBAAgB;EAAE,OAAO;EAAM,YAAY;CAAM,CAAC;AACvF"}

package/build/queries/conditions.d.cts

@@ -0,0 +1,38 @@
+import { ColumnCondition, RawCondition } from "./parsedConditions.cjs";
+//#region src/queries/conditions.d.ts
+declare const predicateBrand: unique symbol;
+/** Combines conditions without tying AND/OR or optional-filter pruning to either public API. */
+type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;
+/** Requires every surviving condition to match. */
+interface AndCondition<C> {
+  and: Array<C | undefined>;
+  or?: never;
+  pruneIfUndefined?: "any" | "all";
+}
+/** Requires at least one surviving condition to match. */
+interface OrCondition<C> {
+  or: Array<C | undefined>;
+  and?: never;
+  pruneIfUndefined?: "any" | "all";
+}
+/** Identifies which API can resolve a predicate's aliases. */
+interface PredicateBrand<K extends "domain" | "sql"> {
+  readonly [predicateBrand]: K;
+}
+/** A predicate built from alias(...) for em.find and scopes. */
+type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"domain">;
+/** A predicate built from table(...), an SQL expression, or sql.condition. */
+type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"sql">;
+/** Existing hand-written conditions remain an escape hatch, but cannot accept a foreign branded predicate. */
+type UnbrandedPredicate = (ColumnCondition | RawCondition) & {
+  readonly [predicateBrand]?: never;
+};
+/** SQL predicates and nested AND/OR groups, before query-specific clauses such as EXISTS are added. */
+type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;
+/** Unbranded compiler input shared by domain filtering and SQL queries after public API validation. */
+type ConditionInput = AndCondition<ConditionInput> | OrCondition<ConditionInput> | ColumnCondition | RawCondition;
+/** Marks a newly created predicate without changing its enumerable SQL representation. */
+declare function brandPredicate<C extends object, K extends "domain" | "sql">(cond: C, kind: K): C & PredicateBrand<K>;
+//#endregion
+export { AndCondition, ConditionGroup, ConditionInput, DomainPredicate, OrCondition, PredicateBrand, SqlCondition, SqlPredicate, UnbrandedPredicate, brandPredicate, predicateBrand };
+//# sourceMappingURL=conditions.d.cts.map

package/build/queries/conditions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.cts","names":[],"sources":["../../src/queries/conditions.ts"],"mappings":";;cAEa;;KAGD,eAAe,KAAK,aAAa,KAAK,YAAY;;UAG7C,aAAa;EAC5B,KAAK,MAAM;EACX;EACA;;;UAIe,YAAY;EAC3B,IAAI,MAAM;EACV;EACA;;;UAIe,eAAe;YACpB,iBAAiB;;;KAIjB,mBAAmB,kBAAkB,gBAAgB;;KAGrD,gBAAgB,kBAAkB,gBAAgB;;KAGlD,sBAAsB,kBAAkB;YAA4B;;;KAGpE,eAAe,aAAa,gBAAgB,YAAY,gBAAgB,eAAe;;KAGvF,iBACR,aAAa,kBACb,YAAY,kBACZ,kBACA;;iBAGY,eAAe,kBAAkB,4BAA4B,MAAM,GAAG,MAAM,IAAI,IAAI,eAAe"}

package/build/queries/conditions.d.mts

@@ -0,0 +1,38 @@
+import { ColumnCondition, RawCondition } from "./parsedConditions.mjs";
+//#region src/queries/conditions.d.ts
+declare const predicateBrand: unique symbol;
+/** Combines conditions without tying AND/OR or optional-filter pruning to either public API. */
+type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;
+/** Requires every surviving condition to match. */
+interface AndCondition<C> {
+  and: Array<C | undefined>;
+  or?: never;
+  pruneIfUndefined?: "any" | "all";
+}
+/** Requires at least one surviving condition to match. */
+interface OrCondition<C> {
+  or: Array<C | undefined>;
+  and?: never;
+  pruneIfUndefined?: "any" | "all";
+}
+/** Identifies which API can resolve a predicate's aliases. */
+interface PredicateBrand<K extends "domain" | "sql"> {
+  readonly [predicateBrand]: K;
+}
+/** A predicate built from alias(...) for em.find and scopes. */
+type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"domain">;
+/** A predicate built from table(...), an SQL expression, or sql.condition. */
+type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"sql">;
+/** Existing hand-written conditions remain an escape hatch, but cannot accept a foreign branded predicate. */
+type UnbrandedPredicate = (ColumnCondition | RawCondition) & {
+  readonly [predicateBrand]?: never;
+};
+/** SQL predicates and nested AND/OR groups, before query-specific clauses such as EXISTS are added. */
+type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;
+/** Unbranded compiler input shared by domain filtering and SQL queries after public API validation. */
+type ConditionInput = AndCondition<ConditionInput> | OrCondition<ConditionInput> | ColumnCondition | RawCondition;
+/** Marks a newly created predicate without changing its enumerable SQL representation. */
+declare function brandPredicate<C extends object, K extends "domain" | "sql">(cond: C, kind: K): C & PredicateBrand<K>;
+//#endregion
+export { AndCondition, ConditionGroup, ConditionInput, DomainPredicate, OrCondition, PredicateBrand, SqlCondition, SqlPredicate, UnbrandedPredicate, brandPredicate, predicateBrand };
+//# sourceMappingURL=conditions.d.mts.map

package/build/queries/conditions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.mts","names":[],"sources":["../../src/queries/conditions.ts"],"mappings":";;cAEa;;KAGD,eAAe,KAAK,aAAa,KAAK,YAAY;;UAG7C,aAAa;EAC5B,KAAK,MAAM;EACX;EACA;;;UAIe,YAAY;EAC3B,IAAI,MAAM;EACV;EACA;;;UAIe,eAAe;YACpB,iBAAiB;;;KAIjB,mBAAmB,kBAAkB,gBAAgB;;KAGrD,gBAAgB,kBAAkB,gBAAgB;;KAGlD,sBAAsB,kBAAkB;YAA4B;;;KAGpE,eAAe,aAAa,gBAAgB,YAAY,gBAAgB,eAAe;;KAGvF,iBACR,aAAa,kBACb,YAAY,kBACZ,kBACA;;iBAGY,eAAe,kBAAkB,4BAA4B,MAAM,GAAG,MAAM,IAAI,IAAI,eAAe"}

package/build/queries/conditions.js

@@ -0,0 +1,13 @@
+//#region src/queries/conditions.ts
+const predicateBrand = Symbol("joist.predicate");
+/** Marks a newly created predicate without changing its enumerable SQL representation. */
+function brandPredicate(cond, kind) {
+	return Object.defineProperty(cond, predicateBrand, {
+		value: kind,
+		enumerable: false
+	});
+}
+//#endregion
+export { brandPredicate, predicateBrand };
+
+//# sourceMappingURL=conditions.js.map

package/build/queries/conditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.js","names":[],"sources":["../../src/queries/conditions.ts"],"sourcesContent":["import type { ColumnCondition, RawCondition } from \"src/queries/parsedConditions.ts\";\n\nexport const predicateBrand: unique symbol = Symbol(\"joist.predicate\");\n\n/** Combines conditions without tying AND/OR or optional-filter pruning to either public API. */\nexport type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;\n\n/** Requires every surviving condition to match. */\nexport interface AndCondition<C> {\n  and: Array<C | undefined>;\n  or?: never;\n  pruneIfUndefined?: \"any\" | \"all\";\n}\n\n/** Requires at least one surviving condition to match. */\nexport interface OrCondition<C> {\n  or: Array<C | undefined>;\n  and?: never;\n  pruneIfUndefined?: \"any\" | \"all\";\n}\n\n/** Identifies which API can resolve a predicate's aliases. */\nexport interface PredicateBrand<K extends \"domain\" | \"sql\"> {\n  readonly [predicateBrand]: K;\n}\n\n/** A predicate built from alias(...) for em.find and scopes. */\nexport type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<\"domain\">;\n\n/** A predicate built from table(...), an SQL expression, or sql.condition. */\nexport type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<\"sql\">;\n\n/** Existing hand-written conditions remain an escape hatch, but cannot accept a foreign branded predicate. */\nexport type UnbrandedPredicate = (ColumnCondition | RawCondition) & { readonly [predicateBrand]?: never };\n\n/** SQL predicates and nested AND/OR groups, before query-specific clauses such as EXISTS are added. */\nexport type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;\n\n/** Unbranded compiler input shared by domain filtering and SQL queries after public API validation. */\nexport type ConditionInput =\n  | AndCondition<ConditionInput>\n  | OrCondition<ConditionInput>\n  | ColumnCondition\n  | RawCondition;\n\n/** Marks a newly created predicate without changing its enumerable SQL representation. */\nexport function brandPredicate<C extends object, K extends \"domain\" | \"sql\">(cond: C, kind: K): C & PredicateBrand<K> {\n  return Object.defineProperty(cond, predicateBrand, { value: kind, enumerable: false }) as C & PredicateBrand<K>;\n}\n"],"mappings":";AAEA,MAAa,iBAAgC,OAAO,iBAAiB;;AA4CrE,SAAgB,eAA6D,MAAS,MAAgC;CACpH,OAAO,OAAO,eAAe,MAAM,gBAAgB;EAAE,OAAO;EAAM,YAAY;CAAM,CAAC;AACvF"}

package/build/queries/entityQueryUtils.cjs

@@ -0,0 +1,60 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_queries_sql_keywords = require("./sql/keywords.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+//#region src/queries/entityQueryUtils.ts
+/**
+* Builds the primary table's SELECT columns explicitly, i.e. excluding any `lazy` columns.
+*
+* Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so
+* that entities without lazy columns emit byte-identical SQL to before this feature existed.
+*/
+function lazyExcludedSelects(meta, alias) {
+	const selects = [];
+	for (const field of Object.values(meta.fields)) {
+		if (!field.serde) continue;
+		if (field.kind === "primitive" && field.lazy) continue;
+		for (const column of field.serde.columns) selects.push(require_queries_sql_keywords.kqDot(alias, column.columnName));
+	}
+	return selects;
+}
+/** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */
+function maybeAddNotSoftDeleted(conditions, meta, alias, softDeletes) {
+	if (filterSoftDeletes(meta, softDeletes)) {
+		const column = meta.allFields[require_EntityMetadata.getBaseMeta(meta).timestampFields.deletedAt].serde?.columns[0];
+		conditions.push({
+			kind: "column",
+			alias,
+			column: column.columnName,
+			dbType: column.dbType,
+			cond: { kind: "is-null" }
+		});
+	}
+}
+/** Returns whether the entity supports and requires soft-delete filtering for this query. */
+function filterSoftDeletes(meta, softDeletes) {
+	return softDeletes === "exclude" && !!require_EntityMetadata.getBaseMeta(meta).timestampFields?.deletedAt && (meta.inheritanceType !== "cti" || meta.baseTypes.length === 0);
+}
+/** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */
+function stiSubtypeFilter(meta, alias) {
+	if (meta.inheritanceType !== "sti" || meta.stiDiscriminatorValue === void 0) return void 0;
+	const baseMeta = require_EntityMetadata.getBaseMeta(meta);
+	const column = baseMeta.fields[baseMeta.stiDiscriminatorField].serde?.columns[0];
+	return {
+		kind: "column",
+		alias,
+		column: column.columnName,
+		dbType: column.dbType,
+		cond: {
+			kind: "eq",
+			value: meta.stiDiscriminatorValue
+		},
+		pruneable: true
+	};
+}
+//#endregion
+exports.filterSoftDeletes = filterSoftDeletes;
+exports.lazyExcludedSelects = lazyExcludedSelects;
+exports.maybeAddNotSoftDeleted = maybeAddNotSoftDeleted;
+exports.stiSubtypeFilter = stiSubtypeFilter;
+
+//# sourceMappingURL=entityQueryUtils.cjs.map

package/build/queries/entityQueryUtils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityQueryUtils.cjs","names":["kqDot","getBaseMeta"],"sources":["../../src/queries/entityQueryUtils.ts"],"sourcesContent":["import { type EntityMetadata, getBaseMeta } from \"src/EntityMetadata.ts\";\nimport type { ColumnCondition } from \"src/queries/parsedConditions.ts\";\nimport { kqDot } from \"src/queries/sql/keywords.ts\";\n\n/**\n * Builds the primary table's SELECT columns explicitly, i.e. excluding any `lazy` columns.\n *\n * Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so\n * that entities without lazy columns emit byte-identical SQL to before this feature existed.\n */\nexport function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[] {\n  const selects: string[] = [];\n  for (const field of Object.values(meta.fields)) {\n    if (!field.serde) continue;\n    if (field.kind === \"primitive\" && field.lazy) continue;\n    for (const column of field.serde.columns) selects.push(kqDot(alias, column.columnName));\n  }\n  return selects;\n}\n\n/** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */\nexport function maybeAddNotSoftDeleted(\n  conditions: ColumnCondition[],\n  meta: EntityMetadata,\n  alias: string,\n  softDeletes: \"include\" | \"exclude\",\n): void {\n  if (filterSoftDeletes(meta, softDeletes)) {\n    const column = meta.allFields[getBaseMeta(meta).timestampFields!.deletedAt!].serde?.columns[0]!;\n    conditions.push({\n      kind: \"column\",\n      alias,\n      column: column.columnName,\n      dbType: column.dbType,\n      cond: { kind: \"is-null\" },\n    });\n  }\n}\n\n/** Returns whether the entity supports and requires soft-delete filtering for this query. */\nexport function filterSoftDeletes(meta: EntityMetadata, softDeletes: \"include\" | \"exclude\"): boolean {\n  return (\n    softDeletes === \"exclude\" &&\n    !!getBaseMeta(meta).timestampFields?.deletedAt &&\n    // We don't support CTI subtype soft-delete filtering yet\n    (meta.inheritanceType !== \"cti\" || meta.baseTypes.length === 0)\n  );\n}\n\n/** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */\nexport function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined {\n  if (meta.inheritanceType !== \"sti\" || meta.stiDiscriminatorValue === undefined) return undefined;\n  const baseMeta = getBaseMeta(meta);\n  const column = baseMeta.fields[baseMeta.stiDiscriminatorField!].serde?.columns[0]!;\n  return {\n    kind: \"column\",\n    alias,\n    column: column.columnName,\n    dbType: column.dbType,\n    cond: { kind: \"eq\", value: meta.stiDiscriminatorValue },\n    pruneable: true,\n  };\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,oBAAoB,MAAsB,OAAyB;CACjF,MAAM,UAAoB,CAAC;CAC3B,KAAK,MAAM,SAAS,OAAO,OAAO,KAAK,MAAM,GAAG;EAC9C,IAAI,CAAC,MAAM,OAAO;EAClB,IAAI,MAAM,SAAS,eAAe,MAAM,MAAM;EAC9C,KAAK,MAAM,UAAU,MAAM,MAAM,SAAS,QAAQ,KAAKA,6BAAAA,MAAM,OAAO,OAAO,UAAU,CAAC;CACxF;CACA,OAAO;AACT;;AAGA,SAAgB,uBACd,YACA,MACA,OACA,aACM;CACN,IAAI,kBAAkB,MAAM,WAAW,GAAG;EACxC,MAAM,SAAS,KAAK,UAAUC,uBAAAA,YAAY,IAAI,CAAC,CAAC,gBAAiB,UAAW,CAAC,OAAO,QAAQ;EAC5F,WAAW,KAAK;GACd,MAAM;GACN;GACA,QAAQ,OAAO;GACf,QAAQ,OAAO;GACf,MAAM,EAAE,MAAM,UAAU;EAC1B,CAAC;CACH;AACF;;AAGA,SAAgB,kBAAkB,MAAsB,aAA6C;CACnG,OACE,gBAAgB,aAChB,CAAC,CAACA,uBAAAA,YAAY,IAAI,CAAC,CAAC,iBAAiB,cAEpC,KAAK,oBAAoB,SAAS,KAAK,UAAU,WAAW;AAEjE;;AAGA,SAAgB,iBAAiB,MAAsB,OAA4C;CACjG,IAAI,KAAK,oBAAoB,SAAS,KAAK,0BAA0B,KAAA,GAAW,OAAO,KAAA;CACvF,MAAM,WAAWA,uBAAAA,YAAY,IAAI;CACjC,MAAM,SAAS,SAAS,OAAO,SAAS,sBAAuB,CAAC,OAAO,QAAQ;CAC/E,OAAO;EACL,MAAM;EACN;EACA,QAAQ,OAAO;EACf,QAAQ,OAAO;EACf,MAAM;GAAE,MAAM;GAAM,OAAO,KAAK;EAAsB;EACtD,WAAW;CACb;AACF"}

package/build/queries/entityQueryUtils.d.cts

@@ -0,0 +1,19 @@
+import { ColumnCondition } from "./parsedConditions.cjs";
+import { EntityMetadata } from "../EntityMetadata.cjs";
+//#region src/queries/entityQueryUtils.d.ts
+/**
+ * Builds the primary table's SELECT columns explicitly, i.e. excluding any `lazy` columns.
+ *
+ * Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so
+ * that entities without lazy columns emit byte-identical SQL to before this feature existed.
+ */
+declare function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[];
+/** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */
+declare function maybeAddNotSoftDeleted(conditions: ColumnCondition[], meta: EntityMetadata, alias: string, softDeletes: "include" | "exclude"): void;
+/** Returns whether the entity supports and requires soft-delete filtering for this query. */
+declare function filterSoftDeletes(meta: EntityMetadata, softDeletes: "include" | "exclude"): boolean;
+/** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */
+declare function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined;
+//#endregion
+export { filterSoftDeletes, lazyExcludedSelects, maybeAddNotSoftDeleted, stiSubtypeFilter };
+//# sourceMappingURL=entityQueryUtils.d.cts.map

package/build/queries/entityQueryUtils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityQueryUtils.d.cts","names":[],"sources":["../../src/queries/entityQueryUtils.ts"],"mappings":";;;;;;;;;iBAUgB,oBAAoB,MAAM,gBAAgB;;iBAW1C,uBACd,YAAY,mBACZ,MAAM,gBACN,eACA;;iBAec,kBAAkB,MAAM,gBAAgB;;iBAUxC,iBAAiB,MAAM,gBAAgB,gBAAgB"}

package/build/queries/entityQueryUtils.d.mts

@@ -0,0 +1,19 @@
+import { ColumnCondition } from "./parsedConditions.mjs";
+import { EntityMetadata } from "../EntityMetadata.mjs";
+//#region src/queries/entityQueryUtils.d.ts
+/**
+ * Builds the primary table's SELECT columns explicitly, i.e. excluding any `lazy` columns.
+ *
+ * Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so
+ * that entities without lazy columns emit byte-identical SQL to before this feature existed.
+ */
+declare function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[];
+/** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */
+declare function maybeAddNotSoftDeleted(conditions: ColumnCondition[], meta: EntityMetadata, alias: string, softDeletes: "include" | "exclude"): void;
+/** Returns whether the entity supports and requires soft-delete filtering for this query. */
+declare function filterSoftDeletes(meta: EntityMetadata, softDeletes: "include" | "exclude"): boolean;
+/** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */
+declare function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined;
+//#endregion
+export { filterSoftDeletes, lazyExcludedSelects, maybeAddNotSoftDeleted, stiSubtypeFilter };
+//# sourceMappingURL=entityQueryUtils.d.mts.map

package/build/queries/entityQueryUtils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityQueryUtils.d.mts","names":[],"sources":["../../src/queries/entityQueryUtils.ts"],"mappings":";;;;;;;;;iBAUgB,oBAAoB,MAAM,gBAAgB;;iBAW1C,uBACd,YAAY,mBACZ,MAAM,gBACN,eACA;;iBAec,kBAAkB,MAAM,gBAAgB;;iBAUxC,iBAAiB,MAAM,gBAAgB,gBAAgB"}

package/build/queries/entityQueryUtils.js

@@ -0,0 +1,56 @@
+import { kqDot } from "./sql/keywords.js";
+import { getBaseMeta } from "../EntityMetadata.js";
+//#region src/queries/entityQueryUtils.ts
+/**
+* Builds the primary table's SELECT columns explicitly, i.e. excluding any `lazy` columns.
+*
+* Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so
+* that entities without lazy columns emit byte-identical SQL to before this feature existed.
+*/
+function lazyExcludedSelects(meta, alias) {
+	const selects = [];
+	for (const field of Object.values(meta.fields)) {
+		if (!field.serde) continue;
+		if (field.kind === "primitive" && field.lazy) continue;
+		for (const column of field.serde.columns) selects.push(kqDot(alias, column.columnName));
+	}
+	return selects;
+}
+/** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */
+function maybeAddNotSoftDeleted(conditions, meta, alias, softDeletes) {
+	if (filterSoftDeletes(meta, softDeletes)) {
+		const column = meta.allFields[getBaseMeta(meta).timestampFields.deletedAt].serde?.columns[0];
+		conditions.push({
+			kind: "column",
+			alias,
+			column: column.columnName,
+			dbType: column.dbType,
+			cond: { kind: "is-null" }
+		});
+	}
+}
+/** Returns whether the entity supports and requires soft-delete filtering for this query. */
+function filterSoftDeletes(meta, softDeletes) {
+	return softDeletes === "exclude" && !!getBaseMeta(meta).timestampFields?.deletedAt && (meta.inheritanceType !== "cti" || meta.baseTypes.length === 0);
+}
+/** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */
+function stiSubtypeFilter(meta, alias) {
+	if (meta.inheritanceType !== "sti" || meta.stiDiscriminatorValue === void 0) return void 0;
+	const baseMeta = getBaseMeta(meta);
+	const column = baseMeta.fields[baseMeta.stiDiscriminatorField].serde?.columns[0];
+	return {
+		kind: "column",
+		alias,
+		column: column.columnName,
+		dbType: column.dbType,
+		cond: {
+			kind: "eq",
+			value: meta.stiDiscriminatorValue
+		},
+		pruneable: true
+	};
+}
+//#endregion
+export { filterSoftDeletes, lazyExcludedSelects, maybeAddNotSoftDeleted, stiSubtypeFilter };
+
+//# sourceMappingURL=entityQueryUtils.js.map

package/build/queries/entityQueryUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityQueryUtils.js","names":[],"sources":["../../src/queries/entityQueryUtils.ts"],"sourcesContent":["import { type EntityMetadata, getBaseMeta } from \"src/EntityMetadata.ts\";\nimport type { ColumnCondition } from \"src/queries/parsedConditions.ts\";\nimport { kqDot } from \"src/queries/sql/keywords.ts\";\n\n/**\n * Builds the primary table's SELECT columns explicitly, i.e. excluding any `lazy` columns.\n *\n * Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so\n * that entities without lazy columns emit byte-identical SQL to before this feature existed.\n */\nexport function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[] {\n  const selects: string[] = [];\n  for (const field of Object.values(meta.fields)) {\n    if (!field.serde) continue;\n    if (field.kind === \"primitive\" && field.lazy) continue;\n    for (const column of field.serde.columns) selects.push(kqDot(alias, column.columnName));\n  }\n  return selects;\n}\n\n/** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */\nexport function maybeAddNotSoftDeleted(\n  conditions: ColumnCondition[],\n  meta: EntityMetadata,\n  alias: string,\n  softDeletes: \"include\" | \"exclude\",\n): void {\n  if (filterSoftDeletes(meta, softDeletes)) {\n    const column = meta.allFields[getBaseMeta(meta).timestampFields!.deletedAt!].serde?.columns[0]!;\n    conditions.push({\n      kind: \"column\",\n      alias,\n      column: column.columnName,\n      dbType: column.dbType,\n      cond: { kind: \"is-null\" },\n    });\n  }\n}\n\n/** Returns whether the entity supports and requires soft-delete filtering for this query. */\nexport function filterSoftDeletes(meta: EntityMetadata, softDeletes: \"include\" | \"exclude\"): boolean {\n  return (\n    softDeletes === \"exclude\" &&\n    !!getBaseMeta(meta).timestampFields?.deletedAt &&\n    // We don't support CTI subtype soft-delete filtering yet\n    (meta.inheritanceType !== \"cti\" || meta.baseTypes.length === 0)\n  );\n}\n\n/** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */\nexport function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined {\n  if (meta.inheritanceType !== \"sti\" || meta.stiDiscriminatorValue === undefined) return undefined;\n  const baseMeta = getBaseMeta(meta);\n  const column = baseMeta.fields[baseMeta.stiDiscriminatorField!].serde?.columns[0]!;\n  return {\n    kind: \"column\",\n    alias,\n    column: column.columnName,\n    dbType: column.dbType,\n    cond: { kind: \"eq\", value: meta.stiDiscriminatorValue },\n    pruneable: true,\n  };\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,oBAAoB,MAAsB,OAAyB;CACjF,MAAM,UAAoB,CAAC;CAC3B,KAAK,MAAM,SAAS,OAAO,OAAO,KAAK,MAAM,GAAG;EAC9C,IAAI,CAAC,MAAM,OAAO;EAClB,IAAI,MAAM,SAAS,eAAe,MAAM,MAAM;EAC9C,KAAK,MAAM,UAAU,MAAM,MAAM,SAAS,QAAQ,KAAK,MAAM,OAAO,OAAO,UAAU,CAAC;CACxF;CACA,OAAO;AACT;;AAGA,SAAgB,uBACd,YACA,MACA,OACA,aACM;CACN,IAAI,kBAAkB,MAAM,WAAW,GAAG;EACxC,MAAM,SAAS,KAAK,UAAU,YAAY,IAAI,CAAC,CAAC,gBAAiB,UAAW,CAAC,OAAO,QAAQ;EAC5F,WAAW,KAAK;GACd,MAAM;GACN;GACA,QAAQ,OAAO;GACf,QAAQ,OAAO;GACf,MAAM,EAAE,MAAM,UAAU;EAC1B,CAAC;CACH;AACF;;AAGA,SAAgB,kBAAkB,MAAsB,aAA6C;CACnG,OACE,gBAAgB,aAChB,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,iBAAiB,cAEpC,KAAK,oBAAoB,SAAS,KAAK,UAAU,WAAW;AAEjE;;AAGA,SAAgB,iBAAiB,MAAsB,OAA4C;CACjG,IAAI,KAAK,oBAAoB,SAAS,KAAK,0BAA0B,KAAA,GAAW,OAAO,KAAA;CACvF,MAAM,WAAW,YAAY,IAAI;CACjC,MAAM,SAAS,SAAS,OAAO,SAAS,sBAAuB,CAAC,OAAO,QAAQ;CAC/E,OAAO;EACL,MAAM;EACN;EACA,QAAQ,OAAO;EACf,QAAQ,OAAO;EACf,MAAM;GAAE,MAAM;GAAM,OAAO,KAAK;EAAsB;EACtD,WAAW;CACb;AACF"}