@atlantjs/arch 9.1.2 → 10.0.1

package/objects/datetime/edges/datetime.edge.js

@@ -0,0 +1,133 @@
+import Holidays from "date-holidays";
+import moment from "moment";
+import { _ } from "../../../index";
+import { MonthNameEnum } from "../points/month-name.enum";
+import { WeekDayEnum } from "../points/week-day.enum";
+export class DatetimeEdge {
+    value;
+    date;
+    constructor(value) {
+        this.value = value;
+        let dateValue;
+        if (_.isUndefined(this.value)) {
+            dateValue = new Date(Date.now());
+        }
+        else if (_.isTypeOf(this.value, "string")) {
+            const parsedDate = new Date(this.value);
+            if (Number.isNaN(parsedDate.getTime())) {
+                throw new Error(`Invalid date string: ${this.value}`);
+            }
+            dateValue = parsedDate;
+        }
+        else {
+            dateValue = this.value;
+        }
+        this.date = moment(dateValue);
+        this.validate();
+    }
+    isAfter(other) {
+        return this.date.isAfter(other.toDatePoint());
+    }
+    diffFromNow() {
+        const now = moment();
+        const diffInSeconds = now.diff(this.date, "seconds");
+        const diffInMinutes = now.diff(this.date, "minutes");
+        const diffInHours = now.diff(this.date, "hours");
+        const diffInDays = now.diff(this.date, "days");
+        const diffInMonths = now.diff(this.date, "months");
+        const diffInYears = now.diff(this.date, "years");
+        if (diffInSeconds < 60) {
+            return `Há ${diffInSeconds} segundo${diffInSeconds === 1 ? "" : "s"}.`;
+        }
+        if (diffInMinutes < 60) {
+            return `Há ${diffInMinutes} minuto${diffInMinutes === 1 ? "" : "s"}.`;
+        }
+        if (diffInHours < 24) {
+            return `Há ${diffInHours} hora${diffInHours === 1 ? "" : "s"}.`;
+        }
+        if (diffInDays < 30) {
+            return `Há ${diffInDays} dia${diffInDays === 1 ? "" : "s"}.`;
+        }
+        if (diffInMonths < 12) {
+            return `Há ${diffInMonths} mês${diffInMonths === 1 ? "" : "es"}.`;
+        }
+        return `Há ${diffInYears} ano${diffInYears === 1 ? "" : "s"}.`;
+    }
+    isEquals(other) {
+        return this.date.isSame(other.toDatePoint());
+    }
+    isBefore(other) {
+        return this.date.isBefore(other.toDatePoint());
+    }
+    isBetween(initialDate, finalDate) {
+        return this.date.isBetween(initialDate.toDatePoint(), finalDate.toDatePoint());
+    }
+    isWeekend() {
+        return [WeekDayEnum.sunday, WeekDayEnum.monday].includes(this.getDayOfWeek());
+    }
+    isHoliday() {
+        const holidays = new Holidays("BR");
+        return holidays.isHoliday(this.date.toDate()) !== false;
+    }
+    isBusinessDay() {
+        return !this.isWeekend() && !this.isHoliday();
+    }
+    getDayOfWeek() {
+        const daysOfWeek = [
+            WeekDayEnum.sunday,
+            WeekDayEnum.monday,
+            WeekDayEnum.tuesday,
+            WeekDayEnum.wednesday,
+            WeekDayEnum.thursday,
+            WeekDayEnum.friday,
+            WeekDayEnum.saturday,
+        ];
+        return daysOfWeek[this.date.days()];
+    }
+    getNameOfMonth() {
+        const months = [
+            MonthNameEnum.january,
+            MonthNameEnum.february,
+            MonthNameEnum.march,
+            MonthNameEnum.april,
+            MonthNameEnum.may,
+            MonthNameEnum.june,
+            MonthNameEnum.july,
+            MonthNameEnum.august,
+            MonthNameEnum.september,
+            MonthNameEnum.october,
+            MonthNameEnum.november,
+            MonthNameEnum.december,
+        ];
+        return months[this.date.month()];
+    }
+    getDayOfMonth() {
+        return this.date.date();
+    }
+    getNumberOfMonth() {
+        return this.date.month();
+    }
+    getYear() {
+        return this.date.year();
+    }
+    toISOStringPoint() {
+        return this.date.toISOString();
+    }
+    timestamp() {
+        return this.date.valueOf();
+    }
+    unix() {
+        return this.date.unix();
+    }
+    toDatePoint() {
+        return this.date.toDate();
+    }
+    toYYYYMMDD() {
+        return this.date.format("YYYY-MM-DD");
+    }
+    validate() {
+        if (!moment(this.date).isValid()) {
+            throw new Error(`${this.constructor.name} should be valid.`);
+        }
+    }
+}

