@cullet/erp-core 1.0.2 → 1.0.4

package/src/core/policies/defs/policy-semver.ts

@@ -1,60 +1,60 @@
 // Semver without build metadata: comparisons are defined only over
 // major.minor.patch and optional pre-release identifiers (semver §11).
 export const POLICY_SEMVER_PATTERN =
-  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
 
 interface ParsedSemver {
-  major: number;
-  minor: number;
-  patch: number;
-  preRelease: string | null;
+    major: number;
+    minor: number;
+    patch: number;
+    preRelease: string | null;
 }
 
 function parseSemver(version: string): ParsedSemver {
-  const withoutBuild = version.split("+")[0];
-  const [core, preRelease = null] = withoutBuild.split("-") as [
-    string,
-    string | undefined,
-  ];
-  const [major, minor, patch] = core.split(".").map(Number) as [
-    number,
-    number,
-    number,
-  ];
-  return { major, minor, patch, preRelease: preRelease ?? null };
+    const withoutBuild = version.split("+")[0];
+    const [core, preRelease = null] = withoutBuild.split("-") as [
+        string,
+        string | undefined,
+    ];
+    const [major, minor, patch] = core.split(".").map(Number) as [
+        number,
+        number,
+        number,
+    ];
+    return { major, minor, patch, preRelease: preRelease ?? null };
 }
 
 function comparePreRelease(a: string, b: string): number {
-  const aIds = a.split(".");
-  const bIds = b.split(".");
-  const len = Math.max(aIds.length, bIds.length);
+    const aIds = a.split(".");
+    const bIds = b.split(".");
+    const len = Math.max(aIds.length, bIds.length);
 
-  for (let i = 0; i < len; i++) {
-    const ai = aIds[i];
-    const bi = bIds[i];
+    for (let i = 0; i < len; i++) {
+        const ai = aIds[i];
+        const bi = bIds[i];
 
-    // Shorter pre-release has lower precedence when prefix matches (semver §11.4.4)
-    if (ai === undefined) return -1;
-    if (bi === undefined) return 1;
+        // Shorter pre-release has lower precedence when prefix matches (semver §11.4.4)
+        if (ai === undefined) return -1;
+        if (bi === undefined) return 1;
 
-    const aNum = Number(ai);
-    const bNum = Number(bi);
-    const aIsNum = !Number.isNaN(aNum);
-    const bIsNum = !Number.isNaN(bNum);
+        const aNum = Number(ai);
+        const bNum = Number(bi);
+        const aIsNum = !Number.isNaN(aNum);
+        const bIsNum = !Number.isNaN(bNum);
 
-    // Numeric identifiers always have lower precedence than alphanumeric (semver §11.4.1)
-    if (aIsNum && !bIsNum) return -1;
-    if (!aIsNum && bIsNum) return 1;
+        // Numeric identifiers always have lower precedence than alphanumeric (semver §11.4.1)
+        if (aIsNum && !bIsNum) return -1;
+        if (!aIsNum && bIsNum) return 1;
 
-    if (aIsNum && bIsNum) {
-      if (aNum !== bNum) return aNum - bNum;
-    } else {
-      if (ai < bi) return -1;
-      if (ai > bi) return 1;
+        if (aIsNum && bIsNum) {
+            if (aNum !== bNum) return aNum - bNum;
+        } else {
+            if (ai < bi) return -1;
+            if (ai > bi) return 1;
+        }
     }
-  }
 
-  return 0;
+    return 0;
 }
 
 /**
@@ -65,19 +65,19 @@ function comparePreRelease(a: string, b: string): number {
  * `POLICY_SEMVER_PATTERN` validation (i.e. values stored in PolicyDefinition).
  */
 export function comparePolicySemver(a: string, b: string): number {
-  const av = parseSemver(a);
-  const bv = parseSemver(b);
+    const av = parseSemver(a);
+    const bv = parseSemver(b);
 
-  if (av.major !== bv.major) return av.major - bv.major;
-  if (av.minor !== bv.minor) return av.minor - bv.minor;
-  if (av.patch !== bv.patch) return av.patch - bv.patch;
+    if (av.major !== bv.major) return av.major - bv.major;
+    if (av.minor !== bv.minor) return av.minor - bv.minor;
+    if (av.patch !== bv.patch) return av.patch - bv.patch;
 
-  // Release > pre-release (semver §11.3)
-  if (av.preRelease === null && bv.preRelease !== null) return 1;
-  if (av.preRelease !== null && bv.preRelease === null) return -1;
-  if (av.preRelease !== null && bv.preRelease !== null) {
-    return comparePreRelease(av.preRelease, bv.preRelease);
-  }
+    // Release > pre-release (semver §11.3)
+    if (av.preRelease === null && bv.preRelease !== null) return 1;
+    if (av.preRelease !== null && bv.preRelease === null) return -1;
+    if (av.preRelease !== null && bv.preRelease !== null) {
+        return comparePreRelease(av.preRelease, bv.preRelease);
+    }
 
-  return 0;
+    return 0;
 }

package/src/core/policies/engines/compute-engine-registry.ts

@@ -6,52 +6,52 @@ import type { ComputeEvaluatorRegistry } from "./compute-evaluator-registry";
 import type { ComputeOutcome, VersionedComputeEngine } from "./compute-types";
 
 export class ComputeEngineRegistry {
-  private readonly engines = new Map<number, VersionedComputeEngine>();
-
-  register(engine: VersionedComputeEngine): void {
-    this.engines.set(engine.version, engine);
-  }
-
-  get(version: number): VersionedComputeEngine | undefined {
-    return this.engines.get(version);
-  }
-
-  evaluate(
-    version: number,
-    params: {
-      readonly policyKey: string;
-      readonly payloadSchemaVersion: number;
-      readonly payload: unknown;
-      readonly context: PolicyContext;
-      readonly evaluators: ComputeEvaluatorRegistry;
-    },
-  ): Result<ComputeOutcome, string> {
-    const engine = this.get(version);
-    if (engine === undefined) {
-      return Result.err(
-        `No compute engine registered for version "${version}"`,
-      );
-    }
+    private readonly engines = new Map<number, VersionedComputeEngine>();
 
-    const evaluator = params.evaluators.get(params.policyKey, version);
-    if (evaluator === undefined) {
-      return Result.err(
-        `No compute evaluator registered for policy key "${params.policyKey}" and version "${version}"`,
-      );
+    register(engine: VersionedComputeEngine): void {
+        this.engines.set(engine.version, engine);
     }
 
-    const parsedPayloadResult = ComputePayloadParsers.parse(
-      params.payloadSchemaVersion,
-      params.payload,
-    );
-    if (parsedPayloadResult.isErr()) {
-      return Result.err(parsedPayloadResult.errorOrNull()!);
+    get(version: number): VersionedComputeEngine | undefined {
+        return this.engines.get(version);
     }
 
-    return engine.evaluate(
-      parsedPayloadResult.getOrNull()!,
-      params.context,
-      evaluator,
-    );
-  }
+    evaluate(
+        version: number,
+        params: {
+            readonly policyKey: string;
+            readonly payloadSchemaVersion: number;
+            readonly payload: unknown;
+            readonly context: PolicyContext;
+            readonly evaluators: ComputeEvaluatorRegistry;
+        },
+    ): Result<ComputeOutcome, string> {
+        const engine = this.get(version);
+        if (engine === undefined) {
+            return Result.err(
+                `No compute engine registered for version "${version}"`,
+            );
+        }
+
+        const evaluator = params.evaluators.get(params.policyKey, version);
+        if (evaluator === undefined) {
+            return Result.err(
+                `No compute evaluator registered for policy key "${params.policyKey}" and version "${version}"`,
+            );
+        }
+
+        const parsedPayloadResult = ComputePayloadParsers.parse(
+            params.payloadSchemaVersion,
+            params.payload,
+        );
+        if (parsedPayloadResult.isErr()) {
+            return Result.err(parsedPayloadResult.errorOrNull()!);
+        }
+
+        return engine.evaluate(
+            parsedPayloadResult.getOrNull()!,
+            params.context,
+            evaluator,
+        );
+    }
 }

package/src/core/policies/engines/compute-evaluator-registry.ts

@@ -1,28 +1,28 @@
 import type {
-  ComputeEvaluator,
-  ComputeEvaluatorRegistration,
+    ComputeEvaluator,
+    ComputeEvaluatorRegistration,
 } from "./compute-types";
 
 export class ComputeEvaluatorRegistry {
-  private readonly evaluators = new Map<string, ComputeEvaluator>();
+    private readonly evaluators = new Map<string, ComputeEvaluator>();
 
-  private static toRegistryKey(policyKey: string, version: number): string {
-    return `${policyKey}::${version}`;
-  }
+    private static toRegistryKey(policyKey: string, version: number): string {
+        return `${policyKey}::${version}`;
+    }
 
-  register(registration: ComputeEvaluatorRegistration): void {
-    this.evaluators.set(
-      ComputeEvaluatorRegistry.toRegistryKey(
-        registration.policyKey,
-        registration.version,
-      ),
-      registration.evaluator,
-    );
-  }
+    register(registration: ComputeEvaluatorRegistration): void {
+        this.evaluators.set(
+            ComputeEvaluatorRegistry.toRegistryKey(
+                registration.policyKey,
+                registration.version,
+            ),
+            registration.evaluator,
+        );
+    }
 
-  get(policyKey: string, version: number): ComputeEvaluator | undefined {
-    return this.evaluators.get(
-      ComputeEvaluatorRegistry.toRegistryKey(policyKey, version),
-    );
-  }
+    get(policyKey: string, version: number): ComputeEvaluator | undefined {
+        return this.evaluators.get(
+            ComputeEvaluatorRegistry.toRegistryKey(policyKey, version),
+        );
+    }
 }

package/src/core/policies/engines/compute-registry.ts

@@ -5,63 +5,63 @@ import { ComputeEngineRegistry } from "./compute-engine-registry";
 import { ComputeEvaluatorRegistry } from "./compute-evaluator-registry";
 import type { PolicyContext } from "./gate-types";
 import type {
-  ComputeEvaluator,
-  ComputeEvaluatorRegistration,
-  ComputeOutcome,
-  VersionedComputeEngine,
+    ComputeEvaluator,
+    ComputeEvaluatorRegistration,
+    ComputeOutcome,
+    VersionedComputeEngine,
 } from "./compute-types";
 import { ComputeEngineV1 } from "./v1/compute";
 
 export interface ComputeRegistryOptions {
-  readonly coreConfig?: CoreConfig;
+    readonly coreConfig?: CoreConfig;
 }
 
 export class ComputeRegistry {
-  private readonly engines = new ComputeEngineRegistry();
-  private readonly evaluators = new ComputeEvaluatorRegistry();
+    private readonly engines = new ComputeEngineRegistry();
+    private readonly evaluators = new ComputeEvaluatorRegistry();
 
-  constructor(params: ComputeRegistryOptions = {}) {
-    const resolvedCoreConfig = params.coreConfig ?? coreConfig;
+    constructor(params: ComputeRegistryOptions = {}) {
+        const resolvedCoreConfig = params.coreConfig ?? coreConfig;
 
-    this.engines.register(
-      new ComputeEngineV1({
-        coreConfig: resolvedCoreConfig,
-      }),
-    );
-  }
+        this.engines.register(
+            new ComputeEngineV1({
+                coreConfig: resolvedCoreConfig,
+            }),
+        );
+    }
 
-  register(registration: ComputeEvaluatorRegistration): void {
-    this.evaluators.register(registration);
-  }
+    register(registration: ComputeEvaluatorRegistration): void {
+        this.evaluators.register(registration);
+    }
 
-  registerEngine(engine: VersionedComputeEngine): void {
-    this.engines.register(engine);
-  }
+    registerEngine(engine: VersionedComputeEngine): void {
+        this.engines.register(engine);
+    }
 
-  getEngine(version: number): VersionedComputeEngine | undefined {
-    return this.engines.get(version);
-  }
+    getEngine(version: number): VersionedComputeEngine | undefined {
+        return this.engines.get(version);
+    }
 
-  getEvaluator(
-    policyKey: string,
-    version: number,
-  ): ComputeEvaluator | undefined {
-    return this.evaluators.get(policyKey, version);
-  }
+    getEvaluator(
+        policyKey: string,
+        version: number,
+    ): ComputeEvaluator | undefined {
+        return this.evaluators.get(policyKey, version);
+    }
 
-  evaluate(
-    policyKey: string,
-    computeEngineVersion: number,
-    payloadSchemaVersion: number,
-    payload: unknown,
-    context: PolicyContext,
-  ): Result<ComputeOutcome, string> {
-    return this.engines.evaluate(computeEngineVersion, {
-      policyKey,
-      payloadSchemaVersion,
-      payload,
-      context,
-      evaluators: this.evaluators,
-    });
-  }
+    evaluate(
+        policyKey: string,
+        computeEngineVersion: number,
+        payloadSchemaVersion: number,
+        payload: unknown,
+        context: PolicyContext,
+    ): Result<ComputeOutcome, string> {
+        return this.engines.evaluate(computeEngineVersion, {
+            policyKey,
+            payloadSchemaVersion,
+            payload,
+            context,
+            evaluators: this.evaluators,
+        });
+    }
 }

package/src/core/policies/engines/compute-types.ts

@@ -9,8 +9,8 @@ import type { PolicyContext, PolicyViolation } from "./gate-types";
 export type ComputeStatus = "OK" | "NOT_APPLICABLE" | "ERROR";
 
 export interface ComputeOutcomeData {
-  readonly values: unknown | null;
-  readonly violations: readonly PolicyViolation[];
+    readonly values: unknown | null;
+    readonly violations: readonly PolicyViolation[];
 }
 
 /** Semantic outcome of a COMPUTE policy evaluation. */
@@ -29,23 +29,23 @@ export type ComputeOutcome = Outcome<ComputeStatus, ComputeOutcomeData>;
  * Outcome carries the semantic business decision.
  */
 export interface ComputeEvaluator {
-  evaluate(
-    resolvedValue: unknown,
-    context: Record<string, unknown>,
-  ): Result<ComputeOutcome, string>;
+    evaluate(
+        resolvedValue: unknown,
+        context: Record<string, unknown>,
+    ): Result<ComputeOutcome, string>;
 }
 
 export interface ComputeEvaluatorRegistration {
-  readonly policyKey: string;
-  readonly version: number;
-  readonly evaluator: ComputeEvaluator;
+    readonly policyKey: string;
+    readonly version: number;
+    readonly evaluator: ComputeEvaluator;
 }
 
 export interface VersionedComputeEngine {
-  readonly version: number;
-  evaluate(
-    payload: ComputePayload,
-    context: PolicyContext,
-    evaluator: ComputeEvaluator,
-  ): Result<ComputeOutcome, string>;
+    readonly version: number;
+    evaluate(
+        payload: ComputePayload,
+        context: PolicyContext,
+        evaluator: ComputeEvaluator,
+    ): Result<ComputeOutcome, string>;
 }

package/src/core/policies/engines/condition-evaluator-reporter.ts

@@ -1,34 +1,34 @@
 export interface ConditionEvaluationCause {
-  readonly name: string;
-  readonly message: string;
+    readonly name: string;
+    readonly message: string;
 }
 
 export type ConditionEvaluationReportLevel = "warn" | "error";
 
 export type ConditionEvaluationReportTag =
-  | "MISSING_CONTEXT_FIELD"
-  | "NULLISH_NUMERIC_OPERAND_NOT_ALLOWED"
-  | "NULLISH_DATE_OPERAND_NOT_ALLOWED"
-  | "INVALID_DATE_OPERAND"
-  | "CONDITION_EVAL_THREW";
+    | "MISSING_CONTEXT_FIELD"
+    | "NULLISH_NUMERIC_OPERAND_NOT_ALLOWED"
+    | "NULLISH_DATE_OPERAND_NOT_ALLOWED"
+    | "INVALID_DATE_OPERAND"
+    | "CONDITION_EVAL_THREW";
 
 export interface ConditionEvaluationReport {
-  readonly occurredAt: Date;
-  readonly level: ConditionEvaluationReportLevel;
-  readonly tag: ConditionEvaluationReportTag;
-  readonly message: string;
-  readonly engineVersion: number;
-  readonly details: Readonly<Record<string, unknown>>;
+    readonly occurredAt: Date;
+    readonly level: ConditionEvaluationReportLevel;
+    readonly tag: ConditionEvaluationReportTag;
+    readonly message: string;
+    readonly engineVersion: number;
+    readonly details: Readonly<Record<string, unknown>>;
 }
 
 export interface ConditionEvaluatorReporter {
-  warn(report: ConditionEvaluationReport): void;
-  error(report: ConditionEvaluationReport): void;
+    warn(report: ConditionEvaluationReport): void;
+    error(report: ConditionEvaluationReport): void;
 }
 
 // Either fully silent (no reporter, no version stamp) or fully observable
 // (reporter paired with engineVersion so every report carries its origin).
 export type ConditionEvaluationOptions = {
-  readonly reporter: ConditionEvaluatorReporter;
-  readonly engineVersion: number;
+    readonly reporter: ConditionEvaluatorReporter;
+    readonly engineVersion: number;
 };

package/src/core/policies/engines/gate-engine-registry.ts

@@ -1,38 +1,40 @@
 import { Result } from "../../result/result";
 
 import type {
-  GateOutcome,
-  PolicyContext,
-  VersionedGateEngine,
+    GateOutcome,
+    PolicyContext,
+    VersionedGateEngine,
 } from "./gate-types";
 import { GatePayloadParsers } from "./parse-gate-payload";
 
 export class GateEngineRegistry {
-  private readonly engines = new Map<number, VersionedGateEngine>();
+    private readonly engines = new Map<number, VersionedGateEngine>();
 
-  register(engine: VersionedGateEngine): void {
-    this.engines.set(engine.version, engine);
-  }
-
-  get(version: number): VersionedGateEngine | undefined {
-    return this.engines.get(version);
-  }
-
-  evaluate(
-    version: number,
-    payload: unknown,
-    context: PolicyContext,
-  ): Result<GateOutcome, string> {
-    const engine = this.engines.get(version);
-    if (!engine) {
-      return Result.err(`No gate engine registered for version "${version}"`);
+    register(engine: VersionedGateEngine): void {
+        this.engines.set(engine.version, engine);
     }
 
-    const parsedPayload = GatePayloadParsers.parse(version, payload);
-    if (parsedPayload.isErr()) {
-      return Result.err(parsedPayload.errorOrNull()!);
+    get(version: number): VersionedGateEngine | undefined {
+        return this.engines.get(version);
     }
 
-    return engine.evaluate(parsedPayload.getOrNull()!, context);
-  }
+    evaluate(
+        version: number,
+        payload: unknown,
+        context: PolicyContext,
+    ): Result<GateOutcome, string> {
+        const engine = this.engines.get(version);
+        if (!engine) {
+            return Result.err(
+                `No gate engine registered for version "${version}"`,
+            );
+        }
+
+        const parsedPayload = GatePayloadParsers.parse(version, payload);
+        if (parsedPayload.isErr()) {
+            return Result.err(parsedPayload.errorOrNull()!);
+        }
+
+        return engine.evaluate(parsedPayload.getOrNull()!, context);
+    }
 }

package/src/core/policies/engines/gate-types.ts

@@ -8,42 +8,42 @@ import type { GatePayload } from "./gate-payload";
 export type PolicyContext = Record<string, unknown>;
 
 export interface GateTraceLeafSnapshot {
-  readonly kind: "LEAF";
-  readonly field: string;
-  readonly op: string;
-  readonly allowNull?: true;
+    readonly kind: "LEAF";
+    readonly field: string;
+    readonly op: string;
+    readonly allowNull?: true;
 }
 
 export type GateTraceNodeSnapshot =
-  | GateTraceLeafSnapshot
-  | {
-      readonly kind: "AND" | "OR";
-      readonly childCount: number;
-    }
-  | {
-      readonly kind: "NOT";
-    };
+    | GateTraceLeafSnapshot
+    | {
+          readonly kind: "AND" | "OR";
+          readonly childCount: number;
+      }
+    | {
+          readonly kind: "NOT";
+      };
 
 export interface GateViolationTrace {
-  readonly conditionPath: string;
-  readonly decisiveNode: GateTraceNodeSnapshot;
-  readonly lastEvaluatedLeaf: GateTraceLeafSnapshot;
-  readonly lastEvaluatedLeafPath: string;
-  readonly lastEvaluatedLeafResult: boolean;
-  readonly field: string;
-  readonly op: string;
+    readonly conditionPath: string;
+    readonly decisiveNode: GateTraceNodeSnapshot;
+    readonly lastEvaluatedLeaf: GateTraceLeafSnapshot;
+    readonly lastEvaluatedLeafPath: string;
+    readonly lastEvaluatedLeafResult: boolean;
+    readonly field: string;
+    readonly op: string;
 }
 
 export interface PolicyViolation {
-  readonly code: string;
-  readonly message: string;
-  readonly trace?: GateViolationTrace;
+    readonly code: string;
+    readonly message: string;
+    readonly trace?: GateViolationTrace;
 }
 
 export type GateStatus = "ALLOW" | "DENY";
 
 export interface GateOutcomeData {
-  readonly violations: readonly PolicyViolation[];
+    readonly violations: readonly PolicyViolation[];
 }
 
 /** Semantic outcome of a GATE policy evaluation. */
@@ -55,9 +55,9 @@ export type GateOutcome = Outcome<GateStatus, GateOutcomeData>;
  * the registry's responsibility via `parseGatePayload`.
  */
 export interface VersionedGateEngine {
-  readonly version: number;
-  evaluate(
-    payload: GatePayload,
-    context: PolicyContext,
-  ): Result<GateOutcome, string>;
+    readonly version: number;
+    evaluate(
+        payload: GatePayload,
+        context: PolicyContext,
+    ): Result<GateOutcome, string>;
 }