@atlantjs/arch 1.0.0

package/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/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/objects/auth/entities/user/password/validation-step.type.d.ts

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

package/objects/auth/entities/user/password/validation-step.type.js

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

package/objects/auth/entities/user/user-credentials.abstract.d.ts

@@ -0,0 +1,9 @@
+import { PasswordAbstract } from "./password/password.abstract";
+import { Email } from "./value-objects/email";
+import { Username } from "./value-objects/username";
+import { Optional } from "../../../../utils/ducts/optional-type";
+export declare abstract class UserCredentialsAbstract {
+    abstract usernameWrapped: Optional<Username>;
+    abstract emailWrapped: Optional<Email>;
+    abstract passwordWrapped: Optional<PasswordAbstract>;
+}

package/objects/auth/entities/user/user-credentials.abstract.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserCredentialsAbstract = void 0;
+class UserCredentialsAbstract {
+}
+exports.UserCredentialsAbstract = UserCredentialsAbstract;

package/objects/auth/entities/user/user-tokens.abstract.d.ts

@@ -0,0 +1,13 @@
+import { AccessTokenPayload, RefreshTokenPayload } from "../token/access-token.abstract.type";
+import { Token } from "../token/token";
+import { UserTokensPrimitive } from "./user-tokens.abstract.type";
+export declare abstract class UserTokensAbstract {
+    protected readonly _accessToken: Token<AccessTokenPayload>;
+    protected readonly _refreshToken: Token<RefreshTokenPayload>;
+    protected readonly _accessTokenExpirationDate: Date;
+    constructor(_accessToken: Token<AccessTokenPayload>, _refreshToken: Token<RefreshTokenPayload>, _accessTokenExpirationDate: Date);
+    get accessToken(): Token<AccessTokenPayload>;
+    get refreshToken(): Token<RefreshTokenPayload>;
+    get accessTokenExpirationDate(): Date;
+    toPlain(): UserTokensPrimitive;
+}

package/objects/auth/entities/user/user-tokens.abstract.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTokensAbstract = void 0;
+class UserTokensAbstract {
+    constructor(_accessToken, _refreshToken, _accessTokenExpirationDate) {
+        this._accessToken = _accessToken;
+        this._refreshToken = _refreshToken;
+        this._accessTokenExpirationDate = _accessTokenExpirationDate;
+    }
+    get accessToken() {
+        return this._accessToken;
+    }
+    get refreshToken() {
+        return this._refreshToken;
+    }
+    get accessTokenExpirationDate() {
+        return this._accessTokenExpirationDate;
+    }
+    toPlain() {
+        return {
+            accessToken: this.accessToken.toString(),
+            refreshToken: this.refreshToken.toString(),
+            accessTokenExpirationDate: this.accessTokenExpirationDate,
+        };
+    }
+}
+exports.UserTokensAbstract = UserTokensAbstract;

package/objects/auth/entities/user/user-tokens.abstract.type.d.ts

@@ -0,0 +1,5 @@
+export interface UserTokensPrimitive {
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpirationDate: Date;
+}

package/objects/auth/entities/user/user-tokens.abstract.type.js

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

package/objects/auth/entities/user/user.abstract.d.ts

@@ -0,0 +1,21 @@
+import { UserStatusEnum } from "./enums/user-status.enum";
+import { UserCredentialsAbstract } from "./user-credentials.abstract";
+import { PersonName } from "./value-objects/person-name";
+import { UserId } from "./value-objects/user-id";
+import { RoleGroupEnum } from "../../enums/role-group.enum";
+import { RoleEnum } from "../../enums/role.enum";
+import { Optional } from "../../../../utils/ducts/optional-type";
+export declare abstract class UserAbstract {
+    protected _id: UserId;
+    protected _personName: PersonName;
+    protected _status: UserStatusEnum;
+    protected _roleGroups: RoleGroupEnum[];
+    abstract rolesWrapped: Optional<RoleEnum[]>;
+    abstract credentialsWrapped: Optional<UserCredentialsAbstract>;
+    constructor(_id: UserId, _personName: PersonName, _status: UserStatusEnum, _roleGroups: RoleGroupEnum[]);
+    get id(): UserId;
+    get status(): UserStatusEnum;
+    get roleGroups(): RoleGroupEnum[];
+    get personName(): PersonName;
+    isActive(): boolean;
+}

