@atlantjs/arch 4.1.4 → 4.1.6

package/@tool-box/tests/builders/user/email.builder.d.ts

@@ -0,0 +1,6 @@
+import { EntityBuilder } from "../../entity-builder.util";
+import { Email } from "../../../../arch/modules/domain/entities/user/value-objects/email";
+export declare class EmailBuilder extends EntityBuilder<Email, EmailBuilder> {
+    constructor();
+    protected buildDefault(): Email;
+}

package/@tool-box/tests/builders/user/email.builder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailBuilder = void 0;
+const entity_builder_util_1 = require("../../entity-builder.util");
+const email_1 = require("../../../../arch/modules/domain/entities/user/value-objects/email");
+const _1 = require("@faker-js/faker/.");
+class EmailBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(EmailBuilder);
+    }
+    buildDefault() {
+        return new email_1.Email(_1.faker.internet.email());
+    }
+}
+exports.EmailBuilder = EmailBuilder;

package/@tool-box/tests/builders/user/person-name.builder.d.ts

@@ -0,0 +1,6 @@
+import { EntityBuilder } from "../../entity-builder.util";
+import { PersonName } from "../../../../arch/modules/domain/entities/user/value-objects/person-name";
+export declare class PersonNameBuilder extends EntityBuilder<PersonName, PersonNameBuilder> {
+    constructor();
+    protected buildDefault(): PersonName;
+}

package/@tool-box/tests/builders/user/person-name.builder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonNameBuilder = void 0;
+const entity_builder_util_1 = require("../../entity-builder.util");
+const person_name_1 = require("../../../../arch/modules/domain/entities/user/value-objects/person-name");
+const _1 = require("@faker-js/faker/.");
+class PersonNameBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(PersonNameBuilder);
+    }
+    buildDefault() {
+        return new person_name_1.PersonName(_1.faker.person.fullName());
+    }
+}
+exports.PersonNameBuilder = PersonNameBuilder;

package/@tool-box/tests/builders/user/user-id.builder.d.ts

@@ -0,0 +1,6 @@
+import { EntityBuilder } from "../../entity-builder.util";
+import { UserId } from "../../../../arch/modules/domain/entities/user/value-objects/user-id";
+export declare class UserIdBuilder extends EntityBuilder<UserId, UserIdBuilder> {
+    constructor();
+    protected buildDefault(): UserId;
+}

package/@tool-box/tests/builders/user/user-id.builder.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserIdBuilder = void 0;
+const entity_builder_util_1 = require("../../entity-builder.util");
+const user_id_1 = require("../../../../arch/modules/domain/entities/user/value-objects/user-id");
+class UserIdBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(UserIdBuilder);
+    }
+    buildDefault() {
+        return new user_id_1.UserId();
+    }
+}
+exports.UserIdBuilder = UserIdBuilder;

package/@tool-box/tests/builders/user/username.builder.d.ts

@@ -0,0 +1,6 @@
+import { EntityBuilder } from "../../entity-builder.util";
+import { Username } from "../../../../arch/modules/domain/entities/user/value-objects/username";
+export declare class UsernameBuilder extends EntityBuilder<Username, UsernameBuilder> {
+    constructor();
+    protected buildDefault(): Username;
+}

package/@tool-box/tests/builders/user/username.builder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsernameBuilder = void 0;
+const entity_builder_util_1 = require("../../entity-builder.util");
+const username_1 = require("../../../../arch/modules/domain/entities/user/value-objects/username");
+const _1 = require("@faker-js/faker/.");
+class UsernameBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(UsernameBuilder);
+    }
+    buildDefault() {
+        return new username_1.Username(_1.faker.internet.username());
+    }
+}
+exports.UsernameBuilder = UsernameBuilder;

package/arch/modules/domain/entities/user/password/password.abstract.d.ts

@@ -0,0 +1,8 @@
+import { PasswordPolicyResult } from "./password.abstract.type";
+export declare abstract class PasswordAbstract {
+    private readonly password;
+    private readonly validationSteps;
+    constructor(password: string);
+    protected validate(password: string): PasswordPolicyResult;
+    toString(): string;
+}

