@cullet/erp-core 1.0.1 → 1.0.3

package/src/core/policies/catalog/policy-catalog.ts

@@ -8,117 +8,117 @@ import { PolicyCatalogEntry } from "./policy-catalog-entry";
  * The catalog defines the universe of policies; the database cannot invent new ones.
  */
 export class PolicyCatalog {
-  private readonly versionedEntries: ReadonlyMap<string, PolicyCatalogEntry>;
-  private readonly entriesByKey: ReadonlyMap<
-    string,
-    readonly PolicyCatalogEntry[]
-  >;
-
-  constructor(entries: readonly PolicyCatalogEntry[]) {
-    const families = new Map<string, PolicyCatalogEntry[]>();
-    const versionedMap = new Map<string, PolicyCatalogEntry>();
-
-    for (const rawEntry of entries) {
-      const entry = PolicyCatalogEntry.from(rawEntry);
-      const key = entry.key.toString();
-      const variantKey = entry.toVariantKey();
-
-      if (versionedMap.has(variantKey)) {
-        throw new UnexpectedError(
-          `Duplicate PolicyCatalog entry for key "${key}" and variant "${variantKey}"`,
-        );
-      }
-
-      const family = families.get(key) ?? [];
-      family.push(entry);
-      families.set(key, family);
-      versionedMap.set(variantKey, entry);
-    }
-
-    for (const family of families.values()) {
-      PolicyCatalogEntry.assertFamilyConsistency(family);
+    private readonly versionedEntries: ReadonlyMap<string, PolicyCatalogEntry>;
+    private readonly entriesByKey: ReadonlyMap<
+        string,
+        readonly PolicyCatalogEntry[]
+    >;
+
+    constructor(entries: readonly PolicyCatalogEntry[]) {
+        const families = new Map<string, PolicyCatalogEntry[]>();
+        const versionedMap = new Map<string, PolicyCatalogEntry>();
+
+        for (const rawEntry of entries) {
+            const entry = PolicyCatalogEntry.from(rawEntry);
+            const key = entry.key.toString();
+            const variantKey = entry.toVariantKey();
+
+            if (versionedMap.has(variantKey)) {
+                throw new UnexpectedError(
+                    `Duplicate PolicyCatalog entry for key "${key}" and variant "${variantKey}"`,
+                );
+            }
+
+            const family = families.get(key) ?? [];
+            family.push(entry);
+            families.set(key, family);
+            versionedMap.set(variantKey, entry);
+        }
+
+        for (const family of families.values()) {
+            PolicyCatalogEntry.assertFamilyConsistency(family);
+        }
+
+        this.versionedEntries = versionedMap;
+        this.entriesByKey = families;
     }
 
-    this.versionedEntries = versionedMap;
-    this.entriesByKey = families;
-  }
-
-  get(key: string): Result<PolicyCatalogEntry, string> {
-    const familyResult = this.getFamily(key);
-    if (familyResult.isErr()) {
-      return Result.err(familyResult.errorOrNull()!);
+    get(key: string): Result<PolicyCatalogEntry, string> {
+        const familyResult = this.getFamily(key);
+        if (familyResult.isErr()) {
+            return Result.err(familyResult.errorOrNull()!);
+        }
+
+        const family = familyResult.getOrNull()!;
+        if (family.length > 1) {
+            return Result.err(
+                `Policy key "${key}" has multiple catalog variants; use getVersioned(...) or getFamily(...)`,
+            );
+        }
+
+        const [entry] = family;
+        if (!entry) {
+            return Result.err(`Policy not found in catalog: "${key}"`);
+        }
+
+        return Result.ok(entry);
     }
 
-    const family = familyResult.getOrNull()!;
-    if (family.length > 1) {
-      return Result.err(
-        `Policy key "${key}" has multiple catalog variants; use getVersioned(...) or getFamily(...)`,
-      );
-    }
+    getFamily(key: string): Result<readonly PolicyCatalogEntry[], string> {
+        const family = this.entriesByKey.get(key);
+        if (!family) {
+            return Result.err(`Policy not found in catalog: "${key}"`);
+        }
 
-    const [entry] = family;
-    if (!entry) {
-      return Result.err(`Policy not found in catalog: "${key}"`);
+        return Result.ok(family);
     }
 
-    return Result.ok(entry);
-  }
-
-  getFamily(key: string): Result<readonly PolicyCatalogEntry[], string> {
-    const family = this.entriesByKey.get(key);
-    if (!family) {
-      return Result.err(`Policy not found in catalog: "${key}"`);
-    }
-
-    return Result.ok(family);
-  }
-
-  getVersioned(params: {
-    readonly key: string;
-    readonly kind: "GATE" | "COMPUTE";
-    readonly gateEngineVersion?: number;
-    readonly computeEngineVersion?: number;
-    readonly payloadSchemaVersion?: number;
-  }): Result<PolicyCatalogEntry, string> {
-    const family = this.entriesByKey.get(params.key);
-    if (!family || family.length === 0) {
-      return Result.err(`Policy not found in catalog: "${params.key}"`);
+    getVersioned(params: {
+        readonly key: string;
+        readonly kind: "GATE" | "COMPUTE";
+        readonly gateEngineVersion?: number;
+        readonly computeEngineVersion?: number;
+        readonly payloadSchemaVersion?: number;
+    }): Result<PolicyCatalogEntry, string> {
+        const family = this.entriesByKey.get(params.key);
+        if (!family || family.length === 0) {
+            return Result.err(`Policy not found in catalog: "${params.key}"`);
+        }
+
+        const exactMatch = family.find((entry) => entry.matchesVersion(params));
+        if (exactMatch) {
+            return Result.ok(exactMatch);
+        }
+
+        if (family.length === 1 && !family[0].hasExplicitVersionSelector()) {
+            return Result.ok(family[0]);
+        }
+
+        const versionDetails = [
+            params.kind,
+            params.gateEngineVersion !== undefined
+                ? `gateEngineVersion=${params.gateEngineVersion}`
+                : null,
+            params.computeEngineVersion !== undefined
+                ? `computeEngineVersion=${params.computeEngineVersion}`
+                : null,
+            params.payloadSchemaVersion !== undefined
+                ? `payloadSchemaVersion=${params.payloadSchemaVersion}`
+                : null,
+        ]
+            .filter((part): part is string => part !== null)
+            .join(", ");
+
+        return Result.err(
+            `Policy variant not found in catalog: "${params.key}" (${versionDetails})`,
+        );
     }
 
-    const exactMatch = family.find((entry) => entry.matchesVersion(params));
-    if (exactMatch) {
-      return Result.ok(exactMatch);
+    list(): readonly PolicyCatalogEntry[] {
+        return Array.from(this.versionedEntries.values());
     }
 
-    if (family.length === 1 && !family[0].hasExplicitVersionSelector()) {
-      return Result.ok(family[0]);
+    has(key: string): boolean {
+        return this.entriesByKey.has(key);
     }
-
-    const versionDetails = [
-      params.kind,
-      params.gateEngineVersion !== undefined
-        ? `gateEngineVersion=${params.gateEngineVersion}`
-        : null,
-      params.computeEngineVersion !== undefined
-        ? `computeEngineVersion=${params.computeEngineVersion}`
-        : null,
-      params.payloadSchemaVersion !== undefined
-        ? `payloadSchemaVersion=${params.payloadSchemaVersion}`
-        : null,
-    ]
-      .filter((part): part is string => part !== null)
-      .join(", ");
-
-    return Result.err(
-      `Policy variant not found in catalog: "${params.key}" (${versionDetails})`,
-    );
-  }
-
-  list(): readonly PolicyCatalogEntry[] {
-    return Array.from(this.versionedEntries.values());
-  }
-
-  has(key: string): boolean {
-    return this.entriesByKey.has(key);
-  }
 }

package/src/core/policies/catalog/policy-key.ts

@@ -13,66 +13,66 @@ const SEGMENT_PATTERN = /^[a-z][a-z0-9_]*$/;
 const MAX_POLICY_KEY_LENGTH = 255;
 
 export class PolicyKey {
-  public readonly module: string;
-  public readonly area: string;
-  public readonly name: string;
+    public readonly module: string;
+    public readonly area: string;
+    public readonly name: string;
 
-  private constructor(module: string, area: string, name: string) {
-    this.module = module;
-    this.area = area;
-    this.name = name;
-    Object.freeze(this);
-  }
-
-  static parse(raw: string): Result<PolicyKey, string> {
-    if (!raw || typeof raw !== "string") {
-      return Result.err("PolicyKey cannot be empty");
+    private constructor(module: string, area: string, name: string) {
+        this.module = module;
+        this.area = area;
+        this.name = name;
+        Object.freeze(this);
     }
 
-    if (raw.length > MAX_POLICY_KEY_LENGTH) {
-      return Result.err(
-        `PolicyKey cannot exceed ${MAX_POLICY_KEY_LENGTH} characters, got ${raw.length}`,
-      );
-    }
+    static parse(raw: string): Result<PolicyKey, string> {
+        if (!raw || typeof raw !== "string") {
+            return Result.err("PolicyKey cannot be empty");
+        }
 
-    const segments = raw.split(".");
-    if (segments.length !== 3) {
-      return Result.err(
-        `PolicyKey must have exactly 3 segments (module.area.name), got ${segments.length}: "${raw}"`,
-      );
-    }
+        if (raw.length > MAX_POLICY_KEY_LENGTH) {
+            return Result.err(
+                `PolicyKey cannot exceed ${MAX_POLICY_KEY_LENGTH} characters, got ${raw.length}`,
+            );
+        }
 
-    const [rawModule, rawArea, name] = segments;
+        const segments = raw.split(".");
+        if (segments.length !== 3) {
+            return Result.err(
+                `PolicyKey must have exactly 3 segments (module.area.name), got ${segments.length}: "${raw}"`,
+            );
+        }
 
-    if (!SEGMENT_PATTERN.test(rawModule)) {
-      return Result.err(
-        `PolicyKey segment "module" is invalid: "${rawModule}". ` +
-          "Must start with a lowercase letter and contain only [a-z0-9_].",
-      );
-    }
+        const [rawModule, rawArea, name] = segments;
 
-    if (!SEGMENT_PATTERN.test(rawArea)) {
-      return Result.err(
-        `PolicyKey segment "area" is invalid: "${rawArea}". ` +
-          "Must start with a lowercase letter and contain only [a-z0-9_].",
-      );
-    }
+        if (!SEGMENT_PATTERN.test(rawModule)) {
+            return Result.err(
+                `PolicyKey segment "module" is invalid: "${rawModule}". ` +
+                    "Must start with a lowercase letter and contain only [a-z0-9_].",
+            );
+        }
 
-    if (!SEGMENT_PATTERN.test(name)) {
-      return Result.err(
-        `PolicyKey segment "name" is invalid: "${name}". ` +
-          "Must start with a lowercase letter and contain only [a-z0-9_].",
-      );
-    }
+        if (!SEGMENT_PATTERN.test(rawArea)) {
+            return Result.err(
+                `PolicyKey segment "area" is invalid: "${rawArea}". ` +
+                    "Must start with a lowercase letter and contain only [a-z0-9_].",
+            );
+        }
 
-    return Result.ok(new PolicyKey(rawModule, rawArea, name));
-  }
+        if (!SEGMENT_PATTERN.test(name)) {
+            return Result.err(
+                `PolicyKey segment "name" is invalid: "${name}". ` +
+                    "Must start with a lowercase letter and contain only [a-z0-9_].",
+            );
+        }
 
-  toString(): string {
-    return `${this.module}.${this.area}.${this.name}`;
-  }
+        return Result.ok(new PolicyKey(rawModule, rawArea, name));
+    }
 
-  equals(other: PolicyKey): boolean {
-    return this.toString() === other.toString();
-  }
+    toString(): string {
+        return `${this.module}.${this.area}.${this.name}`;
+    }
+
+    equals(other: PolicyKey): boolean {
+        return this.toString() === other.toString();
+    }
 }