heimdall-api-platform 1.0.4 → 1.0.6

package/lib/services/server.js

@@ -1,211 +0,0 @@
-"use strict";
-
-const Util = require("../commons-util");
-const path = require("path");
-const express = require("express");
-const ServiceGroup = require("../models/service-group");
-const Router = require("../router");
-const ServiceRoute = require("../models/service-route");
-const HandleRoute = require("../handle-route");
-const OrchestrationFlow = require("../orchestration-flow");
-const commonsCache = require("../commons-cache");
-// const commonsElasticSearch = require("../commons-elasticsearch");
-const commonsOpenSearch = require("../commons-opensearch");
-const commonsSplunkInstance = require("../commons-splunk");
-const ServiceContext = require("../models/service-context");
-const templateMonitorCheckRoute = require("./template-monitorcheck-route");
-const _ = require("underscore");
-const licenseService = require("../license/license-service");
-
-class Server {
-
-    constructor(environment) {
-
-        this.environment = environment;
-        this.initialTime = new Date();
-        this.port = this.environment.application.serverPort || 8080;
-
-        this.app = express();
-
-        //Grupo de Servicos Expostos na API Gateway
-        this.generateMonitorCheckRoutes(environment);
-
-        this.listServiceGroup = createListServiceGroup(environment.mappingServices);
-
-        this.redisClient = commonsCache.createClient(environment.application);
-        // this.elasticSearch = commonsElasticSearch.createClient(environment.application);
-        this.openSearch = commonsOpenSearch.createClient(environment.application);
-        this.splunkInstance = commonsSplunkInstance.createClient(environment.application);
-        this.express = express;
-        this.validateFlowAndFunctions();
-    }
-
-    async licenseValidation() {
-
-        try {
-
-            const appKey = process.env.APP_KEY;
-
-            if (!appKey) {
-                throw new Error(
-                    "[Heimdall API Platform] APP_KEY não definida. " +
-                    "Configure a variável de ambiente APP_KEY com a chave da sua credencial. " +
-                    "Em caso de dúvidas, entre em contato com o suporte técnico da Heimdall API Platform (P4F)."
-                );
-            }
-
-            const license = await licenseService.validate(appKey);
-
-            if (!license || !license.active) {
-                throw new Error(
-                    `[Heimdall API Platform] Licença inválida ou expirada para a APP_KEY '${appKey}'. ` +
-                    "A aplicação não pode ser iniciada. " +
-                    "Entre em contato com o suporte técnico da Heimdall API Platform da P4F para resolver esse problema."
-                );
-            }
-
-            this.app.locals.license = license;
-
-            console.error("stage=warn method=Server.start license validated", license);
-
-            return true;
-
-        } catch (error) {
-            console.error("stage=error method=Server.start license validation failed", { message: error.message });
-            process.exit(1);
-        }
-
-    }
-
-    generateMonitorCheckRoutes(environment) {
-        let serviceHealthCheck = {
-            basePath: "/healthcheck/",
-            description: "Health Clients",
-            version: "V1",
-            services: [],
-        };
-
-        let mappingClients = environment.mappingClients;
-
-        Object.keys(mappingClients).map(function (clientName) {
-            let currentClientConfig = mappingClients[clientName];
-            serviceHealthCheck.services.push(new templateMonitorCheckRoute(clientName, currentClientConfig));
-        });
-
-        environment.mappingServices.push(serviceHealthCheck);
-    }
-
-    validateFlowAndFunctions() {
-        Util.warning("Validate Flows and Services");
-
-        try {
-            let services = this.listServiceGroup.map((group) => {
-                return group.services.map((service) => {
-                    return new ServiceContext(service, null);
-                });
-            });
-        } catch (error) {
-            Util.throwErrorIfItExists(error);
-        }
-    }
-
-    async start() {
-
-        let self = this;
-
-        await this.licenseValidation();
-
-        //SECURITY HEADERS, UUID, QUERYPARSER, BODYPARSER, MORGAN
-        require("../default-routes-pre")(this);
-
-        //DOCUMENTATION
-        require("../default-routes-docs")(this);
-
-        //CRIA AS ROTAS
-        this.registerServiceRoutes();
-
-        //Default API, VERSION, ROOT
-        require("../default-routes-pos")(this);
-
-        if (this.environment.startServer) {
-            this.app.listen(this.port, function (error) {
-                if (error) {
-                    Util.throwErrorIfItExists(error);
-                } else {
-                    var listenMsg = "\n\n " + self.environment.application.appName.toUpperCase();
-                    listenMsg += "\n +++++++++++++++++++++++++++++++++++++++++++++++++++++";
-                    listenMsg += "\n\n Environment " + self.environment.environment.toUpperCase();
-                    listenMsg += "\n\n Listening on port " + self.port;
-                    listenMsg += "\n\n http://localhost:" + self.port + "/";
-                    listenMsg += "\n\n Groups Services: " + self.listServiceGroup.length;
-                    listenMsg +=
-                        "\n\n Services: " +
-                        self.listServiceGroup
-                            .map((group) => group.services.length)
-                            .reduce((a, b) => a + b, 0);
-                    listenMsg +=
-                        "\n\n Flows: " +
-                        self.listServiceGroup
-                            .map((group) => group.services
-                                .map((service) => service.flow.length)
-                                .reduce((a, b) => a + b, 0))
-                            .reduce((a, b) => a + b, 0);
-                    listenMsg += "\n\n Inicialization in " + (new Date() - self.initialTime) + " ms \n\n";
-                    listenMsg += "+++++++++++++++++++++++++++++++++++++++++++++++++++++ \n\n";
-                    Util.warning(listenMsg);
-                }
-            });
-        }
-    }
-
-    registerServiceRoutes() {
-        let self = this;
-
-        let newRouter = new Router(self.app);
-
-        self.listServiceGroup.forEach(function (currentServiceGroup) {
-            Util.info("stage=init method=Server.registerServiceRoutes serviceGroup", {
-                description: currentServiceGroup.description,
-                basePath: currentServiceGroup.basePath,
-                totalServices: currentServiceGroup.services.length,
-            });
-
-            currentServiceGroup.services.forEach(function (currentServiceOptions) {
-                let route = new ServiceRoute({
-                    path: currentServiceGroup.validatePath
-                        ? path.join("/", currentServiceGroup.basePath, "/", currentServiceOptions.route || "")
-                        : currentServiceGroup.basePath + path.join("/", currentServiceOptions.route || ""),
-                    method: currentServiceOptions.method,
-                    enableUploader: currentServiceOptions.enableUploader,
-                    uploadFieldName: currentServiceOptions.uploadFieldName,
-                    security: currentServiceOptions.security,
-                });
-
-                Util.info(
-                    `stage=info method=Server.registerServiceRoutes route method=${currentServiceOptions.method.toUpperCase()} path=${route.getPath()} serviceName=${currentServiceOptions.name
-                    } totalFlows=${currentServiceOptions.flow.length}`
-                );
-
-                let newOrchestrationFlow = new OrchestrationFlow(self.redisClient);
-
-                let newHandleRoute = new HandleRoute(
-                    newOrchestrationFlow,
-                    currentServiceOptions,
-                    self.splunkInstance,
-                    self.openSearch
-                );
-
-                newRouter.addRoute(route, newHandleRoute);
-            });
-        });
-    }
-}
-
-function createListServiceGroup(mappingServices) {
-    return mappingServices.map((serviceGroup) => {
-        return new ServiceGroup(serviceGroup);
-    });
-}
-
-// Hook into commonJS module systems
-module.exports = Server;

