heimdall-api-platform 1.0.4 → 1.0.6

package/lib/factory/transformation-function-factory.js

@@ -1,47 +0,0 @@
-"use strict";
-
-var Util = require("../commons-util");
-var Const = require("../commons-const");
-var Function = require("../operations/function");
-var BaseContext = require("../models/base-context");
-const { v4: uuidv4 } = require("uuid");
-
-class TransformationFunctionFactory {
-    static create(name, context) {
-        if (!name)
-            return new FunctionDefault(
-                {
-                    type: Const.FLOW_OPERATION_TYPE.FUNCTION,
-                    functionName: Const.NOT_IMPLEMENTED_FUNCTION,
-                },
-                context
-            );
-
-        Util.info(`stage=info method=TransformationFunctionFactory.create message=Created function name=${name}`);
-
-        return new Function(
-            {
-                type: Const.FLOW_OPERATION_TYPE.FUNCTION,
-                functionName: name,
-            },
-            context
-        );
-    }
-}
-
-class FunctionDefault extends BaseContext {
-    constructor(options, context) {
-        super(uuidv4(), context);
-        this.type = options.type;
-        this.name = options.functionName;
-    }
-
-    doExecuteFunction(options, context, callback) {
-        callback(null, options);
-    }
-
-    doExecuteFunctionWithoutCallback(options, context) {}
-}
-
-module.exports = TransformationFunctionFactory;
-module.create = TransformationFunctionFactory.create;

package/lib/handle-route.js

