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

package/build/ConditionBuilder.cjs

@@ -0,0 +1,107 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./EntityFilter.cjs");
+const require_utils = require("./utils.cjs");
+const require_skipCondition = require("./skipCondition.cjs");
+const require_EntityManager = require("./EntityManager.cjs");
+const require_QueryParser = require("./QueryParser.cjs");
+//#region src/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: require_QueryParser.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] : require_utils.fail(`Invalid expression ${expression}`);
+	const conditions = expressions.map((exp) => exp && ("and" in exp || "or" in exp) ? parseExpression(exp) : exp);
+	const [skip, valid] = require_utils.partition(conditions, (cond) => cond === void 0 || cond === require_skipCondition.skipCondition);
+	if (skip.length > 0 && expression.pruneIfUndefined === "any" || valid.length === 0) return;
+	return {
+		kind: "exp",
+		op,
+		conditions: valid.filter(require_EntityManager.isDefined)
+	};
+}
+//#endregion
+exports.ConditionBuilder = ConditionBuilder;
+
+//# sourceMappingURL=ConditionBuilder.cjs.map

package/build/ConditionBuilder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBuilder.cjs","names":["mapToDb","fail","partition","skipCondition","isDefined"],"sources":["../src/ConditionBuilder.ts"],"sourcesContent":["import { type Column } from \"./columns.ts\";\nimport { type ExpressionFilter } from \"./EntityFilter.ts\";\nimport { isDefined } from \"./EntityManager.ts\";\nimport {\n  type ColumnCondition,\n  type ParsedExpressionCondition,\n  type ParsedExpressionFilter,\n  type ParsedValueFilter,\n  type RawCondition,\n  mapToDb,\n} from \"./QueryParser.ts\";\nimport { skipCondition } from \"./skipCondition.ts\";\nimport { fail, partition } from \"./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: ExpressionFilter): 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: ExpressionFilter): 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,YAAoC;EACrD,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,MAAMA,oBAAAA,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,YAAkE;CAEzF,MAAM,CAAC,IAAI,eACT,SAAS,cAAc,WAAW,MAC9B,CAAC,OAAgB,WAAW,GAAG,IAC/B,QAAQ,cAAc,WAAW,KAC/B,CAAC,MAAe,WAAW,EAAE,IAC7BC,cAAAA,KAAK,sBAAsB,YAAY;CAE/C,MAAM,aAAa,YAAY,KAAK,QAAS,QAAQ,SAAS,OAAO,QAAQ,OAAO,gBAAgB,GAAG,IAAI,GAAI;CAC/G,MAAM,CAAC,MAAM,SAASC,cAAAA,UAAU,aAAa,SAAS,SAAS,KAAA,KAAa,SAASC,sBAAAA,aAAa;CAClG,IAAK,KAAK,SAAS,KAAK,WAAW,qBAAqB,SAAU,MAAM,WAAW,GACjF;CAEF,OAAO;EAAE,MAAM;EAAO;EAAI,YAAY,MAAM,OAAOC,sBAAAA,SAAS;CAAE;AAChE"}

package/build/ConditionBuilder.d.cts

@@ -0,0 +1,31 @@
+import { Column } from "./columns.cjs";
+import { ExpressionFilter } from "./EntityFilter.cjs";
+import { ColumnCondition, ParsedExpressionFilter, ParsedValueFilter, RawCondition } from "./QueryParser.cjs";
+//#region src/ConditionBuilder.d.ts
+type PartialSome<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/** Converts domain-level values like string ids/enums into their db equivalent. */
+declare class ConditionBuilder {
+  /** Simple, single-column conditions, which will be AND-d together. */
+  private conditions;
+  /** Complex expressions, which will also be AND-d together with `conditions`. */
+  private expressions;
+  /** Accepts a raw user-facing DSL filter, and parses it into a `ParsedExpressionFilter`. */
+  maybeAddExpression(expression: ExpressionFilter): void;
+  /** Adds an already-db-level condition to the simple conditions list. */
+  addSimpleCondition(condition: ColumnCondition): void;
+  /** Adds an already-db-level condition to the simple conditions list. */
+  addRawCondition(condition: PartialSome<RawCondition, "kind" | "bindings">): void;
+  /** Adds an already-db-level expression to the expressions list. */
+  addParsedExpression(parsed: ParsedExpressionFilter): void;
+  /**
+   * 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: string, column: Column, filter: ParsedValueFilter<any>): void;
+  /** Combines our collected `conditions` and `expressions` into a single `ParsedExpressionFilter`. */
+  toExpressionFilter(): ParsedExpressionFilter | undefined;
+}
+//#endregion
+export { ConditionBuilder };
+//# sourceMappingURL=ConditionBuilder.d.cts.map

