joist-core 2.3.0-next.96 → 2.3.0-next.97

package/build/queries/valueFilters.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFilters.cjs","names":["isAlias","isScope","isEntity","isPlainObject","isDefined","assertNever"],"sources":["../../src/queries/valueFilters.ts"],"sourcesContent":["import { isPlainObject } from \"joist-utils\";\n\nimport type { Column } from \"../columns.ts\";\nimport { type Entity, isEntity } from \"../Entity.ts\";\nimport { isDefined } from \"../EntityManager.ts\";\nimport type { EntityMetadata } from \"../EntityMetadata.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { isAlias } from \"./find/Aliases.ts\";\nimport type { ValueFilter } from \"./find/EntityFilter.ts\";\nimport { isScope } from \"./find/scopes.ts\";\nimport type { ParsedValueFilter } from \"./parsedConditions.ts\";\n\n/** An ADT version of `EntityFilter`. */\nexport type ParsedEntityFilter =\n  // ParsedValueFilter is any simple match on `id`\n  | ParsedValueFilter<string | number>\n  // Otherwise we return the join/complex\n  | { kind: \"join\"; subFilter: object };\n\n/** Parses an entity filter, which could be \"just an id\", an array of ids, or a nested filter. */\nexport function parseEntityFilter(meta: EntityMetadata, filter: any): ParsedEntityFilter | undefined {\n  if (filter === undefined) {\n    // This matches legacy `em.find(Book, { author: undefined })` behavior\n    return undefined;\n  } else if (isAlias(filter)) {\n    // We're just binding an alias to this position in the join tree\n    return undefined;\n  } else if (isScope(filter)) {\n    // A scope on a relation (e.g. `{ author: Author.adult }`) always implies conditions on the\n    // related entity, so signal \"needs a join\" via the existing `join` discriminant rather than\n    // adding a dedicated `kind: \"scope\"` that every relation branch would have to learn. The empty\n    // `subFilter` is intentionally never read: the m2o/m2m branches only check `kind === \"join\"` to\n    // decide whether to join, then re-dispatch the original scope value back through `addTable`,\n    // where `isScope(...)` routes it to `addScopeFilterAt` to apply the scope's actual fragments.\n    return { kind: \"join\", subFilter: {} };\n  } else if (filter === null) {\n    return { kind: \"is-null\" };\n  } else if (typeof filter === \"string\" || typeof filter === \"number\") {\n    return { kind: \"eq\", value: filter };\n  } else if (typeof filter === \"boolean\") {\n    return filter ? { kind: \"not-null\" } : { kind: \"is-null\" };\n  } else if (Array.isArray(filter)) {\n    return {\n      kind: \"in\",\n      value: filter.map((v: string | number | Entity) => {\n        return isEntity(v) ? (v.idTaggedMaybe ?? nilIdValue(meta)) : v;\n      }),\n    };\n  } else if (isEntity(filter)) {\n    return { kind: \"eq\", value: filter.idTaggedMaybe || nilIdValue(meta) };\n  } else if (typeof filter === \"object\") {\n    // Looking for `{ firstName: \"f1\" }` or `{ ne: \"f1\" }`\n    const keys = Object.keys(filter);\n    // Special case only looking at `ne`\n    if (keys.length === 1 && keys[0] === \"ne\") {\n      const value = filter[\"ne\"];\n      if (value === undefined) {\n        return undefined;\n      } else if (value === null) {\n        return { kind: \"not-null\" };\n      } else if (typeof value === \"string\" || typeof value === \"number\") {\n        return { kind: \"ne\", value };\n      } else if (isEntity(value)) {\n        return { kind: \"ne\", value: value.idTaggedMaybe || nilIdValue(meta) };\n      } else {\n        throw new Error(`Unsupported \"ne\" value ${value}`);\n      }\n    }\n    // Special case only looking at `id`\n    if (keys.length === 1 && keys[0] === \"id\") {\n      const value = filter[\"id\"];\n      if (value === undefined) {\n        return undefined;\n      } else if (value === null) {\n        return { kind: \"is-null\" };\n      } else if (typeof value === \"string\" || typeof value === \"number\") {\n        return { kind: \"eq\", value };\n      } else if (isEntity(value)) {\n        return { kind: \"eq\", value: value.idTaggedMaybe || nilIdValue(meta) };\n      } else {\n        return parseValueFilter(value)[0] as any;\n      }\n    }\n    // Look for subFilter values being EntityFilter-ish instances like ManyToOneReference\n    // that have an id, and so structurally match the entity filter without really being filters,\n    // and convert them over here before getting into parseValueFilter.\n    const subFilter = {} as any;\n    for (const [key, value] of Object.entries(filter)) {\n      if (value && typeof value === \"object\" && !isPlainObject(value) && \"idTaggedMaybe\" in value) {\n        subFilter[key] = value.idTaggedMaybe || nilIdValue(meta);\n      } else {\n        subFilter[key] = value;\n      }\n    }\n    return { kind: \"join\", subFilter };\n  } else {\n    throw new Error(`Unrecognized filter ${filter}`);\n  }\n}\n\n/**\n * Parses the many/hodgepodge (ergonomic!) patterns of value filters into a `ParsedValueFilter[]`.\n *\n * Note we return an array because filter might be a `ValueGraphQLFilter` that is allowed to have\n * multiple conditions, i.e. `{ lt: 10, gt: 5 }`.\n */\nexport function parseValueFilter<V>(filter: ValueFilter<V, any>): ParsedValueFilter<V>[] {\n  if (filter === null) {\n    return [{ kind: \"is-null\" }];\n  } else if (filter === undefined) {\n    // This is legacy behavior where `em.find(Book, { author: undefined })` would match all books\n    return [];\n  } else if (Array.isArray(filter)) {\n    return [{ kind: \"in\", value: filter }];\n  } else if (isPlainObject(filter)) {\n    const keys = Object.keys(filter);\n    if (keys.length === 0) {\n      // Should this be an error?\n      return [];\n    } else if (keys.length === 2 && \"op\" in filter && \"value\" in filter) {\n      // Probe for `findGql` op & value\n      const { op, value } = filter;\n      if (shouldPruneValueFilter(op, value)) {\n        return [];\n      } else if (value === null) {\n        return [{ kind: \"is-null\" }];\n      } else {\n        return [{ kind: op, value: value ?? null }];\n      }\n    } else if (keys.length === 2 && \"gte\" in filter && \"lte\" in filter) {\n      const { gte, lte } = filter;\n      return [{ kind: \"between\", value: [gte, lte] }];\n    } else {\n      return Object.entries(filter)\n        .map(([key, value]) => {\n          // Always do condition pruning on the value\n          if (shouldPruneValueFilter(key, value)) {\n            return undefined;\n          }\n          switch (key) {\n            case \"eq\":\n              if (value === null) {\n                return { kind: \"is-null\" as const };\n              } else {\n                return { kind: \"eq\" as const, value: filter[key] };\n              }\n            case \"ne\":\n              if (value === null) {\n                return { kind: \"not-null\" as const };\n              } else {\n                return { kind: \"ne\" as const, value: filter[key] ?? null };\n              }\n            case \"in\":\n            case \"nin\":\n            case \"gt\":\n            case \"gte\":\n            case \"lt\":\n            case \"lte\":\n            case \"like\":\n            case \"nlike\":\n            case \"ilike\":\n            case \"nilike\":\n            case \"regex\":\n            case \"nregex\":\n            case \"iregex\":\n            case \"niregex\":\n            case \"contains\":\n            case \"overlaps\":\n            case \"containedBy\":\n              return { kind: key, value: filter[key] };\n            case \"pathExists\":\n              return { kind: \"jsonPathExists\" as const, value: filter[key] };\n            case \"pathIsTrue\":\n              return { kind: \"jsonPathPredicate\" as const, value: filter[key] };\n            case \"search\":\n              return { kind: \"ilike\" as const, value: makeLike(filter[key]) };\n            case \"between\":\n              return { kind: key, value: filter[key] };\n            default:\n              throw new Error(`Unsupported value filter key ${key}`);\n          }\n        })\n        .filter(isDefined);\n    }\n  } else {\n    // This is a primitive like a string, number\n    return [{ kind: \"eq\", value: filter }];\n  }\n}\n\n/** Converts domain-level values like string ids/enums into their db equivalent. */\nexport function mapToDb(column: Column, filter: ParsedValueFilter<any>): ParsedValueFilter<any> {\n  // ...to teach this `mapToDb` function to handle/rewrite `in: [1, null]` handling, we'd need to:\n  // 1. return a maybe-simple/maybe-nested condition, so basically a `ParsedExpressionCondition`, because\n  // this would let `in` return an `{ or: ... }` to all the callers.\n  // 2. also return `{ parsed: ParsedExpressionCondition, simples: SimpleCondition[] }` tuple, for the\n  // alias `addCondition` processing to track the `simples` and rewrite their alias when later bound.\n  switch (filter.kind) {\n    case \"eq\":\n    case \"gt\":\n    case \"gte\":\n    case \"ne\":\n    case \"lt\":\n    case \"lte\":\n    case \"like\":\n    case \"nlike\":\n    case \"ilike\":\n    case \"nilike\":\n    case \"regex\":\n    case \"nregex\":\n    case \"iregex\":\n    case \"niregex\":\n      filter.value = column.mapToDb(filter.value);\n      return filter;\n    case \"in\":\n      if (column.isArray) {\n        // Arrays need a special operator\n        return { kind: \"contains\", value: column.mapToDb(filter.value) };\n      } else {\n        filter.value = filter.value.map((v) => column.mapToDb(v));\n      }\n      return filter;\n    case \"nin\":\n      if (column.isArray) {\n        // Arrays need a special operator\n        throw new Error(\"The nin operator is not supported on array columns yet\");\n      } else {\n        filter.value = filter.value.map((v) => column.mapToDb(v));\n      }\n      return filter;\n    case \"contains\":\n    case \"ncontains\":\n    case \"overlaps\":\n    case \"noverlaps\":\n    case \"containedBy\":\n      const supportsContains = column.isArray || column.dbType === \"jsonb\";\n      if (!supportsContains) {\n        throw new Error(`${filter.kind} is only unsupported on array or jsonb columns`);\n      }\n      if (column.isArray) {\n        filter.value = column.mapToDb(filter.value);\n      } else {\n        // leave jsonb values alone\n      }\n      return filter;\n    case \"between\":\n      filter.value = [column.mapToDb(filter.value[0]), column.mapToDb(filter.value[1])];\n      return filter;\n    case \"is-null\":\n    case \"not-null\":\n    case \"jsonPathExists\":\n    case \"jsonPathPredicate\":\n      return filter;\n    default:\n      throw assertNever(filter);\n  }\n}\n\n/** Converts a search term like `foo bar` into a SQL `like` pattern like `%foo%bar%`. */\nexport function makeLike(search: any | undefined): any {\n  return search ? `%${search.replace(/\\s+/g, \"%\")}%` : undefined;\n}\n\n/** Recognizes placeholder IDs used when a filter contains an unpersisted entity. */\nexport function isNilIdValue(value: unknown): boolean {\n  return value === -1 || value === \"00000000-0000-0000-0000-000000000000\";\n}\n\n/**\n * We use this value if users include new (id-less) entities as em.find conditions.\n *\n * The idea is that this condition would never be met, but we still want to do the em.find\n * query in case it's in an `OR` clause that would match false, but some other part of the\n * clause would match. I.e. instead of just skipping the DB query all together, which is\n * also something we could consider doing.\n *\n * For int IDs we use -1, and for uuid IDs, we use the nil UUID value:\n *\n * https://en.wikipedia.org/wiki/Universally_unique_identifier#Nil_UUID\n */\nfunction nilIdValue(meta: EntityMetadata): any {\n  switch (meta.idDbType) {\n    case \"int\":\n    case \"bigint\":\n      return -1;\n    case \"uuid\":\n      return \"00000000-0000-0000-0000-000000000000\";\n    case \"text\":\n      return \"0\";\n    default:\n      return assertNever(meta.idDbType);\n  }\n}\n\n/** Returns true for values that should be treated like an omitted filter. */\nfunction shouldPruneValueFilter(key: unknown, value: unknown): boolean {\n  if (value === undefined) return true;\n  return value === false && key !== \"eq\" && key !== \"ne\";\n}\n"],"mappings":"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"}

