@cullet/erp-core 1.0.0

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

@@ -0,0 +1,162 @@
+import {
+  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;
+}
+
+interface OrderCreationData {
+  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;
+}
+
+interface OrderCancelledEvent {
+  readonly type: "OrderCancelled";
+  readonly invariantRulesetId: RulesetId;
+}
+
+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;
+}
+
+interface OrderStatic {
+  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);
+  }
+}
+
+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,
+};

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

@@ -0,0 +1,52 @@
+import {
+  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}".`,
+      );
+    }
+
+    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

@@ -0,0 +1,27 @@
+import {
+  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";
+
+  private readonly v1 = new CPFRulesV1();
+
+  constructor(private readonly blocklist: readonly string[]) {}
+
+  validate(value: string): void {
+    this.v1.validate(value);
+
+    if (this.blocklist.includes(value)) {
+      throw new CPFBlocklistError(`CPF "${value}" appears on the blocklist.`);
+    }
+  }
+}
+
+export { CPFRulesV2 };

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

@@ -0,0 +1,37 @@
+import {
+  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;
+}
+
+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);
+  }
+}
+
+const _typeCheck: CPFStatic = CPF;
+void _typeCheck;
+
+export { CPF, type CPFStatic };

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

@@ -0,0 +1,67 @@
+import { CPF } from "./cpf";
+import { PersonName } from "./person-name";
+import {
+  type RulesetId,
+  type ValueObjectRuleset,
+} from "../../../core/domain/rulesets/value-object-ruleset.contracts";
+
+interface CustomerCreateData {
+  readonly cpf: string;
+  readonly name: string;
+}
+
+interface CustomerCreateRulesets {
+  readonly cpf: ValueObjectRuleset<string>;
+  readonly name: ValueObjectRuleset<string>;
+}
+
+interface CustomerSnapshot {
+  readonly cpf_value: string;
+  readonly cpf_ruleset: RulesetId;
+  readonly name_value: string;
+  readonly name_ruleset: RulesetId;
+}
+
+interface CustomerStatic {
+  create(data: CustomerCreateData, rulesets: CustomerCreateRulesets): Customer;
+  reconstitute(snapshot: CustomerSnapshot): Customer;
+}
+
+class Customer {
+  readonly cpf: CPF;
+  readonly name: PersonName;
+
+  private constructor(cpf: CPF, name: PersonName) {
+    this.cpf = cpf;
+    this.name = name;
+  }
+
+  static create(
+    data: CustomerCreateData,
+    rulesets: CustomerCreateRulesets,
+  ): Customer {
+    const cpf = CPF.create(data.cpf, rulesets.cpf);
+    const name = PersonName.create(data.name, rulesets.name);
+    return new Customer(cpf, name);
+  }
+
+  static reconstitute(snapshot: CustomerSnapshot): Customer {
+    const cpf = CPF.reconstitute(snapshot.cpf_value, snapshot.cpf_ruleset);
+    const name = PersonName.reconstitute(
+      snapshot.name_value,
+      snapshot.name_ruleset,
+    );
+    return new Customer(cpf, name);
+  }
+}
+
+const _typeCheck: CustomerStatic = Customer;
+void _typeCheck;
+
+export {
+  Customer,
+  type CustomerCreateData,
+  type CustomerCreateRulesets,
+  type CustomerSnapshot,
+  type CustomerStatic,
+};

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

@@ -0,0 +1,37 @@
+import {
+  DomainException,
+  type ValueObjectRuleset,
+} from "../../../core/domain/rulesets/value-object-ruleset.contracts";
+
+class PersonNameValidationError extends DomainException {}
+
+class PersonNameRulesV1 implements ValueObjectRuleset<string> {
+  readonly id = "person-name-rules@1.0" as const;
+  readonly description = "Name validation requiring at least two words";
+
+  validate(value: string): void {
+    const trimmed = value.trim();
+
+    if (trimmed.length === 0) {
+      throw new PersonNameValidationError("Name cannot be empty.");
+    }
+
+    const words = trimmed.split(/\s+/);
+
+    if (words.length < 2) {
+      throw new PersonNameValidationError(
+        `Name must have at least two words. Received: "${value}".`,
+      );
+    }
+
+    for (const word of words) {
+      if (word.length < 2) {
+        throw new PersonNameValidationError(
+          `Each word of the name must be at least two characters long. Invalid word: "${word}".`,
+        );
+      }
+    }
+  }
+}
+
+export { PersonNameRulesV1 };

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