package/build/ConditionBuilder.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBuilder.d.cts","names":[],"sources":["../src/ConditionBuilder.ts"],"mappings":";;;;KAcK,YAAY,GAAG,gBAAgB,KAAK,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG;;cAGzD;;UAEH;;UAEA;;EAGR,mBAAmB,YAAY;;EAM/B,mBAAmB,WAAW;;EAK9B,gBAAgB,WAAW,YAAY;;EASvC,oBAAoB,QAAQ;;;;;;EAS5B,eAAe,eAAe,QAAQ,QAAQ,QAAQ;;EAqCtD,sBAAsB"}

package/build/ConditionBuilder.d.mts

@@ -0,0 +1,31 @@
+import { Column } from "./columns.mjs";
+import { ExpressionFilter } from "./EntityFilter.mjs";
+import { ColumnCondition, ParsedExpressionFilter, ParsedValueFilter, RawCondition } from "./QueryParser.mjs";
+//#region src/ConditionBuilder.d.ts
+type PartialSome<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/** Converts domain-level values like string ids/enums into their db equivalent. */
+declare class ConditionBuilder {
+  /** Simple, single-column conditions, which will be AND-d together. */
+  private conditions;
+  /** Complex expressions, which will also be AND-d together with `conditions`. */
+  private expressions;
+  /** Accepts a raw user-facing DSL filter, and parses it into a `ParsedExpressionFilter`. */
+  maybeAddExpression(expression: ExpressionFilter): void;
+  /** Adds an already-db-level condition to the simple conditions list. */
+  addSimpleCondition(condition: ColumnCondition): void;
+  /** Adds an already-db-level condition to the simple conditions list. */
+  addRawCondition(condition: PartialSome<RawCondition, "kind" | "bindings">): void;
+  /** Adds an already-db-level expression to the expressions list. */
+  addParsedExpression(parsed: ParsedExpressionFilter): void;
+  /**
+   * 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: string, column: Column, filter: ParsedValueFilter<any>): void;
+  /** Combines our collected `conditions` and `expressions` into a single `ParsedExpressionFilter`. */
+  toExpressionFilter(): ParsedExpressionFilter | undefined;
+}
+//#endregion
+export { ConditionBuilder };
+//# sourceMappingURL=ConditionBuilder.d.mts.map

package/build/ConditionBuilder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBuilder.d.mts","names":[],"sources":["../src/ConditionBuilder.ts"],"mappings":";;;;KAcK,YAAY,GAAG,gBAAgB,KAAK,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG;;cAGzD;;UAEH;;UAEA;;EAGR,mBAAmB,YAAY;;EAM/B,mBAAmB,WAAW;;EAK9B,gBAAgB,WAAW,YAAY;;EASvC,oBAAoB,QAAQ;;;;;;EAS5B,eAAe,eAAe,QAAQ,QAAQ,QAAQ;;EAqCtD,sBAAsB"}

package/build/ConditionBuilder.js

@@ -1,112 +1,106 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConditionBuilder = void 0;
-const EntityManager_1 = require("./EntityManager");
-const QueryParser_1 = require("./QueryParser");
-const utils_1 = require("./utils");
+import "./EntityFilter.js";
+import { fail, partition } from "./utils.js";
+import { skipCondition } from "./skipCondition.js";
+import { isDefined } from "./EntityManager.js";
+import { mapToDb } from "./QueryParser.js";
+//#region src/ConditionBuilder.ts
 /** Converts domain-level values like string ids/enums into their db equivalent. */