package/objects/datetime/points/month-name.enum.d.ts

@@ -0,0 +1,14 @@
+export declare enum MonthNameEnum {
+    january = "january",
+    february = "february",
+    march = "march",
+    april = "april",
+    may = "may",
+    june = "june",
+    july = "july",
+    august = "august",
+    september = "september",
+    october = "october",
+    november = "november",
+    december = "december"
+}

package/objects/datetime/points/month-name.enum.js

@@ -0,0 +1,15 @@
+export var MonthNameEnum;
+(function (MonthNameEnum) {
+    MonthNameEnum["january"] = "january";
+    MonthNameEnum["february"] = "february";
+    MonthNameEnum["march"] = "march";
+    MonthNameEnum["april"] = "april";
+    MonthNameEnum["may"] = "may";
+    MonthNameEnum["june"] = "june";
+    MonthNameEnum["july"] = "july";
+    MonthNameEnum["august"] = "august";
+    MonthNameEnum["september"] = "september";
+    MonthNameEnum["october"] = "october";
+    MonthNameEnum["november"] = "november";
+    MonthNameEnum["december"] = "december";
+})(MonthNameEnum || (MonthNameEnum = {}));

package/objects/datetime/points/week-day.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum WeekDayEnum {
+    sunday = "sunday",
+    monday = "monday",
+    tuesday = "tuesday",
+    wednesday = "wednesday",
+    thursday = "thursday",
+    friday = "friday",
+    saturday = "saturday"
+}

package/objects/datetime/points/week-day.enum.js

@@ -0,0 +1,10 @@
+export var WeekDayEnum;
+(function (WeekDayEnum) {
+    WeekDayEnum["sunday"] = "sunday";
+    WeekDayEnum["monday"] = "monday";
+    WeekDayEnum["tuesday"] = "tuesday";
+    WeekDayEnum["wednesday"] = "wednesday";
+    WeekDayEnum["thursday"] = "thursday";
+    WeekDayEnum["friday"] = "friday";
+    WeekDayEnum["saturday"] = "saturday";
+})(WeekDayEnum || (WeekDayEnum = {}));

package/objects/failure/edges/failure.sketch.edge.d.ts

@@ -0,0 +1,8 @@
+import { FailureSketchEdgeProps, FailureSketchPolygon } from "./failure.sketch.polygon";
+export declare abstract class FailureSketchEdge {
+    private readonly props;
+    protected readonly _code: string;
+    protected readonly _message: string;
+    constructor(props: FailureSketchEdgeProps);
+    toPolygon(): FailureSketchPolygon;
+}

package/objects/failure/edges/failure.sketch.edge.js

@@ -0,0 +1,23 @@
+import { _ } from "../../../index";
+import { NodeEnvs } from "../../@common/points/node-envs.enum";
+export class FailureSketchEdge {
+    props;
+    _code;
+    _message;
+    constructor(props) {
+        this.props = props;
+        this._code = this.props.failureClass.name.toKebabCase();
+        if (_.and(_.isEqual(process.env.ENVIRONMENT, NodeEnvs.development), _.isNotNullOrUndefined(this.props.stackTrace))) {
+            this._message = `${this.props.message} - ${this.props.stackTrace.toString()}`;
+        }
+        else {
+            this._message = this.props.message;
+        }
+    }
+    toPolygon() {
+        return {
+            code: this._code,
+            message: this._message,
+        };
+    }
+}