package/build/queries/valueFilters.d.cts

@@ -0,0 +1,28 @@
+import { Column } from "../columns.cjs";
+import { ParsedValueFilter } from "./parsedConditions.cjs";
+import { ValueFilter } from "./find/EntityFilter.cjs";
+import { EntityMetadata } from "../EntityMetadata.cjs";
+//#region src/queries/valueFilters.d.ts
+/** An ADT version of `EntityFilter`. */
+type ParsedEntityFilter = ParsedValueFilter<string | number> | {
+  kind: "join";
+  subFilter: object;
+};
+/** Parses an entity filter, which could be "just an id", an array of ids, or a nested filter. */
+declare function parseEntityFilter(meta: EntityMetadata, filter: any): ParsedEntityFilter | undefined;
+/**
+ * Parses the many/hodgepodge (ergonomic!) patterns of value filters into a `ParsedValueFilter[]`.
+ *
+ * Note we return an array because filter might be a `ValueGraphQLFilter` that is allowed to have
+ * multiple conditions, i.e. `{ lt: 10, gt: 5 }`.
+ */
+declare function parseValueFilter<V>(filter: ValueFilter<V, any>): ParsedValueFilter<V>[];
+/** Converts domain-level values like string ids/enums into their db equivalent. */
+declare function mapToDb(column: Column, filter: ParsedValueFilter<any>): ParsedValueFilter<any>;
+/** Converts a search term like `foo bar` into a SQL `like` pattern like `%foo%bar%`. */
+declare function makeLike(search: any | undefined): any;
+/** Recognizes placeholder IDs used when a filter contains an unpersisted entity. */
+declare function isNilIdValue(value: unknown): boolean;
+//#endregion
+export { ParsedEntityFilter, isNilIdValue, makeLike, mapToDb, parseEntityFilter, parseValueFilter };
+//# sourceMappingURL=valueFilters.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valueFilters.d.cts","names":[],"sources":["../../src/queries/valueFilters.ts"],"mappings":";;;;;;KAaY,qBAER;EAEE;EAAc;;;iBAGJ,kBAAkB,MAAM,gBAAgB,cAAc;;;;;;;iBAsFtD,iBAAiB,GAAG,QAAQ,YAAY,UAAU,kBAAkB;;iBAqFpE,QAAQ,QAAQ,QAAQ,QAAQ,yBAAyB;;iBAoEzD,SAAS;;iBAKT,aAAa"}

