@cullet/erp-core 1.2.0 → 1.4.0

package/dist/policy-service.js

@@ -1,12 +1,248 @@
-import { t as UnexpectedError } from "./unexpected-error.js";
 import { n as sha256Hex, r as stableStringify } from "./hashing.js";
+import { t as UnexpectedError } from "./unexpected-error.js";
 import { t as ValidationCode } from "./validation-code.js";
 import { t as ValidationField } from "./validation-field.js";
 import { t as InvariantViolationException } from "./invariant-violation-exception.js";
 import { t as InvalidValueException } from "./validation-exception.js";
 import { r as isValidDate } from "./temporal-guards.js";
-import { l as SilentPolicyReporter, o as PolicyContextPath } from "./gate-v1-payload.schema.js";
 import { r as Result } from "./result.js";
+import { a as SilentPolicyReporter, n as PolicyContextPath } from "./condition-evaluator.js";
+//#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 Result.err(PolicyContextBuilder.describeThrownResolverError(error));
+			}
+		};
+		if (timeoutMs === null) return execute();
+		let timeoutId;
+		try {
+			return await Promise.race([execute(), new Promise((resolve) => {
+				timeoutId = setTimeout(() => {
+					resolve(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 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 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 Result.err(`Missing resolver for path "${path}"`);
+			const result = await this.resolveWithResilience(path, resolver, seed);
+			if (result.isErr()) return Result.err(`Resolver error for path "${path}": ${result.errorOrNull()}`);
+			const setPathResult = PolicyContextPath.set(context, path, result.getOrNull());
+			if (setPathResult.isErr()) return Result.err(setPathResult.errorOrNull());
+		}
+		const missing = requirements.filter((path) => {
+			const result = PolicyContextPath.getOrAbsent(context, path);
+			return result.isErr() || result.getOrNull() === void 0;
+		});
+		if (missing.length > 0) return Result.err(`Context missing required paths after resolution: ${missing.join(", ")}`);
+		return 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 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 Result.ok(void 0);
+	}
+	registerAll(resolvers, options = {}) {
+		for (const r of resolvers) {
+			const registrationResult = this.register(r, options);
+			if (registrationResult.isErr()) return registrationResult;
+		}
+		return 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 Result.err(registrationResult.errorOrNull());
+	return 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 Result.err("ContextSeed tenantId must be a non-empty string");
+		if (ContextSeedValidator.isBlankSeedId(seed.schoolId)) return Result.err("ContextSeed schoolId must be a non-empty string");
+		return 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 Result.err(PolicyContextBuilder.describeThrownResolverError(error));
-			}
-		};
-		if (timeoutMs === null) return execute();
-		let timeoutId;
-		try {
-			return await Promise.race([execute(), new Promise((resolve) => {
-				timeoutId = setTimeout(() => {
-					resolve(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 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 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 Result.err(`Missing resolver for path "${path}"`);
-			const result = await this.resolveWithResilience(path, resolver, seed);
-			if (result.isErr()) return Result.err(`Resolver error for path "${path}": ${result.errorOrNull()}`);
-			const setPathResult = PolicyContextPath.set(context, path, result.getOrNull());
-			if (setPathResult.isErr()) return Result.err(setPathResult.errorOrNull());
-		}
-		const missing = requirements.filter((path) => {
-			const result = PolicyContextPath.getOrAbsent(context, path);
-			return result.isErr() || result.getOrNull() === void 0;
-		});
-		if (missing.length > 0) return Result.err(`Context missing required paths after resolution: ${missing.join(", ")}`);
-		return 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 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 Result.ok(void 0);
-	}
-	registerAll(resolvers, options = {}) {
-		for (const r of resolvers) {
-			const registrationResult = this.register(r, options);
-			if (registrationResult.isErr()) return registrationResult;
-		}
-		return 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 Result.err(registrationResult.errorOrNull());
-	return 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 Result.err("ContextSeed tenantId must be a non-empty string");
-		if (ContextSeedValidator.isBlankSeedId(seed.schoolId)) return Result.err("ContextSeed schoolId must be a non-empty string");
-		return Result.ok(seed);
-	}
-};
-//#endregion
 //#region src/core/policies/asof/asof.ts
 const DEFAULT_MAX_AS_OF_FUTURE_YEARS = 10;
 var PolicyAsOfResolver = class PolicyAsOfResolver {
@@ -1060,6 +1060,6 @@ var PolicyService = class {
 	}
 };
 //#endregion
-export { asPolicyDecisionId as _, ContextSeedValidator as a, asTenantId as b, ContextResolverRegistry as c, PolicyDefinition as d, InMemoryPolicyDefinitionRepository as f, PolicyCatalog as g, PolicyCatalogFactory as h, PolicyAsOfResolver as i, registerNamespacedContextResolversIn as l, PolicyKey as m, PolicyEvaluationErrors as n, contextResolverRegistry as o, PolicyScopeMatcher as p, PolicyResolver as r, registerNamespacedContextResolvers as s, PolicyService as t, PolicyContextBuilder as u, asPolicyDefinitionId as v, PolicyHashing as x, asSchoolId as y };
+export { contextResolverRegistry as _, PolicyDefinition as a, registerNamespacedContextResolversIn as b, PolicyKey as c, asPolicyDecisionId as d, asPolicyDefinitionId as f, ContextSeedValidator as g, PolicyHashing as h, PolicyAsOfResolver as i, PolicyCatalogFactory as l, asTenantId as m, PolicyEvaluationErrors as n, InMemoryPolicyDefinitionRepository as o, asSchoolId as p, PolicyResolver as r, PolicyScopeMatcher as s, PolicyService as t, PolicyCatalog as u, registerNamespacedContextResolvers as v, PolicyContextBuilder as x, ContextResolverRegistry as y };
 
 //# sourceMappingURL=policy-service.js.map