@@ -1,472 +0,0 @@
-"use strict";
-
-const Util = require("./commons-util");
-const Const = require("./commons-const");
-const Env = require("./environment").application;
-const { ApiGatewayError, RequestTooManyRequests, CreateCustomError } = require("./commons-errors");
-const _ = require("underscore");
-const Step = require("step");
-const RouteContext = require("./models/route-context");
-const ValidateSecurity = require("./security-validation");
-const ElasticIndexData = require("./models/elastic-index-data");
-const Environment = require("./environment");
-const rateLimiter = require("redis-rate-limiter");
-const SplunkData = require("./models/splunk-data");
-const FunctionFactory = require("./factory/function-factory");
-
-const validContentTypes = [
-    "multipart/form-data",
-    "text/csv",
-    "application/pdf",
-    "application/msword",
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    "application/vnd.ms-excel",
-    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    "application/zip",
-    "application/gzip",
-    "application/octet-stream"
-];
-
-class HandleRoute {
-    constructor(orchestrator, serviceOptions, splunkProvider, openSearch) {
-        if (!serviceOptions.flow) {
-            throw ApiGatewayError("You must provide the flow to be executed.");
-        }
-
-        this.orchestrator = orchestrator;
-        this._serviceOptions = serviceOptions;
-        // this.elasticSearch = elasticSearch;
-        this.splunkProvider = splunkProvider;
-        this.openSearch = openSearch;
-        this.redisClient = orchestrator.redisClient;
-        this.enableRateLimit = serviceOptions.rateLimit ? true : false;
-        this.rateLimit = serviceOptions.rateLimit;
-        this.auditFunction = serviceOptions.auditFunction;
-    }
-
-    handleRequest(request, response, next) {
-        let self = this;
-
-        let context = new RouteContext(request, response, next, this._serviceOptions, this.orchestrator);
-
-        Util.info("stage=init method=HandleRoute.handleRequest configuration", {
-            method: context.service.method.toUpperCase(),
-            service: context.service.name,
-            url: context.request.url,
-            uuid: context.uuid,
-            body: Util.obfuscationJSON(context.body || {}),
-            query: context.query,
-            params: context.params,
-            headers: Util.obfuscationJSON(context.headers || {}),
-        });
-
-        //Inicia Route Request
-        context.init();
-        context.service.setCurrentFlow(context.service.flow[0]);
-
-        Step(
-            function () {
-                self.validateRateLimit(context, this);
-            },
-            //Valida se o Route tem segurança JWT
-            //Todo: implementar funcao custom para validar autenticação
-            function (error) {
-                Util.throwErrorIfItExists(error);
-                self.validateSecurity(context, this);
-            },
-            //Execute Flow
-            function (error) {
-                Util.throwErrorIfItExists(error);
-                self.executeFlow(context, this);
-            },
-            function () {
-                self.processResult(context);
-            }
-        );
-    }
-
-    indexRequest(context) {
-
-        // if (this.elasticSearch.isEnabled()) {
-
-        //     this.elasticSearch.getInstance().index(
-        //         {
-        //             index: Environment.application.elasticSearch.indexName || Environment.application.appName,
-        //             id: context.uuid,
-        //             body: new ElasticIndexData(context),
-        //         },
-        //         (err, data) => {
-        //             //TENTATIVA DE INDEXAR NO ELASTICSEARCH
-        //             context.attemptsIndex++;
-        //             if (err) {
-        //                 // console.log(err)
-        //                 Util.error("stage=error method=HandleRoute.indexRequest message=Indexed Fail", {
-        //                     uuid: context.uuid,
-        //                     error: err,
-        //                 });
-        //                 //Retry Index
-        //                 if (context.attemptsIndex < 10) {
-        //                     Util.warning("stage=warn method=HandleRoute.indexRequest message=Retry Index", {
-        //                         uuid: context.uuid,
-        //                         retryIn: "30s x " + context.attemptsIndex,
-        //                         attemptsIndex: context.attemptsIndex,
-        //                     });
-        //                     setTimeout(() => {
-        //                         this.indexRequest(context);
-        //                     }, 30000 * context.attemptsIndex);
-        //                 }
-        //             } else {
-        //                 Util.info("stage=info method=HandleRoute.indexRequest message=Indexed Successfully", {
-        //                     uuid: context.uuid,
-        //                 });
-        //             }
-        //         }
-        //     );
-        // }
-
-        if (this.splunkProvider.isEnabled()) {
-            this.splunkProvider.sendEvent({
-                event: {
-                    index: Environment.application.splunk.indexName || Environment.application.appName,
-                    type: "requests",
-                    id: context.uuid,
-                    body: new SplunkData(context),
-                },
-            });
-        }
-
-        if (this.openSearch.isEnabled()) {
-            let indexNameOpenSearch = Environment.application.openSearch.indexName || Environment.application.appName;
-
-            this.openSearch.getInstance().index(
-                {
-                    index: indexNameOpenSearch,
-                    id: context.uuid,
-                    body: new ElasticIndexData(context),
-                },
-                (err, data) => {
-                    //TENTATIVA DE INDEXAR NO ELASTICSEARCH
-                    context.attemptsIndex++;
-                    if (err) {
-                        // console.log(err)
-                        Util.error(
-                            `stage=error method=HandleRoute.indexRequest indexName=${indexNameOpenSearch} provider=OpenSearch message=Indexed Fail requestId=${context.uuid
-                            } error=${JSON.stringify(err)}`
-                        );
-                        //Retry Index
-                        if (context.attemptsIndex < 10) {
-                            Util.warning(
-                                `stage=error method=HandleRoute.indexRequest indexName=${indexNameOpenSearch} provider=OpenSearch message=Retry Index requestId=${context.uuid} retryIn=30s x ${context.attemptsIndex} attemptsIndex=${context.attemptsIndex}`
-                            );
-
-                            setTimeout(() => {
-                                this.indexRequest(context);
-                            }, 30000 * context.attemptsIndex);
-                        }
-                    } else {
-                        Util.info(
-                            `stage=info method=HandleRoute.indexRequest indexName=${indexNameOpenSearch} provider=OpenSearch message=Indexed Successfully requestId=${context.uuid} indexId=${data.body._id}`
-                        );
-                    }
-                }
-            );
-        }
-    }
-
-    validateSecurity(context, callback) {
-        Step(
-            function () {
-                ValidateSecurity.execute(context, this);
-            },
-            function (error) {
-                if (error) {
-                    context.statusCode = error.responseCode;
-                    context.error = true;
-                    context.setResult(error);
-                }
-                callback(error);
-            }
-        );
-    }
-
-    getCompileContext(context) {
-        let customerToken = {
-            name: "undefined",
-            ownId: Util.generateKey(context.headers),
-            document: "undefined",
-            type: "undefined",
-            phoneNumber: "undefined",
-        };
-
-        if (context.headers[Const.HEADERS.X_AUTHORIZATION]) {
-            try {
-                let authorizationBearer = context.headers[Const.HEADERS.X_AUTHORIZATION].replace("Bearer", "").trim();
-                let customerTokenData = Util.tryParseJSON(Util.decodeBase64(authorizationBearer.split(".")[1]));
-
-                if (Util.isJSONValid(customerTokenData)) {
-                    customerToken = {
-                        name: customerTokenData.nome,
-                        ownId: customerTokenData.ownid,
-                        document: customerTokenData.sub,
-                        type: customerTokenData.tipoToken,
-                        phoneNumber: customerTokenData.telefone,
-                    };
-                }
-            } catch (e) {
-                Util.error(
-                    `stage=error method=HandleRoute.getCompileContext message=Error Get Compile Context error`,
-                    e
-                );
-            }
-        }
-
-        return _.extend(context, {
-            env: Env,
-            util: Util,
-            customerToken: customerToken,
-        });
-    }
-
-    compileRateLimitKey(context) {
-        let compiled = _.template(
-            `${context.service.name}-${this.rateLimit.key || context.headers["x-forwarded-for"]}`
-        );
-        let keyCompiled = compiled(this.getCompileContext(context));
-
-        Util.info(
-            `stage=error method=HandleRoute.compileRateLimitKey limitKey=${this.rateLimit.key} keyCompiled=${keyCompiled}`
-        );
-
-        return keyCompiled;
-    }
-
-    validateRateLimit(context, callback) {
-
-        try {
-
-            let key = this.rateLimit.hasOwnProperty("key");
-            let rate = this.rateLimit.hasOwnProperty("rate");
-
-            if (!this.redisClient.enableRedis || !key || !rate) {
-                callback();
-                return;
-            }
-
-            const limit = rateLimiter.create({
-                redis: this.redisClient.writerClient,
-                key: (context) => {
-                    return this.compileRateLimitKey(context);
-                },
-                rate: this.rateLimit.rate || Environment.application.requestPerSecond || "40/s", //DEFAULT
-            });
-
-            limit(context, (err, rate) => {
-                if (err) {
-                    Util.error(
-                        `stage=error method=HandleRoute.validateRateLimit message=Rate Limit Validation Error`,
-                        err
-                    );
-                    callback();
-                } else {
-                    Util.info("stage=info method=HandleRoute.validateRateLimit.limit", rate);
-
-                    if (rate.over) {
-                        Util.error(
-                            "stage=error method=HandleRoute.validateRateLimit.limit message=Rate Limit Info Over",
-                            rate
-                        );
-
-                        let error = new RequestTooManyRequests(
-                            "TOO_MANY_REQUESTS",
-                            new CreateCustomError("TOO_MANY_REQUESTS", "Too Many Requests")
-                        );
-                        context.service.addResult(error);
-                        context.setResult(error);
-                        context.statusCode = 429;
-                        context.error = true;
-                        callback(error);
-                    }
-                    callback();
-                }
-            });
-        } catch (e) {
-            Util.error(`stage=error method=HandleRoute.validateRateLimit message=Rate Limit Validation Error`, e);
-            callback();
-        }
-    }
-
-    executeFlow(context, callback) {
-        Util.info(`stage=info method=HandleRoute.executeFlow message=Executing flow(s)`, {
-            service: context.service.name,
-            totalFlow: context.service.flow.length,
-            contextUuid: context.uuid,
-        });
-
-        this.orchestrator.execute(context, callback);
-    }
-
-    generateHeadersDefault(context) {
-        let headers = _.extend(
-            {
-                [Const.HEADERS.X_REQUEST_UUID_NAME]: context.uuid,
-                [Const.HEADERS.X_REQUEST_SERVICE_NAME]: context.service.name,
-                [Const.HEADERS.X_REQUEST_SERVICE_DESCRIPTION]: context.service.description,
-            },
-            context.service.responseHeaders
-        );
-
-        let contentType = headers[Const.HEADERS.CONTENT_TYPE] || this.resolveContextTypeResponse(context);
-
-        headers[Const.HEADERS.CONTENT_TYPE] = contentType;
-        headers[Const.HEADERS.X_REQUEST_DURATION_NAME] = context.timers.duration;
-
-        //VERIFY COOKIES ON RESPONSE HEADERS FROM MICROSERVICES
-        let responseCookie = context.service.headers[Const.HEADERS.SET_COOKIE.toLocaleLowerCase()] || {};
-
-        //VERIFY AND CONCAT COOKIES ON RESPONSE HEADERS FROM GATEWAY
-        const seTCookieOnRespHeaders =
-            context.service.responseHeaders[Const.HEADERS.SET_COOKIE] ||
-            context.service.responseHeaders[Const.HEADERS.SET_COOKIE.toLocaleLowerCase()];
-
-        if (seTCookieOnRespHeaders) {
-            if (Array.isArray(responseCookie) && responseCookie.length) {
-                responseCookie = responseCookie.map((cookieLine) => (cookieLine += `; ${seTCookieOnRespHeaders}`));
-            } else {
-                responseCookie = [seTCookieOnRespHeaders];
-            }
-        }
-
-        if (Util.nonNull(responseCookie)) {
-            headers = _.extend(headers, {
-                [Const.HEADERS.SET_COOKIE.toLocaleLowerCase()]: responseCookie,
-            });
-        }
-
-        //VERIFY CONTENT TYPE FOR DOWNLOAD FILE ON RESPONSE HEADERS FROM MICROSERVICES
-        if (validContentTypes.includes(headers[Const.HEADERS.CONTENT_TYPE]) ||
-            validContentTypes.includes(headers[Const.HEADERS.CONTENT_TYPE.toLocaleLowerCase()])) {
-
-            let responseContentDisposition =
-                context.service.headers[Const.HEADERS.CONTENT_DISPOSITION.toLocaleLowerCase()] ||
-                context.service.headers[Const.HEADERS.CONTENT_DISPOSITION] ||
-                "Download_" + new Date().toDateString();
-
-            headers = {
-                ...headers,
-                [Const.HEADERS.CONTENT_DISPOSITION.toLocaleLowerCase()]: responseContentDisposition,
-            };
-
-        }
-
-        //Update Response Headers
-        context.service.responseHeaders = headers;
-
-        //NAO SETA HEADER PARA REDIRECTS E NO CONTENT PARA RESULTADOS VAZIOS
-        if (!Util.isUrl(context.getResult())) {
-            context.response.writeHead(
-                Util.isEmpty(context.getResult()) ? Const.HTTP_STATUS.NO_CONTENT : context.statusCode,
-                context.service.responseHeaders
-            );
-        }
-    }
-
-    resolveContextTypeResponse(context) {
-        if (Buffer.isBuffer(context.getResult())) return Const.STREAM_CONTENT_TYPE_VALUE;
-
-        if (context.getResult() !== null && typeof context.getResult() === "object")
-            return Const.JSON_CONTENT_TYPE_VALUE;
-
-        if (context.getResult() === "string") return Const.DEFAULT_CONTENT_TYPE_VALUE;
-
-        return Const.DEFAULT_CONTENT_TYPE_VALUE;
-    }
-
-    resolveEndResponse(context) {
-        //Libera resposta para o client no formato correto
-        switch (context.getResult().constructor.name) {
-            case Const.OBJECT_TYPE.READSTREAM: //STREAM FOR BIG FILES
-                context.getResult().pipe(context.response);
-                break;
-            case Const.OBJECT_TYPE.PASSTHROUGH: //STREAM FOR BIG FILES
-                context.getResult().pipe(context.response);
-                break;
-            case Const.OBJECT_TYPE.BUFFER: //BUFFER
-                context.response.end(context.getResult());
-                break;
-            case Const.OBJECT_TYPE.OBJECT: //JSON
-                context.response.end(Util.stringify(context.getResult()));
-                break;
-            case Const.OBJECT_TYPE.STRING: //STRING FOR HTML
-                //VALIDA SE A RESPOSTA É UM URL VALIDA PARA REDIRECT
-                if (Util.isUrl(context.getResult())) {
-                    context.response.redirect(302, context.getResult());
-                } else {
-                    context.response.end(context.getResult());
-                }
-                break;
-            default:
-                context.response.end(Util.stringify(context.getResult()));
-        }
-    }
-
-    releaseResponse(context) {
-        //TODO: Verificar como ver se tem erro para adicionar informações adicionais
-        if (context.error) {
-            let responseError = Util.nonNull(context.service.currentFlow.result)
-                ? context.service.currentFlow.result
-                : context.service.result;
-            let encapsuleError = context.service.currentFlow.operation.encapsuleError || true;
-
-            if (encapsuleError) {
-                context.setResult(
-                    _.extend(responseError || {}, {
-                        description: context.service.description,
-                        serviceName: context.service.name,
-                        requestId: context.uuid,
-                    })
-                );
-            } else {
-                context.setResult(responseError);
-            }
-        }
-
-        this.resolveEndResponse(context);
-    }
-
-    processResult(context) {
-        this.handleResult(context);
-        this.indexRequest(context);
-        this.handleAudit(context);
-    }
-
-    handleResult(context) {
-        //Finish Request
-        context.end();
-
-        this.generateHeadersDefault(context);
-        this.releaseResponse(context);
-
-        Util.info("stage=end method=HandleRoute.handleResult response", {
-            method: context.service.method.toUpperCase(),
-            service: context.service.name,
-            route: context.request.url,
-            uuid: context.uuid,
-            body: Util.isJSONValid(context.getResult()) ? Util.obfuscationJSON(context.getResult()) : {},
-            headers: context.service.responseHeaders,
-            duration: context.timers.duration,
-        });
-    }
-
-    handleAudit(context) {
-        try {
-            if (this.auditFunction) {
-                let auditFunction = FunctionFactory.createFunctionByName(this.auditFunction);
-                auditFunction.handle(context);
-            }
-        } catch (e) {
-            Util.error(`stage=error method=HandleRoute.handleAudit message=Handle Audit Error`, e);
-        }
-    }
-}
-
-module.exports = HandleRoute;