package/build/queries/valueFilters.d.mts

@@ -0,0 +1,28 @@
+import { Column } from "../columns.mjs";
+import { ParsedValueFilter } from "./parsedConditions.mjs";
+import { ValueFilter } from "./find/EntityFilter.mjs";
+import { EntityMetadata } from "../EntityMetadata.mjs";
+//#region src/queries/valueFilters.d.ts
+/** An ADT version of `EntityFilter`. */
+type ParsedEntityFilter = ParsedValueFilter<string | number> | {
+  kind: "join";
+  subFilter: object;
+};
+/** Parses an entity filter, which could be "just an id", an array of ids, or a nested filter. */
+declare function parseEntityFilter(meta: EntityMetadata, filter: any): ParsedEntityFilter | undefined;
+/**
+ * Parses the many/hodgepodge (ergonomic!) patterns of value filters into a `ParsedValueFilter[]`.
+ *
+ * Note we return an array because filter might be a `ValueGraphQLFilter` that is allowed to have
+ * multiple conditions, i.e. `{ lt: 10, gt: 5 }`.
+ */
+declare function parseValueFilter<V>(filter: ValueFilter<V, any>): ParsedValueFilter<V>[];
+/** Converts domain-level values like string ids/enums into their db equivalent. */
+declare function mapToDb(column: Column, filter: ParsedValueFilter<any>): ParsedValueFilter<any>;
+/** Converts a search term like `foo bar` into a SQL `like` pattern like `%foo%bar%`. */
+declare function makeLike(search: any | undefined): any;
+/** Recognizes placeholder IDs used when a filter contains an unpersisted entity. */
+declare function isNilIdValue(value: unknown): boolean;
+//#endregion
+export { ParsedEntityFilter, isNilIdValue, makeLike, mapToDb, parseEntityFilter, parseValueFilter };
+//# sourceMappingURL=valueFilters.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valueFilters.d.mts","names":[],"sources":["../../src/queries/valueFilters.ts"],"mappings":";;;;;;KAaY,qBAER;EAEE;EAAc;;;iBAGJ,kBAAkB,MAAM,gBAAgB,cAAc;;;;;;;iBAsFtD,iBAAiB,GAAG,QAAQ,YAAY,UAAU,kBAAkB;;iBAqFpE,QAAQ,QAAQ,QAAQ,QAAQ,yBAAyB;;iBAoEzD,SAAS;;iBAKT,aAAa"}

package/build/queries/valueFilters.js

