@cullet/erp-core 1.0.2 → 1.0.3

package/src/core/result/result.ts

@@ -3,151 +3,154 @@
  * Useful for avoiding excessive exceptions and making error flows explicit.
  */
 export abstract class Result<T, E> {
-  protected constructor() {
-    // prevent direct instantiation
-  }
-
-  /**
-   * Creates a success result containing a value.
-   */
-  static ok<T>(value: T): Result<T, never> {
-    return new Ok(value);
-  }
-
-  /**
-   * Creates an error result containing an error object.
-   */
-  static err<E>(error: E): Result<never, E> {
-    return new Err(error);
-  }
-
-  /**
-   * Returns true when this is a success result.
-   */
-  abstract isOk(): this is Ok<T>;
-
-  /**
-   * Returns true when this is an error result.
-   */
-  abstract isErr(): this is Err<E>;
-
-  /**
-   * Runs a handler based on the result state (similar to pattern matching).
-   */
-  abstract match<R>(handlers: { ok: (value: T) => R; err: (error: E) => R }): R;
-
-  /**
-   * Returns the value when this is success, or null when this is an error.
-   */
-  getOrNull(): T | null {
-    return this.match({
-      ok: (value) => value,
-      err: () => null,
-    });
-  }
-
-  /**
-   * Returns the error when this is a failure, or null when this is a success.
-   */
-  errorOrNull(): E | null {
-    return this.match({
-      ok: () => null,
-      err: (error) => error,
-    });
-  }
-
-  /**
-   * Returns the value when this is a success, or throws the error when this is a failure.
-   */
-  getOrThrow(): T {
-    return this.match({
-      ok: (value) => value,
-      err: (error) => {
-        throw error instanceof Error ? error : new Error(String(error));
-      },
-    });
-  }
-
-  /**
-   * Transforms the success value using the provided function. Keeps the error when this is a failure.
-   */
-  map<R>(transform: (value: T) => R): Result<R, E> {
-    return this.match<Result<R, E>>({
-      ok: (value) => Result.ok(transform(value)),
-      // TS does not "see" variance here; the cast is intentional and safe:
-      // Err carries no T, so it can be widened to Result<R, E> safely.
-      err: (error) => Result.err(error) as unknown as Result<R, E>,
-    });
-  }
-
-  /**
-   * Transforms the error using the provided function. Keeps the value when this is a success.
-   */
-  mapError<F>(transform: (error: E) => F): Result<T, F> {
-    return this.match<Result<T, F>>({
-      // Ok carries no E, so it can be widened to Result<T, F>.
-      ok: (value) => Result.ok(value) as unknown as Result<T, F>,
-      err: (error) => Result.err(transform(error)),
-    });
-  }
-
-  /**
-   * Chains another operation that returns a Result when this result is a success.
-   */
-  flatMap<R>(transform: (value: T) => Result<R, E>): Result<R, E> {
-    return this.match<Result<R, E>>({
-      ok: (value) => transform(value),
-      err: (error) => Result.err(error) as unknown as Result<R, E>,
-    });
-  }
+    protected constructor() {
+        // prevent direct instantiation
+    }
+
+    /**
+     * Creates a success result containing a value.
+     */
+    static ok<T>(value: T): Result<T, never> {
+        return new Ok(value);
+    }
+
+    /**
+     * Creates an error result containing an error object.
+     */
+    static err<E>(error: E): Result<never, E> {
+        return new Err(error);
+    }
+
+    /**
+     * Returns true when this is a success result.
+     */
+    abstract isOk(): this is Ok<T>;
+
+    /**
+     * Returns true when this is an error result.
+     */
+    abstract isErr(): this is Err<E>;
+
+    /**
+     * Runs a handler based on the result state (similar to pattern matching).
+     */
+    abstract match<R>(handlers: {
+        ok: (value: T) => R;
+        err: (error: E) => R;
+    }): R;
+
+    /**
+     * Returns the value when this is success, or null when this is an error.
+     */
+    getOrNull(): T | null {
+        return this.match({
+            ok: (value) => value,
+            err: () => null,
+        });
+    }
+
+    /**
+     * Returns the error when this is a failure, or null when this is a success.
+     */
+    errorOrNull(): E | null {
+        return this.match({
+            ok: () => null,
+            err: (error) => error,
+        });
+    }
+
+    /**
+     * Returns the value when this is a success, or throws the error when this is a failure.
+     */
+    getOrThrow(): T {
+        return this.match({
+            ok: (value) => value,
+            err: (error) => {
+                throw error instanceof Error ? error : new Error(String(error));
+            },
+        });
+    }
+
+    /**
+     * Transforms the success value using the provided function. Keeps the error when this is a failure.
+     */
+    map<R>(transform: (value: T) => R): Result<R, E> {
+        return this.match<Result<R, E>>({
+            ok: (value) => Result.ok(transform(value)),
+            // TS does not "see" variance here; the cast is intentional and safe:
+            // Err carries no T, so it can be widened to Result<R, E> safely.
+            err: (error) => Result.err(error) as unknown as Result<R, E>,
+        });
+    }
+
+    /**
+     * Transforms the error using the provided function. Keeps the value when this is a success.
+     */
+    mapError<F>(transform: (error: E) => F): Result<T, F> {
+        return this.match<Result<T, F>>({
+            // Ok carries no E, so it can be widened to Result<T, F>.
+            ok: (value) => Result.ok(value) as unknown as Result<T, F>,
+            err: (error) => Result.err(transform(error)),
+        });
+    }
+
+    /**
+     * Chains another operation that returns a Result when this result is a success.
+     */
+    flatMap<R>(transform: (value: T) => Result<R, E>): Result<R, E> {
+        return this.match<Result<R, E>>({
+            ok: (value) => transform(value),
+            err: (error) => Result.err(error) as unknown as Result<R, E>,
+        });
+    }
 }
 
 /**
  * Success variant of Result.
  */
 export class Ok<T> extends Result<T, never> {
-  public readonly value: T;
+    public readonly value: T;
 
-  constructor(value: T) {
-    super();
-    this.value = value;
-    Object.freeze(this);
-  }
+    constructor(value: T) {
+        super();
+        this.value = value;
+        Object.freeze(this);
+    }
 
-  isOk(): this is Ok<T> {
-    return true;
-  }
+    isOk(): this is Ok<T> {
+        return true;
+    }
 
-  isErr(): this is Err<never> {
-    return false;
-  }
+    isErr(): this is Err<never> {
+        return false;
+    }
 
-  match<R>(handlers: { ok: (value: T) => R; err: (error: never) => R }): R {
-    return handlers.ok(this.value);
-  }
+    match<R>(handlers: { ok: (value: T) => R; err: (error: never) => R }): R {
+        return handlers.ok(this.value);
+    }
 }
 
 /**
  * Error variant of Result.
  */
 export class Err<E> extends Result<never, E> {
-  public readonly error: E;
+    public readonly error: E;
 
-  constructor(error: E) {
-    super();
-    this.error = error;
-    Object.freeze(this);
-  }
+    constructor(error: E) {
+        super();
+        this.error = error;
+        Object.freeze(this);
+    }
 
-  isOk(): this is Ok<never> {
-    return false;
-  }
+    isOk(): this is Ok<never> {
+        return false;
+    }
 
-  isErr(): this is Err<E> {
-    return true;
-  }
+    isErr(): this is Err<E> {
+        return true;
+    }
 
-  match<R>(handlers: { ok: (value: never) => R; err: (error: E) => R }): R {
-    return handlers.err(this.error);
-  }
+    match<R>(handlers: { ok: (value: never) => R; err: (error: E) => R }): R {
+        return handlers.err(this.error);
+    }
 }