package/objects/auth/entities/user/user.abstract.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAbstract = void 0;
+const user_status_enum_1 = require("./enums/user-status.enum");
+const guardian_1 = require("../../../../utils/type-guard/guardian");
+class UserAbstract {
+    constructor(_id, _personName, _status, _roleGroups) {
+        this._id = _id;
+        this._personName = _personName;
+        this._status = _status;
+        this._roleGroups = _roleGroups;
+    }
+    get id() {
+        return this._id;
+    }
+    get status() {
+        return this._status;
+    }
+    get roleGroups() {
+        return this._roleGroups;
+    }
+    get personName() {
+        return this._personName;
+    }
+    isActive() {
+        return guardian_1.Guardian.isEqual(this._status, user_status_enum_1.UserStatusEnum.active);
+    }
+}
+exports.UserAbstract = UserAbstract;

package/objects/auth/entities/user/value-objects/email.d.ts

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

package/objects/auth/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("../../../../datatypes/entities/$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 Error(`${this.constructor.name} should be valid.`);
+        }
+    }
+}
+exports.Email = Email;

package/objects/auth/entities/user/value-objects/person-name.d.ts

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

package/objects/auth/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("../../../../datatypes/entities/$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/objects/auth/entities/user/value-objects/user-id.d.ts

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

package/objects/auth/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("../../../../datatypes/entities/uuid.abstract");
+class UserId extends uuid_abstract_1.UuidAbstract {
+}
+exports.UserId = UserId;

package/objects/auth/entities/user/value-objects/username.d.ts

@@ -0,0 +1,3 @@
+import { $string } from "../../../../datatypes/entities/$string.abstract";
+export declare class Username extends $string {
+}

package/objects/auth/entities/user/value-objects/username.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Username = void 0;
+const _string_abstract_1 = require("../../../../datatypes/entities/$string.abstract");
+class Username extends _string_abstract_1.$string {
+}
+exports.Username = Username;

package/objects/auth/enums/client.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum ClientEnum {
+    movindentity = "movindentity_client"
+}

package/objects/auth/enums/client.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientEnum = void 0;
+var ClientEnum;
+(function (ClientEnum) {
+    ClientEnum["movindentity"] = "movindentity_client";
+})(ClientEnum || (exports.ClientEnum = ClientEnum = {}));

package/objects/auth/enums/realm.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum RealmEnum {
+    movingapp = "movingapp"
+}

package/objects/auth/enums/realm.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealmEnum = void 0;
+var RealmEnum;
+(function (RealmEnum) {
+    RealmEnum["movingapp"] = "movingapp";
+})(RealmEnum || (exports.RealmEnum = RealmEnum = {}));

package/objects/auth/enums/role-group.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum RoleGroupEnum {
+    freeUser = "free-user",
+    premiumUser = "premium-user"
+}

package/objects/auth/enums/role-group.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleGroupEnum = void 0;
+var RoleGroupEnum;
+(function (RoleGroupEnum) {
+    RoleGroupEnum["freeUser"] = "free-user";
+    RoleGroupEnum["premiumUser"] = "premium-user";
+})(RoleGroupEnum || (exports.RoleGroupEnum = RoleGroupEnum = {}));

package/objects/auth/enums/role.enum.d.ts

@@ -0,0 +1,17 @@
+export declare enum RoleEnum {
+    readRecipe = "read-recipe",
+    writeRecipe = "write-recipe",
+    deleteRecipe = "delete-recipe",
+    manageRecipe = "manage-recipe",
+    readPremiumRecipe = "read-premium-recipe",
+    manageRecipePremium = "manage-recipe-premium",
+    readIngredient = "read-ingredient",
+    writeIngredient = "write-ingredient",
+    deleteIngredient = "delete-ingredient",
+    manageIngredient = "manage-ingredient",
+    readUtensil = "read-utensil",
+    writeUtensil = "write-utensil",
+    deleteUtensil = "delete-utensil",
+    manageUtensil = "manage-utensil",
+    umaAuthorization = "uma_authorization"
+}

package/objects/auth/enums/role.enum.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleEnum = void 0;
+var RoleEnum;
+(function (RoleEnum) {
+    RoleEnum["readRecipe"] = "read-recipe";
+    RoleEnum["writeRecipe"] = "write-recipe";
+    RoleEnum["deleteRecipe"] = "delete-recipe";
+    RoleEnum["manageRecipe"] = "manage-recipe";
+    RoleEnum["readPremiumRecipe"] = "read-premium-recipe";
+    RoleEnum["manageRecipePremium"] = "manage-recipe-premium";
+    RoleEnum["readIngredient"] = "read-ingredient";
+    RoleEnum["writeIngredient"] = "write-ingredient";
+    RoleEnum["deleteIngredient"] = "delete-ingredient";
+    RoleEnum["manageIngredient"] = "manage-ingredient";
+    RoleEnum["readUtensil"] = "read-utensil";
+    RoleEnum["writeUtensil"] = "write-utensil";
+    RoleEnum["deleteUtensil"] = "delete-utensil";
+    RoleEnum["manageUtensil"] = "manage-utensil";
+    RoleEnum["umaAuthorization"] = "uma_authorization";
+})(RoleEnum || (exports.RoleEnum = RoleEnum = {}));

package/objects/auth/enums/token-name-header.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum TokenNameHeaderEnum {
+    authorizationClient = "authorization_client",
+    authorizationUser = "authorization_user"
+}

package/objects/auth/enums/token-name-header.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenNameHeaderEnum = void 0;
+var TokenNameHeaderEnum;
+(function (TokenNameHeaderEnum) {
+    TokenNameHeaderEnum["authorizationClient"] = "authorization_client";
+    TokenNameHeaderEnum["authorizationUser"] = "authorization_user";
+})(TokenNameHeaderEnum || (exports.TokenNameHeaderEnum = TokenNameHeaderEnum = {}));

package/objects/configs/enums/node-envs.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum NodeEnvs {
+    production = "production",
+    homolog = "homolog",
+    development = "development",
+    test = "test"
+}

package/objects/configs/enums/node-envs.enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeEnvs = void 0;
+var NodeEnvs;
+(function (NodeEnvs) {
+    NodeEnvs["production"] = "production";
+    NodeEnvs["homolog"] = "homolog";
+    NodeEnvs["development"] = "development";
+    NodeEnvs["test"] = "test";
+})(NodeEnvs || (exports.NodeEnvs = NodeEnvs = {}));

package/objects/datatypes/entities/$boolean.abstract.d.ts

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

package/objects/datatypes/entities/$boolean.abstract.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$boolean = void 0;
+class $boolean {
+    constructor(value) {
+        this.value = value;
+    }
+    toBoolean() {
+        return this.value;
+    }
+    isEqual(value) {
+        if (value instanceof $boolean) {
+            return value.toBoolean() === this.value;
+        }
+        return this.value === value;
+    }
+    isDifferent(value) {
+        return this.value !== value;
+    }
+}
+exports.$boolean = $boolean;

package/objects/datatypes/entities/$number.abstract.d.ts

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

package/objects/datatypes/entities/$number.abstract.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$number = void 0;
+const guardian_1 = require("../../../utils/type-guard/guardian");
+class $number {
+    constructor(value) {
+        this.value = value;
+        this.validate(value);
+    }
+    toNumber() {
+        return this.value;
+    }
+    isEqual(value) {
+        if (value instanceof $number) {
+            return value.toNumber() === this.value;
+        }
+        return this.value === value;
+    }
+    isDifferent(value) {
+        if (value instanceof $number) {
+            return value.toNumber() !== this.value;
+        }
+        return this.value !== value;
+    }
+    isBiggerThan(value) {
+        if (value instanceof $number) {
+            return value.toNumber() > this.value;
+        }
+        return this.value > value;
+    }
+    isSmallerThan(value) {
+        if (value instanceof $number) {
+            return value.toNumber() < this.value;
+        }
+        return this.value < value;
+    }
+    isEqualOrBiggerThan(value) {
+        if (value instanceof $number) {
+            return value.toNumber() >= this.value;
+        }
+        return this.value >= value;
+    }
+    isEqualOrSmallerThan(value) {
+        if (value instanceof $number) {
+            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);
+    }
+    validate(value) {
+        if (Number.isNaN(value)) {
+            throw new Error(`${this.constructor.name} should be valid.`);
+        }
+    }
+}
+exports.$number = $number;

package/objects/datatypes/entities/$string.abstract.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class $string {
+    private value;
+    constructor(value: string);
+    toString(): string;
+    has(value: string): boolean;
+    extract(start: string, end: string): string;
+    remove(substrings: string[]): string;
+    private sanitize;
+    private validate;
+}