package/objects/failure/edges/failure.sketch.polygon.d.ts

@@ -0,0 +1,9 @@
+export interface FailureSketchPolygon {
+    code: string;
+    message: string;
+}
+export interface FailureSketchEdgeProps {
+    failureClass: Function;
+    message: string;
+    stackTrace?: any;
+}

package/objects/failure/edges/failure.sketch.polygon.js

@@ -0,0 +1 @@
+export {};

package/objects/password/password.edge.d.ts

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

package/objects/password/password.edge.js

@@ -0,0 +1,38 @@
+import { _ } from "../../@tool-box/utils/type-guard/guardian";
+import { WithAtLeastOneLetterStep } from "./steps/with-at-least-one-letter-step";
+import { WithAtLeastOneNumberDigitStep } from "./steps/with-at-least-one-number-digit-step";
+import { WithAtLeastOneSpecialCharStep } from "./steps/with-at-least-one-special-char-step";
+import { WithLengthStep } from "./steps/with-length-step";
+export class PasswordEdge {
+    password;
+    validationSteps = [
+        new WithAtLeastOneLetterStep(),
+        new WithAtLeastOneNumberDigitStep(),
+        new WithAtLeastOneSpecialCharStep(),
+        new WithLengthStep({ min: 6, max: 999 }),
+    ];
+    constructor(password) {
+        this.password = password;
+        const { valid, validationStepsResults } = this.validate(this.password);
+        if (valid.falsy()) {
+            throw new TypeError(`Password is invalid: ${validationStepsResults.map((result) => result.name)}`);
+        }
+    }
+    validate(password) {
+        if (_.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;
+    }
+}

package/{arch/modules/domain/entities/user/password/password.abstract.type.d.ts → objects/password/password.polygon.d.ts}

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

package/objects/password/password.polygon.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,8 +1,6 @@
-"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 {
+import { ValidationStep } from "../validation-step";
+export class NotAllowingConsecutiveCharsStep extends ValidationStep {
+    params;
     constructor(params) {
         super();
         this.params = params;
@@ -31,4 +29,3 @@ class NotAllowingConsecutiveCharsStep extends validation_step_1.ValidationStep {
         return Math.max(numberOfConsecutiveChars, maxNumberOfConsecutiveChars);
     }
 }
-exports.NotAllowingConsecutiveCharsStep = NotAllowingConsecutiveCharsStep;

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

@@ -1,8 +1,6 @@
-"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 {
+import { ValidationStep } from "../validation-step";
+export class NotAllowingDateStep extends ValidationStep {
+    notAllowedDate;
     constructor(notAllowedDate) {
         super();
         this.notAllowedDate = notAllowedDate;
@@ -58,4 +56,3 @@ class NotAllowingDateStep extends validation_step_1.ValidationStep {
         ];
     }
 }
-exports.NotAllowingDateStep = NotAllowingDateStep;

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

@@ -1,8 +1,6 @@
-"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 {
+import { ValidationStep } from "../validation-step";
+export class NotAllowingPhoneStep extends ValidationStep {
+    notAllowedPhone;
     constructor(phone) {
         super();
         const matches = phone.match(/\d{4}\-?\d{4}$/);
@@ -24,4 +22,3 @@ class NotAllowingPhoneStep extends validation_step_1.ValidationStep {
         };
     }
 }
-exports.NotAllowingPhoneStep = NotAllowingPhoneStep;

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

@@ -1,8 +1,6 @@
-"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 {
+import { ValidationStep } from "../validation-step";
+export class NotAllowingRepeatedCharsStep extends ValidationStep {
+    options;
     constructor(options) {
         super();
         this.options = options;
@@ -31,4 +29,3 @@ class NotAllowingRepeatedCharsStep extends validation_step_1.ValidationStep {
         return Math.max(numberOfRepeatedChars, maxNumberOfRepeatedChars);
     }
 }
-exports.NotAllowingRepeatedCharsStep = NotAllowingRepeatedCharsStep;

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

@@ -1,8 +1,6 @@
-"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 {
+import { ValidationStep } from "../validation-step";
+export class NotAllowingStringStep extends ValidationStep {
+    forbiddenString;
     constructor(forbiddenString) {
         super();
         this.forbiddenString = forbiddenString;
@@ -16,4 +14,3 @@ class NotAllowingStringStep extends validation_step_1.ValidationStep {
         };
     }
 }
-exports.NotAllowingStringStep = NotAllowingStringStep;

package/objects/password/steps/not-allowing-these-chars-step.js

@@ -0,0 +1,14 @@
+import { ValidationStep } from "../validation-step";
+export class NotAllowingTheseCharsStep extends ValidationStep {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: this.options.notAllowedCharsList.every((char) => !password.toLowerCase().includes(char.toLowerCase())),
+            name: this.name,
+        };
+    }
+}

package/objects/password/steps/numeric-step.js

@@ -0,0 +1,9 @@
+import { ValidationStep } from "../validation-step";
+export class NumericStep extends ValidationStep {
+    validate(password) {
+        return {
+            valid: /^\d+$/.test(password),
+            name: this.name,
+        };
+    }
+}

package/objects/password/steps/with-at-least-one-letter-step.js

@@ -0,0 +1,10 @@
+import { ValidationStep } from "../validation-step";
+export class WithAtLeastOneLetterStep extends ValidationStep {
+    validate(password) {
+        const regex = /[a-zA-Z]/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}

package/objects/password/steps/with-at-least-one-number-digit-step.js

@@ -0,0 +1,10 @@
+import { ValidationStep } from "../validation-step";
+export class WithAtLeastOneNumberDigitStep extends ValidationStep {
+    validate(password) {
+        const regex = /\d/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}

package/objects/password/steps/with-at-least-one-special-char-step.js

@@ -0,0 +1,10 @@
+import { ValidationStep } from "../validation-step";
+export class WithAtLeastOneSpecialCharStep extends ValidationStep {
+    validate(password) {
+        const regex = /[ `!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~]/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}

package/{arch/modules/domain/entities/user → objects}/password/steps/with-length-step.js

@@ -1,8 +1,6 @@
-"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 {
+import { ValidationStep } from "../validation-step";
+export class WithLengthStep extends ValidationStep {
+    options;
     constructor(options) {
         super();
         this.options = options;
@@ -15,4 +13,3 @@ class WithLengthStep extends validation_step_1.ValidationStep {
         };
     }
 }
-exports.WithLengthStep = WithLengthStep;

package/objects/password/validation-step.js

@@ -0,0 +1,5 @@
+export class ValidationStep {
+    get name() {
+        return this.constructor.name;
+    }
+}

package/objects/password/validation-step.type.js

@@ -0,0 +1 @@
+export {};

package/objects/primitives/boolean.edge.sketch.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class BooleanEdgeSketch {
+    private value;
+    constructor(value: boolean);
+    toPoint(): boolean;
+    isEqual(value: BooleanEdgeSketch | boolean): boolean;
+    isDifferent(value: boolean): boolean;
+}

package/objects/primitives/boolean.edge.sketch.js

@@ -0,0 +1,18 @@
+export class BooleanEdgeSketch {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toPoint() {
+        return this.value;
+    }
+    isEqual(value) {
+        if (value instanceof BooleanEdgeSketch) {
+            return value.toPoint() === this.value;
+        }
+        return this.value === value;
+    }
+    isDifferent(value) {
+        return this.value !== value;
+    }
+}

package/objects/primitives/datetime.edge.sketch.d.ts

@@ -0,0 +1,3 @@
+import { DatetimeEdge } from "../datetime/edges/datetime.edge";
+export declare abstract class DatetimeEdgeSketch extends DatetimeEdge {
+}

package/objects/primitives/datetime.edge.sketch.js

@@ -0,0 +1,3 @@
+import { DatetimeEdge } from "../datetime/edges/datetime.edge";
+export class DatetimeEdgeSketch extends DatetimeEdge {
+}

package/objects/primitives/number.edge.sketch.d.ts

@@ -0,0 +1,13 @@
+export declare abstract class NumberEdgeSketch {
+    private value;
+    constructor(value: number);
+    toNumber(): number;
+    isEqual(value: number | NumberEdgeSketch): boolean;
+    isDifferent(value: number | NumberEdgeSketch): boolean;
+    isBiggerThan(value: number | NumberEdgeSketch): boolean;
+    isSmallerThan(value: number | NumberEdgeSketch): boolean;
+    isEqualOrBiggerThan(value: number | NumberEdgeSketch): boolean;
+    isEqualOrSmallerThan(value: number | NumberEdgeSketch): boolean;
+    isBetween(min: number | NumberEdgeSketch, max: number | NumberEdgeSketch): boolean;
+    private validate;
+}

package/{arch/modules/domain/entities/$number.abstract.js → objects/primitives/number.edge.sketch.js}

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$number = void 0;
-const guardian_1 = require("../../../../@tool-box/utils/type-guard/guardian");
-class $number {
+import { _ } from "../../@tool-box/utils/type-guard/guardian";
+export class NumberEdgeSketch {
+    value;
     constructor(value) {
         this.value = value;
         this.validate(value);
@@ -11,45 +9,45 @@ class $number {
         return this.value;
     }
     isEqual(value) {
-        if (value instanceof $number) {
+        if (value instanceof NumberEdgeSketch) {
             return value.toNumber() === this.value;
         }
         return this.value === value;
     }
     isDifferent(value) {
-        if (value instanceof $number) {
+        if (value instanceof NumberEdgeSketch) {
             return value.toNumber() !== this.value;
         }
         return this.value !== value;
     }
     isBiggerThan(value) {
-        if (value instanceof $number) {
+        if (value instanceof NumberEdgeSketch) {
             return value.toNumber() > this.value;
         }
         return this.value > value;
     }
     isSmallerThan(value) {
-        if (value instanceof $number) {
+        if (value instanceof NumberEdgeSketch) {
             return value.toNumber() < this.value;
         }
         return this.value < value;
     }
     isEqualOrBiggerThan(value) {
-        if (value instanceof $number) {
+        if (value instanceof NumberEdgeSketch) {
             return value.toNumber() >= this.value;
         }
         return this.value >= value;
     }
     isEqualOrSmallerThan(value) {
-        if (value instanceof $number) {
+        if (value instanceof NumberEdgeSketch) {
             return value.toNumber() <= this.value;
         }
         return this.value <= value;
     }
     isBetween(min, max) {
-        const minimus = min instanceof $number ? min.toNumber() : min;
-        const maximus = max instanceof $number ? max.toNumber() : max;
-        return guardian_1.Guardian.isBetween(this.value, minimus, maximus);
+        const minimus = min instanceof NumberEdgeSketch ? min.toNumber() : min;
+        const maximus = max instanceof NumberEdgeSketch ? max.toNumber() : max;
+        return _.isBetween(this.value, minimus, maximus);
     }
     validate(value) {
         if (Number.isNaN(value)) {
@@ -57,4 +55,3 @@ class $number {
         }
     }
 }
-exports.$number = $number;

package/{arch/modules/domain/entities/$string.abstract.d.ts → objects/primitives/string.edge.sketch.d.ts}

@@ -1,4 +1,4 @@
-export declare abstract class $string {
+export declare abstract class StringEdgeSketch {
     private value;
     constructor(value: string);
     toString(): string;

package/{arch/modules/domain/entities/$string.abstract.js → objects/primitives/string.edge.sketch.js}

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$string = void 0;
-class $string {
+export class StringEdgeSketch {
+    value;
     constructor(value) {
         this.value = value;
         this.sanitize();
@@ -31,4 +29,3 @@ class $string {
         }
     }
 }
-exports.$string = $string;