package/arch/modules/domain/entities/user/password/password.abstract.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordAbstract = void 0;
+const guardian_1 = require("../../../../../../@tool-box/utils/type-guard/guardian");
+const with_at_least_one_letter_step_1 = require("./steps/with-at-least-one-letter-step");
+const with_at_least_one_number_digit_step_1 = require("./steps/with-at-least-one-number-digit-step");
+const with_at_least_one_special_char_step_1 = require("./steps/with-at-least-one-special-char-step");
+const with_length_step_1 = require("./steps/with-length-step");
+class PasswordAbstract {
+    constructor(password) {
+        this.password = password;
+        this.validationSteps = [
+            new with_at_least_one_letter_step_1.WithAtLeastOneLetterStep(),
+            new with_at_least_one_number_digit_step_1.WithAtLeastOneNumberDigitStep(),
+            new with_at_least_one_special_char_step_1.WithAtLeastOneSpecialCharStep(),
+            new with_length_step_1.WithLengthStep({ min: 6, max: 999 }),
+        ];
+        const { valid, validationStepsResults } = this.validate(this.password);
+        if (guardian_1.Guardian.isFalsy(valid)) {
+            throw new TypeError(`Password is invalid: ${validationStepsResults.map((result) => result.name)}`);
+        }
+    }
+    validate(password) {
+        if (guardian_1.Guardian.isEqual(this.validationSteps.length, 0)) {
+            throw new TypeError("No validations found");
+        }
+        const validationStepsResults = [];
+        for (const step of this.validationSteps) {
+            validationStepsResults.push(step.validate(password));
+        }
+        const valid = validationStepsResults.every((result) => result.valid);
+        return {
+            valid,
+            validationStepsResults,
+        };
+    }
+    toString() {
+        return this.password;
+    }
+}
+exports.PasswordAbstract = PasswordAbstract;

package/arch/modules/domain/entities/user/password/password.abstract.type.d.ts

@@ -0,0 +1,5 @@
+import { ValidationStepResult } from "./validation-step.type";
+export interface PasswordPolicyResult {
+    valid: boolean;
+    validationStepsResults: ValidationStepResult[];
+}

package/arch/modules/domain/entities/user/password/password.abstract.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/arch/modules/domain/entities/user/password/steps/not-allowing-consecutive-chars-step.d.ts

@@ -0,0 +1,11 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export interface NotAllowingConsecutiveCharsStepOptions {
+    maxAllowedConsecutiveChars: number;
+}
+export declare class NotAllowingConsecutiveCharsStep extends ValidationStep {
+    private readonly params;
+    constructor(params: NotAllowingConsecutiveCharsStepOptions);
+    validate(password: string): ValidationStepResult;
+    private getMaxNumberOfConsecutiveChars;
+}

package/arch/modules/domain/entities/user/password/steps/not-allowing-consecutive-chars-step.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingConsecutiveCharsStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingConsecutiveCharsStep extends validation_step_1.ValidationStep {
+    constructor(params) {
+        super();
+        this.params = params;
+    }
+    validate(password) {
+        return {
+            valid: this.getMaxNumberOfConsecutiveChars(password) <=
+                this.params.maxAllowedConsecutiveChars,
+            name: this.name,
+        };
+    }
+    getMaxNumberOfConsecutiveChars(password) {
+        let numberOfConsecutiveChars = 1;
+        let maxNumberOfConsecutiveChars = 1;
+        for (let i = 1; i < password.length; i++) {
+            const previousChar = password[i - 1];
+            const char = password[i];
+            if (Math.abs(previousChar.charCodeAt(0) - char.charCodeAt(0)) === 1) {
+                numberOfConsecutiveChars += 1;
+            }
+            else {
+                maxNumberOfConsecutiveChars = Math.max(numberOfConsecutiveChars, maxNumberOfConsecutiveChars);
+                numberOfConsecutiveChars = 1;
+            }
+        }
+        return Math.max(numberOfConsecutiveChars, maxNumberOfConsecutiveChars);
+    }
+}
+exports.NotAllowingConsecutiveCharsStep = NotAllowingConsecutiveCharsStep;

