@cullet/erp-core 1.0.2 → 1.0.3

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

@@ -1,67 +1,70 @@
 import { CPF } from "./cpf";
 import { PersonName } from "./person-name";
 import {
-  type RulesetId,
-  type ValueObjectRuleset,
+    type RulesetId,
+    type ValueObjectRuleset,
 } from "../../../core/domain/rulesets/value-object-ruleset.contracts";
 
 interface CustomerCreateData {
-  readonly cpf: string;
-  readonly name: string;
+    readonly cpf: string;
+    readonly name: string;
 }
 
 interface CustomerCreateRulesets {
-  readonly cpf: ValueObjectRuleset<string>;
-  readonly name: ValueObjectRuleset<string>;
+    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;
+    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;
+    create(
+        data: CustomerCreateData,
+        rulesets: CustomerCreateRulesets,
+    ): Customer;
+    reconstitute(snapshot: CustomerSnapshot): Customer;
 }
 
 class Customer {
-  readonly cpf: CPF;
-  readonly name: PersonName;
+    readonly cpf: CPF;
+    readonly name: PersonName;
 
-  private constructor(cpf: CPF, name: PersonName) {
-    this.cpf = cpf;
-    this.name = name;
-  }
+    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 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);
-  }
+    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,
+    Customer,
+    type CustomerCreateData,
+    type CustomerCreateRulesets,
+    type CustomerSnapshot,
+    type CustomerStatic,
 };

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

@@ -1,37 +1,37 @@
 import {
-  DomainException,
-  type ValueObjectRuleset,
+    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}".`,
-        );
-      }
+    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

@@ -1,27 +1,27 @@
 import {
-  DomainException,
-  type ValueObjectRuleset,
+    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";
+    readonly id = "person-name-rules@2.0" as const;
+    readonly description =
+        "Name validation with restriction on special characters";
 
-  private readonly v1 = new PersonNameRulesV1();
+    private readonly v1 = new PersonNameRulesV1();
 
-  validate(value: string): void {
-    this.v1.validate(value);
+    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.`,
-      );
+        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

@@ -1,36 +1,39 @@
 import {
-  type RulesetId,
-  type ValueObjectRuleset,
+    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;
+    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);
-  }
+    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;

package/src/index.ts

@@ -6,6 +6,6 @@ export const ERP_CORE_NAME = "erp-core";
 export const ERP_CORE_VERSION = version;
 
 export const erpCoreRelease = {
-  name: ERP_CORE_NAME,
-  version: ERP_CORE_VERSION,
+    name: ERP_CORE_NAME,
+    version: ERP_CORE_VERSION,
 } as const;

package/src/version.ts

@@ -4,4 +4,4 @@
 // 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.2";
+export const version = "1.0.3";