@@ -0,0 +1,243 @@
+import { isAlias } from "./find/Aliases.js";
+import { isScope } from "./find/scopes.js";
+import { assertNever } from "../utils.js";
+import { isDefined } from "../EntityManager.js";
+import { isEntity } from "../Entity.js";
+import { isPlainObject } from "joist-utils";
+//#region src/queries/valueFilters.ts
+/** Parses an entity filter, which could be "just an id", an array of ids, or a nested filter. */
+function parseEntityFilter(meta, filter) {
+	if (filter === void 0) return;
+	else if (isAlias(filter)) return;
+	else if (isScope(filter)) return {
+		kind: "join",
+		subFilter: {}
+	};
+	else if (filter === null) return { kind: "is-null" };
+	else if (typeof filter === "string" || typeof filter === "number") return {
+		kind: "eq",
+		value: filter
+	};
+	else if (typeof filter === "boolean") return filter ? { kind: "not-null" } : { kind: "is-null" };
+	else if (Array.isArray(filter)) return {
+		kind: "in",
+		value: filter.map((v) => {
+			return isEntity(v) ? v.idTaggedMaybe ?? nilIdValue(meta) : v;
+		})
+	};
+	else if (isEntity(filter)) return {
+		kind: "eq",
+		value: filter.idTaggedMaybe || nilIdValue(meta)
+	};
+	else if (typeof filter === "object") {
+		const keys = Object.keys(filter);
+		if (keys.length === 1 && keys[0] === "ne") {
+			const value = filter["ne"];
+			if (value === void 0) return;
+			else if (value === null) return { kind: "not-null" };
+			else if (typeof value === "string" || typeof value === "number") return {
+				kind: "ne",
+				value
+			};
+			else if (isEntity(value)) return {
+				kind: "ne",
+				value: value.idTaggedMaybe || nilIdValue(meta)
+			};
+			else throw new Error(`Unsupported "ne" value ${value}`);
+		}
+		if (keys.length === 1 && keys[0] === "id") {
+			const value = filter["id"];
+			if (value === void 0) return;
+			else if (value === null) return { kind: "is-null" };
+			else if (typeof value === "string" || typeof value === "number") return {
+				kind: "eq",
+				value
+			};
+			else if (isEntity(value)) return {
+				kind: "eq",
+				value: value.idTaggedMaybe || nilIdValue(meta)
+			};
+			else return parseValueFilter(value)[0];
+		}
+		const subFilter = {};
+		for (const [key, value] of Object.entries(filter)) if (value && typeof value === "object" && !isPlainObject(value) && "idTaggedMaybe" in value) subFilter[key] = value.idTaggedMaybe || nilIdValue(meta);
+		else subFilter[key] = value;
+		return {
+			kind: "join",
+			subFilter
+		};
+	} else throw new Error(`Unrecognized filter ${filter}`);
+}
+/**
+* Parses the many/hodgepodge (ergonomic!) patterns of value filters into a `ParsedValueFilter[]`.
+*
+* Note we return an array because filter might be a `ValueGraphQLFilter` that is allowed to have
+* multiple conditions, i.e. `{ lt: 10, gt: 5 }`.
+*/
+function parseValueFilter(filter) {
+	if (filter === null) return [{ kind: "is-null" }];
+	else if (filter === void 0) return [];
+	else if (Array.isArray(filter)) return [{
+		kind: "in",
+		value: filter
+	}];
+	else if (isPlainObject(filter)) {
+		const keys = Object.keys(filter);
+		if (keys.length === 0) return [];
+		else if (keys.length === 2 && "op" in filter && "value" in filter) {
+			const { op, value } = filter;
+			if (shouldPruneValueFilter(op, value)) return [];
+			else if (value === null) return [{ kind: "is-null" }];
+			else return [{
+				kind: op,
+				value: value ?? null
+			}];
+		} else if (keys.length === 2 && "gte" in filter && "lte" in filter) {
+			const { gte, lte } = filter;
+			return [{
+				kind: "between",
+				value: [gte, lte]
+			}];
+		} else return Object.entries(filter).map(([key, value]) => {
+			if (shouldPruneValueFilter(key, value)) return;
+			switch (key) {
+				case "eq": if (value === null) return { kind: "is-null" };
+				else return {
+					kind: "eq",
+					value: filter[key]
+				};
+				case "ne": if (value === null) return { kind: "not-null" };
+				else return {
+					kind: "ne",
+					value: filter[key] ?? null
+				};
+				case "in":
+				case "nin":
+				case "gt":
+				case "gte":
+				case "lt":
+				case "lte":
+				case "like":
+				case "nlike":
+				case "ilike":
+				case "nilike":
+				case "regex":
+				case "nregex":
+				case "iregex":
+				case "niregex":
+				case "contains":
+				case "overlaps":
+				case "containedBy": return {
+					kind: key,
+					value: filter[key]
+				};
+				case "pathExists": return {
+					kind: "jsonPathExists",
+					value: filter[key]
+				};
+				case "pathIsTrue": return {
+					kind: "jsonPathPredicate",
+					value: filter[key]
+				};
+				case "search": return {
+					kind: "ilike",
+					value: makeLike(filter[key])
+				};
+				case "between": return {
+					kind: key,
+					value: filter[key]
+				};
+				default: throw new Error(`Unsupported value filter key ${key}`);
+			}
+		}).filter(isDefined);
+	} else return [{
+		kind: "eq",
+		value: filter
+	}];
+}
+/** Converts domain-level values like string ids/enums into their db equivalent. */
+function mapToDb(column, filter) {
+	switch (filter.kind) {
+		case "eq":
+		case "gt":
+		case "gte":
+		case "ne":
+		case "lt":
+		case "lte":
+		case "like":
+		case "nlike":
+		case "ilike":
+		case "nilike":
+		case "regex":
+		case "nregex":
+		case "iregex":
+		case "niregex":
+			filter.value = column.mapToDb(filter.value);
+			return filter;
+		case "in":
+			if (column.isArray) return {
+				kind: "contains",
+				value: column.mapToDb(filter.value)
+			};
+			else filter.value = filter.value.map((v) => column.mapToDb(v));
+			return filter;
+		case "nin":
+			if (column.isArray) throw new Error("The nin operator is not supported on array columns yet");
+			else filter.value = filter.value.map((v) => column.mapToDb(v));
+			return filter;
+		case "contains":
+		case "ncontains":
+		case "overlaps":
+		case "noverlaps":
+		case "containedBy":
+			if (!(column.isArray || column.dbType === "jsonb")) throw new Error(`${filter.kind} is only unsupported on array or jsonb columns`);
+			if (column.isArray) filter.value = column.mapToDb(filter.value);
+			return filter;
+		case "between":
+			filter.value = [column.mapToDb(filter.value[0]), column.mapToDb(filter.value[1])];
+			return filter;
+		case "is-null":
+		case "not-null":
+		case "jsonPathExists":
+		case "jsonPathPredicate": return filter;
+		default: throw assertNever(filter);
+	}
+}
+/** Converts a search term like `foo bar` into a SQL `like` pattern like `%foo%bar%`. */
+function makeLike(search) {
+	return search ? `%${search.replace(/\s+/g, "%")}%` : void 0;
+}
+/** Recognizes placeholder IDs used when a filter contains an unpersisted entity. */
+function isNilIdValue(value) {
+	return value === -1 || value === "00000000-0000-0000-0000-000000000000";
+}
+/**
+* We use this value if users include new (id-less) entities as em.find conditions.
+*
+* The idea is that this condition would never be met, but we still want to do the em.find
+* query in case it's in an `OR` clause that would match false, but some other part of the
+* clause would match. I.e. instead of just skipping the DB query all together, which is
+* also something we could consider doing.
+*
+* For int IDs we use -1, and for uuid IDs, we use the nil UUID value:
+*
+* https://en.wikipedia.org/wiki/Universally_unique_identifier#Nil_UUID
+*/
+function nilIdValue(meta) {
+	switch (meta.idDbType) {
+		case "int":
+		case "bigint": return -1;
+		case "uuid": return "00000000-0000-0000-0000-000000000000";
+		case "text": return "0";
+		default: return assertNever(meta.idDbType);
+	}
+}
+/** Returns true for values that should be treated like an omitted filter. */
+function shouldPruneValueFilter(key, value) {
+	if (value === void 0) return true;
+	return value === false && key !== "eq" && key !== "ne";
+}
+//#endregion
+export { isNilIdValue, makeLike, mapToDb, parseEntityFilter, parseValueFilter };
+
+//# sourceMappingURL=valueFilters.js.map

