@cullet/erp-core 1.0.1 → 1.0.3

package/src/core/domain/rulesets/ruleset-registry.ts

@@ -1,71 +1,71 @@
 import { DomainException } from "../../exceptions/domain-exception";
 import {
-  type Ruleset,
-  type RulesetRegistry as RulesetRegistryContract,
+    type Ruleset,
+    type RulesetRegistry as RulesetRegistryContract,
 } from "./ruleset.contracts";
 
 class RulesetRegistryError extends DomainException {}
 
 function parseVersion(id: string): [number, number] {
-  const atIdx = id.lastIndexOf("@");
-  const versionStr = id.slice(atIdx + 1);
-  const [major, minor] = versionStr.split(".").map(Number);
-  return [major, minor];
+    const atIdx = id.lastIndexOf("@");
+    const versionStr = id.slice(atIdx + 1);
+    const [major, minor] = versionStr.split(".").map(Number);
+    return [major, minor];
 }
 
 class RulesetRegistry implements RulesetRegistryContract {
-  private readonly _store = new Map<string, Ruleset>();
-  private _sealed = false;
+    private readonly _store = new Map<string, Ruleset>();
+    private _sealed = false;
 
-  register(ruleset: Ruleset): void {
-    if (this._sealed) {
-      throw new RulesetRegistryError(
-        "Registry is sealed. No new rulesets can be registered.",
-      );
+    register(ruleset: Ruleset): void {
+        if (this._sealed) {
+            throw new RulesetRegistryError(
+                "Registry is sealed. No new rulesets can be registered.",
+            );
+        }
+        if (this._store.has(ruleset.id)) {
+            throw new RulesetRegistryError(
+                `Ruleset with id "${ruleset.id}" is already registered.`,
+            );
+        }
+        this._store.set(ruleset.id, ruleset);
     }
-    if (this._store.has(ruleset.id)) {
-      throw new RulesetRegistryError(
-        `Ruleset with id "${ruleset.id}" is already registered.`,
-      );
-    }
-    this._store.set(ruleset.id, ruleset);
-  }
 
-  seal(): void {
-    this._sealed = true;
-  }
+    seal(): void {
+        this._sealed = true;
+    }
 
-  get<T extends Ruleset>(id: string): T {
-    const ruleset = this._store.get(id);
-    if (!ruleset) {
-      const available = Array.from(this._store.keys()).join(", ");
-      throw new RulesetRegistryError(
-        `Ruleset "${id}" not found. Available: [${available}]`,
-      );
+    get<T extends Ruleset>(id: string): T {
+        const ruleset = this._store.get(id);
+        if (!ruleset) {
+            const available = Array.from(this._store.keys()).join(", ");
+            throw new RulesetRegistryError(
+                `Ruleset "${id}" not found. Available: [${available}]`,
+            );
+        }
+        return ruleset as T;
     }
-    return ruleset as T;
-  }
 
-  getCurrent<T extends Ruleset>(prefix: string): T {
-    const matchingEntries = Array.from(this._store.entries()).filter(([key]) =>
-      key.startsWith(prefix + "@"),
-    );
+    getCurrent<T extends Ruleset>(prefix: string): T {
+        const matchingEntries = Array.from(this._store.entries()).filter(
+            ([key]) => key.startsWith(prefix + "@"),
+        );
 
-    if (matchingEntries.length === 0) {
-      throw new RulesetRegistryError(
-        `No rulesets found with prefix "${prefix}".`,
-      );
-    }
+        if (matchingEntries.length === 0) {
+            throw new RulesetRegistryError(
+                `No rulesets found with prefix "${prefix}".`,
+            );
+        }
 
-    const sorted = matchingEntries.sort(([a], [b]) => {
-      const [aMajor, aMinor] = parseVersion(a);
-      const [bMajor, bMinor] = parseVersion(b);
-      if (aMajor !== bMajor) return aMajor - bMajor;
-      return aMinor - bMinor;
-    });
+        const sorted = matchingEntries.sort(([a], [b]) => {
+            const [aMajor, aMinor] = parseVersion(a);
+            const [bMajor, bMinor] = parseVersion(b);
+            if (aMajor !== bMajor) return aMajor - bMajor;
+            return aMinor - bMinor;
+        });
 
-    return sorted[sorted.length - 1][1] as T;
-  }
+        return sorted[sorted.length - 1][1] as T;
+    }
 }
 
 export { RulesetRegistry };

package/src/core/domain/rulesets/ruleset.contracts.ts

@@ -1,15 +1,15 @@
 type RulesetId = `${string}@${number}.${number}`;
 
 interface Ruleset {
-  readonly id: RulesetId;
-  readonly description: string;
+    readonly id: RulesetId;
+    readonly description: string;
 }
 
 interface RulesetRegistry {
-  register(ruleset: Ruleset): void;
-  seal(): void;
-  get<T extends Ruleset>(id: string): T;
-  getCurrent<T extends Ruleset>(prefix: string): T;
+    register(ruleset: Ruleset): void;
+    seal(): void;
+    get<T extends Ruleset>(id: string): T;
+    getCurrent<T extends Ruleset>(prefix: string): T;
 }
 
 export { type Ruleset, type RulesetId, type RulesetRegistry };

package/src/core/domain/rulesets/value-object-ruleset.contracts.ts

@@ -2,12 +2,12 @@ import { DomainException } from "../../exceptions/domain-exception";
 import { type Ruleset, type RulesetId } from "./ruleset.contracts";
 
 interface ValueObjectRuleset<T> extends Ruleset {
-  validate(value: T): void;
+    validate(value: T): void;
 }
 
 export {
-  DomainException,
-  type Ruleset,
-  type RulesetId,
-  type ValueObjectRuleset,
+    DomainException,
+    type Ruleset,
+    type RulesetId,
+    type ValueObjectRuleset,
 };

package/src/core/domain/temporal/index.ts

@@ -1,18 +1,18 @@
 export {
-  assertTransactionTime,
-  createTransactionTime,
-  type CreateTransactionTimeInput,
-  type TransactionTime,
+    assertTransactionTime,
+    createTransactionTime,
+    type CreateTransactionTimeInput,
+    type TransactionTime,
 } from "./transaction-time";
 export { contains, isClosed, isOpen, overlaps } from "./temporal-range";
 export {
-  createTemporalSnapshot,
-  type CreateTemporalSnapshotInput,
-  type TemporalSnapshot,
+    createTemporalSnapshot,
+    type CreateTemporalSnapshotInput,
+    type TemporalSnapshot,
 } from "./temporal-snapshot";
 export {
-  assertValidTime,
-  createValidTime,
-  type CreateValidTimeInput,
-  type ValidTime,
+    assertValidTime,
+    createValidTime,
+    type CreateValidTimeInput,
+    type ValidTime,
 } from "./valid-time";

package/src/core/domain/temporal/temporal-range.ts

@@ -7,16 +7,16 @@ import { assertValidTime, type ValidTime } from "./valid-time";
  * Useful for identifying information that is still in effect / active.
  */
 function isOpen(range: ValidTime): boolean {
-  assertValidTime(range, "range");
+    assertValidTime(range, "range");
 
-  return range.to === undefined;
+    return range.to === undefined;
 }
 
 /**
  * Checks whether a temporal range is "closed" (has a defined end date).
  */
 function isClosed(range: ValidTime): boolean {
-  return !isOpen(range);
+    return !isOpen(range);
 }
 
 /**
@@ -24,14 +24,14 @@ function isClosed(range: ValidTime): boolean {
  * The lower bound (`from`) is inclusive, while the upper bound (`to`) is exclusive.
  */
 function contains(range: ValidTime, date: Date): boolean {
-  assertValidTime(range, "range");
-  assertValidDate("date", date);
+    assertValidTime(range, "range");
+    assertValidDate("date", date);
 
-  const fromTime = range.from.getTime();
-  const toTime = range.to?.getTime() ?? Number.POSITIVE_INFINITY;
-  const targetTime = date.getTime();
+    const fromTime = range.from.getTime();
+    const toTime = range.to?.getTime() ?? Number.POSITIVE_INFINITY;
+    const targetTime = date.getTime();
 
-  return targetTime >= fromTime && targetTime < toTime;
+    return targetTime >= fromTime && targetTime < toTime;
 }
 
 /**
@@ -39,15 +39,15 @@ function contains(range: ValidTime, date: Date): boolean {
  * Useful for validating whether a new rule conflicts with an existing one.
  */
 function overlaps(left: ValidTime, right: ValidTime): boolean {
-  assertValidTime(left, "left");
-  assertValidTime(right, "right");
+    assertValidTime(left, "left");
+    assertValidTime(right, "right");
 
-  const leftFrom = left.from.getTime();
-  const leftTo = left.to?.getTime() ?? Number.POSITIVE_INFINITY;
-  const rightFrom = right.from.getTime();
-  const rightTo = right.to?.getTime() ?? Number.POSITIVE_INFINITY;
+    const leftFrom = left.from.getTime();
+    const leftTo = left.to?.getTime() ?? Number.POSITIVE_INFINITY;
+    const rightFrom = right.from.getTime();
+    const rightTo = right.to?.getTime() ?? Number.POSITIVE_INFINITY;
 
-  return leftFrom < rightTo && rightFrom < leftTo;
+    return leftFrom < rightTo && rightFrom < leftTo;
 }
 
 export { contains, isClosed, isOpen, overlaps };

package/src/core/domain/temporal/temporal-snapshot.ts

@@ -1,14 +1,14 @@
 import { type DeepReadonly, makeImmutable } from "../../shared/immutable";
 
 import {
-  createTransactionTime,
-  type CreateTransactionTimeInput,
-  type TransactionTime,
+    createTransactionTime,
+    type CreateTransactionTimeInput,
+    type TransactionTime,
 } from "./transaction-time";
 import {
-  createValidTime,
-  type CreateValidTimeInput,
-  type ValidTime,
+    createValidTime,
+    type CreateValidTimeInput,
+    type ValidTime,
 } from "./valid-time";
 
 /**
@@ -16,32 +16,32 @@ import {
  * It is the representation of an entry in the append-only (historical) table.
  */
 interface TemporalSnapshot<T> {
-  /** The data or state captured by the snapshot. */
-  readonly data: DeepReadonly<T>;
-  /** Period during which this datum was valid in the real world. */
-  readonly validTime: ValidTime;
-  /** Period during which this record was the state known to the system. */
-  readonly txTime: TransactionTime;
+    /** The data or state captured by the snapshot. */
+    readonly data: DeepReadonly<T>;
+    /** Period during which this datum was valid in the real world. */
+    readonly validTime: ValidTime;
+    /** Period during which this record was the state known to the system. */
+    readonly txTime: TransactionTime;
 }
 
 interface CreateTemporalSnapshotInput<T> {
-  readonly data: T;
-  readonly validTime: CreateValidTimeInput;
-  readonly txTime: CreateTransactionTimeInput;
+    readonly data: T;
+    readonly validTime: CreateValidTimeInput;
+    readonly txTime: CreateTransactionTimeInput;
 }
 
 function createTemporalSnapshot<T>(
-  input: CreateTemporalSnapshotInput<T>,
+    input: CreateTemporalSnapshotInput<T>,
 ): TemporalSnapshot<T> {
-  return makeImmutable({
-    data: input.data,
-    validTime: createValidTime(input.validTime),
-    txTime: createTransactionTime(input.txTime),
-  });
+    return makeImmutable({
+        data: input.data,
+        validTime: createValidTime(input.validTime),
+        txTime: createTransactionTime(input.txTime),
+    });
 }
 
 export {
-  createTemporalSnapshot,
-  type CreateTemporalSnapshotInput,
-  type TemporalSnapshot,
+    createTemporalSnapshot,
+    type CreateTemporalSnapshotInput,
+    type TemporalSnapshot,
 };

package/src/core/domain/temporal/transaction-time.ts

@@ -8,53 +8,53 @@ import { assertValidDate } from "../../shared/temporal-guards";
  * Useful for auditing and reconstructing system state at a specific past moment.
  */
 interface TransactionTime {
-  /** When the information was first recorded in the system. */
-  readonly recordedAt: Date;
-  /** When this information was superseded or invalidated by a newer version. */
-  readonly supersededAt?: Date;
+    /** When the information was first recorded in the system. */
+    readonly recordedAt: Date;
+    /** When this information was superseded or invalidated by a newer version. */
+    readonly supersededAt?: Date;
 }
 
 type CreateTransactionTimeInput = TransactionTime;
 
 function assertTransactionTime(
-  txTime: TransactionTime,
-  fieldName: string = "txTime",
+    txTime: TransactionTime,
+    fieldName: string = "txTime",
 ): void {
-  assertValidDate(`${fieldName}.recordedAt`, txTime.recordedAt);
+    assertValidDate(`${fieldName}.recordedAt`, txTime.recordedAt);
 
-  if (txTime.supersededAt === undefined) {
-    return;
-  }
+    if (txTime.supersededAt === undefined) {
+        return;
+    }
 
-  assertValidDate(`${fieldName}.supersededAt`, txTime.supersededAt);
+    assertValidDate(`${fieldName}.supersededAt`, txTime.supersededAt);
 
-  if (txTime.supersededAt.getTime() <= txTime.recordedAt.getTime()) {
-    throw new InvariantViolationException(
-      `${fieldName}.supersededAt must be later than ${fieldName}.recordedAt`,
-    );
-  }
+    if (txTime.supersededAt.getTime() <= txTime.recordedAt.getTime()) {
+        throw new InvariantViolationException(
+            `${fieldName}.supersededAt must be later than ${fieldName}.recordedAt`,
+        );
+    }
 }
 
 function createTransactionTime(
-  input: CreateTransactionTimeInput,
+    input: CreateTransactionTimeInput,
 ): TransactionTime {
-  assertTransactionTime(input, "txTime");
+    assertTransactionTime(input, "txTime");
+
+    if (input.supersededAt === undefined) {
+        return makeImmutable({
+            recordedAt: input.recordedAt,
+        });
+    }
 
-  if (input.supersededAt === undefined) {
     return makeImmutable({
-      recordedAt: input.recordedAt,
+        recordedAt: input.recordedAt,
+        supersededAt: input.supersededAt,
     });
-  }
-
-  return makeImmutable({
-    recordedAt: input.recordedAt,
-    supersededAt: input.supersededAt,
-  });
 }
 
 export {
-  assertTransactionTime,
-  createTransactionTime,
-  type CreateTransactionTimeInput,
-  type TransactionTime,
+    assertTransactionTime,
+    createTransactionTime,
+    type CreateTransactionTimeInput,
+    type TransactionTime,
 };

package/src/core/domain/temporal/valid-time.ts

@@ -7,51 +7,51 @@ import { assertValidDate } from "../../shared/temporal-guards";
  * Defines when a piece of information is considered true or in effect in the real world.
  */
 interface ValidTime {
-  /** Start of the validity window (inclusive). */
-  readonly from: Date;
-  /** End of the validity window (exclusive). When absent, the information is still in effect. */
-  readonly to?: Date;
+    /** Start of the validity window (inclusive). */
+    readonly from: Date;
+    /** End of the validity window (exclusive). When absent, the information is still in effect. */
+    readonly to?: Date;
 }
 
 type CreateValidTimeInput = ValidTime;
 
 function assertValidTime(
-  validTime: ValidTime,
-  fieldName: string = "validTime",
+    validTime: ValidTime,
+    fieldName: string = "validTime",
 ): void {
-  assertValidDate(`${fieldName}.from`, validTime.from);
+    assertValidDate(`${fieldName}.from`, validTime.from);
 
-  if (validTime.to === undefined) {
-    return;
-  }
+    if (validTime.to === undefined) {
+        return;
+    }
 
-  assertValidDate(`${fieldName}.to`, validTime.to);
+    assertValidDate(`${fieldName}.to`, validTime.to);
 
-  if (validTime.to.getTime() <= validTime.from.getTime()) {
-    throw new InvariantViolationException(
-      `${fieldName}.to must be later than ${fieldName}.from`,
-    );
-  }
+    if (validTime.to.getTime() <= validTime.from.getTime()) {
+        throw new InvariantViolationException(
+            `${fieldName}.to must be later than ${fieldName}.from`,
+        );
+    }
 }
 
 function createValidTime(input: CreateValidTimeInput): ValidTime {
-  assertValidTime(input, "validTime");
+    assertValidTime(input, "validTime");
+
+    if (input.to === undefined) {
+        return makeImmutable({
+            from: input.from,
+        });
+    }
 
-  if (input.to === undefined) {
     return makeImmutable({
-      from: input.from,
+        from: input.from,
+        to: input.to,
     });
-  }
-
-  return makeImmutable({
-    from: input.from,
-    to: input.to,
-  });
 }
 
 export {
-  assertValidTime,
-  createValidTime,
-  type CreateValidTimeInput,
-  type ValidTime,
+    assertValidTime,
+    createValidTime,
+    type CreateValidTimeInput,
+    type ValidTime,
 };

package/src/core/domain/value-object.ts

@@ -3,28 +3,28 @@ import { type ContractVersion, version } from "../versioning/version";
 
 @version("1.0")
 abstract class ValueObject<T, P> {
-  public static readonly CONTRACT_VERSION: ContractVersion;
-  public readonly value: DeepReadonly<T>;
+    public static readonly CONTRACT_VERSION: ContractVersion;
+    public readonly value: DeepReadonly<T>;
 
-  protected constructor(value: T) {
-    this.value = makeImmutable(value);
-  }
+    protected constructor(value: T) {
+        this.value = makeImmutable(value);
+    }
 
-  public get contractVersion(): ContractVersion {
-    return ValueObject.CONTRACT_VERSION;
-  }
+    public get contractVersion(): ContractVersion {
+        return ValueObject.CONTRACT_VERSION;
+    }
 
-  protected finalize(): void {
-    Object.freeze(this);
-  }
+    protected finalize(): void {
+        Object.freeze(this);
+    }
 
-  public toJSON(): P {
-    return this.toPrimitive();
-  }
+    public toJSON(): P {
+        return this.toPrimitive();
+    }
 
-  public abstract equals(other: this): boolean;
+    public abstract equals(other: this): boolean;
 
-  public abstract toPrimitive(): P;
+    public abstract toPrimitive(): P;
 }
 
 export { type DeepReadonly, ValueObject };