@atlantjs/arch 2.6.3 → 3.0.0

package/@tool-box/tests/builders/errors/dummies/failure.dummy.d.ts

@@ -0,0 +1,3 @@
+import { FailureAbstract } from "../../../../../arch/modules/application/failures/failure.abstract";
+export declare class ApplicationFailureDummy extends FailureAbstract {
+}

package/{tests → @tool-box/tests}/builders/errors/dummies/failure.dummy.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApplicationFailureDummy = void 0;
-const failure_abstract_1 = require("../../../../objects/arch/application/errors/failure.abstract");
+const failure_abstract_1 = require("../../../../../arch/modules/application/failures/failure.abstract");
 class ApplicationFailureDummy extends failure_abstract_1.FailureAbstract {
 }
 exports.ApplicationFailureDummy = ApplicationFailureDummy;

package/@tool-box/tests/builders/generic/dummies/uuid.dummy.d.ts

@@ -0,0 +1,3 @@
+import { UuidAbstract } from "../../../../../arch/modules/domain/entities/uuid.abstract";
+export declare class UuidDummy extends UuidAbstract {
+}

package/{tests → @tool-box/tests}/builders/generic/dummies/uuid.dummy.js

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

package/{tests → @tool-box/tests}/create-fake-usecase.d.ts

@@ -1,5 +1,5 @@
-import { FailureAbstract } from "../objects/arch/application/errors/failure.abstract";
 import { Return } from "../utils/ducts/return-type";
