sm-utility 2.4.13 → 2.4.15

package/errors/axiosErrors.d.ts

@@ -0,0 +1,36 @@
+import { AxiosError } from '../request';
+export declare const REQUEST_ERRORS: {
+    TIMEOUT: string;
+    NOT_FOUND: string;
+    UNAUTHORIZED: string;
+    UNEXPECTED: string;
+    BAD_REQUEST: string;
+    API_TIMEOUT: string;
+    HUB_TIMEOUT: string;
+};
+export interface AxiosErrorHolder {
+    error: Error;
+    message: string | undefined;
+    type: string | undefined;
+}
+export declare class AxiosErrHandler {
+    static extract(error: AxiosError): AxiosErrorHolder;
+}
+export declare class InternalTimeoutError implements AxiosErrorHolder {
+    error: Error;
+    message: string | undefined;
+    type: string;
+    constructor(error: Error, message: string);
+}
+export declare class ExternalTimeoutError implements AxiosErrorHolder {
+    error: Error;
+    message: string | undefined;
+    type: string;
+    constructor(error: Error, message: string | undefined);
+}
+export declare class UnknownError implements AxiosErrorHolder {
+    error: Error;
+    message: string | undefined;
+    type: string | undefined;
+    constructor(error: Error, message: string | undefined, type: string | undefined);
+}

package/errors/axiosErrors.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownError = exports.ExternalTimeoutError = exports.InternalTimeoutError = exports.AxiosErrHandler = void 0;
+class AxiosErrorWrapper {
+    constructor(error) {
+        this.error = error;
+    }
+    isInternalTimeout() {
+        if (!this.error.response) {
+            return (this.error.code === 'ETIMEDOUT' || this.error.code === 'ECONNABORTED');
+        }
+        return false;
+    }
+    isExternalTimeout() {
+        if (this.error.response) {
+            return (this.error.response.status === 504 || this.error.response.status === 408);
+        }
+        return false;
+    }
+    getResponseData() {
+        if (this.error.response) {
+            return this.error.response.data;
+        }
+        return undefined;
+    }
+}
+class AxiosErrHandler {
+    static extract(error) {
+        const err = new AxiosErrorWrapper(error);
+        const httpResponse = err.getResponseData();
+        if (!httpResponse) {
+            if (err.isInternalTimeout()) {
+                return new InternalTimeoutError(error, error.message);
+            }
+        }
+        if (err.isExternalTimeout()) {
+            return new ExternalTimeoutError(error, httpResponse === null || httpResponse === void 0 ? void 0 : httpResponse.message);
+        }
+        return new UnknownError(error, httpResponse === null || httpResponse === void 0 ? void 0 : httpResponse.message, httpResponse === null || httpResponse === void 0 ? void 0 : httpResponse.status);
+    }
+}
+exports.AxiosErrHandler = AxiosErrHandler;
+class InternalTimeoutError {
+    constructor(error, message) {
+        this.error = error;
+        this.message = message || error.message;
+        this.type = exports.REQUEST_ERRORS.API_TIMEOUT;
+    }
+}
+exports.InternalTimeoutError = InternalTimeoutError;
+class ExternalTimeoutError {
+    constructor(error, message) {
+        this.error = error;
+        this.message = message || error.message;
+        this.type = exports.REQUEST_ERRORS.HUB_TIMEOUT;
+    }
+}
+exports.ExternalTimeoutError = ExternalTimeoutError;
+class UnknownError {
+    constructor(error, message, type) {
+        this.error = error;
+        this.message = message || error.message;
+        this.type = type || 'UNKNOWN';
+    }
+}
+exports.UnknownError = UnknownError;

package/general/decorators/logMethod.decorator.d.ts