package/src/core/shared/aggregate-version.ts

@@ -1,11 +1,11 @@
 import { InvariantViolationException } from "../exceptions/invariant-violation-exception";
 
 function assertValidAggregateVersion(aggregateVersion: number): void {
-  if (!Number.isInteger(aggregateVersion) || aggregateVersion < 0) {
-    throw new InvariantViolationException(
-      `aggregateVersion must be a non-negative integer. Received: ${aggregateVersion}`,
-    );
-  }
+    if (!Number.isInteger(aggregateVersion) || aggregateVersion < 0) {
+        throw new InvariantViolationException(
+            `aggregateVersion must be a non-negative integer. Received: ${aggregateVersion}`,
+        );
+    }
 }
 
 export { assertValidAggregateVersion };

package/src/core/shared/hashing.ts

@@ -1,38 +1,38 @@
 import { createHash } from "node:crypto";
 
 function sha256Hex(value: string): string {
-  return createHash("sha256").update(value, "utf8").digest("hex");
+    return createHash("sha256").update(value, "utf8").digest("hex");
 }
 
 function sortKeysDeep(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map((item) => sortKeysDeep(item));
-  }
+    if (Array.isArray(value)) {
+        return value.map((item) => sortKeysDeep(item));
+    }
 
-  if (value instanceof Date) {
-    return value;
-  }
+    if (value instanceof Date) {
+        return value;
+    }
 
-  if (value && typeof value === "object") {
-    const record = value as Record<string, unknown>;
-    const ordered = Object.create(null) as Record<string, unknown>;
+    if (value && typeof value === "object") {
+        const record = value as Record<string, unknown>;
+        const ordered = Object.create(null) as Record<string, unknown>;
 
-    for (const key of Object.keys(record).sort()) {
-      ordered[key] = sortKeysDeep(record[key]);
-    }
+        for (const key of Object.keys(record).sort()) {
+            ordered[key] = sortKeysDeep(record[key]);
+        }
 
-    return ordered;
-  }
+        return ordered;
+    }
 
