@cullet/erp-core 1.0.2 → 1.0.3

package/src/core/policies/context/context-registry.instance.ts

@@ -1,8 +1,8 @@
 import { Result } from "../../result/result";
 
 import {
-  ContextResolverRegistry,
-  registerNamespacedContextResolversIn,
+    ContextResolverRegistry,
+    registerNamespacedContextResolversIn,
 } from "./context-registry";
 
 import type { ContextValueResolver } from "./context-resolver";
@@ -15,12 +15,12 @@ import type { ContextValueResolver } from "./context-resolver";
 export const contextResolverRegistry = new ContextResolverRegistry();
 
 export function registerNamespacedContextResolvers(
-  namespace: string,
-  resolvers: readonly ContextValueResolver[],
+    namespace: string,
+    resolvers: readonly ContextValueResolver[],
 ): Result<ContextResolverRegistry, string> {
-  return registerNamespacedContextResolversIn(
-    contextResolverRegistry,
-    namespace,
-    resolvers,
-  );
+    return registerNamespacedContextResolversIn(
+        contextResolverRegistry,
+        namespace,
+        resolvers,
+    );
 }

package/src/core/policies/context/context-registry.ts

@@ -3,93 +3,93 @@ import { Result } from "../../result/result";
 import type { ContextValueResolver } from "./context-resolver";
 
 export interface ContextResolverRegistrationOptions {
-  readonly namespace?: string;
+    readonly namespace?: string;
 }
 
 interface RegisteredContextResolver {
-  readonly namespace: string;
-  readonly resolver: ContextValueResolver;
+    readonly namespace: string;
+    readonly resolver: ContextValueResolver;
 }
 
 const DEFAULT_CONTEXT_RESOLVER_NAMESPACE = "default";
 
 function normalizeNamespace(namespace?: string): string {
-  const normalized = namespace?.trim();
+    const normalized = namespace?.trim();
 
-  if (normalized === undefined || normalized.length === 0) {
-    return DEFAULT_CONTEXT_RESOLVER_NAMESPACE;
-  }
+    if (normalized === undefined || normalized.length === 0) {
+        return DEFAULT_CONTEXT_RESOLVER_NAMESPACE;
+    }
 
-  return normalized;
+    return normalized;
 }
 
 /**
  * Registry of context value resolvers, keyed by path.
  */
 export class ContextResolverRegistry {
-  private readonly resolvers = new Map<string, RegisteredContextResolver>();
-
-  register(
-    resolver: ContextValueResolver,
-    options: ContextResolverRegistrationOptions = {},
-  ): Result<void, string> {
-    const namespace = normalizeNamespace(options.namespace);
-    const existing = this.resolvers.get(resolver.path);
-
-    if (existing !== undefined && existing.namespace !== namespace) {
-      return Result.err(
-        `Resolver path "${resolver.path}" is already registered by namespace "${existing.namespace}" and cannot be replaced by "${namespace}".`,
-      );
+    private readonly resolvers = new Map<string, RegisteredContextResolver>();
+
+    register(
+        resolver: ContextValueResolver,
+        options: ContextResolverRegistrationOptions = {},
+    ): Result<void, string> {
+        const namespace = normalizeNamespace(options.namespace);
+        const existing = this.resolvers.get(resolver.path);
+
+        if (existing !== undefined && 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(undefined);
     }
 
-    this.resolvers.set(resolver.path, {
-      namespace,
-      resolver,
-    });
-
-    return Result.ok(undefined);
-  }
-
-  registerAll(
-    resolvers: readonly ContextValueResolver[],
-    options: ContextResolverRegistrationOptions = {},
-  ): Result<void, string> {
-    for (const r of resolvers) {
-      const registrationResult = this.register(r, options);
-      if (registrationResult.isErr()) {
-        return registrationResult;
-      }
+    registerAll(
+        resolvers: readonly ContextValueResolver[],
+        options: ContextResolverRegistrationOptions = {},
+    ): Result<void, string> {
+        for (const r of resolvers) {
+            const registrationResult = this.register(r, options);
+            if (registrationResult.isErr()) {
+                return registrationResult;
+            }
+        }
+
+        return Result.ok(undefined);
     }
 
-    return Result.ok(undefined);
-  }
-
-  get(path: string): ContextValueResolver | undefined {
-    return this.resolvers.get(path)?.resolver;
-  }
+    get(path: string): ContextValueResolver | undefined {
+        return this.resolvers.get(path)?.resolver;
+    }
 
-  has(path: string): boolean {
-    return this.resolvers.has(path);
-  }
+    has(path: string): boolean {
+        return this.resolvers.has(path);
+    }
 
-  getNamespace(path: string): string | undefined {
-    return this.resolvers.get(path)?.namespace;
-  }
+    getNamespace(path: string): string | undefined {
+        return this.resolvers.get(path)?.namespace;
+    }
 }
 
 export function registerNamespacedContextResolversIn(
-  registry: ContextResolverRegistry,
-  namespace: string,
-  resolvers: readonly ContextValueResolver[],
+    registry: ContextResolverRegistry,
+    namespace: string,
+    resolvers: readonly ContextValueResolver[],
 ): Result<ContextResolverRegistry, string> {
-  const registrationResult = registry.registerAll(resolvers, {
-    namespace,
-  });
-  if (registrationResult.isErr()) {
-    return Result.err(registrationResult.errorOrNull()!);
-  }
-
-  return Result.ok(registry);
+    const registrationResult = registry.registerAll(resolvers, {
+        namespace,
+    });
+    if (registrationResult.isErr()) {
+        return Result.err(registrationResult.errorOrNull()!);
+    }
+
+    return Result.ok(registry);
 }
 
 export { DEFAULT_CONTEXT_RESOLVER_NAMESPACE };

package/src/core/policies/context/context-resolver.ts

@@ -3,21 +3,21 @@ import { Result } from "../../result/result";
 import type { ContextSeed } from "./context-seed";
 
 export interface ContextResolverRetryOptions {
-  readonly maxAttempts?: number;
-  readonly initialDelayMs?: number;
-  readonly maxDelayMs?: number;
-  readonly backoffMultiplier?: number;
+    readonly maxAttempts?: number;
+    readonly initialDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly backoffMultiplier?: number;
 }
 
 export interface ContextResolverCircuitBreakerOptions {
-  readonly failureThreshold?: number;
-  readonly cooldownMs?: number;
+    readonly failureThreshold?: number;
+    readonly cooldownMs?: number;
 }
 
 export interface ContextResolverResilienceOptions {
-  readonly timeoutMs?: number;
-  readonly retry?: ContextResolverRetryOptions | false;
-  readonly circuitBreaker?: ContextResolverCircuitBreakerOptions | false;
+    readonly timeoutMs?: number;
+    readonly retry?: ContextResolverRetryOptions | false;
+    readonly circuitBreaker?: ContextResolverCircuitBreakerOptions | false;
 }
 
 /**
@@ -25,7 +25,7 @@ export interface ContextResolverResilienceOptions {
  * Designed as async to allow future DB/API lookups without breaking the interface.
  */
 export interface ContextValueResolver {
-  readonly path: string;
-  readonly resilience?: ContextResolverResilienceOptions;
-  resolve(seed: ContextSeed): Promise<Result<unknown, string>>;
+    readonly path: string;
+    readonly resilience?: ContextResolverResilienceOptions;
+    resolve(seed: ContextSeed): Promise<Result<unknown, string>>;
 }

package/src/core/policies/context/context-seed.ts

@@ -8,25 +8,29 @@ import type { SchoolId, TenantId } from "../policy-ids";
  * Each resolver is responsible for validating and extracting what it needs from fields.
  */
 export interface ContextSeed {
-  readonly tenantId: TenantId;
-  readonly schoolId: SchoolId;
-  readonly fields: Record<string, unknown>;
+    readonly tenantId: TenantId;
+    readonly schoolId: SchoolId;
+    readonly fields: Record<string, unknown>;
 }
 
 export class ContextSeedValidator {
-  private static isBlankSeedId(value: string): boolean {
-    return value.trim().length === 0;
-  }
-
-  static validate(seed: ContextSeed): Result<ContextSeed, string> {
-    if (ContextSeedValidator.isBlankSeedId(seed.tenantId)) {
-      return Result.err("ContextSeed tenantId must be a non-empty string");
+    private static isBlankSeedId(value: string): boolean {
+        return value.trim().length === 0;
     }
 
-    if (ContextSeedValidator.isBlankSeedId(seed.schoolId)) {
-      return Result.err("ContextSeed schoolId must be a non-empty string");
-    }
+    static validate(seed: ContextSeed): Result<ContextSeed, string> {
+        if (ContextSeedValidator.isBlankSeedId(seed.tenantId)) {
+            return Result.err(
+                "ContextSeed tenantId must be a non-empty string",
+            );
+        }
 
-    return Result.ok(seed);
-  }
+        if (ContextSeedValidator.isBlankSeedId(seed.schoolId)) {
+            return Result.err(
+                "ContextSeed schoolId must be a non-empty string",
+            );
+        }
+
+        return Result.ok(seed);
+    }
 }

package/src/core/policies/context/index.ts

@@ -1,19 +1,19 @@
 export { PolicyContextBuilder } from "./context-builder";
 export {
-  ContextResolverRegistry,
-  DEFAULT_CONTEXT_RESOLVER_NAMESPACE,
-  registerNamespacedContextResolversIn,
+    ContextResolverRegistry,
+    DEFAULT_CONTEXT_RESOLVER_NAMESPACE,
+    registerNamespacedContextResolversIn,
 } from "./context-registry";
 export {
-  contextResolverRegistry,
-  registerNamespacedContextResolvers,
+    contextResolverRegistry,
+    registerNamespacedContextResolvers,
 } from "./context-registry.instance";
 export type { ContextResolverRegistrationOptions } from "./context-registry";
 export type {
-  ContextResolverCircuitBreakerOptions,
-  ContextResolverResilienceOptions,
-  ContextResolverRetryOptions,
-  ContextValueResolver,
+    ContextResolverCircuitBreakerOptions,
+    ContextResolverResilienceOptions,
+    ContextResolverRetryOptions,
+    ContextValueResolver,
 } from "./context-resolver";
 export type { PolicyContextBuilderOptions } from "./context-builder";
 export { ContextSeedValidator } from "./context-seed";

package/src/core/policies/context/path.ts

@@ -6,147 +6,154 @@
 import { Result } from "../../result/result";
 
 export class PolicyContextPath {
-  private static readonly FORBIDDEN_SEGMENTS = new Set([
-    "__proto__",
-    "prototype",
-    "constructor",
-  ]);
-
-  private static resolve(
-    obj: Record<string, unknown>,
-    path: string,
-  ): Result<
-    {
-      readonly found: boolean;
-      readonly value: unknown;
-    },
-    string
-  > {
-    const segmentsResult = PolicyContextPath.parseSegments(path);
-    if (segmentsResult.isErr()) {
-      return Result.err(segmentsResult.errorOrNull()!);
+    private static readonly FORBIDDEN_SEGMENTS = new Set([
+        "__proto__",
+        "prototype",
+        "constructor",
+    ]);
+
+    private static resolve(
+        obj: Record<string, unknown>,
+        path: string,
+    ): Result<
+        {
+            readonly found: boolean;
+            readonly value: unknown;
+        },
+        string
+    > {
+        const segmentsResult = PolicyContextPath.parseSegments(path);
+        if (segmentsResult.isErr()) {
+            return Result.err(segmentsResult.errorOrNull()!);
+        }
+
+        const segments = segmentsResult.getOrNull()!;
+        let current: unknown = obj;
+
+        for (const segment of segments) {
+            if (
+                current === null ||
+                current === undefined ||
+                typeof current !== "object"
+            ) {
+                return Result.ok({ found: false, value: undefined });
+            }
+
+            const record = current as Record<string, unknown>;
+            if (!Object.prototype.hasOwnProperty.call(record, segment)) {
+                return Result.ok({ found: false, value: undefined });
+            }
+
+            current = record[segment];
+        }
+
+        return Result.ok({ found: true, value: current });
     }
 
-    const segments = segmentsResult.getOrNull()!;
-    let current: unknown = obj;
+    private static parseSegments(
+        path: string,
+    ): Result<readonly string[], string> {
+        if (path.trim().length === 0) {
+            return Result.err("Path cannot be empty");
+        }
 
-    for (const segment of segments) {
-      if (
-        current === null ||
-        current === undefined ||
-        typeof current !== "object"
-      ) {
-        return Result.ok({ found: false, value: undefined });
-      }
+        const segments = path.split(".");
+        if (segments.some((segment) => segment.length === 0)) {
+            return Result.err(`Path "${path}" contains an empty segment`);
+        }
 
-      const record = current as Record<string, unknown>;
-      if (!Object.prototype.hasOwnProperty.call(record, segment)) {
-        return Result.ok({ found: false, value: undefined });
-      }
-
-      current = record[segment];
-    }
-
-    return Result.ok({ found: true, value: current });
-  }
-
-  private static parseSegments(
-    path: string,
-  ): Result<readonly string[], string> {
-    if (path.trim().length === 0) {
-      return Result.err("Path cannot be empty");
-    }
-
-    const segments = path.split(".");
-    if (segments.some((segment) => segment.length === 0)) {
-      return Result.err(`Path "${path}" contains an empty segment`);
-    }
-
-    const forbiddenSegment = segments.find((segment) =>
-      PolicyContextPath.FORBIDDEN_SEGMENTS.has(segment),
-    );
-    if (forbiddenSegment !== undefined) {
-      return Result.err(
-        `Path "${path}" contains forbidden segment "${forbiddenSegment}"`,
-      );
-    }
-
-    return Result.ok(segments);
-  }
+        const forbiddenSegment = segments.find((segment) =>
+            PolicyContextPath.FORBIDDEN_SEGMENTS.has(segment),
+        );
+        if (forbiddenSegment !== undefined) {
+            return Result.err(
+                `Path "${path}" contains forbidden segment "${forbiddenSegment}"`,
+            );
+        }
 
-  private static isPlainRecord(
-    value: unknown,
-  ): value is Record<string, unknown> {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      return false;
+        return Result.ok(segments);
     }
 
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-  }
-
-  static getOrAbsent(
-    obj: Record<string, unknown>,
-    path: string,
-  ): Result<unknown, "absent"> {
-    const resolvedPath = PolicyContextPath.resolve(obj, path);
-    if (resolvedPath.isErr()) {
-      return Result.err("absent");
+    private static isPlainRecord(
+        value: unknown,
+    ): value is Record<string, unknown> {
+        if (
+            typeof value !== "object" ||
+            value === null ||
+            Array.isArray(value)
+        ) {
+            return false;
+        }
+
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
     }
 
-    const { found, value } = resolvedPath.getOrNull()!;
-    if (!found) {
-      return Result.err("absent");
+    static getOrAbsent(
+        obj: Record<string, unknown>,
+        path: string,
+    ): Result<unknown, "absent"> {
+        const resolvedPath = PolicyContextPath.resolve(obj, path);
+        if (resolvedPath.isErr()) {
+            return Result.err("absent");
+        }
+
+        const { found, value } = resolvedPath.getOrNull()!;
+        if (!found) {
+            return Result.err("absent");
+        }
+
+        return Result.ok(value);
     }
 
-    return Result.ok(value);
-  }
-
-  static has(obj: Record<string, unknown>, path: string): boolean {
-    const resolvedPath = PolicyContextPath.resolve(obj, path);
-    if (resolvedPath.isErr()) {
-      return false;
-    }
+    static has(obj: Record<string, unknown>, path: string): boolean {
+        const resolvedPath = PolicyContextPath.resolve(obj, path);
+        if (resolvedPath.isErr()) {
+            return false;
+        }
 
-    return resolvedPath.getOrNull()!.found;
-  }
-
-  static set(
-    obj: Record<string, unknown>,
-    path: string,
-    value: unknown,
-  ): Result<void, string> {
-    const segmentsResult = PolicyContextPath.parseSegments(path);
-    if (segmentsResult.isErr()) {
-      return Result.err(segmentsResult.errorOrNull()!);
+        return resolvedPath.getOrNull()!.found;
     }
 
-    const segments = segmentsResult.getOrNull()!;
-    let current: Record<string, unknown> = obj;
-
-    for (let i = 0; i < segments.length - 1; i++) {
-      const seg = segments[i];
-      const next = current[seg];
-
-      if (next === undefined) {
-        const container = Object.create(null) as Record<string, unknown>;
-        current[seg] = container;
-        current = container;
-        continue;
-      }
-
-      if (!PolicyContextPath.isPlainRecord(next)) {
-        return Result.err(
-          `Cannot create nested path "${path}" because "${segments
-            .slice(0, i + 1)
-            .join(".")}" already contains a non-plain object`,
-        );
-      }
-
-      current = next;
+    static set(
+        obj: Record<string, unknown>,
+        path: string,
+        value: unknown,
+    ): Result<void, string> {
+        const segmentsResult = PolicyContextPath.parseSegments(path);
+        if (segmentsResult.isErr()) {
+            return Result.err(segmentsResult.errorOrNull()!);
+        }
+
+        const segments = segmentsResult.getOrNull()!;
+        let current: Record<string, unknown> = obj;
+
+        for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            const next = current[seg];
+
+            if (next === undefined) {
+                const container = Object.create(null) as Record<
+                    string,
+                    unknown
+                >;
+                current[seg] = container;
+                current = container;
+                continue;
+            }
+
+            if (!PolicyContextPath.isPlainRecord(next)) {
+                return 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 Result.ok(undefined);
     }
-
-    current[segments[segments.length - 1]] = value;
-    return Result.ok(undefined);
-  }
 }