@atlantjs/arch 15.7.7 → 15.7.8

package/src/@tool-box/utils/ducts/optional-type.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nothing = void 0;
+exports.Optional = Optional;
+const common_1 = require("../../../@tool-box/utils/ducts/common");
+class OptionalType {
+    [common_1.SuccessReturn];
+    [common_1.ValueReturn];
+    /**
+     * Cria uma nova instância de OptionalType.
+     * @param val Valor interno.
+     * @param something Indica presença de valor.
+     * @example
+     * const some = new (class extends OptionalType<string> {})("x", true);
+     */
+    constructor(val, something) {
+        this[common_1.SuccessReturn] = something;
+        this[common_1.ValueReturn] = val;
+    }
+    /**
+     * Permite iteração quando houver valor iterável.
+     * @example
+     * const maybeArr = Optional([1, 2, 3]);
+     * for (const n of maybeArr) {
+     *   // 1, 2, 3
+     * }
+     */
+    [Symbol.iterator]() {
+        return this[common_1.SuccessReturn]
+            ? this[common_1.ValueReturn][Symbol.iterator]()
+            : common_1.EmptyArray[Symbol.iterator]();
+    }
+    /**
+     * Verifica se existe valor.
+     * @returns true se houver valor.
+     * @example
+     * Optional("abc").hasSomething(); // true
+     * Optional("").hasSomething(); // false
+     */
+    hasSomething() {
+        return this[common_1.SuccessReturn];
+    }
+    /**
+     * Verifica se não existe valor.
+     * @returns true se não houver valor.
+     * @example
+     * Optional(null).hasNothing(); // true
+     */
+    hasNothing() {
+        return !this[common_1.SuccessReturn];
+    }
+    /**
+     * Retorna o valor interno.
+     * @throws {Error} Se não houver valor.
+     * @example
+     * Optional(10).unpack(); // 10
+     */
+    unpack() {
+        if (this[common_1.SuccessReturn]) {
+            return this[common_1.ValueReturn];
+        }
+        throw new Error("Failed to unpack optional value. There is nothing in here");
+    }
+    /**
+     * Retorna o valor interno mesmo quando vazio.
+     * @returns Valor interno ou undefined.
+     * @example
+     * Optional("x").unpackAnyway(); // "x"
+     * Optional("").unpackAnyway(); // undefined
+     */
+    unpackAnyway() {
+        return this[common_1.ValueReturn];
+    }
+    /**
+     * Retorna o valor interno ou valor padrão.
+     * @param def Valor padrão.
+     * @example
+     * Optional("").unpackOr("default"); // "default"
+     */
+    unpackOr(def) {
+        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : def;
+    }
+    /**
+     * Retorna o valor interno ou calcula valor padrão sob demanda.
+     * @param f Função para gerar valor padrão.
+     * @example
+     * Optional("").unpackOrElse(() => "fallback"); // "fallback"
+     */
+    unpackOrElse(f) {
+        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : f();
+    }
+}
+/**
+ * Cria um Optional a partir de um valor.
+ * Valores falsey e Error resultam em Nothing.
+ * @param val Valor de entrada.
+ * @example
+ * Optional("abc").hasSomething(); // true
+ * Optional(0).hasNothing(); // true
+ */
+function Optional(val) {
+    return from(val);
+}
+/**
+ * Cria um Optional no estado Something.
+ * @param val Valor presente.
+ * @example
+ * const some = Something("ok");
+ */
+function Something(val) {
+    return new OptionalType(val, true);
+}
+/**
+ * Singleton representando ausência de valor.
+ * @example
+ * Nothing.hasNothing(); // true
+ */
+exports.Nothing = Object.freeze(new OptionalType(undefined, false));
+/**
+ * Converte valor para Optional conforme regra de truthy.
+ * @param val Valor de entrada.
+ * @example
+ * from("x").hasSomething(); // true
+ * from(false).hasNothing(); // true
+ */
+function from(val) {
+    return (0, common_1.isTruthy)(val) && !(val instanceof Error)
+        ? Something(val)
+        : exports.Nothing;
+}

package/src/@tool-box/utils/ducts/return-type.d.ts

@@ -1,5 +1,5 @@
-import { FalseyValues, IterType, SuccessReturn as SuccessReturnSymbol, ValueReturn as ValueReturnSymbol } from "#/@tool-box/utils/ducts/common";
-import { FailureAbstract } from "#/objects/failure/edges/failure.abstract";
+import { FalseyValues, IterType, SuccessReturn as SuccessReturnSymbol, ValueReturn as ValueReturnSymbol } from "../../../@tool-box/utils/ducts/common";
+import { FailureAbstract } from "../../../objects/failure/edges/failure.abstract";
 export type Success<TSuccess> = ReturnType<TSuccess, never>;
 export type Failure<TFailure> = ReturnType<never, TFailure>;
 export type Return<TSuccess, TFailure> = ReturnType<TSuccess, TFailure>;