-class ConditionBuilder {
-    /** 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)) {
-            // If the filter contains a null, we need to split it into an `is-null` and `in` condition
-            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",
-                    // Filter out the nulls from the in condition
-                    value: filter.value.filter((v) => v !== null).map((v) => column.mapToDb(v)),
-                },
-            };
-            // Now OR them back together
-            this.expressions.push({ kind: "exp", op: "or", conditions: [isNull, inValues] });
-        }
-        else {
-            const cond = {
-                kind: "column",
-                alias,
-                column: column.columnName,
-                dbType: column.dbType,
-                // Rewrite the user-facing domain values to db values
-                cond: (0, QueryParser_1.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) {
-            // If no inline conditions, and just 1 opt expression, just use that
-            return expressions[0];
-        }
-        else if (expressions.length === 1 && expressions[0].op === "and") {
-            // Merge the 1 `AND` expression with the other simple conditions
-            return { kind: "exp", op: "and", conditions: [...allSimple, ...expressions[0].conditions] };
-        }
-        else if (allSimple.length > 0 || expressions.length > 0) {
-            // Combine the conditions within the `em.find` join literal & the `conditions` as ANDs
-            return { kind: "exp", op: "and", conditions: [...allSimple, ...expressions] };
-        }
-        return undefined;
-    }
-}
-exports.ConditionBuilder = ConditionBuilder;
+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) {
-    // Look for `{ and: [...] }` or `{ or: [...] }`
-    const [op, expressions] = "and" in expression && expression.and
-        ? ["and", expression.and]
-        : "or" in expression && expression.or
-            ? ["or", expression.or]
-            : fail(`Invalid expression ${expression}`);
-    // Potentially recurse into nested expressions
-    const conditions = expressions.map((exp) => (exp && ("and" in exp || "or" in exp) ? parseExpression(exp) : exp));
-    const [skip, valid] = (0, utils_1.partition)(conditions, (cond) => cond === undefined || cond === QueryParser_1.skipCondition);
-    if ((skip.length > 0 && expression.pruneIfUndefined === "any") || valid.length === 0) {
-        return undefined;
-    }
-    return { kind: "exp", op, conditions: valid.filter(EntityManager_1.isDefined) };
+	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/ConditionBuilder.js.map

@@ -1 +1 @@
-{"version":3,"file":"ConditionBuilder.js","sourceRoot":"","sources":["../src/ConditionBuilder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ConditionBuilder.js","names":[],"sources":["../src/ConditionBuilder.ts"],"sourcesContent":["import { type Column } from \"./columns.ts\";\nimport { type ExpressionFilter } from \"./EntityFilter.ts\";\nimport { isDefined } from \"./EntityManager.ts\";\nimport {\n  type ColumnCondition,\n  type ParsedExpressionCondition,\n  type ParsedExpressionFilter,\n  type ParsedValueFilter,\n  type RawCondition,\n  mapToDb,\n} from \"./QueryParser.ts\";\nimport { skipCondition } from \"./skipCondition.ts\";\nimport { fail, partition } from \"./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: ExpressionFilter): 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: ExpressionFilter): 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,YAAoC;EACrD,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,YAAkE;CAEzF,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/DeferredAlias.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./EntityMetadata.cjs");
+require("./QueryParser.cjs");
+//#region src/DeferredAlias.ts
+const deferredAliasSym = Symbol("joist.deferredAliasCondition");
+/** Detects conditions that carry a per-parse alias resolver. */
+function isDeferredAliasCondition(cond) {
+	return typeof cond === "object" && cond !== null && deferredAliasSym in cond;
+}
+/** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */
+function withDeferredAlias(cond, resolve) {
+	return Object.defineProperty(cond, deferredAliasSym, {
+		value: (r) => {
+			const copy = { ...cond };
+			resolve(r, copy);
+			return copy;
+		},
+		enumerable: false
+	});
+}
+//#endregion
+exports.deferredAliasSym = deferredAliasSym;
+exports.isDeferredAliasCondition = isDeferredAliasCondition;
+exports.withDeferredAlias = withDeferredAlias;
+
+//# sourceMappingURL=DeferredAlias.cjs.map

package/build/DeferredAlias.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeferredAlias.cjs","names":[],"sources":["../src/DeferredAlias.ts"],"sourcesContent":["// Erased imports keep domain predicates independent of the query parser at module load time.\nimport { type EntityMetadata } from \"./EntityMetadata.ts\";\nimport { type ColumnCondition, type RawCondition } from \"./QueryParser.ts\";\n\nexport const deferredAliasSym: unique symbol = Symbol(\"joist.deferredAliasCondition\");\n\n/** Resolves a domain alias to this em.find parse's binding. */\nexport type AliasResolver = (handle: { meta: EntityMetadata; tableName: string }) => {\n  meta: EntityMetadata;\n  alias: string;\n};\n\n/** A domain condition whose SQL aliases are resolved afresh for each occurrence in em.find. */\nexport interface DeferredAliasCondition<C = ColumnCondition | RawCondition> {\n  [deferredAliasSym]: (resolve: AliasResolver) => C;\n}\n\n/** Detects conditions that carry a per-parse alias resolver. */\nexport function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C> {\n  return typeof cond === \"object\" && cond !== null && deferredAliasSym in cond;\n}\n\n/** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */\nexport function withDeferredAlias<C extends object>(\n  cond: C,\n  resolve: (r: AliasResolver, copy: C) => void,\n): C & DeferredAliasCondition<C> {\n  return Object.defineProperty(cond, deferredAliasSym, {\n    value: (r: AliasResolver) => {\n      const copy = { ...cond };\n      resolve(r, copy);\n      return copy;\n    },\n    enumerable: false,\n  }) as C & DeferredAliasCondition<C>;\n}\n"],"mappings":";;;;AAIA,MAAa,mBAAkC,OAAO,8BAA8B;;AAcpF,SAAgB,yBAA4B,MAAgD;CAC1F,OAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,oBAAoB;AAC1E;;AAGA,SAAgB,kBACd,MACA,SAC+B;CAC/B,OAAO,OAAO,eAAe,MAAM,kBAAkB;EACnD,QAAQ,MAAqB;GAC3B,MAAM,OAAO,EAAE,GAAG,KAAK;GACvB,QAAQ,GAAG,IAAI;GACf,OAAO;EACT;EACA,YAAY;CACd,CAAC;AACH"}

package/build/DeferredAlias.d.cts

@@ -0,0 +1,23 @@
+import { EntityMetadata } from "./EntityMetadata.cjs";
+import { ColumnCondition, RawCondition } from "./QueryParser.cjs";
+//#region src/DeferredAlias.d.ts
+declare const deferredAliasSym: unique symbol;
+/** Resolves a domain alias to this em.find parse's binding. */
+type AliasResolver = (handle: {
+  meta: EntityMetadata;
+  tableName: string;
+}) => {
+  meta: EntityMetadata;
+  alias: string;
+};
+/** A domain condition whose SQL aliases are resolved afresh for each occurrence in em.find. */
+interface DeferredAliasCondition<C = ColumnCondition | RawCondition> {
+  [deferredAliasSym]: (resolve: AliasResolver) => C;
+}
+/** Detects conditions that carry a per-parse alias resolver. */
+declare function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C>;
+/** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */
+declare function withDeferredAlias<C extends object>(cond: C, resolve: (r: AliasResolver, copy: C) => void): C & DeferredAliasCondition<C>;
+//#endregion
+export { AliasResolver, DeferredAliasCondition, deferredAliasSym, isDeferredAliasCondition, withDeferredAlias };
+//# sourceMappingURL=DeferredAlias.d.cts.map

package/build/DeferredAlias.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeferredAlias.d.cts","names":[],"sources":["../src/DeferredAlias.ts"],"mappings":";;;cAIa;;KAGD,iBAAiB;EAAU,MAAM;EAAgB;;EAC3D,MAAM;EACN;;;UAIe,uBAAuB,IAAI,kBAAkB;GAC3D,oBAAoB,SAAS,kBAAkB;;;iBAIlC,yBAAyB,GAAG,MAAM,IAAI,QAAQ,IAAI,uBAAuB;;iBAKzE,kBAAkB,kBAChC,MAAM,GACN,UAAU,GAAG,eAAe,MAAM,aACjC,IAAI,uBAAuB"}

package/build/DeferredAlias.d.mts

@@ -0,0 +1,23 @@
+import { EntityMetadata } from "./EntityMetadata.mjs";
+import { ColumnCondition, RawCondition } from "./QueryParser.mjs";
+//#region src/DeferredAlias.d.ts
+declare const deferredAliasSym: unique symbol;
+/** Resolves a domain alias to this em.find parse's binding. */
+type AliasResolver = (handle: {
+  meta: EntityMetadata;
+  tableName: string;
+}) => {
+  meta: EntityMetadata;
+  alias: string;
+};
+/** A domain condition whose SQL aliases are resolved afresh for each occurrence in em.find. */
+interface DeferredAliasCondition<C = ColumnCondition | RawCondition> {
+  [deferredAliasSym]: (resolve: AliasResolver) => C;
+}
+/** Detects conditions that carry a per-parse alias resolver. */
+declare function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C>;
+/** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */
+declare function withDeferredAlias<C extends object>(cond: C, resolve: (r: AliasResolver, copy: C) => void): C & DeferredAliasCondition<C>;
+//#endregion
+export { AliasResolver, DeferredAliasCondition, deferredAliasSym, isDeferredAliasCondition, withDeferredAlias };
+//# sourceMappingURL=DeferredAlias.d.mts.map

package/build/DeferredAlias.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeferredAlias.d.mts","names":[],"sources":["../src/DeferredAlias.ts"],"mappings":";;;cAIa;;KAGD,iBAAiB;EAAU,MAAM;EAAgB;;EAC3D,MAAM;EACN;;;UAIe,uBAAuB,IAAI,kBAAkB;GAC3D,oBAAoB,SAAS,kBAAkB;;;iBAIlC,yBAAyB,GAAG,MAAM,IAAI,QAAQ,IAAI,uBAAuB;;iBAKzE,kBAAkB,kBAChC,MAAM,GACN,UAAU,GAAG,eAAe,MAAM,aACjC,IAAI,uBAAuB"}

package/build/DeferredAlias.js

@@ -0,0 +1,23 @@
+import "./EntityMetadata.js";
+import "./QueryParser.js";
+//#region src/DeferredAlias.ts
+const deferredAliasSym = Symbol("joist.deferredAliasCondition");
+/** Detects conditions that carry a per-parse alias resolver. */
+function isDeferredAliasCondition(cond) {
+	return typeof cond === "object" && cond !== null && deferredAliasSym in cond;
+}
+/** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */
+function withDeferredAlias(cond, resolve) {
+	return Object.defineProperty(cond, deferredAliasSym, {
+		value: (r) => {
+			const copy = { ...cond };
+			resolve(r, copy);
+			return copy;
+		},
+		enumerable: false
+	});
+}
+//#endregion
+export { deferredAliasSym, isDeferredAliasCondition, withDeferredAlias };
+
+//# sourceMappingURL=DeferredAlias.js.map

package/build/DeferredAlias.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeferredAlias.js","names":[],"sources":["../src/DeferredAlias.ts"],"sourcesContent":["// Erased imports keep domain predicates independent of the query parser at module load time.\nimport { type EntityMetadata } from \"./EntityMetadata.ts\";\nimport { type ColumnCondition, type RawCondition } from \"./QueryParser.ts\";\n\nexport const deferredAliasSym: unique symbol = Symbol(\"joist.deferredAliasCondition\");\n\n/** Resolves a domain alias to this em.find parse's binding. */\nexport type AliasResolver = (handle: { meta: EntityMetadata; tableName: string }) => {\n  meta: EntityMetadata;\n  alias: string;\n};\n\n/** A domain condition whose SQL aliases are resolved afresh for each occurrence in em.find. */\nexport interface DeferredAliasCondition<C = ColumnCondition | RawCondition> {\n  [deferredAliasSym]: (resolve: AliasResolver) => C;\n}\n\n/** Detects conditions that carry a per-parse alias resolver. */\nexport function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C> {\n  return typeof cond === \"object\" && cond !== null && deferredAliasSym in cond;\n}\n\n/** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */\nexport function withDeferredAlias<C extends object>(\n  cond: C,\n  resolve: (r: AliasResolver, copy: C) => void,\n): C & DeferredAliasCondition<C> {\n  return Object.defineProperty(cond, deferredAliasSym, {\n    value: (r: AliasResolver) => {\n      const copy = { ...cond };\n      resolve(r, copy);\n      return copy;\n    },\n    enumerable: false,\n  }) as C & DeferredAliasCondition<C>;\n}\n"],"mappings":";;;AAIA,MAAa,mBAAkC,OAAO,8BAA8B;;AAcpF,SAAgB,yBAA4B,MAAgD;CAC1F,OAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,oBAAoB;AAC1E;;AAGA,SAAgB,kBACd,MACA,SAC+B;CAC/B,OAAO,OAAO,eAAe,MAAM,kBAAkB;EACnD,QAAQ,MAAqB;GAC3B,MAAM,OAAO,EAAE,GAAG,KAAK;GACvB,QAAQ,GAAG,IAAI;GACf,OAAO;EACT;EACA,YAAY;CACd,CAAC;AACH"}

package/build/Entity.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./index.cjs");
+require("./EntityManager.cjs");
+const require_BaseEntity = require("./BaseEntity.cjs");
+//#region src/Entity.ts
+function isEntity(maybeEntity) {
+	return maybeEntity instanceof require_BaseEntity.BaseEntity;
+}
+//#endregion
+exports.isEntity = isEntity;
+
+//# sourceMappingURL=Entity.cjs.map

package/build/Entity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.cjs","names":["BaseEntity"],"sources":["../src/Entity.ts"],"sourcesContent":["import { type EntityManager, type TaggedId } from \"./EntityManager.ts\";\nimport { BaseEntity } from \"./index.ts\";\n\nexport function isEntity(maybeEntity: unknown): maybeEntity is Entity {\n  return maybeEntity instanceof BaseEntity;\n}\n\n/** All the types we support for entity `id` fields. */\nexport type IdType = number | string;\n\n/** A marker/base interface for all of our entity types. */\nexport interface Entity {\n  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */\n  id: IdType;\n  idMaybe: IdType | undefined;\n  /** The entity id that is always tagged, regardless of the idType config. */\n  idTagged: TaggedId;\n  idTaggedMaybe: TaggedId | undefined;\n  readonly em: EntityManager;\n  readonly isNewEntity: boolean;\n  readonly isDeletedEntity: boolean;\n  readonly isDirtyEntity: boolean;\n  readonly transientFields: Record<string, unknown>;\n  set(opts: unknown): void;\n  setPartial(opts: unknown): void;\n  setDeepPartial(opts: unknown): Promise<void>;\n  /**\n   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.\n   *\n   * Once an entity is persisted, we'll return `Author#1:1` to denote \"the previously-new author #1\n   * is now authors row id=1 in the database\".\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toString(): string;\n  /**\n   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toTaggedString(): string;\n}\n"],"mappings":";;;;;AAGA,SAAgB,SAAS,aAA6C;CACpE,OAAO,uBAAuBA,mBAAAA;AAChC"}