package/build/queries/valueFilters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFilters.js","names":[],"sources":["../../src/queries/valueFilters.ts"],"sourcesContent":["import { isPlainObject } from \"joist-utils\";\n\nimport type { Column } from \"../columns.ts\";\nimport { type Entity, isEntity } from \"../Entity.ts\";\nimport { isDefined } from \"../EntityManager.ts\";\nimport type { EntityMetadata } from \"../EntityMetadata.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { isAlias } from \"./find/Aliases.ts\";\nimport type { ValueFilter } from \"./find/EntityFilter.ts\";\nimport { isScope } from \"./find/scopes.ts\";\nimport type { ParsedValueFilter } from \"./parsedConditions.ts\";\n\n/** An ADT version of `EntityFilter`. */\nexport type ParsedEntityFilter =\n  // ParsedValueFilter is any simple match on `id`\n  | ParsedValueFilter<string | number>\n  // Otherwise we return the join/complex\n  | { kind: \"join\"; subFilter: object };\n\n/** Parses an entity filter, which could be \"just an id\", an array of ids, or a nested filter. */\nexport function parseEntityFilter(meta: EntityMetadata, filter: any): ParsedEntityFilter | undefined {\n  if (filter === undefined) {\n    // This matches legacy `em.find(Book, { author: undefined })` behavior\n    return undefined;\n  } else if (isAlias(filter)) {\n    // We're just binding an alias to this position in the join tree\n    return undefined;\n  } else if (isScope(filter)) {\n    // A scope on a relation (e.g. `{ author: Author.adult }`) always implies conditions on the\n    // related entity, so signal \"needs a join\" via the existing `join` discriminant rather than\n    // adding a dedicated `kind: \"scope\"` that every relation branch would have to learn. The empty\n    // `subFilter` is intentionally never read: the m2o/m2m branches only check `kind === \"join\"` to\n    // decide whether to join, then re-dispatch the original scope value back through `addTable`,\n    // where `isScope(...)` routes it to `addScopeFilterAt` to apply the scope's actual fragments.\n    return { kind: \"join\", subFilter: {} };\n  } else if (filter === null) {\n    return { kind: \"is-null\" };\n  } else if (typeof filter === \"string\" || typeof filter === \"number\") {\n    return { kind: \"eq\", value: filter };\n  } else if (typeof filter === \"boolean\") {\n    return filter ? { kind: \"not-null\" } : { kind: \"is-null\" };\n  } else if (Array.isArray(filter)) {\n    return {\n      kind: \"in\",\n      value: filter.map((v: string | number | Entity) => {\n        return isEntity(v) ? (v.idTaggedMaybe ?? nilIdValue(meta)) : v;\n      }),\n    };\n  } else if (isEntity(filter)) {\n    return { kind: \"eq\", value: filter.idTaggedMaybe || nilIdValue(meta) };\n  } else if (typeof filter === \"object\") {\n    // Looking for `{ firstName: \"f1\" }` or `{ ne: \"f1\" }`\n    const keys = Object.keys(filter);\n    // Special case only looking at `ne`\n    if (keys.length === 1 && keys[0] === \"ne\") {\n      const value = filter[\"ne\"];\n      if (value === undefined) {\n        return undefined;\n      } else if (value === null) {\n        return { kind: \"not-null\" };\n      } else if (typeof value === \"string\" || typeof value === \"number\") {\n        return { kind: \"ne\", value };\n      } else if (isEntity(value)) {\n        return { kind: \"ne\", value: value.idTaggedMaybe || nilIdValue(meta) };\n      } else {\n        throw new Error(`Unsupported \"ne\" value ${value}`);\n      }\n    }\n    // Special case only looking at `id`\n    if (keys.length === 1 && keys[0] === \"id\") {\n      const value = filter[\"id\"];\n      if (value === undefined) {\n        return undefined;\n      } else if (value === null) {\n        return { kind: \"is-null\" };\n      } else if (typeof value === \"string\" || typeof value === \"number\") {\n        return { kind: \"eq\", value };\n      } else if (isEntity(value)) {\n        return { kind: \"eq\", value: value.idTaggedMaybe || nilIdValue(meta) };\n      } else {\n        return parseValueFilter(value)[0] as any;\n      }\n    }\n    // Look for subFilter values being EntityFilter-ish instances like ManyToOneReference\n    // that have an id, and so structurally match the entity filter without really being filters,\n    // and convert them over here before getting into parseValueFilter.\n    const subFilter = {} as any;\n    for (const [key, value] of Object.entries(filter)) {\n      if (value && typeof value === \"object\" && !isPlainObject(value) && \"idTaggedMaybe\" in value) {\n        subFilter[key] = value.idTaggedMaybe || nilIdValue(meta);\n      } else {\n        subFilter[key] = value;\n      }\n    }\n    return { kind: \"join\", subFilter };\n  } else {\n    throw new Error(`Unrecognized filter ${filter}`);\n  }\n}\n\n/**\n * Parses the many/hodgepodge (ergonomic!) patterns of value filters into a `ParsedValueFilter[]`.\n *\n * Note we return an array because filter might be a `ValueGraphQLFilter` that is allowed to have\n * multiple conditions, i.e. `{ lt: 10, gt: 5 }`.\n */\nexport function parseValueFilter<V>(filter: ValueFilter<V, any>): ParsedValueFilter<V>[] {\n  if (filter === null) {\n    return [{ kind: \"is-null\" }];\n  } else if (filter === undefined) {\n    // This is legacy behavior where `em.find(Book, { author: undefined })` would match all books\n    return [];\n  } else if (Array.isArray(filter)) {\n    return [{ kind: \"in\", value: filter }];\n  } else if (isPlainObject(filter)) {\n    const keys = Object.keys(filter);\n    if (keys.length === 0) {\n      // Should this be an error?\n      return [];\n    } else if (keys.length === 2 && \"op\" in filter && \"value\" in filter) {\n      // Probe for `findGql` op & value\n      const { op, value } = filter;\n      if (shouldPruneValueFilter(op, value)) {\n        return [];\n      } else if (value === null) {\n        return [{ kind: \"is-null\" }];\n      } else {\n        return [{ kind: op, value: value ?? null }];\n      }\n    } else if (keys.length === 2 && \"gte\" in filter && \"lte\" in filter) {\n      const { gte, lte } = filter;\n      return [{ kind: \"between\", value: [gte, lte] }];\n    } else {\n      return Object.entries(filter)\n        .map(([key, value]) => {\n          // Always do condition pruning on the value\n          if (shouldPruneValueFilter(key, value)) {\n            return undefined;\n          }\n          switch (key) {\n            case \"eq\":\n              if (value === null) {\n                return { kind: \"is-null\" as const };\n              } else {\n                return { kind: \"eq\" as const, value: filter[key] };\n              }\n            case \"ne\":\n              if (value === null) {\n                return { kind: \"not-null\" as const };\n              } else {\n                return { kind: \"ne\" as const, value: filter[key] ?? null };\n              }\n            case \"in\":\n            case \"nin\":\n            case \"gt\":\n            case \"gte\":\n            case \"lt\":\n            case \"lte\":\n            case \"like\":\n            case \"nlike\":\n            case \"ilike\":\n            case \"nilike\":\n            case \"regex\":\n            case \"nregex\":\n            case \"iregex\":\n            case \"niregex\":\n            case \"contains\":\n            case \"overlaps\":\n            case \"containedBy\":\n              return { kind: key, value: filter[key] };\n            case \"pathExists\":\n              return { kind: \"jsonPathExists\" as const, value: filter[key] };\n            case \"pathIsTrue\":\n              return { kind: \"jsonPathPredicate\" as const, value: filter[key] };\n            case \"search\":\n              return { kind: \"ilike\" as const, value: makeLike(filter[key]) };\n            case \"between\":\n              return { kind: key, value: filter[key] };\n            default:\n              throw new Error(`Unsupported value filter key ${key}`);\n          }\n        })\n        .filter(isDefined);\n    }\n  } else {\n    // This is a primitive like a string, number\n    return [{ kind: \"eq\", value: filter }];\n  }\n}\n\n/** Converts domain-level values like string ids/enums into their db equivalent. */\nexport function mapToDb(column: Column, filter: ParsedValueFilter<any>): ParsedValueFilter<any> {\n  // ...to teach this `mapToDb` function to handle/rewrite `in: [1, null]` handling, we'd need to:\n  // 1. return a maybe-simple/maybe-nested condition, so basically a `ParsedExpressionCondition`, because\n  // this would let `in` return an `{ or: ... }` to all the callers.\n  // 2. also return `{ parsed: ParsedExpressionCondition, simples: SimpleCondition[] }` tuple, for the\n  // alias `addCondition` processing to track the `simples` and rewrite their alias when later bound.\n  switch (filter.kind) {\n    case \"eq\":\n    case \"gt\":\n    case \"gte\":\n    case \"ne\":\n    case \"lt\":\n    case \"lte\":\n    case \"like\":\n    case \"nlike\":\n    case \"ilike\":\n    case \"nilike\":\n    case \"regex\":\n    case \"nregex\":\n    case \"iregex\":\n    case \"niregex\":\n      filter.value = column.mapToDb(filter.value);\n      return filter;\n    case \"in\":\n      if (column.isArray) {\n        // Arrays need a special operator\n        return { kind: \"contains\", value: column.mapToDb(filter.value) };\n      } else {\n        filter.value = filter.value.map((v) => column.mapToDb(v));\n      }\n      return filter;\n    case \"nin\":\n      if (column.isArray) {\n        // Arrays need a special operator\n        throw new Error(\"The nin operator is not supported on array columns yet\");\n      } else {\n        filter.value = filter.value.map((v) => column.mapToDb(v));\n      }\n      return filter;\n    case \"contains\":\n    case \"ncontains\":\n    case \"overlaps\":\n    case \"noverlaps\":\n    case \"containedBy\":\n      const supportsContains = column.isArray || column.dbType === \"jsonb\";\n      if (!supportsContains) {\n        throw new Error(`${filter.kind} is only unsupported on array or jsonb columns`);\n      }\n      if (column.isArray) {\n        filter.value = column.mapToDb(filter.value);\n      } else {\n        // leave jsonb values alone\n      }\n      return filter;\n    case \"between\":\n      filter.value = [column.mapToDb(filter.value[0]), column.mapToDb(filter.value[1])];\n      return filter;\n    case \"is-null\":\n    case \"not-null\":\n    case \"jsonPathExists\":\n    case \"jsonPathPredicate\":\n      return filter;\n    default:\n      throw assertNever(filter);\n  }\n}\n\n/** Converts a search term like `foo bar` into a SQL `like` pattern like `%foo%bar%`. */\nexport function makeLike(search: any | undefined): any {\n  return search ? `%${search.replace(/\\s+/g, \"%\")}%` : undefined;\n}\n\n/** Recognizes placeholder IDs used when a filter contains an unpersisted entity. */\nexport function isNilIdValue(value: unknown): boolean {\n  return value === -1 || value === \"00000000-0000-0000-0000-000000000000\";\n}\n\n/**\n * We use this value if users include new (id-less) entities as em.find conditions.\n *\n * The idea is that this condition would never be met, but we still want to do the em.find\n * query in case it's in an `OR` clause that would match false, but some other part of the\n * clause would match. I.e. instead of just skipping the DB query all together, which is\n * also something we could consider doing.\n *\n * For int IDs we use -1, and for uuid IDs, we use the nil UUID value:\n *\n * https://en.wikipedia.org/wiki/Universally_unique_identifier#Nil_UUID\n */\nfunction nilIdValue(meta: EntityMetadata): any {\n  switch (meta.idDbType) {\n    case \"int\":\n    case \"bigint\":\n      return -1;\n    case \"uuid\":\n      return \"00000000-0000-0000-0000-000000000000\";\n    case \"text\":\n      return \"0\";\n    default:\n      return assertNever(meta.idDbType);\n  }\n}\n\n/** Returns true for values that should be treated like an omitted filter. */\nfunction shouldPruneValueFilter(key: unknown, value: unknown): boolean {\n  if (value === undefined) return true;\n  return value === false && key !== \"eq\" && key !== \"ne\";\n}\n"],"mappings":"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"}