@@ -20,4 +20,3 @@ export declare function Return<T>(val: T): Return<From<T>, (T extends Error ? T
 export declare function Success<TSuccess>(successValue?: TSuccess): Success<TSuccess>;
 export declare function Failure<TFailure extends FailureAbstract | Error | null | undefined>(failureValue?: TFailure): Failure<TFailure>;
 export {};
-//# sourceMappingURL=return-type.d.ts.map

package/src/@tool-box/utils/ducts/return-type.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnType = void 0;
+exports.Return = Return;
+exports.Success = Success;
+exports.Failure = Failure;
+const common_1 = require("../../../@tool-box/utils/ducts/common");
+class ReturnType {
+    [common_1.SuccessReturn];
+    [common_1.ValueReturn];
+    constructor(value, hasSuccess) {
+        this[common_1.ValueReturn] = value;
+        this[common_1.SuccessReturn] = hasSuccess;
+    }
+    [Symbol.iterator]() {
+        if (!this[common_1.SuccessReturn]) {
+            return common_1.EmptyArray[Symbol.iterator]();
+        }
+        const value = this[common_1.ValueReturn];
+        if (value !== null &&
+            value !== undefined &&
+            typeof value[Symbol.iterator] ===
+                "function") {
+            return value[Symbol.iterator]();
+        }
+        return common_1.EmptyArray[Symbol.iterator]();
+    }
+    hasSuccess() {
+        return this[common_1.SuccessReturn];
+    }
+    hasFailure() {
+        return !this[common_1.SuccessReturn];
+    }
+    unwrap() {
+        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.SuccessReturn]) {
+            throw new Error("Failed to unwrapFail Return. There is success in here");
+        }
+        return this[common_1.ValueReturn];
+    }
+    unwrapOr(def) {
+        return this[common_1.SuccessReturn]
+            ? this[common_1.ValueReturn]
+            : def;
+    }
+    unwrapAnyway() {
+        return this[common_1.ValueReturn];
+    }
+}
+exports.ReturnType = ReturnType;
+function Return(val) {
+    return from(val);
+}
+function Success(successValue) {
+    return new ReturnType(successValue, true);
+}
+function Failure(failureValue) {
+    return new ReturnType(failureValue, false);
+}
+function from(val) {
+    return (0, common_1.isTruthy)(val)
+        ? new ReturnType(val, !(val instanceof Error))
+        : Failure(null);
+}

package/src/@tool-box/utils/http-provider/http-provider-failure-response.d.ts