+import { FailureAbstract } from "../../arch/modules/application/failures/failure.abstract";
 export declare class CreateFakeUsecase {
     private _response;
     static new<UsecaseStub>(): UsecaseStub & CreateFakeUsecase;

package/@tool-box/tests/faker/faker.js

@@ -0,0 +1 @@
+"use strict";

package/@tool-box/utils/datatypes/boolean-utils.d.ts

@@ -0,0 +1,8 @@
+interface Boolean {
+    truthy(): boolean;
+    falsy(): boolean;
+    equal(value: boolean): boolean;
+    not(): boolean;
+    and(value: boolean): boolean;
+    or(value: boolean): boolean;
+}

package/@tool-box/utils/datatypes/boolean-utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Boolean.prototype.truthy = function () {
+    return this === true;
+};
+Boolean.prototype.falsy = function () {
+    return this === false || this === undefined;
+};
+Boolean.prototype.not = function () {
+    return !this.valueOf();
+};
+Boolean.prototype.and = function (value) {
+    return this.valueOf() && value;
+};
+Boolean.prototype.or = function (value) {
+    return this.valueOf() || value;
+};
+Boolean.prototype.equal = function (value) {
+    return this === value;
+};

package/{utils → @tool-box/utils}/ducts/common.d.ts

@@ -1,5 +1,5 @@
-export declare const T: unique symbol;
-export declare const Val: unique symbol;
+export declare const SuccessReturn: unique symbol;
+export declare const ValueReturn: unique symbol;
 export declare const FnVal: unique symbol;
 export declare const EmptyArray: readonly any[];
 export type FalseyValues = false | null | undefined | 0 | 0n | "";

package/{utils → @tool-box/utils}/ducts/common.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyArray = exports.FnVal = exports.Val = exports.T = void 0;
+exports.EmptyArray = exports.FnVal = exports.ValueReturn = exports.SuccessReturn = void 0;
 exports.isTruthy = isTruthy;
 const guardian_1 = require("../type-guard/guardian");
-exports.T = Symbol("T");
-exports.Val = Symbol("Val");
+exports.SuccessReturn = Symbol("SuccessReturn");
+exports.ValueReturn = Symbol("ValueReturn");
 exports.FnVal = Symbol("FnVal");
 exports.EmptyArray = Object.freeze([]);
 function isTruthy(val) {

package/{utils → @tool-box/utils}/ducts/optional-type.d.ts

@@ -1,15 +1,15 @@
-import { FalseyValues, IterType, T, Val } from "./common";
+import { FalseyValues, IterType, SuccessReturn, ValueReturn } from "./common";
 export type Something<T> = OptionalType<T> & {
-    [T]: true;
+    [SuccessReturn]: true;
 };
 export type Nothing = OptionalType<never> & {
-    [T]: false;
+    [SuccessReturn]: false;
 };
 export type Optional<T> = OptionalType<T>;
 type From<T> = Exclude<T, Error | FalseyValues>;
 declare class OptionalType<T> {
-    readonly [T]: boolean;
-    readonly [Val]: T;
+    readonly [SuccessReturn]: boolean;
+    readonly [ValueReturn]: T;
     constructor(val: T, something: boolean);
     [Symbol.iterator](this: Optional<T>): IterType<T>;
     hasSomething(this: Optional<T>): this is Something<T>;

package/{utils → @tool-box/utils}/ducts/optional-type.js

@@ -6,34 +6,34 @@ exports.Something = Something;
 const common_1 = require("./common");
 class OptionalType {
     constructor(val, something) {
-        this[common_1.T] = something;
-        this[common_1.Val] = val;
+        this[common_1.SuccessReturn] = something;
+        this[common_1.ValueReturn] = val;
     }
     [Symbol.iterator]() {
-        return this[common_1.T]
-            ? this[common_1.Val][Symbol.iterator]()
+        return this[common_1.SuccessReturn]
+            ? this[common_1.ValueReturn][Symbol.iterator]()
             : common_1.EmptyArray[Symbol.iterator]();
     }
     hasSomething() {
-        return this[common_1.T];
+        return this[common_1.SuccessReturn];
     }
     hasNothing() {
-        return !this[common_1.T];
+        return !this[common_1.SuccessReturn];
     }
     unpack() {
-        if (this[common_1.T]) {
-            return this[common_1.Val];
+        if (this[common_1.SuccessReturn]) {
+            return this[common_1.ValueReturn];
         }
         throw new Error("Failed to unpack optional value. There is nothing in here");
     }
     unpackAnyway() {
-        return this[common_1.Val];
+        return this[common_1.ValueReturn];
     }
     unpackOr(def) {
-        return this[common_1.T] ? this[common_1.Val] : def;
+        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : def;
     }
     unpackOrElse(f) {
-        return this[common_1.T] ? this[common_1.Val] : f();
+        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : f();
     }
 }
 function Optional(val) {

package/{utils → @tool-box/utils}/ducts/return-type.d.ts

@@ -1,5 +1,5 @@
-import { FailureAbstract } from "../../objects/arch/application/errors/failure.abstract";
-import { FalseyValues, IterType, T as SuccessReturn, Val as ValueReturn } from "./common";
+import { FailureAbstract } from "../../../arch/modules/application/failures/failure.abstract";
+import { FalseyValues, IterType, SuccessReturn, ValueReturn } from "./common";
 export type Success<SuccessReturn> = ReturnType<SuccessReturn, never>;
 export type Failure<FailureReturn> = ReturnType<never, FailureReturn>;
 export type Return<T, E> = ReturnType<T, E>;
@@ -16,7 +16,7 @@ export declare class ReturnType<SuccessReturn, FailureReturn> {
     unwrapOr(this: Return<SuccessReturn, FailureReturn>, def: SuccessReturn): SuccessReturn;
     unwrapAnyway(this: Return<SuccessReturn, FailureReturn>): SuccessReturn | FailureReturn | undefined;
 }
-export declare function Result<T>(val: T): Return<From<T>, (T extends Error ? T : never) | (Extract<FalseyValues, T> extends never ? never : null)>;
+export declare function Return<T>(val: T): Return<From<T>, (T extends Error ? T : never) | (Extract<FalseyValues, T> extends never ? never : null)>;
 export declare function Success<SuccessReturn>(successValue?: SuccessReturn): Success<SuccessReturn>;
 export declare function Failure<FailureReturn extends FailureAbstract | null | undefined>(failureValue?: FailureReturn): Failure<FailureReturn>;
 export {};

package/{utils → @tool-box/utils}/ducts/return-type.js

@@ -1,47 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReturnType = void 0;
-exports.Result = Result;
+exports.Return = Return;
 exports.Success = Success;
 exports.Failure = Failure;
 const common_1 = require("./common");
 class ReturnType {
     constructor(value, hasSuccess) {
-        this[common_1.Val] = value;
-        this[common_1.T] = hasSuccess;
+        this[common_1.ValueReturn] = value;
+        this[common_1.SuccessReturn] = hasSuccess;
     }
     [Symbol.iterator]() {
-        return this[common_1.T]
-            ? this[common_1.Val][Symbol.iterator]()
+        return this[common_1.SuccessReturn]
+            ? this[common_1.ValueReturn][Symbol.iterator]()
             : common_1.EmptyArray[Symbol.iterator]();
     }
     hasSuccess() {
-        return this[common_1.T];
+        return this[common_1.SuccessReturn];
     }
     hasFailure() {
-        return !this[common_1.T];
+        return !this[common_1.SuccessReturn];
     }
     unwrap() {
-        if (this[common_1.T]) {
-            return this[common_1.Val];
+        if (this[common_1.SuccessReturn]) {
+            return this[common_1.ValueReturn];
         }
         throw new Error("Failed to unwrap Return. There is failure in here");
     }
     unwrapFail() {
-        if (this[common_1.T]) {
+        if (this[common_1.SuccessReturn]) {
             throw new Error("Failed to unwrapFail Return. There is success in here");
         }
-        return this[common_1.Val];
+        return this[common_1.ValueReturn];
     }
     unwrapOr(def) {
-        return this[common_1.T] ? this[common_1.Val] : def;
+        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : def;
     }
     unwrapAnyway() {
-        return this[common_1.Val];
+        return this[common_1.ValueReturn];
     }
 }
 exports.ReturnType = ReturnType;
-function Result(val) {
+function Return(val) {
     return from(val);
 }
 function Success(successValue) {

package/{utils → @tool-box/utils}/http-client/http-client-response.d.ts

@@ -1,8 +1,8 @@
 import { AxiosResponseHeaders, RawAxiosResponseHeaders } from "axios";
-import { FailureAbstract } from "../../objects/arch/application/errors/failure.abstract";
-import { Newable, ObjectType } from "../datatypes/generic-types";
+import { ObjectType, Newable } from "../datatypes/generic-types";
 import { Optional } from "../ducts/optional-type";
-import { Return } from "./../ducts/return-type";
+import { Return } from "../ducts/return-type";
+import { FailureAbstract } from "../../../arch/modules/application/failures/failure.abstract";
 type Header = RawAxiosResponseHeaders | AxiosResponseHeaders;
 export declare class HttpClientResponse {
     readonly statusCode: number;

package/{utils → @tool-box/utils}/http-client/http-client-response.get-header.failure.d.ts

@@ -1,4 +1,4 @@
-import { FailureAbstract } from "../../objects/arch/application/errors/failure.abstract";
+import { FailureAbstract } from "../../../arch/modules/application/failures/failure.abstract";
 export declare class HttpClientResponseGetHeaderFailure extends FailureAbstract {
     constructor(keyName: string, error?: any);
 }

package/{utils → @tool-box/utils}/http-client/http-client-response.get-header.failure.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientResponseGetHeaderFailure = void 0;
-const failure_abstract_1 = require("../../objects/arch/application/errors/failure.abstract");
+const failure_abstract_1 = require("../../../arch/modules/application/failures/failure.abstract");
 class HttpClientResponseGetHeaderFailure extends failure_abstract_1.FailureAbstract {
     constructor(keyName, error) {
         super({

package/{utils → @tool-box/utils}/http-client/http-client-response.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientResponse = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
-const http_status_codes_enum_1 = require("../../objects/arch/infrastructure/http-status-codes.enum");
 const optional_type_1 = require("../ducts/optional-type");
+const return_type_1 = require("../ducts/return-type");
 const http_client_response_get_header_failure_1 = require("./http-client-response.get-header.failure");
 const guardian_1 = require("../type-guard/guardian");
-const return_type_1 = require("./../ducts/return-type");
+const http_status_codes_enum_1 = require("../../../arch/modules/domain/enums/http-status-codes.enum");
 class HttpClientResponse {
     constructor(statusCode, data, headers) {
         this.statusCode = statusCode;

package/@tool-box/utils/randoms/random-value.d.ts

@@ -0,0 +1,5 @@
+export declare class RandomValue {
+    static randomNumber(min: number, max: number): number;
+    static randomEnumValue<T extends Record<string, unknown>>(anEnum: T): T[keyof T];
+    static randomEnumValueExcept<T extends Record<string, unknown>>(anEnum: T, excepts: Array<T[keyof T]>): T[keyof T];
+}

package/@tool-box/utils/randoms/random-value.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomValue = void 0;
+class RandomValue {
+    static randomNumber(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    static randomEnumValue(anEnum) {
+        const keys = Object.keys(anEnum).filter((x) => Number.isNaN(Number(x)));
+        const randomKeyIndex = Math.floor(Math.random() * keys.length);
+        const randomKey = keys[randomKeyIndex];
+        return anEnum[randomKey];
+    }
+    static randomEnumValueExcept(anEnum, excepts) {
+        const exceptKeys = excepts.map((value) => Object.keys(anEnum).find((key) => anEnum[key] === value));
+        const validKeys = Object.keys(anEnum).filter((key) => Number.isNaN(Number(key)) && !exceptKeys.includes(key));
+        if (validKeys.length === 0) {
+            throw new Error("No valid enum keys available after excluding 'excepts'.");
+        }
+        const randomKeyIndex = Math.floor(Math.random() * validKeys.length);
+        const randomKey = validKeys[randomKeyIndex];
+        return anEnum[randomKey];
+    }
+}
+exports.RandomValue = RandomValue;

package/arch/modules/application/databases/database.factory.abstract.d.ts

@@ -0,0 +1,3 @@
+export interface DatabaseFactoryAbstract {
+    create(...args: unknown[]): any;
+}

package/arch/modules/application/databases/database.helper.abstract.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class DatabaseHelperAbstract {
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+}

package/arch/modules/application/databases/database.helper.abstract.js

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

package/{objects/arch/application/errors → arch/modules/application/failures}/failure.abstract.d.ts

@@ -1,4 +1,4 @@
-import { FailurePrimitive, FailureProps } from "./failure.abstract.type";
+import { FailureProps, FailurePrimitive } from "./failure.abstract.type";
 import { SolidAbstract } from "../../domain/solid.abstract";
 export declare abstract class FailureAbstract implements SolidAbstract {
     private readonly props;

package/{objects/arch/application/errors → arch/modules/application/failures}/failure.abstract.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FailureAbstract = void 0;
-const env_vars_1 = require("../../../../configs/env/env-vars");
-const node_envs_enum_1 = require("../../../configs/enums/node-envs.enum");
-const guardian_1 = require("../../../../utils/type-guard/guardian");
+const guardian_1 = require("../../../../@tool-box/utils/type-guard/guardian");
+const node_envs_enum_1 = require("../../domain/enums/node-envs.enum");
+const env_vars_1 = require("../../../../setup/env/env-vars");
 class FailureAbstract {
     constructor(props) {
         this.props = props;

package/arch/modules/application/failures/unknown-failure.d.ts

@@ -0,0 +1,15 @@
+interface UnknownFailurePrimitive {
+    code: string;
+    message: string;
+}
+interface UnknownFailureProps {
+    className: string;
+    failure: UnknownFailurePrimitive;
+}
+export declare class UnknownFailure {
+    protected readonly unknownCode: string;
+    protected readonly unknownMessage: string;
+    constructor({ className, failure }: UnknownFailureProps);
+    toPlain(): UnknownFailurePrimitive;
+}
+export {};

package/{objects/arch/application/errors/unknown-application-error.js → arch/modules/application/failures/unknown-failure.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownApplicationFailure = void 0;
-class UnknownApplicationFailure {
+exports.UnknownFailure = void 0;
+class UnknownFailure {
     constructor({ className, failure }) {
         this.unknownCode = className.toKebabCase();
         this.unknownMessage = failure.message;
@@ -13,4 +13,4 @@ class UnknownApplicationFailure {
         };
     }
 }
-exports.UnknownApplicationFailure = UnknownApplicationFailure;
+exports.UnknownFailure = UnknownFailure;

package/arch/modules/application/injections.abstract.d.ts

@@ -0,0 +1,11 @@
+import { Injections } from "./injections.abstract.type";
+export declare abstract class InjectionsAbstract {
+    protected abstract _injections: Injections;
+    constructor();
+    private injectControllers;
+    private injectMiddlewares;
+    private injectUsecases;
+    private injectServices;
+    private injectRepositories;
+    private injectProviders;
+}

package/arch/modules/application/injections.abstract.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectionsAbstract = void 0;
+const dependency_injections_1 = require("../../../setup/dependency-injections");
+class InjectionsAbstract {
+    constructor() {
+        this.injectControllers();
+        this.injectMiddlewares();
+        this.injectUsecases();
+        this.injectServices();
+        this.injectRepositories();
+        this.injectProviders();
+    }
+    injectControllers() {
+        this._injections.controllers?.map((controller) => {
+            dependency_injections_1.diContainer.bind(controller).toSelf();
+        });
+    }
+    injectMiddlewares() {
+        this._injections.middlewares?.map((middleware) => {
+            dependency_injections_1.diContainer.bind(middleware).toSelf();
+        });
+    }
+    injectUsecases() {
+        this._injections.usecases?.map((usecase) => {
+            dependency_injections_1.diContainer.bind(usecase.ref).to(usecase.target);
+        });
+    }
+    injectServices() {
+        this._injections.services?.map((service) => {
+            dependency_injections_1.diContainer.bind(service.ref).to(service.target);
+        });
+    }
+    injectRepositories() {
+        this._injections.repositories?.map((repository) => {
+            dependency_injections_1.diContainer.bind(repository.ref).to(repository.target);
+        });
+    }
+    injectProviders() {
+        this._injections.providers?.map((provider) => {
+            dependency_injections_1.diContainer.bind(provider.ref).to(provider.target);
+        });
+    }
+}
+exports.InjectionsAbstract = InjectionsAbstract;

package/arch/modules/application/injections.abstract.type.d.ts

@@ -0,0 +1,17 @@
+import { Newable } from "../../../@tool-box/utils/datatypes/generic-types";
+import { RepositoryAbstract } from "../domain/repositories/repository.abstract";
+import { ServiceAbstract } from "../domain/services/service.abstract";
+import { UsecaseAbstract } from "../domain/usecases/usecase.abstract";
+interface BindTo<T> {
+    ref: Newable<Symbol>;
+    target: Newable<T>;
+}
+export interface Injections {
+    controllers?: [];
+    middlewares?: [];
+    usecases?: BindTo<UsecaseAbstract>[];
+    services?: BindTo<ServiceAbstract>[];
+    repositories?: BindTo<RepositoryAbstract>[];
+    providers?: BindTo<RepositoryAbstract>[];
+}
+export {};

package/arch/modules/domain/entities/$array.abstract.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class $array {
+}

package/arch/modules/domain/entities/$array.abstract.js

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

package/arch/modules/domain/entities/$date.abstract.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class $date {
+}

package/{tests/faker/faker.js → arch/modules/domain/entities/$date.abstract.js}

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

package/{objects/datatypes → arch/modules/domain}/entities/$number.abstract.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$number = void 0;
-const guardian_1 = require("../../../utils/type-guard/guardian");
+const guardian_1 = require("../../../../@tool-box/utils/type-guard/guardian");
 class $number {
     constructor(value) {
         this.value = value;

package/arch/modules/domain/entities/$object.abstract.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class $object {
+}

package/arch/modules/domain/entities/$object.abstract.js

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

package/arch/modules/domain/entities/solid.abstract.d.ts

@@ -0,0 +1,4 @@
+import { ObjectType } from "../../../../@tool-box/utils/datatypes/generic-types";
+export interface SolidAbstract {
+    toPlain(): ObjectType;
+}

package/arch/modules/domain/entities/solid.abstract.js

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