@cullet/erp-core 1.5.0 → 2.0.0

package/dist/condition-evaluator.js

@@ -6,14 +6,23 @@ var SilentPolicyReporter = class {
 };
 //#endregion
 //#region src/core/config/core-config.ts
-function reportSafely(policyReporter, event) {
+/** Reports an event without letting a throwing reporter abort the caller. */
+function safeReport(policyReporter, event) {
 	try {
 		policyReporter.report(event);
 	} catch {}
 }
 /**
-* Centraliza a configuracao pura do core sem depender de implementacoes
-* concretas de logging, tracing ou report.
+* The core's config namespace. Today it holds a single section —
+* `observability` — whose whole job is to decide *where policy telemetry goes*
+* while guaranteeing telemetry is best-effort (a throwing reporter can never
+* abort a domain flow). App config (env, settings, feature flags) is
+* deliberately absent for now: when the core needs it, it joins here as a
+* sibling section rather than a new module — which is why this is `config`,
+* not `observability`. It holds the active {@link PolicyReporter} (silent by
+* default, so the core carries no logging dependency), bridges it to the
+* engines' {@link ConditionEvaluatorReporter}, and offers `reportSafely` as
+* the single guarded emit path shared with {@link PolicyService}.
 */
 var CoreConfig = class {
 	#initialReporter;
@@ -23,17 +32,23 @@ var CoreConfig = class {
 		this.#initialReporter = reporter;
 		this.#currentReporter = reporter;
 	}
+	/**
+	* Swaps the active reporter. Pass `observability.reporter` to enable
+	* telemetry, or set it explicitly to `undefined` to go silent again.
+	* Omitting `observability` (or its `reporter` key) is a no-op.
+	*/
 	configure(options) {
-		const reporter = options.observability?.reporter;
-		if (reporter) this.#currentReporter = reporter;
+		const observability = options.observability;
+		if (observability && "reporter" in observability) this.#currentReporter = observability.reporter ?? new SilentPolicyReporter();
 		return this;
 	}
 	reset() {
 		this.#currentReporter = this.#initialReporter;
 		return this;
 	}
-	getPolicyReporter() {
-		return this.#currentReporter;
+	/** Emits a policy event through the active reporter, best-effort. */
+	reportSafely(event) {
+		safeReport(this.#currentReporter, event);
 	}
 	getConditionEvaluationOptions(engineVersion) {
 		return {
@@ -42,19 +57,16 @@ var CoreConfig = class {
 		};
 	}
 	#bridgeToConditionReporter(policyReporter) {
+		const emit = (level, report) => {
+			safeReport(policyReporter, {
+				kind: "condition-eval",
+				...report,
+				level
+			});
+		};
 		return {
-			warn(report) {
-				reportSafely(policyReporter, {
-					kind: "condition-eval",
-					...report
-				});
-			},
-			error(report) {
-				reportSafely(policyReporter, {
-					kind: "condition-eval",
-					...report
-				});
-			}
+			warn: (report) => emit("warn", report),
+			error: (report) => emit("error", report)
 		};
 	}
 };
@@ -159,6 +171,54 @@ var PolicyDateUtils = class {
 	}
 };
 //#endregion
+//#region src/core/policies/engines/v1/condition-date-operands.ts
+/**
+* The one instant format condition date operands may use. Strict on purpose
+* (UTC, milliseconds) so comparisons are unambiguous across time zones — and
+* so a malformed operand fails loudly instead of comparing wrong.
+*/
+const CANONICAL_UTC_DATE_FORMAT = "YYYY-MM-DDTHH:mm:ss.SSSZ";
+const ISO_8601_UTC_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const ISO_8601_DATE_LIKE_PATTERN = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/;
+/**
+* Parses a value used as a date operand:
+* - `Result.ok(Date)` for a valid Date or a canonical ISO-8601 UTC string;
+* - `Result.err` when it is date-shaped but malformed (invalid Date, or a
+*   date-like string that isn't canonical UTC) — a configuration error worth
+*   surfacing rather than silently treating as "not a date";
+* - `null` when the value isn't date-shaped at all, so the caller can fall
+*   through to a numeric comparison.
+*/
+function parseComparableDate(value) {
+	if (value instanceof Date) return PolicyDateUtils.isValid(value) ? Result.ok(value) : Result.err("Invalid Date instance");
+	if (typeof value !== "string") return null;
+	if (ISO_8601_UTC_DATE_PATTERN.test(value)) {
+		const parsed = new Date(value);
+		if (!PolicyDateUtils.isValid(parsed) || parsed.toISOString() !== value) return Result.err("Invalid ISO 8601 UTC date string");
+		return Result.ok(parsed);
+	}
+	if (ISO_8601_DATE_LIKE_PATTERN.test(value)) return Result.err(`date operand must be canonical ISO 8601 UTC (${CANONICAL_UTC_DATE_FORMAT})`);
+	return null;
+}
+function evaluateRelationalNumbers(actual, op, expected) {
+	switch (op) {
+		case "gt": return actual > expected;
+		case "gte": return actual >= expected;
+		case "lt": return actual < expected;
+		case "lte": return actual <= expected;
+	}
+}
+function containsInvalidDate(value) {
+	if (value instanceof Date) return !PolicyDateUtils.isValid(value);
+	if (Array.isArray(value)) return value.some((item) => containsInvalidDate(item));
+	return false;
+}
+function normalizeDateOperand(value) {
+	if (value instanceof Date) return value.toISOString();
+	if (Array.isArray(value)) return value.map((item) => normalizeDateOperand(item));
+	return value;
+}
+//#endregion
 //#region src/core/policies/engines/v1/condition-evaluator.ts
 const CONDITION_EVAL_THROWN_TAG = "CONDITION_EVAL_THREW";
 const NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG = "NULLISH_NUMERIC_OPERAND_NOT_ALLOWED";
@@ -168,7 +228,6 @@ const INVALID_NUMERIC_OPERAND_TAG = "INVALID_NUMERIC_OPERAND";
 const INVALID_SET_OPERAND_TAG = "INVALID_SET_OPERAND";
 const EMPTY_OR_CONDITION_TAG = "EMPTY_OR_CONDITION";
 const EMPTY_AND_CONDITION_TAG = "EMPTY_AND_CONDITION";
-const ISO_8601_UTC_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
 	constructor(context, options) {
 		this.context = context;
@@ -199,46 +258,8 @@ var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
 			message: String(error)
 		};
 	}
-	static buildNullishNumericOperandMessage(node, actual) {
-		const resolvedValue = actual === null ? "null" : "undefined";
-		return `${NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG}: "${node.field}" resolved to ${resolvedValue} for numeric operator "${node.op}"`;
-	}
-	static buildNullishDateOperandMessage(node, actual) {
-		const resolvedValue = actual === null ? "null" : "undefined";
-		return `${NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG}: "${node.field}" resolved to ${resolvedValue} for date comparison operator "${node.op}"`;
-	}
-	static buildInvalidDateOperandMessage(node) {
-		return `${INVALID_DATE_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires Date or ISO 8601 UTC string operands`;
-	}
-	static buildInvalidNumericOperandMessage(node) {
-		return `${INVALID_NUMERIC_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires numeric operands`;
-	}
-	static buildInvalidSetOperandMessage(node) {
-		return `${INVALID_SET_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires an array operand`;
-	}
-	static buildEmptyOrConditionMessage() {
-		return `${EMPTY_OR_CONDITION_TAG}: OR nodes must contain at least one child condition`;
-	}
-	static buildEmptyAndConditionMessage() {
-		return `${EMPTY_AND_CONDITION_TAG}: AND nodes must contain at least one child condition`;
-	}
-	static parseComparableDate(value) {
-		if (value instanceof Date) {
-			if (!PolicyDateUtils.isValid(value)) return Result.err("Invalid Date instance");
-			return Result.ok(value);
-		}
-		if (typeof value !== "string" || !ISO_8601_UTC_DATE_PATTERN.test(value)) return null;
-		const parsed = new Date(value);
-		if (!PolicyDateUtils.isValid(parsed) || parsed.toISOString() !== value) return Result.err("Invalid ISO 8601 UTC date string");
-		return Result.ok(parsed);
-	}
-	static evaluateRelationalNumbers(actual, op, expected) {
-		switch (op) {
-			case "gt": return actual > expected;
-			case "gte": return actual >= expected;
-			case "lt": return actual < expected;
-			case "lte": return actual <= expected;
-		}
+	static invalidDateOperandMessage(node) {
+		return `${INVALID_DATE_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires Date or ISO 8601 UTC (${CANONICAL_UTC_DATE_FORMAT}) string operands`;
 	}
 	buildReport(params) {
 		return {
@@ -250,172 +271,88 @@ var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
 			details: params.details
 		};
 	}
-	conditionEvalErr(node, error) {
-		const cause = ConditionEvaluatorV1.describeError(error);
-		const message = `${CONDITION_EVAL_THROWN_TAG}: ${cause.name}: ${cause.message}`;
+	reportLeafError(tag, message, node, actual, extra) {
 		this.options.reporter.error(this.buildReport({
 			level: "error",
-			tag: CONDITION_EVAL_THROWN_TAG,
-			message,
-			details: {
-				node,
-				cause
-			}
-		}));
-		return Result.err(message);
-	}
-	static containsInvalidDate(value) {
-		if (value instanceof Date) return !PolicyDateUtils.isValid(value);
-		if (Array.isArray(value)) return value.some((item) => ConditionEvaluatorV1.containsInvalidDate(item));
-		return false;
-	}
-	static normalizeDateOperand(value) {
-		if (value instanceof Date) return value.toISOString();
-		if (Array.isArray(value)) return value.map((item) => ConditionEvaluatorV1.normalizeDateOperand(item));
-		return value;
-	}
-	reportDateOperandError(node, actual) {
-		const message = ConditionEvaluatorV1.buildInvalidDateOperandMessage(node);
-		this.options.reporter.error(this.buildReport({
-			level: "error",
-			tag: INVALID_DATE_OPERAND_TAG,
+			tag,
 			message,
 			details: {
 				field: node.field,
 				op: node.op,
 				actual,
 				expected: node.value,
+				...extra,
 				node
 			}
 		}));
 		return Result.err(message);
 	}
-	reportInvalidNumericOperand(node, actual) {
-		const message = ConditionEvaluatorV1.buildInvalidNumericOperandMessage(node);
-		this.options.reporter.error(this.buildReport({
-			level: "error",
-			tag: INVALID_NUMERIC_OPERAND_TAG,
-			message,
-			details: {
-				field: node.field,
-				op: node.op,
-				actual,
-				expected: node.value,
-				node
-			}
-		}));
-		return Result.err(message);
-	}
-	reportInvalidSetOperand(node, actual) {
-		const message = ConditionEvaluatorV1.buildInvalidSetOperandMessage(node);
+	conditionEvalErr(node, error) {
+		const cause = ConditionEvaluatorV1.describeError(error);
+		const message = `${CONDITION_EVAL_THROWN_TAG}: ${cause.name}: ${cause.message}`;
 		this.options.reporter.error(this.buildReport({
 			level: "error",
-			tag: INVALID_SET_OPERAND_TAG,
+			tag: CONDITION_EVAL_THROWN_TAG,
 			message,
 			details: {
-				field: node.field,
-				op: node.op,
-				actual,
-				expected: node.value,
-				node
+				node,
+				cause
 			}
 		}));
 		return Result.err(message);
 	}
 	evaluateDateRelationalNode(node, actual) {
 		if (!ConditionEvaluatorV1.isRelationalOperator(node.op)) return null;
-		const actualDateResult = ConditionEvaluatorV1.parseComparableDate(actual);
-		const expectedDateResult = ConditionEvaluatorV1.parseComparableDate(node.value);
-		if (actualDateResult === null && expectedDateResult === null) return null;
+		const actualDate = parseComparableDate(actual);
+		const expectedDate = parseComparableDate(node.value);
+		if (actualDate === null && expectedDate === null) return null;
 		const allowsNull = node.allowNull === true;
-		if (actual === null) {
-			if (allowsNull) return Result.ok(false);
-			const message = ConditionEvaluatorV1.buildNullishDateOperandMessage(node, actual);
-			this.options.reporter.error(this.buildReport({
-				level: "error",
-				tag: NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG,
-				message,
-				details: {
-					field: node.field,
-					op: node.op,
-					actual,
-					expected: node.value,
-					allowNull: allowsNull,
-					node
-				}
-			}));
-			return Result.err(message);
-		}
-		if (actual === void 0) {
-			const message = ConditionEvaluatorV1.buildNullishDateOperandMessage(node, actual);
-			this.options.reporter.error(this.buildReport({
-				level: "error",
-				tag: NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG,
-				message,
-				details: {
-					field: node.field,
-					op: node.op,
-					actual,
-					expected: node.value,
-					allowNull: allowsNull,
-					node
-				}
-			}));
-			return Result.err(message);
+		if (actual === null && allowsNull) return Result.ok(false);
+		if (actual === null || actual === void 0) {
+			const resolved = actual === null ? "null" : "undefined";
+			return this.reportLeafError(NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG, `${NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG}: "${node.field}" resolved to ${resolved} for date comparison operator "${node.op}"`, node, actual, { allowNull: allowsNull });
 		}
-		if (actualDateResult === null || actualDateResult.isErr() || expectedDateResult === null || expectedDateResult.isErr()) return this.reportDateOperandError(node, actual);
-		return Result.ok(ConditionEvaluatorV1.evaluateRelationalNumbers(actualDateResult.getOrNull().getTime(), node.op, expectedDateResult.getOrNull().getTime()));
+		if (actualDate === null || actualDate.isErr() || expectedDate === null || expectedDate.isErr()) return this.reportLeafError(INVALID_DATE_OPERAND_TAG, ConditionEvaluatorV1.invalidDateOperandMessage(node), node, actual);
+		return Result.ok(evaluateRelationalNumbers(actualDate.getOrNull().getTime(), node.op, expectedDate.getOrNull().getTime()));
 	}
 	evaluateOperator(actual, op, expected) {
 		switch (op) {
 			case "eq": return actual === expected;
 			case "neq": return actual !== expected;
-			case "gt": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
-			case "gte": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
-			case "lt": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
-			case "lte": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
+			case "gt":
+			case "gte":
+			case "lt":
+			case "lte": return typeof actual === "number" && typeof expected === "number" && evaluateRelationalNumbers(actual, op, expected);
 			case "in": return Array.isArray(expected) && expected.includes(actual);
 			case "notIn": return Array.isArray(expected) && !expected.includes(actual);
-			case "isNull": return actual === null;
+			case "isNull": return actual === null || actual === void 0;
 			case "isNotNull": return actual !== null && actual !== void 0;
 		}
 	}
 	evaluateNumericRelationalNode(node, actual) {
 		const allowsNull = node.allowNull === true;
 		if (actual === void 0 || actual === null && !allowsNull) {
-			const message = ConditionEvaluatorV1.buildNullishNumericOperandMessage(node, actual);
-			this.options.reporter.error(this.buildReport({
-				level: "error",
-				tag: NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG,
-				message,
-				details: {
-					field: node.field,
-					op: node.op,
-					actual,
-					expected: node.value,
-					allowNull: allowsNull,
-					node
-				}
-			}));
-			return Result.err(message);
+			const resolved = actual === null ? "null" : "undefined";
+			return this.reportLeafError(NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG, `${NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG}: "${node.field}" resolved to ${resolved} for numeric operator "${node.op}"`, node, actual, { allowNull: allowsNull });
 		}
 		if (actual === null) return Result.ok(false);
-		if (typeof actual !== "number" || typeof node.value !== "number") return this.reportInvalidNumericOperand(node, actual);
+		if (typeof actual !== "number" || Number.isNaN(actual) || typeof node.value !== "number" || Number.isNaN(node.value)) return this.reportLeafError(INVALID_NUMERIC_OPERAND_TAG, `${INVALID_NUMERIC_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires numeric operands`, node, actual);
 		return Result.ok(this.evaluateOperator(actual, node.op, node.value));
 	}
 	evaluateLeafNode(node) {
 		const actualResult = PolicyContextPath.getOrAbsent(this.context, node.field);
 		if (actualResult.isErr()) {
+			const message = `MISSING_CONTEXT_FIELD: "${node.field}" not found in context`;
 			this.options.reporter.warn(this.buildReport({
 				level: "warn",
 				tag: "MISSING_CONTEXT_FIELD",
-				message: `MISSING_CONTEXT_FIELD: "${node.field}" not found in context`,
+				message,
 				details: {
 					field: node.field,
 					node
 				}
 			}));
-			return Result.err(`MISSING_CONTEXT_FIELD: "${node.field}" not found in context`);
+			return Result.err(message);
 		}
 		try {
 			const actual = actualResult.getOrThrow();
@@ -424,10 +361,10 @@ var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
 				if (dateResult !== null) return dateResult;
 				return this.evaluateNumericRelationalNode(node, actual);
 			}
-			if ((node.op === "in" || node.op === "notIn") && !Array.isArray(node.value)) return this.reportInvalidSetOperand(node, actual);
+			if ((node.op === "in" || node.op === "notIn") && !Array.isArray(node.value)) return this.reportLeafError(INVALID_SET_OPERAND_TAG, `${INVALID_SET_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires an array operand`, node, actual);
 			if (node.op === "eq" || node.op === "neq" || node.op === "in" || node.op === "notIn") {
-				if (ConditionEvaluatorV1.containsInvalidDate(actual) || ConditionEvaluatorV1.containsInvalidDate(node.value)) return this.reportDateOperandError(node, actual);
-				return Result.ok(this.evaluateOperator(ConditionEvaluatorV1.normalizeDateOperand(actual), node.op, ConditionEvaluatorV1.normalizeDateOperand(node.value)));
+				if (containsInvalidDate(actual) || containsInvalidDate(node.value)) return this.reportLeafError(INVALID_DATE_OPERAND_TAG, ConditionEvaluatorV1.invalidDateOperandMessage(node), node, actual);
+				return Result.ok(this.evaluateOperator(normalizeDateOperand(actual), node.op, normalizeDateOperand(node.value)));
 			}
 			return Result.ok(this.evaluateOperator(actual, node.op, node.value));
 		} catch (error) {
@@ -460,7 +397,7 @@ var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
 			});
 		}
 		if (ConditionEvaluatorV1.isAndNode(node)) {
-			if (node.and.length === 0) return Result.err(ConditionEvaluatorV1.buildEmptyAndConditionMessage());
+			if (node.and.length === 0) return Result.err(`${EMPTY_AND_CONDITION_TAG}: AND nodes must contain at least one child condition`);
 			let lastTracedChild = null;
 			for (const [index, child] of node.and.entries()) {
 				const childPath = `${path}.and[${index}]`;
@@ -496,7 +433,7 @@ var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
 					trace: tracedChild.trace
 				});
 			}
-			if (lastTrace === null) return Result.err(ConditionEvaluatorV1.buildEmptyOrConditionMessage());
+			if (lastTrace === null) return Result.err(`${EMPTY_OR_CONDITION_TAG}: OR nodes must contain at least one child condition`);
 			return Result.ok({
 				matched: false,
 				trace: lastTrace
@@ -545,6 +482,6 @@ var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
 	}
 };
 //#endregion
-export { SilentPolicyReporter as a, CoreConfig as i, PolicyContextPath as n, coreConfig as r, ConditionEvaluatorV1 as t };
+export { CoreConfig as i, PolicyContextPath as n, coreConfig as r, ConditionEvaluatorV1 as t };
 
 //# sourceMappingURL=condition-evaluator.js.map