@cullet/erp-core 1.3.0 → 1.4.0

package/dist/policy-service.cjs

@@ -1,12 +1,248 @@
-const require_unexpected_error = require("./unexpected-error.cjs");
 const require_hashing = require("./hashing.cjs");
+const require_unexpected_error = require("./unexpected-error.cjs");
 const require_validation_code = require("./validation-code.cjs");
 const require_validation_field = require("./validation-field.cjs");
 const require_invariant_violation_exception = require("./invariant-violation-exception.cjs");
 const require_validation_exception = require("./validation-exception.cjs");
 const require_temporal_guards = require("./temporal-guards.cjs");
-const require_gate_v1_payload_schema = require("./gate-v1-payload.schema.cjs");
 const require_result = require("./result.cjs");
+const require_condition_evaluator = require("./condition-evaluator.cjs");
+//#region src/core/policies/context/context-builder.ts
+const DEFAULT_RESOLVER_RETRY_OPTIONS = {
+	maxAttempts: 1,
+	initialDelayMs: 25,
+	maxDelayMs: 1e3,
+	backoffMultiplier: 2
+};
+/**
+* Builds a context object by resolving required paths from a seed.
+*/
+var PolicyContextBuilder = class PolicyContextBuilder {
+	constructor(registry, options = {}) {
+		this.registry = registry;
+		this.circuitStates = /* @__PURE__ */ new Map();
+		this.defaultResolverResilience = options.defaultResolverResilience;
+		this.now = options.now ?? Date.now;
+		this.sleep = options.sleep ?? (async (delayMs) => {
+			if (delayMs <= 0) return;
+			await new Promise((resolve) => {
+				setTimeout(resolve, delayMs);
+			});
+		});
+	}
+	static clampPositiveInteger(value, fallback) {
+		if (value === void 0 || !Number.isFinite(value)) return fallback;
+		return Math.max(1, Math.trunc(value));
+	}
+	static clampNonNegativeInteger(value, fallback) {
+		if (value === void 0 || !Number.isFinite(value)) return fallback;
+		return Math.max(0, Math.trunc(value));
+	}
+	static normalizeTimeoutMs(value) {
+		if (value === void 0 || !Number.isFinite(value) || value <= 0) return null;
+		return Math.trunc(value);
+	}
+	static mergeRetryOptions(defaults, overrides) {
+		if (overrides === false) return false;
+		if (overrides !== void 0) return {
+			...defaults === false || defaults === void 0 ? {} : defaults,
+			...overrides
+		};
+		return defaults;
+	}
+	static mergeCircuitBreakerOptions(defaults, overrides) {
+		if (overrides === false) return false;
+		if (overrides !== void 0) return {
+			...defaults === false || defaults === void 0 ? {} : defaults,
+			...overrides
+		};
+		return defaults;
+	}
+	resolveResilienceOptions(resolver) {
+		const defaults = this.defaultResolverResilience;
+		const override = resolver.resilience;
+		const retry = PolicyContextBuilder.mergeRetryOptions(defaults?.retry, override?.retry);
+		const circuitBreaker = PolicyContextBuilder.mergeCircuitBreakerOptions(defaults?.circuitBreaker, override?.circuitBreaker);
+		const retryOptions = retry === false ? void 0 : retry;
+		const circuitBreakerOptions = circuitBreaker === false ? void 0 : circuitBreaker;
+		return {
+			timeoutMs: PolicyContextBuilder.normalizeTimeoutMs(override?.timeoutMs ?? defaults?.timeoutMs),
+			retry: {
+				maxAttempts: PolicyContextBuilder.clampPositiveInteger(retryOptions?.maxAttempts, DEFAULT_RESOLVER_RETRY_OPTIONS.maxAttempts),
+				initialDelayMs: PolicyContextBuilder.clampNonNegativeInteger(retryOptions?.initialDelayMs, DEFAULT_RESOLVER_RETRY_OPTIONS.initialDelayMs),
+				maxDelayMs: PolicyContextBuilder.clampNonNegativeInteger(retryOptions?.maxDelayMs, DEFAULT_RESOLVER_RETRY_OPTIONS.maxDelayMs),
+				backoffMultiplier: PolicyContextBuilder.clampPositiveInteger(retryOptions?.backoffMultiplier, DEFAULT_RESOLVER_RETRY_OPTIONS.backoffMultiplier)
+			},
+			circuitBreaker: circuitBreakerOptions === void 0 ? null : {
+				failureThreshold: PolicyContextBuilder.clampPositiveInteger(circuitBreakerOptions.failureThreshold, 5),
+				cooldownMs: PolicyContextBuilder.clampPositiveInteger(circuitBreakerOptions.cooldownMs, 3e4)
+			}
+		};
+	}
+	getRetryDelayMs(attempt, retry) {
+		return Math.min(retry.initialDelayMs * retry.backoffMultiplier ** (attempt - 1), retry.maxDelayMs);
+	}
+	resetCircuit(path) {
+		this.circuitStates.delete(path);
+	}
+	isCircuitOpen(path, circuitBreaker) {
+		if (circuitBreaker === null) return false;
+		const state = this.circuitStates.get(path);
+		if (state === void 0 || state.openUntilMs === null) return false;
+		if (state.openUntilMs <= this.now()) {
+			this.resetCircuit(path);
+			return false;
+		}
+		return true;
+	}
+	recordResolverFailure(path, circuitBreaker) {
+		if (circuitBreaker === null) return;
+		const nextFailureCount = (this.circuitStates.get(path)?.failureCount ?? 0) + 1;
+		if (nextFailureCount >= circuitBreaker.failureThreshold) {
+			this.circuitStates.set(path, {
+				failureCount: 0,
+				openUntilMs: this.now() + circuitBreaker.cooldownMs
+			});
+			return;
+		}
+		this.circuitStates.set(path, {
+			failureCount: nextFailureCount,
+			openUntilMs: null
+		});
+	}
+	static describeThrownResolverError(error) {
+		if (error instanceof Error) return `threw ${error.name}: ${error.message}`;
+		return `threw ${String(error)}`;
+	}
+	async resolveOnce(resolver, seed, timeoutMs) {
+		const execute = async () => {
+			try {
+				return await resolver.resolve(seed);
+			} catch (error) {
+				return require_result.Result.err(PolicyContextBuilder.describeThrownResolverError(error));
+			}
+		};
+		if (timeoutMs === null) return execute();
+		let timeoutId;
+		try {
+			return await Promise.race([execute(), new Promise((resolve) => {
+				timeoutId = setTimeout(() => {
+					resolve(require_result.Result.err(`timed out after ${timeoutMs}ms`));
+				}, timeoutMs);
+			})]);
+		} finally {
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
+		}
+	}
+	async resolveWithResilience(path, resolver, seed) {
+		const resilience = this.resolveResilienceOptions(resolver);
+		if (this.isCircuitOpen(path, resilience.circuitBreaker)) return require_result.Result.err("circuit breaker is open");
+		let lastError = "resolver failed";
+		for (let attempt = 1; attempt <= resilience.retry.maxAttempts; attempt++) {
+			const result = await this.resolveOnce(resolver, seed, resilience.timeoutMs);
+			if (result.isOk()) {
+				this.resetCircuit(path);
+				return result;
+			}
+			lastError = result.errorOrNull() ?? lastError;
+			if (attempt < resilience.retry.maxAttempts) await this.sleep(this.getRetryDelayMs(attempt, resilience.retry));
+		}
+		this.recordResolverFailure(path, resilience.circuitBreaker);
+		return require_result.Result.err(lastError);
+	}
+	/**
+	* Resolves all required context paths and returns a flat context object.
+	* If any required path cannot be resolved, returns an error.
+	*/
+	async build(requirements, seed) {
+		const context = {};
+		for (const path of requirements) {
+			const resolver = this.registry.get(path);
+			if (!resolver) return require_result.Result.err(`Missing resolver for path "${path}"`);
+			const result = await this.resolveWithResilience(path, resolver, seed);
+			if (result.isErr()) return require_result.Result.err(`Resolver error for path "${path}": ${result.errorOrNull()}`);
+			const setPathResult = require_condition_evaluator.PolicyContextPath.set(context, path, result.getOrNull());
+			if (setPathResult.isErr()) return require_result.Result.err(setPathResult.errorOrNull());
+		}
+		const missing = requirements.filter((path) => {
+			const result = require_condition_evaluator.PolicyContextPath.getOrAbsent(context, path);
+			return result.isErr() || result.getOrNull() === void 0;
+		});
+		if (missing.length > 0) return require_result.Result.err(`Context missing required paths after resolution: ${missing.join(", ")}`);
+		return require_result.Result.ok(context);
+	}
+};
+//#endregion
+//#region src/core/policies/context/context-registry.ts
+const DEFAULT_CONTEXT_RESOLVER_NAMESPACE = "default";
+function normalizeNamespace(namespace) {
+	const normalized = namespace?.trim();
+	if (normalized === void 0 || normalized.length === 0) return DEFAULT_CONTEXT_RESOLVER_NAMESPACE;
+	return normalized;
+}
+/**
+* Registry of context value resolvers, keyed by path.
+*/
+var ContextResolverRegistry = class {
+	constructor() {
+		this.resolvers = /* @__PURE__ */ new Map();
+	}
+	register(resolver, options = {}) {
+		const namespace = normalizeNamespace(options.namespace);
+		const existing = this.resolvers.get(resolver.path);
+		if (existing !== void 0 && existing.namespace !== namespace) return require_result.Result.err(`Resolver path "${resolver.path}" is already registered by namespace "${existing.namespace}" and cannot be replaced by "${namespace}".`);
+		this.resolvers.set(resolver.path, {
+			namespace,
+			resolver
+		});
+		return require_result.Result.ok(void 0);
+	}
+	registerAll(resolvers, options = {}) {
+		for (const r of resolvers) {
+			const registrationResult = this.register(r, options);
+			if (registrationResult.isErr()) return registrationResult;
+		}
+		return require_result.Result.ok(void 0);
+	}
+	get(path) {
+		return this.resolvers.get(path)?.resolver;
+	}
+	has(path) {
+		return this.resolvers.has(path);
+	}
+	getNamespace(path) {
+		return this.resolvers.get(path)?.namespace;
+	}
+};
+function registerNamespacedContextResolversIn(registry, namespace, resolvers) {
+	const registrationResult = registry.registerAll(resolvers, { namespace });
+	if (registrationResult.isErr()) return require_result.Result.err(registrationResult.errorOrNull());
+	return require_result.Result.ok(registry);
+}
+//#endregion
+//#region src/core/policies/context/context-registry.instance.ts
+/**
+* Official instance of the ContextResolverRegistry.
+* Use `new ContextResolverRegistry()` plus `registerNamespacedContextResolversIn`
+* when each runtime/composition root needs its own isolated resolver graph.
+*/
+const contextResolverRegistry = new ContextResolverRegistry();
+function registerNamespacedContextResolvers(namespace, resolvers) {
+	return registerNamespacedContextResolversIn(contextResolverRegistry, namespace, resolvers);
+}
+//#endregion
+//#region src/core/policies/context/context-seed.ts
+var ContextSeedValidator = class ContextSeedValidator {
+	static isBlankSeedId(value) {
+		return value.trim().length === 0;
+	}
+	static validate(seed) {
+		if (ContextSeedValidator.isBlankSeedId(seed.tenantId)) return require_result.Result.err("ContextSeed tenantId must be a non-empty string");
+		if (ContextSeedValidator.isBlankSeedId(seed.schoolId)) return require_result.Result.err("ContextSeed schoolId must be a non-empty string");
+		return require_result.Result.ok(seed);
+	}
+};
+//#endregion
 //#region src/core/policies/utils/hash.ts
 /**
 * Produces a deterministic SHA-256 hex digest of a canonical JSON representation.
@@ -487,242 +723,6 @@ var PolicyDefinition = class PolicyDefinition {
 	}
 };
 //#endregion
-//#region src/core/policies/context/context-builder.ts
-const DEFAULT_RESOLVER_RETRY_OPTIONS = {
-	maxAttempts: 1,
-	initialDelayMs: 25,
-	maxDelayMs: 1e3,
-	backoffMultiplier: 2
-};
-/**
-* Builds a context object by resolving required paths from a seed.
-*/
-var PolicyContextBuilder = class PolicyContextBuilder {
-	constructor(registry, options = {}) {
-		this.registry = registry;
-		this.circuitStates = /* @__PURE__ */ new Map();
-		this.defaultResolverResilience = options.defaultResolverResilience;
-		this.now = options.now ?? Date.now;
-		this.sleep = options.sleep ?? (async (delayMs) => {
-			if (delayMs <= 0) return;
-			await new Promise((resolve) => {
-				setTimeout(resolve, delayMs);
-			});
-		});
-	}
-	static clampPositiveInteger(value, fallback) {
-		if (value === void 0 || !Number.isFinite(value)) return fallback;
-		return Math.max(1, Math.trunc(value));
-	}
-	static clampNonNegativeInteger(value, fallback) {
-		if (value === void 0 || !Number.isFinite(value)) return fallback;
-		return Math.max(0, Math.trunc(value));
-	}
-	static normalizeTimeoutMs(value) {
-		if (value === void 0 || !Number.isFinite(value) || value <= 0) return null;
-		return Math.trunc(value);
-	}
-	static mergeRetryOptions(defaults, overrides) {
-		if (overrides === false) return false;
-		if (overrides !== void 0) return {
-			...defaults === false || defaults === void 0 ? {} : defaults,
-			...overrides
-		};
-		return defaults;
-	}
-	static mergeCircuitBreakerOptions(defaults, overrides) {
-		if (overrides === false) return false;
-		if (overrides !== void 0) return {
-			...defaults === false || defaults === void 0 ? {} : defaults,
-			...overrides
-		};
-		return defaults;
-	}
-	resolveResilienceOptions(resolver) {
-		const defaults = this.defaultResolverResilience;
-		const override = resolver.resilience;
-		const retry = PolicyContextBuilder.mergeRetryOptions(defaults?.retry, override?.retry);
-		const circuitBreaker = PolicyContextBuilder.mergeCircuitBreakerOptions(defaults?.circuitBreaker, override?.circuitBreaker);
-		const retryOptions = retry === false ? void 0 : retry;
-		const circuitBreakerOptions = circuitBreaker === false ? void 0 : circuitBreaker;
-		return {
-			timeoutMs: PolicyContextBuilder.normalizeTimeoutMs(override?.timeoutMs ?? defaults?.timeoutMs),
-			retry: {
-				maxAttempts: PolicyContextBuilder.clampPositiveInteger(retryOptions?.maxAttempts, DEFAULT_RESOLVER_RETRY_OPTIONS.maxAttempts),
-				initialDelayMs: PolicyContextBuilder.clampNonNegativeInteger(retryOptions?.initialDelayMs, DEFAULT_RESOLVER_RETRY_OPTIONS.initialDelayMs),
-				maxDelayMs: PolicyContextBuilder.clampNonNegativeInteger(retryOptions?.maxDelayMs, DEFAULT_RESOLVER_RETRY_OPTIONS.maxDelayMs),
-				backoffMultiplier: PolicyContextBuilder.clampPositiveInteger(retryOptions?.backoffMultiplier, DEFAULT_RESOLVER_RETRY_OPTIONS.backoffMultiplier)
-			},
-			circuitBreaker: circuitBreakerOptions === void 0 ? null : {
-				failureThreshold: PolicyContextBuilder.clampPositiveInteger(circuitBreakerOptions.failureThreshold, 5),
-				cooldownMs: PolicyContextBuilder.clampPositiveInteger(circuitBreakerOptions.cooldownMs, 3e4)
-			}
-		};
-	}
-	getRetryDelayMs(attempt, retry) {
-		return Math.min(retry.initialDelayMs * retry.backoffMultiplier ** (attempt - 1), retry.maxDelayMs);
-	}
-	resetCircuit(path) {
-		this.circuitStates.delete(path);
-	}
-	isCircuitOpen(path, circuitBreaker) {
-		if (circuitBreaker === null) return false;
-		const state = this.circuitStates.get(path);
-		if (state === void 0 || state.openUntilMs === null) return false;
-		if (state.openUntilMs <= this.now()) {
-			this.resetCircuit(path);
-			return false;
-		}
-		return true;
-	}
-	recordResolverFailure(path, circuitBreaker) {
-		if (circuitBreaker === null) return;
-		const nextFailureCount = (this.circuitStates.get(path)?.failureCount ?? 0) + 1;
-		if (nextFailureCount >= circuitBreaker.failureThreshold) {
-			this.circuitStates.set(path, {
-				failureCount: 0,
-				openUntilMs: this.now() + circuitBreaker.cooldownMs
-			});
-			return;
-		}
-		this.circuitStates.set(path, {
-			failureCount: nextFailureCount,
-			openUntilMs: null
-		});
-	}
-	static describeThrownResolverError(error) {
-		if (error instanceof Error) return `threw ${error.name}: ${error.message}`;
-		return `threw ${String(error)}`;
-	}
-	async resolveOnce(resolver, seed, timeoutMs) {
-		const execute = async () => {
-			try {
-				return await resolver.resolve(seed);
-			} catch (error) {
-				return require_result.Result.err(PolicyContextBuilder.describeThrownResolverError(error));
-			}
-		};
-		if (timeoutMs === null) return execute();
-		let timeoutId;
-		try {
-			return await Promise.race([execute(), new Promise((resolve) => {
-				timeoutId = setTimeout(() => {
-					resolve(require_result.Result.err(`timed out after ${timeoutMs}ms`));
-				}, timeoutMs);
-			})]);
-		} finally {
-			if (timeoutId !== void 0) clearTimeout(timeoutId);
-		}
-	}
-	async resolveWithResilience(path, resolver, seed) {
-		const resilience = this.resolveResilienceOptions(resolver);
-		if (this.isCircuitOpen(path, resilience.circuitBreaker)) return require_result.Result.err("circuit breaker is open");
-		let lastError = "resolver failed";
-		for (let attempt = 1; attempt <= resilience.retry.maxAttempts; attempt++) {
-			const result = await this.resolveOnce(resolver, seed, resilience.timeoutMs);
-			if (result.isOk()) {
-				this.resetCircuit(path);
-				return result;
-			}
-			lastError = result.errorOrNull() ?? lastError;
-			if (attempt < resilience.retry.maxAttempts) await this.sleep(this.getRetryDelayMs(attempt, resilience.retry));
-		}
-		this.recordResolverFailure(path, resilience.circuitBreaker);
-		return require_result.Result.err(lastError);
-	}
-	/**
-	* Resolves all required context paths and returns a flat context object.
-	* If any required path cannot be resolved, returns an error.
-	*/
-	async build(requirements, seed) {
-		const context = {};
-		for (const path of requirements) {
-			const resolver = this.registry.get(path);
-			if (!resolver) return require_result.Result.err(`Missing resolver for path "${path}"`);
-			const result = await this.resolveWithResilience(path, resolver, seed);
-			if (result.isErr()) return require_result.Result.err(`Resolver error for path "${path}": ${result.errorOrNull()}`);
-			const setPathResult = require_gate_v1_payload_schema.PolicyContextPath.set(context, path, result.getOrNull());
-			if (setPathResult.isErr()) return require_result.Result.err(setPathResult.errorOrNull());
-		}
-		const missing = requirements.filter((path) => {
-			const result = require_gate_v1_payload_schema.PolicyContextPath.getOrAbsent(context, path);
-			return result.isErr() || result.getOrNull() === void 0;
-		});
-		if (missing.length > 0) return require_result.Result.err(`Context missing required paths after resolution: ${missing.join(", ")}`);
-		return require_result.Result.ok(context);
-	}
-};
-//#endregion
-//#region src/core/policies/context/context-registry.ts
-const DEFAULT_CONTEXT_RESOLVER_NAMESPACE = "default";
-function normalizeNamespace(namespace) {
-	const normalized = namespace?.trim();
-	if (normalized === void 0 || normalized.length === 0) return DEFAULT_CONTEXT_RESOLVER_NAMESPACE;
-	return normalized;
-}
-/**
-* Registry of context value resolvers, keyed by path.
-*/
-var ContextResolverRegistry = class {
-	constructor() {
-		this.resolvers = /* @__PURE__ */ new Map();
-	}
-	register(resolver, options = {}) {
-		const namespace = normalizeNamespace(options.namespace);
-		const existing = this.resolvers.get(resolver.path);
-		if (existing !== void 0 && existing.namespace !== namespace) return require_result.Result.err(`Resolver path "${resolver.path}" is already registered by namespace "${existing.namespace}" and cannot be replaced by "${namespace}".`);
-		this.resolvers.set(resolver.path, {
-			namespace,
-			resolver
-		});
-		return require_result.Result.ok(void 0);
-	}
-	registerAll(resolvers, options = {}) {
-		for (const r of resolvers) {
-			const registrationResult = this.register(r, options);
-			if (registrationResult.isErr()) return registrationResult;
-		}
-		return require_result.Result.ok(void 0);
-	}
-	get(path) {
-		return this.resolvers.get(path)?.resolver;
-	}
-	has(path) {
-		return this.resolvers.has(path);
-	}
-	getNamespace(path) {
-		return this.resolvers.get(path)?.namespace;
-	}
-};
-function registerNamespacedContextResolversIn(registry, namespace, resolvers) {
-	const registrationResult = registry.registerAll(resolvers, { namespace });
-	if (registrationResult.isErr()) return require_result.Result.err(registrationResult.errorOrNull());
-	return require_result.Result.ok(registry);
-}
-//#endregion
-//#region src/core/policies/context/context-registry.instance.ts
-/**
-* Official instance of the ContextResolverRegistry.
-* Use `new ContextResolverRegistry()` plus `registerNamespacedContextResolversIn`
-* when each runtime/composition root needs its own isolated resolver graph.
-*/
-const contextResolverRegistry = new ContextResolverRegistry();
-function registerNamespacedContextResolvers(namespace, resolvers) {
-	return registerNamespacedContextResolversIn(contextResolverRegistry, namespace, resolvers);
-}
-//#endregion
-//#region src/core/policies/context/context-seed.ts
-var ContextSeedValidator = class ContextSeedValidator {
-	static isBlankSeedId(value) {
-		return value.trim().length === 0;
-	}
-	static validate(seed) {
-		if (ContextSeedValidator.isBlankSeedId(seed.tenantId)) return require_result.Result.err("ContextSeed tenantId must be a non-empty string");
-		if (ContextSeedValidator.isBlankSeedId(seed.schoolId)) return require_result.Result.err("ContextSeed schoolId must be a non-empty string");
-		return require_result.Result.ok(seed);
-	}
-};
-//#endregion
 //#region src/core/policies/asof/asof.ts
 const DEFAULT_MAX_AS_OF_FUTURE_YEARS = 10;
 var PolicyAsOfResolver = class PolicyAsOfResolver {
@@ -875,7 +875,7 @@ var PolicyService = class {
 		this.gateEngines = params.gateEngines;
 		this.computeRegistry = params.computeRegistry;
 		this.options = params.options ?? {};
-		this.#reporter = this.options.reporter ?? new require_gate_v1_payload_schema.SilentPolicyReporter();
+		this.#reporter = this.options.reporter ?? new require_condition_evaluator.SilentPolicyReporter();
 	}
 	#reportSafely(event) {
 		try {