@cullet/erp-core 1.3.0 → 1.5.0

package/dist/gate-v1-payload.schema.cjs

@@ -1,165 +1,5 @@
-const require_temporal_guards = require("./temporal-guards.cjs");
 const require_result = require("./result.cjs");
 let zod = require("zod");
-//#region src/core/config/silent-policy-reporter.ts
-var SilentPolicyReporter = class {
-	report(_event) {}
-};
-//#endregion
-//#region src/core/config/core-config.ts
-function reportSafely(policyReporter, event) {
-	try {
-		policyReporter.report(event);
-	} catch {}
-}
-/**
-* Centraliza a configuracao pura do core sem depender de implementacoes
-* concretas de logging, tracing ou report.
-*/
-var CoreConfig = class {
-	#initialReporter;
-	#currentReporter;
-	constructor(options = {}) {
-		const reporter = options.observability?.reporter ?? new SilentPolicyReporter();
-		this.#initialReporter = reporter;
-		this.#currentReporter = reporter;
-	}
-	configure(options) {
-		const reporter = options.observability?.reporter;
-		if (reporter) this.#currentReporter = reporter;
-		return this;
-	}
-	reset() {
-		this.#currentReporter = this.#initialReporter;
-		return this;
-	}
-	getPolicyReporter() {
-		return this.#currentReporter;
-	}
-	getConditionEvaluationOptions(engineVersion) {
-		return {
-			reporter: this.#bridgeToConditionReporter(this.#currentReporter),
-			engineVersion
-		};
-	}
-	#bridgeToConditionReporter(policyReporter) {
-		return {
-			warn(report) {
-				reportSafely(policyReporter, {
-					kind: "condition-eval",
-					...report
-				});
-			},
-			error(report) {
-				reportSafely(policyReporter, {
-					kind: "condition-eval",
-					...report
-				});
-			}
-		};
-	}
-};
-//#endregion
-//#region src/core/config/core-config.instance.ts
-/**
-* Shared instance for the application composition root.
-* Use `new CoreConfig()` for isolated runtimes, tests, or multi-tenant hosts.
-*
-* The default reporter is silent so the core has no runtime logging dependency.
-* Hosts can swap in their own `PolicyReporter` via
-* `coreConfig.configure({ observability: { reporter } })`.
-*/
-const coreConfig = new CoreConfig({ observability: { reporter: new SilentPolicyReporter() } });
-//#endregion
-//#region src/core/policies/utils/date.ts
-var PolicyDateUtils = class {
-	static isValid(value) {
-		return require_temporal_guards.isValidDate(value);
-	}
-};
-//#endregion
-//#region src/core/policies/context/path.ts
-/**
-* Utilities for reading/writing values at dot-separated paths
-* in plain objects, e.g. "installment.dueDate".
-*/
-var PolicyContextPath = class PolicyContextPath {
-	static {
-		this.FORBIDDEN_SEGMENTS = new Set([
-			"__proto__",
-			"prototype",
-			"constructor"
-		]);
-	}
-	static resolve(obj, path) {
-		const segmentsResult = PolicyContextPath.parseSegments(path);
-		if (segmentsResult.isErr()) return require_result.Result.err(segmentsResult.errorOrNull());
-		const segments = segmentsResult.getOrNull();
-		let current = obj;
-		for (const segment of segments) {
-			if (current === null || current === void 0 || typeof current !== "object") return require_result.Result.ok({
-				found: false,
-				value: void 0
-			});
-			const record = current;
-			if (!Object.prototype.hasOwnProperty.call(record, segment)) return require_result.Result.ok({
-				found: false,
-				value: void 0
-			});
-			current = record[segment];
-		}
-		return require_result.Result.ok({
-			found: true,
-			value: current
-		});
-	}
-	static parseSegments(path) {
-		if (path.trim().length === 0) return require_result.Result.err("Path cannot be empty");
-		const segments = path.split(".");
-		if (segments.some((segment) => segment.length === 0)) return require_result.Result.err(`Path "${path}" contains an empty segment`);
-		const forbiddenSegment = segments.find((segment) => PolicyContextPath.FORBIDDEN_SEGMENTS.has(segment));
-		if (forbiddenSegment !== void 0) return require_result.Result.err(`Path "${path}" contains forbidden segment "${forbiddenSegment}"`);
-		return require_result.Result.ok(segments);
-	}
-	static isPlainRecord(value) {
-		if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-		const prototype = Object.getPrototypeOf(value);
-		return prototype === Object.prototype || prototype === null;
-	}
-	static getOrAbsent(obj, path) {
-		const resolvedPath = PolicyContextPath.resolve(obj, path);
-		if (resolvedPath.isErr()) return require_result.Result.err("absent");
-		const { found, value } = resolvedPath.getOrNull();
-		if (!found) return require_result.Result.err("absent");
-		return require_result.Result.ok(value);
-	}
-	static has(obj, path) {
-		const resolvedPath = PolicyContextPath.resolve(obj, path);
-		if (resolvedPath.isErr()) return false;
-		return resolvedPath.getOrNull().found;
-	}
-	static set(obj, path, value) {
-		const segmentsResult = PolicyContextPath.parseSegments(path);
-		if (segmentsResult.isErr()) return require_result.Result.err(segmentsResult.errorOrNull());
-		const segments = segmentsResult.getOrNull();
-		let current = obj;
-		for (let i = 0; i < segments.length - 1; i++) {
-			const seg = segments[i];
-			const next = current[seg];
-			if (next === void 0) {
-				const container = Object.create(null);
-				current[seg] = container;
-				current = container;
-				continue;
-			}
-			if (!PolicyContextPath.isPlainRecord(next)) return require_result.Result.err(`Cannot create nested path "${path}" because "${segments.slice(0, i + 1).join(".")}" already contains a non-plain object`);
-			current = next;
-		}
-		current[segments[segments.length - 1]] = value;
-		return require_result.Result.ok(void 0);
-	}
-};
-//#endregion
 //#region src/core/policies/engines/v1/condition-schema.ts
 const conditionOpSchema = zod.z.enum([
 	"eq",
@@ -186,378 +26,6 @@ const conditionNodeSchema = zod.z.lazy(() => zod.z.union([
 	zod.z.object({ not: conditionNodeSchema }).strict()
 ]));
 //#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";
-const NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG = "NULLISH_DATE_OPERAND_NOT_ALLOWED";
-const INVALID_DATE_OPERAND_TAG = "INVALID_DATE_OPERAND";
-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;
-		this.options = options;
-	}
-	static isLeafNode(node) {
-		return "field" in node && "op" in node;
-	}
-	static isAndNode(node) {
-		return "and" in node;
-	}
-	static isOrNode(node) {
-		return "or" in node;
-	}
-	static isNotNode(node) {
-		return "not" in node;
-	}
-	static isRelationalOperator(op) {
-		return op === "gt" || op === "gte" || op === "lt" || op === "lte";
-	}
-	static describeError(error) {
-		if (error instanceof Error) return {
-			name: error.name,
-			message: error.message
-		};
-		return {
-			name: "NonErrorThrown",
-			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 require_result.Result.err("Invalid Date instance");
-			return require_result.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 require_result.Result.err("Invalid ISO 8601 UTC date string");
-		return require_result.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;
-		}
-	}
-	buildReport(params) {
-		return {
-			occurredAt: /* @__PURE__ */ new Date(),
-			level: params.level,
-			tag: params.tag,
-			message: params.message,
-			engineVersion: this.options.engineVersion,
-			details: params.details
-		};
-	}
-	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: CONDITION_EVAL_THROWN_TAG,
-			message,
-			details: {
-				node,
-				cause
-			}
-		}));
-		return require_result.Result.err(message);
-	}
-	reportDateOperandError(node, actual) {
-		const message = ConditionEvaluatorV1.buildInvalidDateOperandMessage(node);
-		this.options.reporter.error(this.buildReport({
-			level: "error",
-			tag: INVALID_DATE_OPERAND_TAG,
-			message,
-			details: {
-				field: node.field,
-				op: node.op,
-				actual,
-				expected: node.value,
-				node
-			}
-		}));
-		return require_result.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 require_result.Result.err(message);
-	}
-	reportInvalidSetOperand(node, actual) {
-		const message = ConditionEvaluatorV1.buildInvalidSetOperandMessage(node);
-		this.options.reporter.error(this.buildReport({
-			level: "error",
-			tag: INVALID_SET_OPERAND_TAG,
-			message,
-			details: {
-				field: node.field,
-				op: node.op,
-				actual,
-				expected: node.value,
-				node
-			}
-		}));
-		return require_result.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 allowsNull = node.allowNull === true;
-		if (actual === null) {
-			if (allowsNull) return require_result.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 require_result.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 require_result.Result.err(message);
-		}
-		if (actualDateResult === null || actualDateResult.isErr() || expectedDateResult === null || expectedDateResult.isErr()) return this.reportDateOperandError(node, actual);
-		return require_result.Result.ok(ConditionEvaluatorV1.evaluateRelationalNumbers(actualDateResult.getOrNull().getTime(), node.op, expectedDateResult.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 "in": return Array.isArray(expected) && expected.includes(actual);
-			case "notIn": return Array.isArray(expected) && !expected.includes(actual);
-			case "isNull": return actual === null;
-			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 require_result.Result.err(message);
-		}
-		if (actual === null) return require_result.Result.ok(false);
-		if (typeof actual !== "number" || typeof node.value !== "number") return this.reportInvalidNumericOperand(node, actual);
-		return require_result.Result.ok(this.evaluateOperator(actual, node.op, node.value));
-	}
-	evaluateLeafNode(node) {
-		const actualResult = PolicyContextPath.getOrAbsent(this.context, node.field);
-		if (actualResult.isErr()) {
-			this.options.reporter.warn(this.buildReport({
-				level: "warn",
-				tag: "MISSING_CONTEXT_FIELD",
-				message: `MISSING_CONTEXT_FIELD: "${node.field}" not found in context`,
-				details: {
-					field: node.field,
-					node
-				}
-			}));
-			return require_result.Result.err(`MISSING_CONTEXT_FIELD: "${node.field}" not found in context`);
-		}
-		try {
-			const actual = actualResult.getOrThrow();
-			if (ConditionEvaluatorV1.isRelationalOperator(node.op)) {
-				const dateResult = this.evaluateDateRelationalNode(node, actual);
-				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);
-			return require_result.Result.ok(this.evaluateOperator(actual, node.op, node.value));
-		} catch (error) {
-			return this.conditionEvalErr(node, error);
-		}
-	}
-	buildTrace(params) {
-		return {
-			conditionPath: params.conditionPath,
-			decisiveNode: params.decisiveNode,
-			lastEvaluatedLeaf: params.lastEvaluatedLeaf,
-			lastEvaluatedLeafPath: params.lastEvaluatedLeafPath,
-			lastEvaluatedLeafResult: params.lastEvaluatedLeafResult
-		};
-	}
-	evaluateWithTraceInternal(node, path) {
-		if (ConditionEvaluatorV1.isLeafNode(node)) {
-			const leafResult = this.evaluateLeafNode(node);
-			if (leafResult.isErr()) return require_result.Result.err(leafResult.errorOrNull());
-			const matched = leafResult.getOrNull();
-			return require_result.Result.ok({
-				matched,
-				trace: this.buildTrace({
-					conditionPath: path,
-					decisiveNode: node,
-					lastEvaluatedLeaf: node,
-					lastEvaluatedLeafPath: path,
-					lastEvaluatedLeafResult: matched
-				})
-			});
-		}
-		if (ConditionEvaluatorV1.isAndNode(node)) {
-			if (node.and.length === 0) return require_result.Result.err(ConditionEvaluatorV1.buildEmptyAndConditionMessage());
-			let lastTracedChild = null;
-			for (const [index, child] of node.and.entries()) {
-				const childPath = `${path}.and[${index}]`;
-				const childResult = this.evaluateWithTraceInternal(child, childPath);
-				if (childResult.isErr()) return require_result.Result.err(childResult.errorOrNull());
-				const tracedChild = childResult.getOrNull();
-				lastTracedChild = tracedChild;
-				if (!tracedChild.matched) return require_result.Result.ok({
-					matched: false,
-					trace: this.buildTrace({
-						conditionPath: childPath,
-						decisiveNode: child,
-						lastEvaluatedLeaf: tracedChild.trace.lastEvaluatedLeaf,
-						lastEvaluatedLeafPath: tracedChild.trace.lastEvaluatedLeafPath,
-						lastEvaluatedLeafResult: tracedChild.trace.lastEvaluatedLeafResult
-					})
-				});
-			}
-			return require_result.Result.ok({
-				matched: true,
-				trace: lastTracedChild.trace
-			});
-		}
-		if (ConditionEvaluatorV1.isOrNode(node)) {
-			let lastTrace = null;
-			for (const [index, child] of node.or.entries()) {
-				const childResult = this.evaluateWithTraceInternal(child, `${path}.or[${index}]`);
-				if (childResult.isErr()) return require_result.Result.err(childResult.errorOrNull());
-				const tracedChild = childResult.getOrNull();
-				lastTrace = tracedChild.trace;
-				if (tracedChild.matched) return require_result.Result.ok({
-					matched: true,
-					trace: tracedChild.trace
-				});
-			}
-			if (lastTrace === null) return require_result.Result.err(ConditionEvaluatorV1.buildEmptyOrConditionMessage());
-			return require_result.Result.ok({
-				matched: false,
-				trace: lastTrace
-			});
-		}
-		if (ConditionEvaluatorV1.isNotNode(node)) {
-			const childPath = `${path}.not`;
-			const childResult = this.evaluateWithTraceInternal(node.not, childPath);
-			if (childResult.isErr()) return require_result.Result.err(childResult.errorOrNull());
-			const tracedChild = childResult.getOrNull();
-			return require_result.Result.ok({
-				matched: !tracedChild.matched,
-				trace: this.buildTrace({
-					conditionPath: path,
-					decisiveNode: node,
-					lastEvaluatedLeaf: tracedChild.trace.lastEvaluatedLeaf,
-					lastEvaluatedLeafPath: tracedChild.trace.lastEvaluatedLeafPath,
-					lastEvaluatedLeafResult: tracedChild.trace.lastEvaluatedLeafResult
-				})
-			});
-		}
-		return this.conditionEvalErr(node, /* @__PURE__ */ new TypeError("Invalid condition node shape"));
-	}
-	evaluate(node) {
-		try {
-			const result = this.evaluateWithTraceInternal(node, "$");
-			if (result.isErr()) return require_result.Result.err(result.errorOrNull());
-			return require_result.Result.ok(result.getOrNull().matched);
-		} catch (error) {
-			return this.conditionEvalErr(node, error);
-		}
-	}
-	evaluateWithTrace(node) {
-		try {
-			return this.evaluateWithTraceInternal(node, "$");
-		} catch (error) {
-			return this.conditionEvalErr(node, error);
-		}
-	}
-	static extractFields(node) {
-		if (ConditionEvaluatorV1.isLeafNode(node)) return [node.field];
-		if (ConditionEvaluatorV1.isAndNode(node)) return node.and.flatMap((child) => ConditionEvaluatorV1.extractFields(child));
-		if (ConditionEvaluatorV1.isOrNode(node)) return node.or.flatMap((child) => ConditionEvaluatorV1.extractFields(child));
-		if (ConditionEvaluatorV1.isNotNode(node)) return ConditionEvaluatorV1.extractFields(node.not);
-		return [];
-	}
-};
-//#endregion
 //#region src/core/policies/engines/v1/gate/gate-v1-payload.schema.ts
 var GatePayloadSchemaV1 = class GatePayloadSchemaV1 {
 	static {
@@ -580,36 +48,12 @@ var GatePayloadSchemaV1 = class GatePayloadSchemaV1 {
 };
 const gatePayloadSchema = GatePayloadSchemaV1.schema;
 //#endregion
-Object.defineProperty(exports, "ConditionEvaluatorV1", {
-	enumerable: true,
-	get: function() {
-		return ConditionEvaluatorV1;
-	}
-});
-Object.defineProperty(exports, "CoreConfig", {
-	enumerable: true,
-	get: function() {
-		return CoreConfig;
-	}
-});
 Object.defineProperty(exports, "GatePayloadSchemaV1", {
 	enumerable: true,
 	get: function() {
 		return GatePayloadSchemaV1;
 	}
 });
-Object.defineProperty(exports, "PolicyContextPath", {
-	enumerable: true,
-	get: function() {
-		return PolicyContextPath;
-	}
-});
-Object.defineProperty(exports, "SilentPolicyReporter", {
-	enumerable: true,
-	get: function() {
-		return SilentPolicyReporter;
-	}
-});
 Object.defineProperty(exports, "conditionLeafNodeSchema", {
 	enumerable: true,
 	get: function() {
@@ -622,12 +66,6 @@ Object.defineProperty(exports, "conditionNodeSchema", {
 		return conditionNodeSchema;
 	}
 });
-Object.defineProperty(exports, "coreConfig", {
-	enumerable: true,
-	get: function() {
-		return coreConfig;
-	}
-});
 Object.defineProperty(exports, "gatePayloadSchema", {
 	enumerable: true,
 	get: function() {