@@ -1,4 +1,4 @@
-import { FailureAbstract } from "#/objects/failure/edges/failure.abstract";
+import { FailureAbstract } from "../../../objects/failure/edges/failure.abstract";
 export declare class HttpProviderFailureResponse extends FailureAbstract {
     protected readonly _message: string;
     protected readonly _statusCode: number;
@@ -6,4 +6,3 @@ export declare class HttpProviderFailureResponse extends FailureAbstract {
     constructor(_message: string, _statusCode: number, _request: unknown);
     hasStatus(status: number): boolean;
 }
-//# sourceMappingURL=http-provider-failure-response.d.ts.map

package/src/@tool-box/utils/http-provider/http-provider-failure-response.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpProviderFailureResponse = void 0;
+const failure_abstract_1 = require("../../../objects/failure/edges/failure.abstract");
+class HttpProviderFailureResponse extends failure_abstract_1.FailureAbstract {
+    _message;
+    _statusCode;
+    _request;
+    constructor(_message, _statusCode, _request) {
+        super({
+            failureClass: HttpProviderFailureResponse,
+            message: `${_message}`,
+        });
+        this._message = _message;
+        this._statusCode = _statusCode;
+        this._request = _request;
+    }
+    hasStatus(status) {
+        return this._statusCode === status;
+    }
+}
+exports.HttpProviderFailureResponse = HttpProviderFailureResponse;

package/src/@tool-box/utils/http-provider/http-provider-success-response.d.ts

@@ -1,4 +1,4 @@
-import { Newable, ObjectType } from "#/@tool-box/utils/datatypes/generic-types";
+import { Newable, ObjectType } from "../../../@tool-box/utils/datatypes/generic-types";
 export declare class HttpProviderSuccessResponse {
     readonly statusCode: number;
     private readonly data;
@@ -6,4 +6,3 @@ export declare class HttpProviderSuccessResponse {
     hasStatus(status: number): boolean;
     getData<T extends ObjectType>(dataType: Newable<T>): Promise<T>;
 }
-//# sourceMappingURL=http-provider-success-response.d.ts.map

package/src/@tool-box/utils/http-provider/http-provider-success-response.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpProviderSuccessResponse = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+class HttpProviderSuccessResponse {
+    statusCode;
+    data;
+    constructor(statusCode, data) {
+        this.statusCode = statusCode;
+        this.data = data;
+    }
+    hasStatus(status) {
+        return this.statusCode === status;
+    }
+    async getData(dataType) {
+        const data = (0, class_transformer_1.plainToClass)(dataType, this.data);
+        await (0, class_validator_1.validateOrReject)(data);
+        return data;
+    }
+}
+exports.HttpProviderSuccessResponse = HttpProviderSuccessResponse;

package/src/@tool-box/utils/http-provider/http-provider.d.ts

@@ -1,8 +1,8 @@
 import { AxiosInstance } from "axios";
-import { Return } from "#/@tool-box/utils/ducts/return-type";
-import { HttpProviderFailureResponse } from "#/@tool-box/utils/http-provider/http-provider-failure-response";
-import { HttpProviderSuccessResponse } from "#/@tool-box/utils/http-provider/http-provider-success-response";
-import { RequestAbstract } from "#/shared/request.abstract";
+import { Return } from "../../../@tool-box/utils/ducts/return-type";
+import { HttpProviderFailureResponse } from "../../../@tool-box/utils/http-provider/http-provider-failure-response";
+import { HttpProviderSuccessResponse } from "../../../@tool-box/utils/http-provider/http-provider-success-response";
+import { RequestAbstract } from "../../../shared/request.abstract";
 export declare class HttpProvider {
     readonly baseUrl: string;
     protected readonly axios: AxiosInstance;
@@ -15,4 +15,3 @@ export declare class HttpProvider {
     private buildFailureFromResponse;
     private extractErrorMessage;
 }
-//# sourceMappingURL=http-provider.d.ts.map

package/src/@tool-box/utils/http-provider/http-provider.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const return_type_1 = require("../../../@tool-box/utils/ducts/return-type");
+const http_provider_failure_response_1 = require("../../../@tool-box/utils/http-provider/http-provider-failure-response");
+const http_provider_success_response_1 = require("../../../@tool-box/utils/http-provider/http-provider-success-response");
+const http_status_codes_point_1 = require("../../../objects/@common/points/http-status-codes.point");
+function replaceUrlParams(url, params) {
+    return url.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+        const value = params[key];
+        if (value === undefined) {
+            throw new Error(`Parâmetro "${key}" não encontrado em params`);
+        }
+        return encodeURIComponent(String(value));
+    });
+}
+class HttpProvider {
+    baseUrl;
+    axios;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+        this.axios = axios_1.default.create({
+            baseURL: baseUrl,
+        });
+    }
+    setDefaultHeader(key, value) {
+        this.axios.defaults.headers.common[key] = value;
+    }
+    removeDefaultHeader(key) {
+        delete this.axios.defaults.headers.common[key];
+    }
+    setBearerToken(token) {
+        this.setDefaultHeader("Authorization", `Bearer ${token}`);
+    }
+    async request(request) {
+        let resolvedUrl = request.url;
+        try {
+            if (request.params) {
+                resolvedUrl = replaceUrlParams(resolvedUrl, request.params);
+            }
+            const response = await this.axios.request({
+                url: resolvedUrl,
+                method: request.method,
+                params: request.queryParams,
+                data: request.payload,
+                headers: request.headers,
+                responseType: request.responseType,
+                validateStatus: () => true,
+            });
+            if (!this.isSuccessStatus(response.status)) {
+                return (0, return_type_1.Failure)(this.buildFailureFromResponse(response, resolvedUrl));
+            }
+            return (0, return_type_1.Success)(new http_provider_success_response_1.HttpProviderSuccessResponse(response.status, response.data));
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response) {
+                return (0, return_type_1.Failure)(this.buildFailureFromResponse(error.response, resolvedUrl));
+            }
+            return (0, return_type_1.Failure)(new http_provider_failure_response_1.HttpProviderFailureResponse("The request could not be completed. The server is currently unavailable.", http_status_codes_point_1.HttpStatusCodes.SERVICE_UNAVAILABLE, resolvedUrl));
+        }
+    }
+    isSuccessStatus(status) {
+        return status >= 200 && status < 300;
+    }
+    buildFailureFromResponse(response, url) {
+        return new http_provider_failure_response_1.HttpProviderFailureResponse(this.extractErrorMessage(response.data, response.statusText), response.status, url);
+    }
+    extractErrorMessage(data, fallback) {
+        if (typeof data === "string" && data.trim().length > 0) {
+            return data;
+        }
+        if (data && typeof data === "object") {
+            const maybeMessage = data.message;
+            if (typeof maybeMessage === "string" && maybeMessage.trim().length > 0) {
+                return maybeMessage;
+            }
+        }
+        return fallback?.trim()
+            ? fallback
+            : "The request failed. Please try again later.";
+    }
+}
+exports.HttpProvider = HttpProvider;

