heimdall-api-platform 1.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Márcio Rosa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# heimdall-api-platform
+This application is an gateway api platform

package/lib/clients/http-client.js

@@ -0,0 +1,296 @@
+"use strict";
+
+const Util = require("../commons-util");
+const Const = require("../commons-const");
+const { CreateHttpError } = require("../commons-errors");
+const http = require("http");
+const https = require("https");
+const doRequest = require("axios");
+const path = require("path");
+const _ = require("underscore");
+const { promisify } = require("util");
+const FormData = require('form-data');
+
+
+// require("axios-debug-log")({
+//     request: function (debug, config) {
+//         Util.info(
+//             `stage=request method=interceptors.request url=${config.baseURL}${config.url} request=${config.data}`
+//         );
+//     },
+//     response: function (debug, response) {
+//         Util.info(
+//             `stage=request method=interceptors.response url=${response.config.baseURL}${response.config.url} request=${
+//                 response.config.data
+//             } response=${JSON.stringify(response.data, null, 2)}`
+//         );
+//     },
+//     error: function (debug, error) {
+//         Util.error(
+//             `stage=request method=interceptors.error url=${error.config.baseURL}${error.config.url} request=${
+//                 error.config.data
+//             } error=${JSON.stringify(new CreateHttpError(error), null, 2)}`
+//         );
+//     },
+// });
+
+class HttpClient {
+    constructor(options) {
+        if (!options.host) {
+            Util.throwErrorIfItExists(new Error("The url can not be empty."));
+        }
+
+        this.host = options.host || "";
+        this.basePath = options.basePath || "";
+        this.user = options.user;
+        this.password = options.password || "";
+        this.token = options.token || "";
+        this.poolSize = options.poolSize || Const.DEFAULT_POOLSIZE;
+        this.authentication = options.authentication || "";
+        this.timeout = options.timeout || Const.DEFAULT_TIMEOUT_MS;
+        this.mtls = options.mtls || {};
+        this.enableMtls = this.mtls.hasOwnProperty("cert") && this.mtls.hasOwnProperty("key") ? true : false;
+        this.enableMtlsPfx = this.mtls.hasOwnProperty("pfx") && this.mtls.hasOwnProperty("passphrase") ? true : false;
+        this.protocol = this.host.substr(0, this.host.indexOf(":"));
+    }
+
+    generateRequestOptions(options) {
+
+        let requestOptions = {
+            method: (options.method || Const.HTTP_METHOD.GET).toLocaleLowerCase(),
+            baseURL: this.host,
+            url: path.join("/", this.basePath),
+            params: options.query || {},
+            timeout: this.timeout,
+            gzip: true,
+            responseType: "json",
+            headers: this.generateRequestHeaders(options),
+        };
+
+        // Adicionar options.path à URL se existir
+        if (options.path) {
+            requestOptions.url = path.join(requestOptions.url, "/", options.path);
+        }
+
+        // Construir a URL completa
+        requestOptions.urlFull = requestOptions.baseURL + requestOptions.url;
+
+        // Ajustar a URL para rotas de monitoramento
+        if (options.monitor) {
+            requestOptions.url = this.host + path.join("/", options.path || "").replace(/\\/g, "/");
+        }
+
+        //Validate path windows
+        if (process.platform == 'win32') {
+            requestOptions.url = requestOptions.url.replace(/\\/g, "/");
+        }
+
+        // Configurar agentes HTTP/HTTPS com mTLS se necessário
+        if (this.protocol === "https") {
+            if (this.enableMtls) {
+                requestOptions.httpsAgent = new https.Agent({
+                    cert: Buffer.from(this.mtls.cert, "base64").toString("utf8"),
+                    key: Buffer.from(this.mtls.key, "base64").toString("utf8"),
+                    keepAlive: true,
+                });
+            } else if (this.enableMtlsPfx) {
+                requestOptions.httpsAgent = new https.Agent({
+                    pfx: Buffer.from(this.mtls.pfx, "base64"),
+                    passphrase: Buffer.from(this.mtls.passphrase, "base64").toString("utf8"),
+                    minVersion: 'TLSv1.2',
+                    keepAlive: true,
+                });
+            } else {
+                requestOptions.httpsAgent = this.getAgent();
+            }
+        } else {
+            requestOptions.httpAgent = this.getAgent();
+        }
+
+        // Configurar dados da requisição para métodos POST
+        if (
+            requestOptions.method === Const.HTTP_METHOD.POST.toLocaleLowerCase() &&
+            requestOptions.headers[Const.HEADERS.CONTENT_TYPE].indexOf(Const.FORM_CONTENT_TYPE_VALUE) > -1
+        ) {
+            requestOptions.data = !_.isEmpty(options.params) ? options.params : options.body;
+            requestOptions.dataType = "form";
+        } else if (
+            requestOptions.method === Const.HTTP_METHOD.POST.toLowerCase() &&
+            requestOptions.headers[Const.HEADERS.CONTENT_TYPE].indexOf(Const.FORM_MULTIPART_CONTENT_TYPE_VALUE) > -1
+        ) {
+            requestOptions.dataType = "multipart";
+
+            const form = new FormData();
+
+            if (options.request?.file) {
+                const request = options.request;
+                const file = request.file;
+                form.append(options.service.rawOptions.uploadFieldName || 'file', file.buffer, {
+                    filename: file.originalname,
+                    contentType: file.mimetype,
+                });
+            }
+
+            // Adiciona outros campos do params/body
+            const fields = !_.isEmpty(options.params) ? options.params : options.body;
+            if (fields && typeof fields === 'object') {
+                for (const [key, value] of Object.entries(fields)) {
+                    form.append(key, value);
+                }
+            }
+
+            // Sobrescreve os headers para incluir os do FormData
+            requestOptions.headers = {
+                ...requestOptions.headers,
+                ...form.getHeaders(),
+            };
+
+            requestOptions.data = form;
+
+        } else if (!_.isEmpty(options.body)) {
+            requestOptions.dataType = "json";
+            requestOptions.data = JSON.stringify(options.body);
+        }
+
+        return requestOptions;
+    }
+
+
+    getAgent() {
+        let agent = null;
+
+        switch (this.protocol) {
+            case "https":
+                agent = new https.Agent({ keepAlive: true });
+                break;
+            default:
+                agent = new http.Agent({ keepAlive: true });
+                break;
+        }
+
+        agent.maxSockets = this.poolSize || Const.DEFAULT_POOLSIZE;
+
+        return agent;
+    }
+
+    generateRequestHeaders(options) {
+        let headers = {};
+
+        if (options.headers) {
+            headers = _.extend(headers, options.headers);
+        }
+
+        if (this.authentication && this.authentication.toLowerCase() === "basic" && this.user && this.password) {
+            headers.Authorization = "Basic " + new Buffer(this.user + ":" + this.password).toString("base64");
+        }
+
+        if (this.authentication && this.authentication.toLowerCase() === "bearer" && this.token) {
+            headers.Authorization = "Bearer " + this.token;
+        }
+
+        /*if (options.method == Const.HTTP_METHOD.POST &&
+            options.headers[Const.HEADERS.CONTENT_TYPE] == 'application/x-www-form-urlencoded;charset=UTF-8') {
+            headers[Const.HEADERS.CONTENT_LENGTH] = querystring.stringify(options.params).length;
+        } else {
+            headers[Const.HEADERS.CONTENT_LENGTH] = querystring.stringify(options.body).length;
+        }*/
+
+        //headers.Connection = 'keep-alive';
+
+        headers.Connection = "close";
+
+        return headers;
+    }
+
+    //TODO ADICIONAR O STEPFLOW PORQUE ELE TEM O CONTEXT
+    async execute(options, callbackStep) {
+
+        let requestOptions = this.generateRequestOptions(options);
+
+        Util.info(
+            `stage=init method=HttpClient.execute (${this.protocol.toUpperCase()}) for Client Name=${options.name || ""
+            } config`,
+            {
+                uuid: options.uuid || "",
+                flowStepUuid: options.flowStepUuid || "",
+                contextUuid: options.contextUuid || "",
+                timeout: requestOptions.timeout,
+                method: requestOptions.method,
+                url: requestOptions.urlFull,
+                body: Util.isJSONValid(requestOptions.data) ? Util.obfuscationJSON(requestOptions.data) : {},
+                query: requestOptions.params || {},
+                headers: Util.obfuscationJSON(requestOptions.headers || {}),
+            }
+        );
+
+        doRequest(requestOptions)
+            .then((response) => {
+                Util.info(
+                    `stage=end method=HttpClient.execute (${this.protocol.toUpperCase()}) for Client Name=${options.name || ""
+                    } response`,
+                    {
+                        uuid: options.uuid || "",
+                        flowStepUuid: options.flowStepUuid || "",
+                        contextUuid: options.contextUuid || "",
+                        timeout: requestOptions.timeout,
+                        method: requestOptions.method,
+                        url: requestOptions.urlFull,
+                        body: Util.isJSONValid(requestOptions.data) ? Util.obfuscationJSON(requestOptions.data) : {},
+                        query: requestOptions.params || {},
+                        headers: Util.obfuscationJSON(requestOptions.headers || {}),
+                        result: Util.obfuscationJSON(response.data || {}),
+                    }
+                );
+
+                callbackStep(null, response);
+            })
+            .catch((error) => {
+                //TODO: TRATAR ESSES ERROS
+                //error.code[EHOSTUNREACH,ECONNREFUSED,ECONNRESET,ESOCKETTIMEDOUT]
+
+                Util.error(
+                    `stage=error method=HttpClient.execute (${this.protocol.toUpperCase()}) for Client Name=${options.name || ""
+                    } response`,
+                    {
+                        uuid: options.uuid || "",
+                        flowStepUuid: options.flowStepUuid || "",
+                        contextUuid: options.contextUuid || "",
+                        timeout: requestOptions.timeout,
+                        method: requestOptions.method,
+                        url: requestOptions.urlFull,
+                        body: Util.isJSONValid(requestOptions.data) ? Util.obfuscationJSON(requestOptions.data) : {},
+                        query: requestOptions.params || {},
+                        headers: Util.obfuscationJSON(requestOptions.headers || {}),
+                        error: Util.obfuscationJSON(new CreateHttpError(error) || {}),
+                    }
+                );
+
+                if (error || error.response.status >= Const.HTTP_STATUS.ERROR_CLIENT_RANGE_START) {
+                    callbackStep(new CreateHttpError(error), null);
+                } else {
+                    Util.info(
+                        `stage=error method=HttpClient.execute (${this.protocol.toUpperCase()}) for Client Name=${options.name || ""
+                        } response`,
+                        {
+                            uuid: options.uuid || "",
+                            flowStepUuid: options.flowStepUuid || "",
+                            contextUuid: options.contextUuid || "",
+                            timeout: requestOptions.timeout,
+                            method: requestOptions.method,
+                            url: requestOptions.urlFull,
+                            body: Util.isJSONValid(requestOptions.data) ? Util.obfuscationJSON(requestOptions.data) : {},
+                            query: requestOptions.params || {},
+                            headers: Util.obfuscationJSON(requestOptions.headers || {}),
+                            result: Util.obfuscationJSON(error.response.data || {}),
+                        }
+                    );
+
+                    callbackStep(null, error.response || {});
+                }
+            });
+    }
+}
+
+HttpClient.prototype.executePromise = promisify(HttpClient.prototype.execute);
+
+module.exports = HttpClient;