@@ -0,0 +1,27 @@
+import {
+  DomainException,
+  type ValueObjectRuleset,
+} from "../../../core/domain/rulesets/value-object-ruleset.contracts";
+import { PersonNameRulesV1 } from "./person-name-rules-v1";
+
+class PersonNameCharacterError extends DomainException {}
+
+class PersonNameRulesV2 implements ValueObjectRuleset<string> {
+  readonly id = "person-name-rules@2.0" as const;
+  readonly description =
+    "Name validation with restriction on special characters";
+
+  private readonly v1 = new PersonNameRulesV1();
+
+  validate(value: string): void {
+    this.v1.validate(value);
+
+    if (/[^a-zA-ZÀ-ÿ\s'-]/.test(value)) {
+      throw new PersonNameCharacterError(
+        `Name contains invalid characters: "${value}". Only letters, hyphens, and apostrophes are allowed.`,
+      );
+    }
+  }
+}
+
+export { PersonNameRulesV2 };

package/src/examples/rulesets/value-object/person-name.ts

@@ -0,0 +1,39 @@
+import {
+  type RulesetId,
+  type ValueObjectRuleset,
+} from "../../../core/domain/rulesets/value-object-ruleset.contracts";
+
+interface PersonNameStatic {
+  create(raw: string, ruleset: ValueObjectRuleset<string>): PersonName;
+  reconstitute(value: string, rulesetId: RulesetId): PersonName;
+}
+
+class PersonName {
+  readonly value: string;
+  readonly appliedRulesetId: RulesetId;
+
+  private constructor(value: string, appliedRulesetId: RulesetId) {
+    this.value = value;
+    this.appliedRulesetId = appliedRulesetId;
+  }
+
+  equals(other: PersonName): boolean {
+    const normalize = (v: string) =>
+      v.trim().replace(/\s+/g, " ").toLowerCase();
+    return normalize(this.value) === normalize(other.value);
+  }
+
+  static create(raw: string, ruleset: ValueObjectRuleset<string>): PersonName {
+    ruleset.validate(raw);
+    return new PersonName(raw, ruleset.id);
+  }
+
+  static reconstitute(value: string, rulesetId: RulesetId): PersonName {
+    return new PersonName(value, rulesetId);
+  }
+}
+
+const _typeCheck: PersonNameStatic = PersonName;
+void _typeCheck;
+
+export { PersonName, type PersonNameStatic };

package/src/exceptions/validation-field.ts

@@ -0,0 +1 @@
+export * from "../core/exceptions/validation-field.js";

package/src/index.ts

@@ -0,0 +1,11 @@
+import { version } from "./version.js";
+
+export * from "./core/index.js";
+
+export const ERP_CORE_NAME = "erp-core";
+export const ERP_CORE_VERSION = version;
+
+export const erpCoreRelease = {
+  name: ERP_CORE_NAME,
+  version: ERP_CORE_VERSION,
+} as const;

package/src/policies/engines/index.ts

@@ -0,0 +1 @@
+export * from "../../core/policies/engines/index.js";

package/src/policies/engines/v1/gate/index.ts

@@ -0,0 +1 @@
+export * from "../../../../core/policies/engines/v1/gate/index.js";

package/src/policies/index.ts

@@ -0,0 +1 @@
+export * from "../core/policies/index.js";

package/src/version.ts

@@ -0,0 +1,7 @@
+// Versao do kit, sincronizada com package.json por scripts/sync-kit-version.mjs.
+// Nao edite a mao: rode `npm run sync-kit-version` (ou e regenerado no release).
+//
+// Mantemos a versao aqui, dentro de src/, para que a copia full-control seja
+// auto-contida: ao copiar so o conteudo de src/, o entry nao depende de um
+// `../package.json` que deixaria de existir no projeto consumidor.
+export const version = "1.0.0";