package/arch/modules/domain/entities/user/password/steps/not-allowing-date-step.d.ts

@@ -0,0 +1,11 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class NotAllowingDateStep extends ValidationStep {
+    private readonly notAllowedDate;
+    constructor(notAllowedDate: Date);
+    validate(password: string): ValidationStepResult;
+    private possibleDateCombinations;
+    private buildDayFormats;
+    private buildMonthFormats;
+    private buildYearFormat;
+}

package/arch/modules/domain/entities/user/password/steps/not-allowing-date-step.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingDateStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingDateStep extends validation_step_1.ValidationStep {
+    constructor(notAllowedDate) {
+        super();
+        this.notAllowedDate = notAllowedDate;
+    }
+    validate(password) {
+        const cleanPassword = password.replace(/[^\w]/gi, "");
+        const result = this.possibleDateCombinations().every((dateFormat) => !cleanPassword.includes(dateFormat.toLowerCase()));
+        return {
+            valid: result,
+            name: this.name,
+        };
+    }
+    possibleDateCombinations() {
+        const formats = [];
+        this.buildDayFormats().forEach((day) => {
+            this.buildMonthFormats().forEach((month) => {
+                this.buildYearFormat().forEach((year) => {
+                    formats.push(`${day}${month}`);
+                    formats.push(`${month}${day}`);
+                    formats.push(`${day}${month}${year}`);
+                    formats.push(`${month}${day}${year}`);
+                    formats.push(`${year}${month}${day}`);
+                });
+            });
+        });
+        return [...new Set(formats)];
+    }
+    buildDayFormats() {
+        const day = this.notAllowedDate.getUTCDate();
+        const dayLength = 2;
+        return [
+            ...new Set([day.toString(), day.toString().padStart(dayLength, "0")]),
+        ];
+    }
+    buildMonthFormats() {
+        const month = this.notAllowedDate.getUTCMonth() + 1;
+        const monthLength = 2;
+        return [
+            ...new Set([
+                month.toString(),
+                month.toString().padStart(monthLength, "0"),
+            ]),
+        ];
+    }
+    buildYearFormat() {
+        const year = this.notAllowedDate.getUTCFullYear();
+        const abbreviateYearLength = 2;
+        return [
+            ...new Set([
+                year.toString(),
+                year.toString().slice(-abbreviateYearLength),
+            ]),
+        ];
+    }
+}
+exports.NotAllowingDateStep = NotAllowingDateStep;

package/arch/modules/domain/entities/user/password/steps/not-allowing-phone-step.d.ts