-  return value;
+    return value;
 }
 
 function stableStringify(value: unknown): string {
-  return JSON.stringify(sortKeysDeep(value));
+    return JSON.stringify(sortKeysDeep(value));
 }
 
 function payloadHash(value: unknown): string {
-  return sha256Hex(stableStringify(value));
+    return sha256Hex(stableStringify(value));
 }
 
 export { payloadHash, sha256Hex, stableStringify };

package/src/core/shared/immutable.ts

@@ -1,46 +1,46 @@
 type PrimitiveValue =
-  | bigint
-  | boolean
-  | null
-  | number
-  | string
-  | symbol
-  | undefined;
+    | bigint
+    | boolean
+    | null
+    | number
+    | string
+    | symbol
+    | undefined;
 
 type DeepReadonly<T> = T extends PrimitiveValue | Date
-  ? T
-  : T extends readonly (infer TItem)[]
-    ? readonly DeepReadonly<TItem>[]
-    : { readonly [TKey in keyof T]: DeepReadonly<T[TKey]> };
+    ? T
+    : T extends readonly (infer TItem)[]
+      ? readonly DeepReadonly<TItem>[]
+      : { readonly [TKey in keyof T]: DeepReadonly<T[TKey]> };
 
 function deepFreeze<T>(value: T): T {
-  if (typeof value !== "object" || value === null || value instanceof Date) {
-    return value;
-  }
-
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      deepFreeze(item);
+    if (typeof value !== "object" || value === null || value instanceof Date) {
+        return value;
     }
 
-    return Object.freeze(value);
-  }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            deepFreeze(item);
+        }
 
-  const objectValue = value as Record<PropertyKey, object | PrimitiveValue>;
+        return Object.freeze(value);
+    }
 
-  for (const propertyKey of Reflect.ownKeys(objectValue)) {
-    deepFreeze(objectValue[propertyKey]);
-  }
+    const objectValue = value as Record<PropertyKey, object | PrimitiveValue>;
 
-  return Object.freeze(value);
+    for (const propertyKey of Reflect.ownKeys(objectValue)) {
+        deepFreeze(objectValue[propertyKey]);
+    }
+
+    return Object.freeze(value);
 }
 
 function makeImmutable<T>(value: T): DeepReadonly<T> {
-  if (typeof value !== "object" || value === null) {
-    return value as DeepReadonly<T>;
-  }
+    if (typeof value !== "object" || value === null) {
+        return value as DeepReadonly<T>;
+    }
 
-  return deepFreeze(structuredClone(value)) as DeepReadonly<T>;
+    return deepFreeze(structuredClone(value)) as DeepReadonly<T>;
 }
 
 export { deepFreeze, makeImmutable, type DeepReadonly };

package/src/core/shared/temporal-guards.ts

@@ -1,22 +1,22 @@
 import { InvariantViolationException } from "../exceptions/invariant-violation-exception";
 
 function isValidDate(value: unknown): value is Date {
-  return value instanceof Date && !Number.isNaN(value.getTime());
+    return value instanceof Date && !Number.isNaN(value.getTime());
 }
 
 function cloneDate(date: Date): Date {
-  return new Date(date.getTime());
+    return new Date(date.getTime());
 }
 
 function assertValidDate(
-  fieldName: string,
-  value: unknown,
+    fieldName: string,
+    value: unknown,
 ): asserts value is Date {
-  if (!isValidDate(value)) {
-    throw new InvariantViolationException(
-      `${fieldName} must be a valid Date instance`,
-    );
-  }
+    if (!isValidDate(value)) {
+        throw new InvariantViolationException(
+            `${fieldName} must be a valid Date instance`,
+        );
+    }
 }
 
 export { assertValidDate, cloneDate, isValidDate };

package/src/core/versioning/domain-event-contracts.ts