package/lib/commons-cache.js

@@ -0,0 +1,185 @@
+"use strict";
+
+const redis = require("redis");
+const { promisify } = require("util");
+const NodeCache = require("node-cache");
+const Util = require("./commons-util.js");
+
+const DEFAULT_REDIS_CONNECT_TIMEOUT = 30000;
+const DEFAULT_REDIS_RECONNECT_TIMEOUT = 30000;
+
+class RedisClient {
+    constructor(options = {}) {
+        this.enableRedis = options.enableRedis || false;
+        this.readClient = null;
+        this.writerClient = null;
+
+        this.localCache = new NodeCache({
+            stdTTL: 120, // Default TTL of 120 seconds
+            checkperiod: 1, // Check expired keys every 1 second
+        });
+
+        if (this.enableRedis && options.redisCache) {
+            const { reader, writer } = options.redisCache;
+            this.readClient = this.createRedisClient(reader, "read");
+            this.writerClient = this.createRedisClient(writer, "writer");
+        }
+    }
+
+    createRedisClient(config, type) {
+        if (!config) {
+            Util.warning(`stage=warn method=createRedisClient message=No Redis configuration provided for type=${type}`);
+            return null;
+        }
+
+        const client = redis.createClient(config.port, config.host, {
+            enable_offline_queue: false,
+            no_ready_check: true,
+            connect_timeout: config.connectTimeout || DEFAULT_REDIS_CONNECT_TIMEOUT,
+            retry_strategy: RedisClient.retryStrategy,
+        });
+
+        client.on("error", (err) => {
+            Util.error(`stage=error method=createRedisClient message=Redis[${type}] error`, err);
+        });
+
+        client.on("connect", () => {
+            Util.info(`stage=info method=createRedisClient message=Redis[${type}] connected`, {
+                host: config.host,
+                port: config.port,
+            });
+        });
+
+        return client;
+    }
+
+    async put(cacheName, key, value, ttl) {
+        const composedKey = this.composeKey(cacheName, key);
+
+        if (this.writerClient && this.writerClient.connected) {
+            const setexAsync = promisify(this.writerClient.setex).bind(this.writerClient);
+            try {
+                await setexAsync(composedKey, ttl, JSON.stringify(value));
+                Util.info(`stage=info method=put message=Cache set successfully`, { cacheName, key, ttl });
+                return;
+            } catch (err) {
+                Util.error(`stage=error method=put message=Error setting cache in Redis`, err);
+            }
+        }
+
+        // Fallback to local cache
+        this.localCache.set(composedKey, value, ttl);
+        Util.warning(`stage=warn method=put message=Using local cache as fallback`, { cacheName, key });
+    }
+
+    async get(cacheName, key) {
+        const composedKey = this.composeKey(cacheName, key);
+
+        if (this.readClient && this.readClient.connected) {
+            const getAsync = promisify(this.readClient.get).bind(this.readClient);
+            try {
+                const entry = await getAsync(composedKey);
+                if (entry) {
+                    Util.info(`stage=info method=get message=Cache hit in Redis`, { cacheName, key });
+                    return JSON.parse(entry);
+                } else {
+                    Util.warning(`stage=warn method=get message=Cache miss in Redis`, { cacheName, key });
+                }
+            } catch (err) {
+                Util.error(`stage=error method=get message=Error retrieving cache from Redis`, err);
+            }
+        }
+
+        // Fallback to local cache
+        const localValue = this.localCache.get(composedKey);
+        if (localValue) {
+            Util.info(`stage=info method=get message=Cache hit in local cache`, { cacheName, key });
+        } else {
+            Util.warning(`stage=warn method=get message=Cache miss in local cache`, { cacheName, key });
+        }
+        return localValue || null;
+    }
+
+    async delete(cacheName, key) {
+        const composedKey = this.composeKey(cacheName, key);
+
+        if (this.writerClient && this.writerClient.connected) {
+            const delAsync = promisify(this.writerClient.del).bind(this.writerClient);
+            try {
+                const result = await delAsync(composedKey);
+                if (result) {
+                    Util.info(`stage=info method=delete message=Key deleted successfully in Redis`, { cacheName, key });
+                    return;
+                }
+                Util.warning(`stage=warn method=delete message=Key not found in Redis`, { cacheName, key });
+            } catch (err) {
+                Util.error(`stage=error method=delete message=Error deleting key in Redis`, err);
+            }
+        }
+
+        // Fallback to local cache
+        const localDeleted = this.localCache.del(composedKey);
+        if (localDeleted) {
+            Util.info(`stage=info method=delete message=Key deleted successfully in local cache`, { cacheName, key });
+        } else {
+            Util.warning(`stage=warn method=delete message=Key not found in local cache`, { cacheName, key });
+        }
+    }
+
+    async getKeys(cacheName) {
+        if (this.readClient && this.readClient.connected) {
+            const keysAsync = promisify(this.readClient.keys).bind(this.readClient);
+            try {
+                const keys = await keysAsync(`${cacheName}:*`);
+                if (keys.length) {
+                    Util.info(`stage=info method=getKeys message=Keys found in Redis`, { cacheName, keys });
+                    return keys;
+                }
+                Util.warning(`stage=warn method=getKeys message=No keys found in Redis`, { cacheName });
+            } catch (err) {
+                Util.error(`stage=error method=getKeys message=Error retrieving keys from Redis`, err);
+            }
+        }
+
+        // Fallback to local cache
+        const keys = this.localCache.keys().filter((key) => key.startsWith(`${cacheName}:`));
+        if (keys.length) {
+            Util.info(`stage=info method=getKeys message=Keys found in local cache`, { cacheName, keys });
+        } else {
+            Util.warning(`stage=warn method=getKeys message=No keys found in local cache`, { cacheName });
+        }
+        return keys;
+    }
+
+    composeKey(cacheName, key) {
+        return `${cacheName}:${key}`;
+    }
+
+    static retryStrategy(options) {
+        const MAX_RETRY_TIME = 1000 * 60 * 60;
+        const MAX_ATTEMPTS = 10;
+
+        if (options.error && options.error.code === "ECONNREFUSED") {
+            Util.error(`stage=error method=retryStrategy message=Connection refused`, options.error);
+            return DEFAULT_REDIS_RECONNECT_TIMEOUT;
+        }
+
+        if (options.total_retry_time > MAX_RETRY_TIME) {
+            Util.error(`stage=error method=retryStrategy message=Retry time exhausted`);
+            return new Error("Retry time exhausted");
+        }
+
+        if (options.attempt > MAX_ATTEMPTS) {
+            Util.warning(`stage=warn method=retryStrategy message=Max attempts reached`, { attempts: options.attempt });
+            return undefined;
+        }
+
+        Util.info(`stage=info method=retryStrategy message=Retrying connection`, { attempts: options.attempt });
+        return Math.min(options.attempt * 100, DEFAULT_REDIS_RECONNECT_TIMEOUT);
+    }
+}
+
+module.exports = {
+    createClient: (options) => new RedisClient(options),
+    RedisClient,
+};