@@ -17,4 +17,5 @@
 export declare function LogMethod(options?: {
     logParams?: boolean;
     logReturn?: boolean;
+    throwError?: boolean;
 }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/general/decorators/logMethod.decorator.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogMethod = void 0;
-const logger_1 = require("src/logger");
+const logger_1 = require("../../logger");
+const axios_1 = require("axios");
+const axiosErrors_1 = require("../../errors/axiosErrors");
 /**
  * Decorator that logs the execution of a method.
  *
@@ -22,7 +24,7 @@ function LogMethod(options) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = async function (...args) {
-            var _a, _b;
+            var _a;
             const className = target.constructor.name;
             const params = (options === null || options === void 0 ? void 0 : options.logParams) ? args : undefined;
             const metadata = (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.getData();
@@ -34,6 +36,10 @@ function LogMethod(options) {
                     },
                 });
                 const result = await originalMethod.apply(this, args);
+                if (result.error) {
+                    handleError(result.error, className, propertyKey, metadata, params);
+                    return result;
+                }
                 logger_1.logger.info(`${className}.${propertyKey} Finished`, {
                     metadata,
                     context: {
@@ -44,33 +50,53 @@ function LogMethod(options) {
                 return result;
             }
             catch (error) {
-                if (error instanceof Error) {
-                    // Tentativa de deixar o stack trace mais limpo
-                    const cleanStack = (_b = error.stack) === null || _b === void 0 ? void 0 : _b.split('\n').filter((line) => !line.includes('descriptor.value') &&
-                        !line.includes('logMethod.decorator.ts') &&
-                        !line.includes('node:internal/process/task_queues')).join('\n');
-                    logger_1.logger.error(`${className}.${propertyKey} Failed`, {
-                        err: { message: error.message, stack: cleanStack },
-                        metadata,
-                        context: {
-                            params,
-                        },
-                    });
-                }
-                else {
-                    // Caso o erro não seja uma instância de Error, logamos como um objeto desconhecido
-                    logger_1.logger.error(`${className}.${propertyKey} Failed`, {
-                        err: { message: 'Unknown error', details: error },
-                        metadata,
-                        context: {
-                            params,
-                        },
-                    });
+                const errorToThrow = handleError(error, className, propertyKey, metadata, params);
+                if ((options === null || options === void 0 ? void 0 : options.throwError) === undefined || (options === null || options === void 0 ? void 0 : options.throwError) === true) {
+                    throw errorToThrow;
                 }
-                throw error;
             }
         };
         return descriptor;
     };
 }
 exports.LogMethod = LogMethod;
+function handleError(error, className, propertyKey, metadata, params) {
+    if ((0, axios_1.isAxiosError)(error)) {
+        const fullErr = axiosErrors_1.AxiosErrHandler.extract(error);
+        const cleanStack = cleanErrorStack(fullErr.error.stack);
+        logger_1.logger.error(`${className}.${propertyKey} Failed`, {
+            err: { message: error.message, stack: cleanStack },
+            metadata,
+            context: {
+                params,
+            },
+        });
+        return fullErr;
+    }
+    if (error instanceof Error) {
+        const cleanStack = cleanErrorStack(error.stack);
+        logger_1.logger.error(`${className}.${propertyKey} Failed`, {
+            err: { message: error.message, stack: cleanStack },
+            metadata,
+            context: {
+                params,
+            },
+        });
+        return error;
+    }
+    else {
+        logger_1.logger.error(`${className}.${propertyKey} Failed`, {
+            err: { message: 'Unknown error', details: error },
+            metadata,
+            context: {
+                params,
+            },
+        });
+        return error;
+    }
+}
+function cleanErrorStack(stack) {
+    return stack === null || stack === void 0 ? void 0 : stack.split('\n').filter((line) => !line.includes('descriptor.value') &&
+        !line.includes('logMethod.decorator.ts') &&
+        !line.includes('node:internal/process/task_queues')).join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sm-utility",
-  "version": "2.4.13",
+  "version": "2.4.15",
   "description": "reusable utility codes for sm projects",
   "main": "index.js",
   "types": "./index.d.ts",
@@ -36,7 +36,7 @@
     "@opentelemetry/sdk-node": "0.57.1",
     "@opentelemetry/sdk-trace-base": "1.30.1",
     "aws-sdk": "^2.1134.0",
-    "axios": "^1.6.8",
+    "axios": "1.6.8",
     "express-winston": "^4.1.0",
     "nanoid": "^3.3.6",
     "node-xlsx": "^0.24.0",