package/src/@tool-box/utils/logger/index.d.ts

@@ -2,4 +2,3 @@ export declare const c: {
     log: (prefix: string, value: unknown) => void;
     warn: (prefix: string, value: unknown) => void;
 };
-//# sourceMappingURL=index.d.ts.map

package/src/@tool-box/utils/logger/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c = void 0;
+exports.c = {
+    log: (prefix, value) => {
+        console.log(prefix, JSON.stringify(value, (key, val) => {
+            if (val && typeof val === "object" && val.constructor !== Object) {
+                const symbolKeys = Object.getOwnPropertySymbols(val);
+                const symbolProps = symbolKeys.reduce((acc, sym) => {
+                    acc[sym.toString()] = val[sym];
+                    return acc;
+                }, {});
+                return { ...val, ...symbolProps };
+            }
+            return val;
+        }, 2));
+    },
+    warn: (prefix, value) => {
+        console.warn(prefix, JSON.stringify(value, (key, val) => {
+            if (val && typeof val === "object" && val.constructor !== Object) {
+                const symbolKeys = Object.getOwnPropertySymbols(val);
+                const symbolProps = symbolKeys.reduce((acc, sym) => {
+                    acc[sym.toString()] = val[sym];
+                    return acc;
+                }, {});
+                return { ...val, ...symbolProps };
+            }
+            return val;
+        }, 2));
+    },
+};

package/src/@tool-box/utils/map/map.abstract.d.ts

@@ -43,4 +43,3 @@ export declare abstract class MapAbstract<K, V> {
     protected delete(key: K): boolean;
     protected clear(): void;
 }
-//# sourceMappingURL=map.abstract.d.ts.map

package/src/@tool-box/utils/map/map.abstract.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapAbstract = void 0;
+class MapAbstract {
+    /**
+     * Mantido por compatibilidade.
+     * Retorna o valor mapeado para a chave ou lança erro.
+     */
+    toMap(key) {
+        return this.getOrThrow(key);
+    }
+    /**
+     * Retorna o valor mapeado para a chave ou lança erro.
+     */
+    get(key) {
+        return this.getOrThrow(key);
+    }
+    /**
+     * Retorna true se a chave existir no map.
+     */
+    has(key) {
+        return this.map.has(key);
+    }
+    /**
+     * Retorna o valor ou undefined.
+     */
+    getOrUndefined(key) {
+        return this.map.get(key);
+    }
+    /**
+     * Retorna a quantidade de itens.
+     */
+    size() {
+        return this.map.size;
+    }
+    /**
+     * Retorna true se o map estiver vazio.
+     */
+    isEmpty() {
+        return this.map.size === 0;
+    }
+    /**
+     * Retorna todas as chaves.
+     */
+    keys() {
+        return Array.from(this.map.keys());
+    }
+    /**
+     * Retorna todos os valores.
+     */
+    values() {
+        return Array.from(this.map.values());
+    }
+    /**
+     * Retorna todas as entradas.
+     */
+    entries() {
+        return Array.from(this.map.entries());
+    }
+    getOrDefault(key, defaultValue) {
+        // bug fix: usar has() evita confundir chave existente com valor undefined
+        if (!this.map.has(key)) {
+            return defaultValue;
+        }
+        return this.map.get(key);
+    }
+    getOrThrow(key, errorMessage = "Key not mapped") {
+        // bug fix: validar existência da chave com has(), não pelo valor retornado
+        if (!this.map.has(key)) {
+            throw new Error(errorMessage);
+        }
+        return this.map.get(key);
+    }
+    set(key, value) {
+        this.map.set(key, value);
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+exports.MapAbstract = MapAbstract;

package/src/@tool-box/utils/random/random.d.ts

@@ -171,4 +171,3 @@ export declare class Random {
      */
     static futureDate(daysAhead?: number): Date;
 }
-//# sourceMappingURL=random.d.ts.map