package/lib/index.js

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-'use strict'
-
-require('dotenv').config()
-
-const APIGateway = require('./factory/api-gateway');
-const Environment = require('./environment');
-const Util = require('./commons-util');
-const JWTUtil = require('./jwt-util');
-const Errors = require('./commons-errors');
-const ClientFactory = require('./factory/client-factory');
-// const ElasticSearch = require('./commons-elasticsearch');
-const CommonsCache = require("./commons-cache");
-const Const = require('./commons-const');
-const ElasticIndexData = require('./models/elastic-index-data');
-
-if (process.env.NODE_ENV == 'production') {
-    process.on('uncaughtException', function (err) {
-        Util.error(`UncaughtException error=${Util.stringifyInfo(err)}`);
-        console.error(err);
-    });
-};
-
-process.on('SIGTERM', function () {
-    Util.error(Util.format("Process %s was kill", process.pid));
-    // some other closing procedures go here
-    process.exit(0);
-});
-
-// Memory check:
-process.nextTick(function memory() {
-    Util.warning(Util.format('Memory (Master): %s', Math.round(((process.memoryUsage().rss / 1024) / 1024)) + "MB"));
-    var timeout = setTimeout(memory, Environment.application.memoryCheckInterval);
-});
-
-// Hook into commonJS module systems
-module.exports = {
-    APIGateway: APIGateway,
-    Environment: Environment,
-    Const: Const,
-    Util: Util,
-    JWTUtil: JWTUtil,
-    Errors: Errors,
-    ClientFactory: ClientFactory,
-    CommonsCache: CommonsCache,
-    // ElasticSearch: ElasticSearch,
-    Models: {
-        ElasticIndexData: ElasticIndexData
-    }
-};