package/build/reactiveHints.cjs

@@ -1,16 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./typeMap.cjs");
-const require_getProperties = require("./getProperties.cjs");
 const require_relations_hasProperty = require("./relations/hasProperty.cjs");
+require("./typeMap.cjs");
+require("./changes.cjs");
 require("./relations/OneToOneReference.cjs");
 const require_relations_ReactiveGetter = require("./relations/ReactiveGetter.cjs");
 const require_relations_RecursiveCollection = require("./relations/RecursiveCollection.cjs");
-require("./relations/index.cjs");
-const require_EntityMetadata = require("./EntityMetadata.cjs");
-require("./changes.cjs");
 const require_normalizeHints = require("./normalizeHints.cjs");
 require("./loadHints.cjs");
 const require_utils = require("./utils.cjs");
+const require_getProperties = require("./getProperties.cjs");
+require("./relations/index.cjs");
+const require_EntityMetadata = require("./EntityMetadata.cjs");
 const require_EntityManager = require("./EntityManager.cjs");
 const require_Entity = require("./Entity.cjs");
 const require_BaseEntity = require("./BaseEntity.cjs");

package/build/reactiveHints.js

@@ -1,15 +1,15 @@
-import "./typeMap.js";
-import { getProperties } from "./getProperties.js";
 import { PropertyImpl } from "./relations/hasProperty.js";
+import "./typeMap.js";
+import "./changes.js";
 import "./relations/OneToOneReference.js";
 import { ReactiveGetterImpl } from "./relations/ReactiveGetter.js";
 import { RecursiveChildrenCollectionImpl, RecursiveM2mCollectionImpl, RecursiveParentsCollectionImpl } from "./relations/RecursiveCollection.js";
-import "./relations/index.js";
-import { getBaseAndSelfMetas, getBaseMeta, getMetadata } from "./EntityMetadata.js";
-import "./changes.js";
 import { normalizeHint, suffixRe } from "./normalizeHints.js";
 import "./loadHints.js";
 import { fail, flatAndUnique, mergeNormalizedHints } from "./utils.js";
+import { getProperties } from "./getProperties.js";
+import "./relations/index.js";
+import { getBaseAndSelfMetas, getBaseMeta, getMetadata } from "./EntityMetadata.js";
 import { getEmInternalApi, isId } from "./EntityManager.js";
 import { isEntity } from "./Entity.js";
 import { getInstanceData } from "./BaseEntity.js";