package/lib/services/template-monitorcheck-route.js

@@ -1,61 +0,0 @@
-'use strict';
-
-const path = require('path')
-
-class templateMonitorCheckRoute {
-
-    constructor(clientName, options) {
-
-        this.name = `${clientName}HealthCheck`;
-        this.description = options.description;
-        this.method = 'GET';
-        this.route = `${clientName}`;
-        this.flow = []
-
-        if (options.hasOwnProperty('healthCheck')) {
-            this.flow.push(this.addFlowHealth(clientName, options));
-        };
-
-        if (options.hasOwnProperty('infoCheck')) {
-            this.flow.push(this.addFlowInfo(clientName, options));
-        };
-
-    };
-
-    addFlowInfo(clientName, options) {
-        return {
-            resultVariable: 'info',
-            operation: {
-                clientName: clientName,
-                path: options.infoCheck,
-                type: 'monitor'
-            }
-        };
-    };
-
-    addFlowHealth(clientName, options) {
-        return {
-            resultVariable: 'health',
-            operation: {
-                clientName: clientName,
-                path: options.healthCheck,
-                type: 'monitor'
-            }
-        };
-    };
-
-};
-
-
-
-// {
-//     description: 'Login API',
-//     clientName: 'loginSantander',
-//     basePath: '',
-//     host: 'https://santander2.continuousplatform.com',
-//     poolSize: 50,
-//     timeout: 60000,
-//     healthCheck: 'monitor/health'
-// }
-
-module.exports = templateMonitorCheckRoute;