@@ -0,0 +1,7 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class NotAllowingPhoneStep extends ValidationStep {
+    private readonly notAllowedPhone?;
+    constructor(phone: string);
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/not-allowing-phone-step.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingPhoneStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingPhoneStep extends validation_step_1.ValidationStep {
+    constructor(phone) {
+        super();
+        const matches = phone.match(/\d{4}\-?\d{4}$/);
+        if (matches) {
+            this.notAllowedPhone = matches[0].replace(/\-/, "");
+        }
+    }
+    validate(password) {
+        if (!this.notAllowedPhone) {
+            return {
+                valid: true,
+                name: this.name,
+            };
+        }
+        const cleanPassword = password.replace(/[\-\s]/gi, "");
+        return {
+            valid: !cleanPassword.includes(this.notAllowedPhone),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingPhoneStep = NotAllowingPhoneStep;

package/arch/modules/domain/entities/user/password/steps/not-allowing-repeated-chars-step.d.ts

@@ -0,0 +1,11 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export interface NotAllowingRepeatedCharsStepOptions {
+    maxAllowedRepeatedChars: number;
+}
+export declare class NotAllowingRepeatedCharsStep extends ValidationStep {
+    private readonly options;
+    constructor(options: NotAllowingRepeatedCharsStepOptions);
+    validate(password: string): ValidationStepResult;
+    private getMaxNumberOfRepeatedChars;
+}

package/arch/modules/domain/entities/user/password/steps/not-allowing-repeated-chars-step.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingRepeatedCharsStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingRepeatedCharsStep extends validation_step_1.ValidationStep {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: this.getMaxNumberOfRepeatedChars(password) <=
+                this.options.maxAllowedRepeatedChars,
+            name: this.name,
+        };
+    }
+    getMaxNumberOfRepeatedChars(password) {
+        let numberOfRepeatedChars = 1;
+        let maxNumberOfRepeatedChars = 1;
+        for (let i = 1; i < password.length; i++) {
+            const previousChar = password[i - 1];
+            const char = password[i];
+            if (previousChar === char) {
+                numberOfRepeatedChars += 1;
+            }
+            else {
+                maxNumberOfRepeatedChars = Math.max(numberOfRepeatedChars, maxNumberOfRepeatedChars);
+                numberOfRepeatedChars = 1;
+            }
+        }
+        return Math.max(numberOfRepeatedChars, maxNumberOfRepeatedChars);
+    }
+}
+exports.NotAllowingRepeatedCharsStep = NotAllowingRepeatedCharsStep;

package/arch/modules/domain/entities/user/password/steps/not-allowing-string-step.d.ts

@@ -0,0 +1,7 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class NotAllowingStringStep extends ValidationStep {
+    private readonly forbiddenString;
+    constructor(forbiddenString: string);
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/not-allowing-string-step.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingStringStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingStringStep extends validation_step_1.ValidationStep {
+    constructor(forbiddenString) {
+        super();
+        this.forbiddenString = forbiddenString;
+    }
+    validate(password) {
+        return {
+            valid: !password
+                .toLowerCase()
+                .includes(this.forbiddenString.toLowerCase()),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingStringStep = NotAllowingStringStep;

package/arch/modules/domain/entities/user/password/steps/not-allowing-these-chars-step.d.ts

@@ -0,0 +1,10 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export interface NotAllowingTheseCharsStepOptions {
+    notAllowedCharsList: string[];
+}
+export declare class NotAllowingTheseCharsStep extends ValidationStep {
+    private readonly options;
+    constructor(options: NotAllowingTheseCharsStepOptions);
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/not-allowing-these-chars-step.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingTheseCharsStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NotAllowingTheseCharsStep extends validation_step_1.ValidationStep {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: this.options.notAllowedCharsList.every((char) => !password.toLowerCase().includes(char.toLowerCase())),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingTheseCharsStep = NotAllowingTheseCharsStep;

package/arch/modules/domain/entities/user/password/steps/numeric-step.d.ts

@@ -0,0 +1,5 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class NumericStep extends ValidationStep {
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/numeric-step.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericStep = void 0;
+const validation_step_1 = require("../validation-step");
+class NumericStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        return {
+            valid: /^\d+$/.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.NumericStep = NumericStep;

package/arch/modules/domain/entities/user/password/steps/with-at-least-one-letter-step.d.ts

@@ -0,0 +1,5 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class WithAtLeastOneLetterStep extends ValidationStep {
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/with-at-least-one-letter-step.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithAtLeastOneLetterStep = void 0;
+const validation_step_1 = require("../validation-step");
+class WithAtLeastOneLetterStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        const regex = /[a-zA-Z]/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.WithAtLeastOneLetterStep = WithAtLeastOneLetterStep;

package/arch/modules/domain/entities/user/password/steps/with-at-least-one-number-digit-step.d.ts

@@ -0,0 +1,5 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class WithAtLeastOneNumberDigitStep extends ValidationStep {
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/with-at-least-one-number-digit-step.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithAtLeastOneNumberDigitStep = void 0;
+const validation_step_1 = require("../validation-step");
+class WithAtLeastOneNumberDigitStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        const regex = /\d/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.WithAtLeastOneNumberDigitStep = WithAtLeastOneNumberDigitStep;

package/arch/modules/domain/entities/user/password/steps/with-at-least-one-special-char-step.d.ts

@@ -0,0 +1,5 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export declare class WithAtLeastOneSpecialCharStep extends ValidationStep {
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/with-at-least-one-special-char-step.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithAtLeastOneSpecialCharStep = void 0;
+const validation_step_1 = require("../validation-step");
+class WithAtLeastOneSpecialCharStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        const regex = /[ `!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~]/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.WithAtLeastOneSpecialCharStep = WithAtLeastOneSpecialCharStep;

package/arch/modules/domain/entities/user/password/steps/with-length-step.d.ts

@@ -0,0 +1,11 @@
+import { ValidationStep } from "../validation-step";
+import { ValidationStepResult } from "../validation-step.type";
+export interface WithLengthStepOptions {
+    min: number;
+    max: number;
+}
+export declare class WithLengthStep extends ValidationStep {
+    private readonly options;
+    constructor(options: WithLengthStepOptions);
+    validate(password: string): ValidationStepResult;
+}

package/arch/modules/domain/entities/user/password/steps/with-length-step.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithLengthStep = void 0;
+const validation_step_1 = require("../validation-step");
+class WithLengthStep extends validation_step_1.ValidationStep {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: password.length >= this.options.min &&
+                password.length <= this.options.max,
+            name: this.name,
+        };
+    }
+}
+exports.WithLengthStep = WithLengthStep;

package/arch/modules/domain/entities/user/password/validation-step.d.ts

@@ -0,0 +1,5 @@
+import { ValidationStepResult } from "./validation-step.type";
+export declare abstract class ValidationStep {
+    abstract validate(password: string): ValidationStepResult;
+    protected get name(): string;
+}

package/arch/modules/domain/entities/user/password/validation-step.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationStep = void 0;
+class ValidationStep {
+    get name() {
+        return this.constructor.name;
+    }
+}
+exports.ValidationStep = ValidationStep;

package/arch/modules/domain/entities/user/password/validation-step.type.d.ts

@@ -0,0 +1,4 @@
+export interface ValidationStepResult {
+    valid: boolean;
+    name: string;
+}

package/arch/modules/domain/entities/user/password/validation-step.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/arch/modules/domain/entities/user/value-objects/email.d.ts

@@ -0,0 +1,6 @@
+import { $string } from "../../$string.abstract";
+export declare class Email extends $string {
+    private readonly email;
+    constructor(email: string);
+    protected validation(): void;
+}

package/arch/modules/domain/entities/user/value-objects/email.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Email = void 0;
+const _string_abstract_1 = require("../../$string.abstract");
+class Email extends _string_abstract_1.$string {
+    constructor(email) {
+        super(email);
+        this.email = email;
+        this.validation();
+    }
+    validation() {
+        if (!/^[\w-\\.]+@([\w-]+\.)+[\w-]{2,4}$/.test(this.email)) {
+            throw new TypeError(`${this.constructor.name} should be valid.`);
+        }
+    }
+}
+exports.Email = Email;

package/arch/modules/domain/entities/user/value-objects/person-name.d.ts

@@ -0,0 +1,7 @@
+import { $string } from "../../$string.abstract";
+export declare class PersonName extends $string {
+    private readonly name;
+    constructor(name: string);
+    get firstName(): string;
+    get lastName(): string;
+}

package/arch/modules/domain/entities/user/value-objects/person-name.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonName = void 0;
+const _string_abstract_1 = require("../../$string.abstract");
+class PersonName extends _string_abstract_1.$string {
+    constructor(name) {
+        super(name);
+        this.name = name;
+    }
+    get firstName() {
+        return this.name.split(" ")[0];
+    }
+    get lastName() {
+        return this.name.split(" ").slice(1).join(" ");
+    }
+}
+exports.PersonName = PersonName;

package/arch/modules/domain/entities/user/value-objects/user-id.d.ts

@@ -0,0 +1,3 @@
+import { UuidAbstract } from "../../uuid.abstract";
+export declare class UserId extends UuidAbstract {
+}

package/arch/modules/domain/entities/user/value-objects/user-id.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserId = void 0;
+const uuid_abstract_1 = require("../../uuid.abstract");
+class UserId extends uuid_abstract_1.UuidAbstract {
+}
+exports.UserId = UserId;