@@ -5,69 +5,69 @@ import { assertValidAggregateVersion } from "../shared/aggregate-version";
 import { type ContractVersion } from "./version";
 
 interface DomainEventContractSelection {
-  readonly entity?: boolean;
-  readonly valueObject?: boolean;
-  readonly useCase?: boolean;
+    readonly entity?: boolean;
+    readonly valueObject?: boolean;
+    readonly useCase?: boolean;
 }
 
 interface DomainEventContractVersions {
-  readonly entity_contract?: ContractVersion;
-  readonly value_object_contract?: ContractVersion;
-  readonly use_case_contract?: ContractVersion;
+    readonly entity_contract?: ContractVersion;
+    readonly value_object_contract?: ContractVersion;
+    readonly use_case_contract?: ContractVersion;
 }
 
 interface CreateDomainEventEnvelopeInput<TPayload> {
-  readonly aggregateVersion: number;
-  readonly payload: TPayload;
-  readonly contracts: DomainEventContractSelection;
+    readonly aggregateVersion: number;
+    readonly payload: TPayload;
+    readonly contracts: DomainEventContractSelection;
 }
 
 interface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {
-  readonly aggregate_version: number;
-  readonly payload: TPayload;
+    readonly aggregate_version: number;
+    readonly payload: TPayload;
 }
 
 function buildDomainEventContractVersions(
-  selection: DomainEventContractSelection,
+    selection: DomainEventContractSelection,
 ): DomainEventContractVersions {
-  const contractVersions: {
-    entity_contract?: ContractVersion;
-    value_object_contract?: ContractVersion;
-    use_case_contract?: ContractVersion;
-  } = {};
+    const contractVersions: {
+        entity_contract?: ContractVersion;
+        value_object_contract?: ContractVersion;
+        use_case_contract?: ContractVersion;
+    } = {};
 
-  if (selection.entity) {
-    contractVersions.entity_contract = Entity.CONTRACT_VERSION;
-  }
+    if (selection.entity) {
+        contractVersions.entity_contract = Entity.CONTRACT_VERSION;
+    }
 
-  if (selection.valueObject) {
-    contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;
-  }
+    if (selection.valueObject) {
+        contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;
+    }
 
-  if (selection.useCase) {
-    contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;
-  }
+    if (selection.useCase) {
+        contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;
+    }
 
-  return Object.freeze(contractVersions);
+    return Object.freeze(contractVersions);
 }
 
 function createDomainEventEnvelope<TPayload>(
-  input: CreateDomainEventEnvelopeInput<TPayload>,
+    input: CreateDomainEventEnvelopeInput<TPayload>,
 ): DomainEventEnvelope<TPayload> {
-  assertValidAggregateVersion(input.aggregateVersion);
+    assertValidAggregateVersion(input.aggregateVersion);
 
-  return Object.freeze({
-    aggregate_version: input.aggregateVersion,
-    payload: input.payload,
-    ...buildDomainEventContractVersions(input.contracts),
-  });
+    return Object.freeze({
+        aggregate_version: input.aggregateVersion,
+        payload: input.payload,
+        ...buildDomainEventContractVersions(input.contracts),
+    });
 }
 
 export {
-  buildDomainEventContractVersions,
-  createDomainEventEnvelope,
-  type CreateDomainEventEnvelopeInput,
-  type DomainEventContractSelection,
-  type DomainEventContractVersions,
-  type DomainEventEnvelope,
+    buildDomainEventContractVersions,
+    createDomainEventEnvelope,
+    type CreateDomainEventEnvelopeInput,
+    type DomainEventContractSelection,
+    type DomainEventContractVersions,
+    type DomainEventEnvelope,
 };

package/src/core/versioning/version.ts

@@ -1,34 +1,34 @@
 type ContractVersion = `${number}.${number}`;
 
 type VersionedTarget = {
-  readonly prototype: object;
+    readonly prototype: object;
 };
 
 const CONTRACT_VERSION_PROPERTY = "CONTRACT_VERSION" as const;
 const CONTRACT_VERSION_PATTERN = /^\d+\.\d+$/;
 
 function version<const TVersion extends ContractVersion>(
-  contractVersion: TVersion,
+    contractVersion: TVersion,
 ) {
-  if (!CONTRACT_VERSION_PATTERN.test(contractVersion)) {
-    throw new TypeError(
-      `Invalid contract version "${contractVersion}". Expected MAJOR.MINOR.`,
-    );
-  }
+    if (!CONTRACT_VERSION_PATTERN.test(contractVersion)) {
+        throw new TypeError(
+            `Invalid contract version "${contractVersion}". Expected MAJOR.MINOR.`,
+        );
+    }
 
-  return (target: VersionedTarget): void => {
-    Object.defineProperty(target, CONTRACT_VERSION_PROPERTY, {
-      value: contractVersion,
-      writable: false,
-      configurable: false,
-      enumerable: false,
-    });
-  };
+    return (target: VersionedTarget): void => {
+        Object.defineProperty(target, CONTRACT_VERSION_PROPERTY, {
+            value: contractVersion,
+            writable: false,
+            configurable: false,
+            enumerable: false,
+        });
+    };
 }
 
 export {
-  CONTRACT_VERSION_PROPERTY,
-  type ContractVersion,
-  version,
-  type VersionedTarget,
+    CONTRACT_VERSION_PROPERTY,
+    type ContractVersion,
+    version,
+    type VersionedTarget,
 };