package/build/relations/AbstractRelationImpl.cjs

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
-const require_EntityMetadata = require("../EntityMetadata.cjs");
 //#region src/relations/AbstractRelationImpl.ts
 /**
 * Defines common hooks that relations can respond to to keep the entity graph in sync.
@@ -10,11 +9,7 @@ var AbstractRelationImpl = class extends require_relations_AbstractPropertyImpl.
 		super(entity);
 	}
 };
-function isCascadeDelete(relation, fieldName) {
-	return require_EntityMetadata.getBaseAndSelfMetas(require_EntityMetadata.getMetadata(relation.entity)).some((meta) => meta.config.__data.cascadeDeleteFields.includes(fieldName));
-}
 //#endregion
 exports.AbstractRelationImpl = AbstractRelationImpl;
-exports.isCascadeDelete = isCascadeDelete;
 
 //# sourceMappingURL=AbstractRelationImpl.cjs.map

package/build/relations/AbstractRelationImpl.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRelationImpl.cjs","names":["AbstractPropertyImpl","getBaseAndSelfMetas","getMetadata"],"sources":["../../src/relations/AbstractRelationImpl.ts"],"sourcesContent":["import { getBaseAndSelfMetas, getMetadata } from \"../EntityMetadata.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\n\n/**\n * Defines common hooks that relations can respond to to keep the entity graph in sync.\n */\nexport abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {\n  constructor(entity: T) {\n    super(entity);\n  }\n\n  /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */\n  abstract setFromOpts(value: U): void;\n\n  /** Similar to setFromOpts, but called post-construction. */\n  abstract set(value: U): void;\n\n  /** Whether this relation is loaded. */\n  abstract get isLoaded(): boolean;\n\n  /** Whether this relation is preloaded. */\n  abstract get isPreloaded(): boolean;\n\n  /** Loads the other side of this relation. */\n  abstract load(opts?: { forceReload?: boolean }): Promise<any>;\n\n  /** Whether the relation from the preload cache, if preloaded. */\n  abstract preload(): void;\n\n  abstract get get(): U | undefined;\n\n  /**\n   * Called when our entity has been `em.delete`-d and then `em.flush` is being called,\n   * so we can unset any foreign keys to the being-deleted entity and clear out any pointers\n   * to it. I.e.:\n   *\n   * - `em.delete(author)`\n   * - `em.flush` loads all `author.books`\n   * - Unsets their `book.author` to let their validation rules know\n   */\n  abstract cleanupOnEntityDeleted(): Promise<void>;\n\n  /**\n   * Called to cascade deletes into the relation if it has cascade behavior enabled.  This function is called twice,\n   * once on the initial `EntityManager.delete` call in a potentially unloaded state, then again from a `beforeDelete`\n   * hook after the relation is fully loaded.\n   */\n  abstract maybeCascadeDelete(): void;\n\n  abstract get fieldName(): string;\n}\n\nexport function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean {\n  return getBaseAndSelfMetas(getMetadata(relation.entity)).some((meta) =>\n    meta.config.__data.cascadeDeleteFields.includes(fieldName as any),\n  );\n}\n"],"mappings":";;;;;;;AAMA,IAAsB,uBAAtB,cAAyDA,uCAAAA,qBAAwB;CAC/E,YAAY,QAAW;EACrB,MAAM,MAAM;CACd;AAyCF;AAEA,SAAgB,gBAAgB,UAA0C,WAA4B;CACpG,OAAOC,uBAAAA,oBAAoBC,uBAAAA,YAAY,SAAS,MAAM,CAAC,CAAC,CAAC,MAAM,SAC7D,KAAK,OAAO,OAAO,oBAAoB,SAAS,SAAgB,CAClE;AACF"}
+{"version":3,"file":"AbstractRelationImpl.cjs","names":["AbstractPropertyImpl"],"sources":["../../src/relations/AbstractRelationImpl.ts"],"sourcesContent":["import { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\n\n/**\n * Defines common hooks that relations can respond to to keep the entity graph in sync.\n */\nexport abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {\n  constructor(entity: T) {\n    super(entity);\n  }\n\n  /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */\n  abstract setFromOpts(value: U): void;\n\n  /** Similar to setFromOpts, but called post-construction. */\n  abstract set(value: U): void;\n\n  /** Whether this relation is loaded. */\n  abstract get isLoaded(): boolean;\n\n  /** Whether this relation is preloaded. */\n  abstract get isPreloaded(): boolean;\n\n  /** Loads the other side of this relation. */\n  abstract load(opts?: { forceReload?: boolean }): Promise<any>;\n\n  /** Whether the relation from the preload cache, if preloaded. */\n  abstract preload(): void;\n\n  abstract get get(): U | undefined;\n\n  /**\n   * Called when our entity has been `em.delete`-d and then `em.flush` is being called,\n   * so we can unset any foreign keys to the being-deleted entity and clear out any pointers\n   * to it. I.e.:\n   *\n   * - `em.delete(author)`\n   * - `em.flush` loads all `author.books`\n   * - Unsets their `book.author` to let their validation rules know\n   */\n  abstract cleanupOnEntityDeleted(): Promise<void>;\n\n  /**\n   * Called to cascade deletes into the relation if it has cascade behavior enabled.  This function is called twice,\n   * once on the initial `EntityManager.delete` call in a potentially unloaded state, then again from a `beforeDelete`\n   * hook after the relation is fully loaded.\n   */\n  abstract maybeCascadeDelete(): void;\n\n  abstract get fieldName(): string;\n}\n"],"mappings":";;;;;;AAKA,IAAsB,uBAAtB,cAAyDA,uCAAAA,qBAAwB;CAC/E,YAAY,QAAW;EACrB,MAAM,MAAM;CACd;AAyCF"}

package/build/relations/AbstractRelationImpl.d.cts

@@ -38,7 +38,6 @@ declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T
   abstract maybeCascadeDelete(): void;
   abstract get fieldName(): string;
 }
-declare function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean;
 //#endregion
-export { AbstractRelationImpl, isCascadeDelete };
+export { AbstractRelationImpl };
 //# sourceMappingURL=AbstractRelationImpl.d.cts.map

package/build/relations/AbstractRelationImpl.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRelationImpl.d.cts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;uBAMsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI;;iBAGC,gBAAgB,UAAU,gCAAgC"}
+{"version":3,"file":"AbstractRelationImpl.d.cts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;uBAKsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI"}

package/build/relations/AbstractRelationImpl.d.mts

@@ -38,7 +38,6 @@ declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T
   abstract maybeCascadeDelete(): void;
   abstract get fieldName(): string;
 }
-declare function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean;
 //#endregion
-export { AbstractRelationImpl, isCascadeDelete };
+export { AbstractRelationImpl };
 //# sourceMappingURL=AbstractRelationImpl.d.mts.map

package/build/relations/AbstractRelationImpl.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRelationImpl.d.mts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;uBAMsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI;;iBAGC,gBAAgB,UAAU,gCAAgC"}
+{"version":3,"file":"AbstractRelationImpl.d.mts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;uBAKsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI"}

package/build/relations/AbstractRelationImpl.js

@@ -1,5 +1,4 @@
 import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