package/lib/jwt-util.js

@@ -1,38 +0,0 @@
-'use strict';
-
-var Util = require('./commons-util');
-var environment = require('./environment');
-var JWT = require('jsonwebtoken');
-var { CreateCustomError, Errors } = require('./commons-errors');
-
-function validateAccessToken(token, callback) {
-
-    if (token) {
-
-        JWT.verify(token, environment.application.security.secret, { algorithms: ['HS256'] }, function (err, decoded) {
-            if (err) {
-                Util.error(`Failed to authenticate token=${token}`, err);
-                callback(Errors.handleSecurityError(err, null));
-            } else {
-                callback(null, decoded);
-            }
-        });
-
-    } else {
-        Util.error('Authentication token not informed.');
-        callback(Errors.handleSecurityError(CreateCustomError('JsonWebTokenError', 'Authentication token not informed.')), null);
-    }
-}
-
-function createAccessToken(payload) {
-
-    var tokenJWT = JWT.sign(payload, environment.application.security.secret, {
-        expiresIn: '365d' // 1 year
-    });
-
-    return tokenJWT;
-
-};
-
-exports.validateAccessToken = validateAccessToken;
-exports.createAccessToken = createAccessToken;

package/lib/license/license-service.js

@@ -1,27 +0,0 @@
-// core/services/licenseService.js
-const axios = require("axios");
-
-const LICENSE_API_URL = "https://heimdall-api-platform.p4f.tech/app-key";
-
-module.exports = {
-
-    async validate(appKey) {
-
-        try {
-
-            const response = await axios.get(`${LICENSE_API_URL}/${appKey}/validation`);
-
-            if (response.status !== 200 || !response.data.active) {
-                return null;
-            }
-
-            return response.data;
-
-        } catch (err) {
-            console.error("stage=error msg=License API validation failed", err.message);
-            return null;
-        }
-
-    },
-
-};