@cullet/erp-core 1.0.2 → 1.0.3

package/src/examples/rulesets/entity/order-creation-rules-v1.ts

@@ -4,28 +4,28 @@ import { type OrderCreationData, type OrderCreationRuleset } from "./order";
 class OrderCreationValidationError extends DomainException {}
 
 class OrderCreationRulesV1 implements OrderCreationRuleset {
-  readonly id = "order-creation@1.0" as const;
-  readonly description = "Order creation rules — version 1.0";
+    readonly id = "order-creation@1.0" as const;
+    readonly description = "Order creation rules — version 1.0";
 
-  validate(data: OrderCreationData): void {
-    if (!data.customerId) {
-      throw new OrderCreationValidationError("customerId is required.");
-    }
+    validate(data: OrderCreationData): void {
+        if (!data.customerId) {
+            throw new OrderCreationValidationError("customerId is required.");
+        }
 
-    if (!data.items || data.items.length === 0) {
-      throw new OrderCreationValidationError(
-        "The order must contain at least one item.",
-      );
-    }
+        if (!data.items || data.items.length === 0) {
+            throw new OrderCreationValidationError(
+                "The order must contain at least one item.",
+            );
+        }
 
-    for (const item of data.items) {
-      if (item.quantity <= 0) {
-        throw new OrderCreationValidationError(
-          `Item "${item.sku}" quantity must be greater than zero. Received: ${item.quantity}.`,
-        );
-      }
+        for (const item of data.items) {
+            if (item.quantity <= 0) {
+                throw new OrderCreationValidationError(
+                    `Item "${item.sku}" quantity must be greater than zero. Received: ${item.quantity}.`,
+                );
+            }
+        }
     }
-  }
 }
 
 export { OrderCreationRulesV1 };

package/src/examples/rulesets/entity/order-invariants-v1.ts

@@ -1,48 +1,50 @@
 import {
-  DomainException,
-  type RulesetId,
+    DomainException,
+    type RulesetId,
 } from "../../../core/domain/rulesets/entity-ruleset.contracts";
 import {
-  type Order,
-  type OrderInvariantRuleset,
-  type OrderItem,
+    type Order,
+    type OrderInvariantRuleset,
+    type OrderItem,
 } from "./order";
 
 class OrderInvariantError extends DomainException {}
 
 class OrderInvariantsV1 implements OrderInvariantRuleset {
-  readonly id: RulesetId = "order-invariants@1.0";
-  readonly description: string = "Order invariants — version 1.0";
+    readonly id: RulesetId = "order-invariants@1.0";
+    readonly description: string = "Order invariants — version 1.0";
 
-  assertCanAddItem(order: Order, _item: OrderItem): void {
-    if (order.status !== "open") {
-      throw new OrderInvariantError(
-        `Cannot add an item to an order with status "${order.status}". The order must be open.`,
-      );
+    assertCanAddItem(order: Order, _item: OrderItem): void {
+        if (order.status !== "open") {
+            throw new OrderInvariantError(
+                `Cannot add an item to an order with status "${order.status}". The order must be open.`,
+            );
+        }
     }
-  }
 
-  assertCanCancel(order: Order): void {
-    if (order.status === "delivered") {
-      throw new OrderInvariantError(
-        "Cannot cancel an order that has already been delivered.",
-      );
+    assertCanCancel(order: Order): void {
+        if (order.status === "delivered") {
+            throw new OrderInvariantError(
+                "Cannot cancel an order that has already been delivered.",
+            );
+        }
     }
-  }
 
-  assertCanCheckout(order: Order): void {
-    if (order.items.length === 0) {
-      throw new OrderInvariantError("Cannot check out an order with no items.");
+    assertCanCheckout(order: Order): void {
+        if (order.items.length === 0) {
+            throw new OrderInvariantError(
+                "Cannot check out an order with no items.",
+            );
+        }
     }
-  }
 
-  assertCanMarkAsDelivered(order: Order): void {
-    if (order.status !== "shipped") {
-      throw new OrderInvariantError(
-        `Cannot mark as delivered an order with status "${order.status}". The order must be shipped.`,
-      );
+    assertCanMarkAsDelivered(order: Order): void {
+        if (order.status !== "shipped") {
+            throw new OrderInvariantError(
+                `Cannot mark as delivered an order with status "${order.status}". The order must be shipped.`,
+            );
+        }
     }
-  }
 }
 
 export { OrderInvariantsV1 };

package/src/examples/rulesets/entity/order-invariants-v2.ts

@@ -1,6 +1,6 @@
 import {
-  DomainException,
-  type RulesetId,
+    DomainException,
+    type RulesetId,
 } from "../../../core/domain/rulesets/entity-ruleset.contracts";
 import { type Order } from "./order";
 import { OrderInvariantsV1 } from "./order-invariants-v1";
@@ -10,19 +10,19 @@ class OrderCancellationWindowError extends DomainException {}
 const FORTY_EIGHT_HOURS_MS = 48 * 60 * 60 * 1000;
 
 class OrderInvariantsV2 extends OrderInvariantsV1 {
-  override readonly id: RulesetId = "order-invariants@2.0";
-  override readonly description = "Order invariants — version 2.0";
+    override readonly id: RulesetId = "order-invariants@2.0";
+    override readonly description = "Order invariants — version 2.0";
 
-  override assertCanCancel(order: Order): void {
-    super.assertCanCancel(order);
+    override assertCanCancel(order: Order): void {
+        super.assertCanCancel(order);
 
-    const ageMs = Date.now() - order.createdAt.getTime();
-    if (ageMs > FORTY_EIGHT_HOURS_MS) {
-      throw new OrderCancellationWindowError(
-        "Cannot cancel an order created more than 48 hours ago.",
-      );
+        const ageMs = Date.now() - order.createdAt.getTime();
+        if (ageMs > FORTY_EIGHT_HOURS_MS) {
+            throw new OrderCancellationWindowError(
+                "Cannot cancel an order created more than 48 hours ago.",
+            );
+        }
     }
-  }
 }
 
 export { OrderInvariantsV2 };

package/src/examples/rulesets/entity/order.ts

@@ -1,32 +1,32 @@
 import {
-  type CreationRuleset,
-  type InvariantRuleset,
-  type RulesetId,
+    type CreationRuleset,
+    type InvariantRuleset,
+    type RulesetId,
 } from "../../../core/domain/rulesets/entity-ruleset.contracts";
 
 type OrderStatus = "open" | "cancelled" | "shipped" | "delivered";
 
 interface OrderItem {
-  readonly sku: string;
-  readonly quantity: number;
+    readonly sku: string;
+    readonly quantity: number;
 }
 
 interface OrderCreationData {
-  readonly id: string;
-  readonly customerId: string;
-  readonly items: readonly OrderItem[];
-  readonly createdAt: Date;
+    readonly id: string;
+    readonly customerId: string;
+    readonly items: readonly OrderItem[];
+    readonly createdAt: Date;
 }
 
 interface OrderSnapshot extends OrderCreationData {
-  readonly status: OrderStatus;
-  readonly creationRulesetId: RulesetId;
-  readonly aggregateVersion: number;
+    readonly status: OrderStatus;
+    readonly creationRulesetId: RulesetId;
+    readonly aggregateVersion: number;
 }
 
 interface OrderCancelledEvent {
-  readonly type: "OrderCancelled";
-  readonly invariantRulesetId: RulesetId;
+    readonly type: "OrderCancelled";
+    readonly invariantRulesetId: RulesetId;
 }
 
 type OrderDomainEvent = OrderCancelledEvent;
@@ -34,129 +34,129 @@ type OrderDomainEvent = OrderCancelledEvent;
 type OrderCreationRuleset = CreationRuleset<OrderCreationData>;
 
 interface OrderInvariantRuleset extends InvariantRuleset {
-  assertCanAddItem(order: Order, item: OrderItem): void;
-  assertCanCancel(order: Order): void;
-  assertCanCheckout(order: Order): void;
-  assertCanMarkAsDelivered(order: Order): void;
+    assertCanAddItem(order: Order, item: OrderItem): void;
+    assertCanCancel(order: Order): void;
+    assertCanCheckout(order: Order): void;
+    assertCanMarkAsDelivered(order: Order): void;
 }
 
 interface OrderStatic {
-  create(data: OrderCreationData, ruleset: OrderCreationRuleset): Order;
-  reconstitute(snapshot: OrderSnapshot): Order;
+    create(data: OrderCreationData, ruleset: OrderCreationRuleset): Order;
+    reconstitute(snapshot: OrderSnapshot): Order;
 }
 
 class Order {
-  private readonly _id: string;
-  private readonly _customerId: string;
-  private _status: OrderStatus;
-  private readonly _items: OrderItem[];
-  private readonly _createdAt: Date;
-  private readonly _creationRulesetId: RulesetId;
-  private _aggregateVersion: number;
-  private readonly _domainEvents: OrderDomainEvent[] = [];
-
-  private constructor(snapshot: OrderSnapshot) {
-    this._id = snapshot.id;
-    this._customerId = snapshot.customerId;
-    this._status = snapshot.status;
-    this._items = [...snapshot.items];
-    this._createdAt = new Date(snapshot.createdAt.getTime());
-    this._creationRulesetId = snapshot.creationRulesetId;
-    this._aggregateVersion = snapshot.aggregateVersion;
-  }
-
-  get id(): string {
-    return this._id;
-  }
-
-  get customerId(): string {
-    return this._customerId;
-  }
-
-  get status(): OrderStatus {
-    return this._status;
-  }
-
-  get items(): readonly OrderItem[] {
-    return this._items;
-  }
-
-  get createdAt(): Date {
-    return new Date(this._createdAt.getTime());
-  }
-
-  get creationRulesetId(): RulesetId {
-    return this._creationRulesetId;
-  }
-
-  get aggregateVersion(): number {
-    return this._aggregateVersion;
-  }
-
-  addItem(item: OrderItem, ruleset: OrderInvariantRuleset): void {
-    ruleset.assertCanAddItem(this, item);
-    this._items.push(item);
-    this._aggregateVersion += 1;
-  }
-
-  cancel(ruleset: OrderInvariantRuleset): void {
-    ruleset.assertCanCancel(this);
-    this._status = "cancelled";
-    this._aggregateVersion += 1;
-    this._domainEvents.push({
-      type: "OrderCancelled",
-      invariantRulesetId: ruleset.id,
-    });
-  }
-
-  checkout(ruleset: OrderInvariantRuleset): void {
-    ruleset.assertCanCheckout(this);
-    this._status = "shipped";
-    this._aggregateVersion += 1;
-  }
-
-  markAsDelivered(ruleset: OrderInvariantRuleset): void {
-    ruleset.assertCanMarkAsDelivered(this);
-    this._status = "delivered";
-    this._aggregateVersion += 1;
-  }
-
-  pullDomainEvents(): readonly OrderDomainEvent[] {
-    const events = [...this._domainEvents];
-    this._domainEvents.length = 0;
-    return events;
-  }
-
-  static create(
-    data: OrderCreationData,
-    ruleset: CreationRuleset<OrderCreationData>,
-  ): Order {
-    ruleset.validate(data);
-    return new Order({
-      ...data,
-      status: "open",
-      creationRulesetId: ruleset.id,
-      aggregateVersion: 0,
-    });
-  }
-
-  static reconstitute(snapshot: OrderSnapshot): Order {
-    return new Order(snapshot);
-  }
+    private readonly _id: string;
+    private readonly _customerId: string;
+    private _status: OrderStatus;
+    private readonly _items: OrderItem[];
+    private readonly _createdAt: Date;
+    private readonly _creationRulesetId: RulesetId;
+    private _aggregateVersion: number;
+    private readonly _domainEvents: OrderDomainEvent[] = [];
+
+    private constructor(snapshot: OrderSnapshot) {
+        this._id = snapshot.id;
+        this._customerId = snapshot.customerId;
+        this._status = snapshot.status;
+        this._items = [...snapshot.items];
+        this._createdAt = new Date(snapshot.createdAt.getTime());
+        this._creationRulesetId = snapshot.creationRulesetId;
+        this._aggregateVersion = snapshot.aggregateVersion;
+    }
+
+    get id(): string {
+        return this._id;
+    }
+
+    get customerId(): string {
+        return this._customerId;
+    }
+
+    get status(): OrderStatus {
+        return this._status;
+    }
+
+    get items(): readonly OrderItem[] {
+        return this._items;
+    }
+
+    get createdAt(): Date {
+        return new Date(this._createdAt.getTime());
+    }
+
+    get creationRulesetId(): RulesetId {
+        return this._creationRulesetId;
+    }
+
+    get aggregateVersion(): number {
+        return this._aggregateVersion;
+    }
+
+    addItem(item: OrderItem, ruleset: OrderInvariantRuleset): void {
+        ruleset.assertCanAddItem(this, item);
+        this._items.push(item);
+        this._aggregateVersion += 1;
+    }
+
+    cancel(ruleset: OrderInvariantRuleset): void {
+        ruleset.assertCanCancel(this);
+        this._status = "cancelled";
+        this._aggregateVersion += 1;
+        this._domainEvents.push({
+            type: "OrderCancelled",
+            invariantRulesetId: ruleset.id,
+        });
+    }
+
+    checkout(ruleset: OrderInvariantRuleset): void {
+        ruleset.assertCanCheckout(this);
+        this._status = "shipped";
+        this._aggregateVersion += 1;
+    }
+
+    markAsDelivered(ruleset: OrderInvariantRuleset): void {
+        ruleset.assertCanMarkAsDelivered(this);
+        this._status = "delivered";
+        this._aggregateVersion += 1;
+    }
+
+    pullDomainEvents(): readonly OrderDomainEvent[] {
+        const events = [...this._domainEvents];
+        this._domainEvents.length = 0;
+        return events;
+    }
+
+    static create(
+        data: OrderCreationData,
+        ruleset: CreationRuleset<OrderCreationData>,
+    ): Order {
+        ruleset.validate(data);
+        return new Order({
+            ...data,
+            status: "open",
+            creationRulesetId: ruleset.id,
+            aggregateVersion: 0,
+        });
+    }
+
+    static reconstitute(snapshot: OrderSnapshot): Order {
+        return new Order(snapshot);
+    }
 }
 
 const _typeCheck: OrderStatic = Order;
 void _typeCheck;
 
 export {
-  Order,
-  type OrderCancelledEvent,
-  type OrderCreationData,
-  type OrderCreationRuleset,
-  type OrderDomainEvent,
-  type OrderInvariantRuleset,
-  type OrderItem,
-  type OrderSnapshot,
-  type OrderStatic,
-  type OrderStatus,
+    Order,
+    type OrderCancelledEvent,
+    type OrderCreationData,
+    type OrderCreationRuleset,
+    type OrderDomainEvent,
+    type OrderInvariantRuleset,
+    type OrderItem,
+    type OrderSnapshot,
+    type OrderStatic,
+    type OrderStatus,
 };

package/src/examples/rulesets/value-object/cpf-rules-v1.ts

@@ -1,52 +1,54 @@
 import {
-  DomainException,
-  type ValueObjectRuleset,
+    DomainException,
+    type ValueObjectRuleset,
 } from "../../../core/domain/rulesets/value-object-ruleset.contracts";
 
 class CPFValidationError extends DomainException {}
 
 function validateCheckDigits(digits: number[]): boolean {
-  // First check digit: multiply first 9 digits by weights 10..2
-  let sum = 0;
-  for (let i = 0; i < 9; i++) {
-    sum += digits[i]! * (10 - i);
-  }
-  const rem1 = sum % 11;
-  const expected1 = rem1 < 2 ? 0 : 11 - rem1;
-  if (digits[9] !== expected1) return false;
-
-  // Second check digit: multiply first 10 digits by weights 11..2
-  sum = 0;
-  for (let i = 0; i < 10; i++) {
-    sum += digits[i]! * (11 - i);
-  }
-  const rem2 = sum % 11;
-  const expected2 = rem2 < 2 ? 0 : 11 - rem2;
-  return digits[10] === expected2;
-}
-
-class CPFRulesV1 implements ValueObjectRuleset<string> {
-  readonly id = "cpf-rules@1.0" as const;
-  readonly description = "CPF validation using the check-digit algorithm";
-
-  validate(value: string): void {
-    if (!/^\d{11}$/.test(value)) {
-      throw new CPFValidationError(
-        `CPF must contain exactly 11 numeric digits. Received: "${value}".`,
-      );
+    // First check digit: multiply first 9 digits by weights 10..2
+    let sum = 0;
+    for (let i = 0; i < 9; i++) {
+        sum += digits[i]! * (10 - i);
     }
-
-    if (/^(\d)\1{10}$/.test(value)) {
-      throw new CPFValidationError(
-        `A CPF with all repeating digits is invalid: "${value}".`,
-      );
+    const rem1 = sum % 11;
+    const expected1 = rem1 < 2 ? 0 : 11 - rem1;
+    if (digits[9] !== expected1) return false;
+
+    // Second check digit: multiply first 10 digits by weights 11..2
+    sum = 0;
+    for (let i = 0; i < 10; i++) {
+        sum += digits[i]! * (11 - i);
     }
+    const rem2 = sum % 11;
+    const expected2 = rem2 < 2 ? 0 : 11 - rem2;
+    return digits[10] === expected2;
+}
 
-    const digits = value.split("").map(Number);
-    if (!validateCheckDigits(digits)) {
-      throw new CPFValidationError(`Invalid check digits for CPF "${value}".`);
+class CPFRulesV1 implements ValueObjectRuleset<string> {
+    readonly id = "cpf-rules@1.0" as const;
+    readonly description = "CPF validation using the check-digit algorithm";
+
+    validate(value: string): void {
+        if (!/^\d{11}$/.test(value)) {
+            throw new CPFValidationError(
+                `CPF must contain exactly 11 numeric digits. Received: "${value}".`,
+            );
+        }
+
+        if (/^(\d)\1{10}$/.test(value)) {
+            throw new CPFValidationError(
+                `A CPF with all repeating digits is invalid: "${value}".`,
+            );
+        }
+
+        const digits = value.split("").map(Number);
+        if (!validateCheckDigits(digits)) {
+            throw new CPFValidationError(
+                `Invalid check digits for CPF "${value}".`,
+            );
+        }
     }
-  }
 }
 
 export { CPFRulesV1 };

package/src/examples/rulesets/value-object/cpf-rules-v2.ts

@@ -1,27 +1,29 @@
 import {
-  DomainException,
-  type ValueObjectRuleset,
+    DomainException,
+    type ValueObjectRuleset,
 } from "../../../core/domain/rulesets/value-object-ruleset.contracts";
 import { CPFRulesV1 } from "./cpf-rules-v1";
 
 class CPFBlocklistError extends DomainException {}
 
 class CPFRulesV2 implements ValueObjectRuleset<string> {
-  readonly id = "cpf-rules@2.0" as const;
-  readonly description =
-    "CPF validation with check-digit algorithm and blocklist";
+    readonly id = "cpf-rules@2.0" as const;
+    readonly description =
+        "CPF validation with check-digit algorithm and blocklist";
 
-  private readonly v1 = new CPFRulesV1();
+    private readonly v1 = new CPFRulesV1();
 
-  constructor(private readonly blocklist: readonly string[]) {}
+    constructor(private readonly blocklist: readonly string[]) {}
 
-  validate(value: string): void {
-    this.v1.validate(value);
+    validate(value: string): void {
+        this.v1.validate(value);
 
-    if (this.blocklist.includes(value)) {
-      throw new CPFBlocklistError(`CPF "${value}" appears on the blocklist.`);
+        if (this.blocklist.includes(value)) {
+            throw new CPFBlocklistError(
+                `CPF "${value}" appears on the blocklist.`,
+            );
+        }
     }
-  }
 }
 
 export { CPFRulesV2 };

package/src/examples/rulesets/value-object/cpf.ts

@@ -1,34 +1,34 @@
 import {
-  type RulesetId,
-  type ValueObjectRuleset,
+    type RulesetId,
+    type ValueObjectRuleset,
 } from "../../../core/domain/rulesets/value-object-ruleset.contracts";
 
 interface CPFStatic {
-  create(raw: string, ruleset: ValueObjectRuleset<string>): CPF;
-  reconstitute(value: string, rulesetId: RulesetId): CPF;
+    create(raw: string, ruleset: ValueObjectRuleset<string>): CPF;
+    reconstitute(value: string, rulesetId: RulesetId): CPF;
 }
 
 class CPF {
-  readonly value: string;
-  readonly appliedRulesetId: RulesetId;
-
-  private constructor(value: string, appliedRulesetId: RulesetId) {
-    this.value = value;
-    this.appliedRulesetId = appliedRulesetId;
-  }
-
-  equals(other: CPF): boolean {
-    return this.value === other.value;
-  }
-
-  static create(raw: string, ruleset: ValueObjectRuleset<string>): CPF {
-    ruleset.validate(raw);
-    return new CPF(raw, ruleset.id);
-  }
-
-  static reconstitute(value: string, rulesetId: RulesetId): CPF {
-    return new CPF(value, rulesetId);
-  }
+    readonly value: string;
+    readonly appliedRulesetId: RulesetId;
+
+    private constructor(value: string, appliedRulesetId: RulesetId) {
+        this.value = value;
+        this.appliedRulesetId = appliedRulesetId;
+    }
+
+    equals(other: CPF): boolean {
+        return this.value === other.value;
+    }
+
+    static create(raw: string, ruleset: ValueObjectRuleset<string>): CPF {
+        ruleset.validate(raw);
+        return new CPF(raw, ruleset.id);
+    }
+
+    static reconstitute(value: string, rulesetId: RulesetId): CPF {
+        return new CPF(value, rulesetId);
+    }
 }
 
 const _typeCheck: CPFStatic = CPF;