-import { getBaseAndSelfMetas, getMetadata } from "../EntityMetadata.js";
 //#region src/relations/AbstractRelationImpl.ts
 /**
 * Defines common hooks that relations can respond to to keep the entity graph in sync.
@@ -9,10 +8,7 @@ var AbstractRelationImpl = class extends AbstractPropertyImpl {
 		super(entity);
 	}
 };
-function isCascadeDelete(relation, fieldName) {
-	return getBaseAndSelfMetas(getMetadata(relation.entity)).some((meta) => meta.config.__data.cascadeDeleteFields.includes(fieldName));
-}
 //#endregion
-export { AbstractRelationImpl, isCascadeDelete };
+export { AbstractRelationImpl };
 
 //# sourceMappingURL=AbstractRelationImpl.js.map

package/build/relations/AbstractRelationImpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRelationImpl.js","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"sourcesContent":["import { getBaseAndSelfMetas, getMetadata } from \"../EntityMetadata.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\n\n/**\n * Defines common hooks that relations can respond to to keep the entity graph in sync.\n */\nexport abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {\n  constructor(entity: T) {\n    super(entity);\n  }\n\n  /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */\n  abstract setFromOpts(value: U): void;\n\n  /** Similar to setFromOpts, but called post-construction. */\n  abstract set(value: U): void;\n\n  /** Whether this relation is loaded. */\n  abstract get isLoaded(): boolean;\n\n  /** Whether this relation is preloaded. */\n  abstract get isPreloaded(): boolean;\n\n  /** Loads the other side of this relation. */\n  abstract load(opts?: { forceReload?: boolean }): Promise<any>;\n\n  /** Whether the relation from the preload cache, if preloaded. */\n  abstract preload(): void;\n\n  abstract get get(): U | undefined;\n\n  /**\n   * Called when our entity has been `em.delete`-d and then `em.flush` is being called,\n   * so we can unset any foreign keys to the being-deleted entity and clear out any pointers\n   * to it. I.e.:\n   *\n   * - `em.delete(author)`\n   * - `em.flush` loads all `author.books`\n   * - Unsets their `book.author` to let their validation rules know\n   */\n  abstract cleanupOnEntityDeleted(): Promise<void>;\n\n  /**\n   * Called to cascade deletes into the relation if it has cascade behavior enabled.  This function is called twice,\n   * once on the initial `EntityManager.delete` call in a potentially unloaded state, then again from a `beforeDelete`\n   * hook after the relation is fully loaded.\n   */\n  abstract maybeCascadeDelete(): void;\n\n  abstract get fieldName(): string;\n}\n\nexport function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean {\n  return getBaseAndSelfMetas(getMetadata(relation.entity)).some((meta) =>\n    meta.config.__data.cascadeDeleteFields.includes(fieldName as any),\n  );\n}\n"],"mappings":";;;;;;AAMA,IAAsB,uBAAtB,cAAyD,qBAAwB;CAC/E,YAAY,QAAW;EACrB,MAAM,MAAM;CACd;AAyCF;AAEA,SAAgB,gBAAgB,UAA0C,WAA4B;CACpG,OAAO,oBAAoB,YAAY,SAAS,MAAM,CAAC,CAAC,CAAC,MAAM,SAC7D,KAAK,OAAO,OAAO,oBAAoB,SAAS,SAAgB,CAClE;AACF"}
+{"version":3,"file":"AbstractRelationImpl.js","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"sourcesContent":["import { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\n\n/**\n * Defines common hooks that relations can respond to to keep the entity graph in sync.\n */\nexport abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {\n  constructor(entity: T) {\n    super(entity);\n  }\n\n  /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */\n  abstract setFromOpts(value: U): void;\n\n  /** Similar to setFromOpts, but called post-construction. */\n  abstract set(value: U): void;\n\n  /** Whether this relation is loaded. */\n  abstract get isLoaded(): boolean;\n\n  /** Whether this relation is preloaded. */\n  abstract get isPreloaded(): boolean;\n\n  /** Loads the other side of this relation. */\n  abstract load(opts?: { forceReload?: boolean }): Promise<any>;\n\n  /** Whether the relation from the preload cache, if preloaded. */\n  abstract preload(): void;\n\n  abstract get get(): U | undefined;\n\n  /**\n   * Called when our entity has been `em.delete`-d and then `em.flush` is being called,\n   * so we can unset any foreign keys to the being-deleted entity and clear out any pointers\n   * to it. I.e.:\n   *\n   * - `em.delete(author)`\n   * - `em.flush` loads all `author.books`\n   * - Unsets their `book.author` to let their validation rules know\n   */\n  abstract cleanupOnEntityDeleted(): Promise<void>;\n\n  /**\n   * Called to cascade deletes into the relation if it has cascade behavior enabled.  This function is called twice,\n   * once on the initial `EntityManager.delete` call in a potentially unloaded state, then again from a `beforeDelete`\n   * hook after the relation is fully loaded.\n   */\n  abstract maybeCascadeDelete(): void;\n\n  abstract get fieldName(): string;\n}\n"],"mappings":";;;;;AAKA,IAAsB,uBAAtB,cAAyD,qBAAwB;CAC/E,YAAY,QAAW;EACrB,MAAM,MAAM;CACd;AAyCF"}

package/build/relations/AsyncProperty.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
 require("./hasProperty.cjs");
+const require_newEntity = require("../newEntity.cjs");
 require("../Entity.cjs");
 //#region src/relations/AsyncProperty.ts
 /**

package/build/relations/AsyncProperty.js

@@ -1,7 +1,7 @@
-import { lazyField } from "../newEntity.js";
 import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
 import { PropertyT } from "./PropertySymbols.js";
 import "./hasProperty.js";
+import { lazyField } from "../newEntity.js";
 import "../Entity.js";
 //#region src/relations/AsyncProperty.ts
 /**

package/build/relations/AsyncReactiveField.cjs

@@ -1,13 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
+const require_fields = require("../fields.cjs");
 const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
-const require_EntityMetadata = require("../EntityMetadata.cjs");
-const require_fields = require("../fields.cjs");
 const require_reactiveHints = require("../reactiveHints.cjs");
 const require_normalizeHints = require("../normalizeHints.cjs");
 const require_loadHints = require("../loadHints.cjs");
 const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
 require("../index.cjs");
 require("../Entity.cjs");
 //#region src/relations/AsyncReactiveField.ts

package/build/relations/AsyncReactiveField.js

@@ -1,12 +1,12 @@
-import { lazyField } from "../newEntity.js";
+import { getField, isFieldSet, setField } from "../fields.js";
 import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
 import { PropertyT } from "./PropertySymbols.js";
-import { getMetadata } from "../EntityMetadata.js";
-import { getField, isFieldSet, setField } from "../fields.js";
 import { convertToLoadHint } from "../reactiveHints.js";
 import { deepNormalizeHint } from "../normalizeHints.js";
 import { isLoaded } from "../loadHints.js";
 import { mergeNormalizedHints } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
 import "../index.js";
 import "../Entity.js";
 //#region src/relations/AsyncReactiveField.ts

package/build/relations/Collection.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
 const require_relations_CustomCollection = require("./CustomCollection.cjs");
 const require_relations_ManyToManyCollection = require("./ManyToManyCollection.cjs");
-const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
 const require_relations_ReactiveManyToMany = require("./ReactiveManyToMany.cjs");
 const require_relations_ReactiveManyToManyOtherSide = require("./ReactiveManyToManyOtherSide.cjs");
 require("./index.cjs");

package/build/relations/Collection.js

@@ -1,6 +1,6 @@
+import { OneToManyCollection } from "./OneToManyCollection.js";
 import { CustomCollection } from "./CustomCollection.js";
 import { ManyToManyCollection } from "./ManyToManyCollection.js";
-import { OneToManyCollection } from "./OneToManyCollection.js";
 import { ReactiveManyToManyImpl } from "./ReactiveManyToMany.js";
 import { ReactiveManyToManyOtherSideImpl } from "./ReactiveManyToManyOtherSide.js";
 import "./index.js";

package/build/relations/CustomCollection.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
 const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
 const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
 const require_index = require("../index.cjs");
 const require_EntityManager = require("../EntityManager.cjs");
 require("../Entity.cjs");

package/build/relations/CustomCollection.js

@@ -1,7 +1,7 @@
-import { lazyField } from "../newEntity.js";
 import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
 import { RelationT, RelationU } from "./RelationSymbols.js";
 import { fail } from "../utils.js";
+import { lazyField } from "../newEntity.js";
 import { ensureNotDeleted } from "../index.js";
 import { getEmInternalApi } from "../EntityManager.js";
 import "../Entity.js";