heimdall-api-platform 1.0.4

package/lib/orchestration-flow.js

@@ -0,0 +1,323 @@
+"use strict";
+
+const Util = require("./commons-util");
+const async = require("async");
+const Step = require("step");
+const errors = require("./commons-errors");
+const Const = require("./commons-const");
+const _ = require("underscore");
+const Env = require("./environment").application;
+
+class OrchestrationFlow {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+
+    execute(routeContext, mainCallback) {
+        let self = this;
+
+        routeContext.service.init();
+
+        async.mapSeries(
+            routeContext.service.flow,
+            (flowStep, callbackMapSeries) => {
+                //STEP 1 - VALIDATE CONDITION AND VALIDATION TO EXECUTE FLOW
+                flowStep.service = routeContext.service;
+                
+                if (self.checkCondition(flowStep, routeContext) && self.checkValidation(flowStep, routeContext)) {
+                    self.executeFlowStep(flowStep, routeContext, callbackMapSeries);
+                } else {
+                    self.executeFlowFailed(flowStep, routeContext, callbackMapSeries);
+                }
+            },
+            () => {
+                routeContext.service.end();
+                mainCallback();
+            }
+        );
+    }
+
+    executeFlowFailed(flowStep, routeContext, callbackMapSeries) {
+        let self = this;
+
+        Util.info(
+            `stage=init method=OrchestrationFlow.executeFlowFailed Skip operation flow(${flowStep.operation.type.toUpperCase()}) name=${flowStep.operation.name
+            }`,
+            {
+                flowStepUuid: flowStep.uuid,
+                contextUuid: routeContext.uuid,
+            }
+        );
+
+        //Inicializa timers
+        flowStep.init();
+        routeContext.service.setCurrentFlow(flowStep);
+
+        flowStep.result = flowStep.condition.whenFail.result;
+        flowStep.statusCode = flowStep.condition.whenFail.statusCode;
+        flowStep.error = flowStep.condition.whenFail.error;
+
+        Step(
+            //STEP 4 - UPDATE MAIN CONTEXT
+            function () {
+                self.updateRouteContext(flowStep, routeContext, this);
+            },
+            //STEP 5 - SKIP ERROR?
+            function () {
+                flowStep.end();
+                callbackMapSeries(!flowStep.skipErrors && flowStep.error ? true : null);
+            }
+        );
+    }
+
+    executeFlowStep(flowStep, routeContext, callbackMapSeries) {
+        let self = this;
+
+        if (!flowStep.operation) {
+            callback(new errors.ApiGatewayError("An operation must be provided to execute the flow."));
+        } else {
+            //Inicializa timers
+            flowStep.init();
+            routeContext.service.setCurrentFlow(flowStep);
+
+            Step(
+                //STEP 1 - LOAD CACHE
+                function () {
+                    self.getResponseFlowFromCache(flowStep, routeContext, this);
+                },
+                //STEP 2 - VALIDATE CACHE / EXECUTE FLOW
+                function (responseFlowCache) {
+                    self.executeFlowOperation(responseFlowCache, flowStep, routeContext, this);
+                },
+                //STEP 4 - UPDATE MAIN CONTEXT
+                function () {
+                    self.updateRouteContext(flowStep, routeContext, this);
+                },
+                //STEP 5 - SKIP ERROR?
+                function () {
+                    flowStep.end();
+                    callbackMapSeries(!flowStep.skipErrors && flowStep.error ? true : null);
+                }
+            );
+        }
+    }
+
+    executeFlowOperation(responseFlowCache, flowStep, routeContext, callbackStep) {
+        if (!responseFlowCache) {
+            flowStep.operation.execute(flowStep, routeContext, () => {
+                this.validateCache(flowStep, routeContext, callbackStep);
+            });
+        } else {
+            flowStep.statusCode = responseFlowCache.statusCode;
+            flowStep.setResult(Util.tryParseJSON(responseFlowCache.result));
+            callbackStep();
+        }
+    }
+
+    async getResponseFlowFromCache(flowStep, routeContext, callbackStep) {
+
+        let self = this;
+
+        if (this.redisClient.enableRedis && flowStep.cacheEnable) {
+
+            let cacheKey = self.generateCacheKey(flowStep, routeContext);
+
+            Util.info(
+                `stage=info method=OrchestrationFlow.getResponseFlowFromCache flow=${flowStep.operation.type.toUpperCase()} name=${flowStep.operation.name
+                } function=getResponseFlowFromCache cacheKey=${cacheKey}`
+            );
+
+            callbackStep(await this.redisClient.get(flowStep.cacheName || routeContext.service.name, cacheKey));
+
+        } else {
+            callbackStep(null);
+        }
+    }
+
+    async validateCache(flowStep, routeContext, callbackStep) {
+
+        if (!this.shouldCache(flowStep)) {
+            return callbackStep();
+        }
+
+        const cacheKey = this.generateCacheKey(flowStep, routeContext);
+        const cacheTtl = this.resolveCacheTtl(flowStep, routeContext, cacheKey);
+
+        Util.info(
+            `stage=info method=OrchestrationFlow.validateCache flow=${flowStep.operation.type.toUpperCase()} name=${flowStep.operation.name} cacheKey=${cacheKey} finalCacheTtl=${cacheTtl}`
+        );
+
+        await this.saveToCache(flowStep, routeContext, cacheKey, cacheTtl);
+
+        callbackStep();
+    }
+
+    shouldCache(flowStep) {
+        return this.redisClient?.enableRedis && flowStep?.cacheEnable && !flowStep?.error && flowStep.getResult();
+    }
+
+    resolveCacheTtl(flowStep, routeContext, cacheKey) {
+        
+        let cacheTtl = flowStep.cacheTtl || 0;
+
+        try {
+            const cacheTtlExpression = this.generateCacheTTLExpression(flowStep, routeContext);
+            if (cacheTtlExpression) {
+                cacheTtl = cacheTtlExpression;
+                Util.info(
+                    `stage=info method=OrchestrationFlow.resolveCacheTtl flow=${flowStep.operation.type.toUpperCase()} name=${flowStep.operation.name} cacheKey=${cacheKey} resolvedCacheTtl=${cacheTtl}`
+                );
+            } else {
+                Util.info(
+                    `stage=info method=OrchestrationFlow.resolveCacheTtl flow=${flowStep.operation.type.toUpperCase()} name=${flowStep.operation.name} cacheKey=${cacheKey} message="No cacheTtlExpression found, using fallback cacheTtl=${cacheTtl}"`
+                );
+            }
+        } catch (error) {
+            Util.warn(
+                `stage=warn method=OrchestrationFlow.resolveCacheTtl flow=${flowStep.operation.type.toUpperCase()} name=${flowStep.operation.name} cacheKey=${cacheKey} message="Failed to evaluate cacheTtlExpression, falling back to cacheTtl=${cacheTtl}" error=${error.message}`
+            );
+        }
+
+        return cacheTtl;
+    }
+
+    async saveToCache(flowStep, routeContext, cacheKey, cacheTtl) {
+        await this.redisClient.put(
+            flowStep.cacheName || routeContext.service.name,
+            cacheKey,
+            {
+                result: flowStep.getResult(),
+                statusCode: flowStep.statusCode,
+            },
+            cacheTtl
+        );
+    }
+
+    getCompileContext(context) {
+        return _.extend(context, {
+            env: Env,
+        });
+    }
+
+    checkCondition(flowStep, routeContext) {
+        let { condition } = flowStep;
+
+        try {
+            return (
+                condition.compileExpression === true ||
+                _.template(condition.compileExpression)(this.getCompileContext(routeContext)) === "true"
+            );
+        } catch (error) {
+            Util.error(`stage=error method=OrchestrationFlow.checkCondition compile condition=${condition.compileExpression} error`, error);
+            return false;
+        }
+    }
+
+    checkValidation(flowStep, routeContext) {
+        let { validation } = flowStep;
+
+        try {
+            if (validation !== true && _.template(validation)(this.getCompileContext(routeContext)) !== "true") {
+                throw new errors.SecurityError("Unauthorized");
+            } else {
+                return true;
+            }
+        } catch (error) {
+            Util.error(`stage=error method=OrchestrationFlow.checkValidation compile condition=${validation} error`, error);
+            return false;
+        }
+    }
+
+    updateRouteContext(flowStep, routeContext, callbackStep) {
+        //FOR RESPONSE TO CLIENT USE THIS RESULT
+        if (flowStep.hasResult() || flowStep.resultVariable !== Const.OPERATION_RESULT_IS_ORCHESTRATION_RESULT) {
+            //Propagate Result Flow to Body for the Next Flow
+            if (flowStep.propagateResult) {
+                routeContext.setBody(flowStep.getResult());
+            }
+
+            //ADD ALL RESULTS TO SERVICE FOR HELP FLOWS
+            routeContext.service.addResult(flowStep.getResult());
+            routeContext.service.addHeaders(flowStep.responseHeaders);
+
+            if (flowStep.resultVariable === Const.OPERATION_RESULT_IS_ORCHESTRATION_RESULT) {
+                routeContext.setResult(flowStep.getResult());
+            } else {
+                routeContext.setResult(
+                    Util.setValue(routeContext.getResult(), flowStep.resultVariable, flowStep.getResult())
+                );
+            }
+
+            routeContext.statusCode = flowStep.statusCode;
+            routeContext.error = flowStep.error;
+        }
+
+        callbackStep();
+    }
+
+    compileCacheKey(cacheKey, routeContext) {
+
+        try {
+            let contextData = {
+                ...routeContext,
+                queryHash: Util.generateQueryHash(routeContext.query),
+                result: typeof routeContext.getResult === "function" ? routeContext.getResult() : routeContext.result
+            };
+            let compiled = _.template(cacheKey);
+            return compiled(contextData);
+        } catch (error) {
+            Util.error(`stage=error method=OrchestrationFlow.compileCacheKey compile cacheKey=${cacheKey} error`, error);
+            return cacheKey;
+        }
+
+    }
+
+    generateCacheKey(flowStep, routeContext) {
+        let self = this;
+
+        if (flowStep.cacheKey) {
+            return self.compileCacheKey(flowStep.cacheKey, routeContext);
+        } else {
+            return self.getRequestDNA(routeContext);
+        }
+    }
+
+    generateCacheTTLExpression(flowStep, routeContext) {
+
+        let self = this;
+
+        if (flowStep.cacheTtlExpression) {
+            return self.compileCacheKey(flowStep.cacheTtlExpression, routeContext);
+        } else {
+            return 0;
+        }
+
+    }
+
+    getRequestDNA(routeContext) {
+        let body = JSON.stringify(Util.underscore().clone(routeContext.request.body || {}));
+
+        return Util.generateKey(
+            JSON.stringify({
+                url: {
+                    protocol: routeContext.request.secure ? "https:" : "http:",
+                    hostname: routeContext.request.hostname,
+                    port: routeContext.request.connection.localPort,
+                    path: routeContext.request.path,
+                },
+                socket: {
+                    remoteAddress: routeContext.request.socket.remoteAddress,
+                    encrypted: routeContext.request.secure,
+                },
+                httpVersion: routeContext.request.httpVersion,
+                method: routeContext.request.method,
+                body: body,
+                query: routeContext.query || {},
+                params: routeContext.params || {},
+                headers: routeContext.headers || {},
+            })
+        );
+    }
+}
+
+module.exports = OrchestrationFlow;

package/lib/public/redoc.html

@@ -0,0 +1,152 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Documentação da API | Pay2B</title>
+
+  <link rel="icon" href="https://pay2b.com.br/favicon.ico" type="image/x-icon" />
+  <script src="https://cdn.redoc.ly/redoc/latest/bundles/redoc.standalone.js"></script>
+
+  <style>
+    html,
+    body {
+      margin: 0;
+      padding: 0;
+      height: 100%;
+      font-family: "Segoe UI", Tahoma, sans-serif;
+      background-color: #f9fafc;
+      color: #333;
+    }
+
+    .navbar {
+      background-color: #1f2d3d;
+      color: #fff;
+      padding: 12px 24px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+    }
+
+    .navbar__logo {
+      display: flex;
+      align-items: center;
+    }
+
+    .navbar__logo img {
+      height: 36px;
+      margin-right: 12px;
+    }
+
+    .navbar__title {
+      font-size: 18px;
+      font-weight: bold;
+    }
+
+    #redoc-container {
+      height: calc(100% - 120px);
+      /* espaço reservado para navbar e footer */
+    }
+
+    .pay2b-footer {
+      background-color: #1f2d3d;
+      color: #fff;
+      padding: 20px 40px;
+      font-size: 14px;
+    }
+
+    .footer__container {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      flex-wrap: wrap;
+    }
+
+    .footer__left {
+      display: flex;
+      align-items: center;
+    }
+
+    .footer__logo {
+      height: 28px;
+    }
+
+    .footer__right {
+      display: flex;
+      flex-wrap: wrap;
+      align-items: center;
+      gap: 12px;
+      font-weight: 400;
+    }
+
+    .footer__right a {
+      color: #fff;
+      text-decoration: none;
+      transition: opacity 0.2s;
+    }
+
+    .footer__right a:hover {
+      opacity: 0.75;
+    }
+
+    .sep {
+      color: #999;
+    }
+  </style>
+</head>
+
+<body>
+
+  <!-- Navbar -->
+  <div class="navbar">
+    <div class="navbar__logo">
+      <img src="https://cdn-email.s3.us-east-1.amazonaws.com/images/pay2b-logo-header.png" alt="Pay2B Logo" />
+      <span class="navbar__title">Documentação da API</span>
+    </div>
+  </div>
+
+  <!-- ReDoc container -->
+  <div id="redoc-container"></div>
+
+  <!-- Footer -->
+  <footer class="pay2b-footer">
+    <div class="footer__container">
+      <div class="footer__left">
+        <img src="https://cdn-email.s3.us-east-1.amazonaws.com/images/pay2b-logo-header.png" alt="Pay2B"
+          class="footer__logo" />
+      </div>
+      <div class="footer__right">
+        <a href="https://www.linkedin.com/company/pay2b" target="_blank" rel="noopener noreferrer">LinkedIn</a>
+        <span class="sep">|</span>
+        <a href="https://pay2b.com.br/termos" target="_blank">Termos e Condições</a>
+        <span class="sep">|</span>
+        <a href="https://www.pay2b.com.br/politica-de-privacidade" target="_blank">Política de Privacidade</a>
+      </div>
+    </div>
+  </footer>
+
+  <!-- Redoc script -->
+  <script>
+    Redoc.init('/docs/openapi.yaml', {
+      theme: {
+        colors: {
+          primary: {
+            main: '#5B2C6F'
+          }
+        },
+        typography: {
+          fontFamily: 'Segoe UI, Tahoma, sans-serif',
+          headings: {
+            fontWeight: 'bold'
+          }
+        }
+      },
+      scrollYOffset: 60,
+      hideDownloadButton: false,
+      expandResponses: '200,201'
+    }, document.getElementById('redoc-container'));
+  </script>
+</body>
+
+</html>

package/lib/public/swagger.html

@@ -0,0 +1,143 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+
+<head>
+    <meta charset="UTF-8" />
+    <title>Pay2B API Reference</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    <link rel="icon" href="https://pay2b.com.br/favicon.ico" type="image/x-icon" />
+
+    <!-- Swagger UI assets -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist/swagger-ui.css" />
+    <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist/swagger-ui-bundle.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist/swagger-ui-standalone-preset.js"></script>
+
+    <style>
+        html,
+        body {
+            margin: 0;
+            padding: 0;
+            font-family: "Segoe UI", Roboto, sans-serif;
+            background-color: #f5f6fa;
+        }
+
+        .header {
+            background-color: #1f2d3d;
+            color: white;
+            padding: 16px 32px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        .header-left {
+            display: flex;
+            align-items: center;
+        }
+
+        .header-left img {
+            height: 36px;
+            margin-right: 12px;
+        }
+
+        .header-left h1 {
+            font-size: 20px;
+            margin: 0;
+            font-weight: 600;
+        }
+
+        #swagger-ui {
+            margin: 0 auto;
+            max-width: 1400px;
+            padding: 24px;
+            background-color: white;
+            box-shadow: 0 0 5px rgba(0, 0, 0, 0.05);
+        }
+
+        footer {
+            background-color: #1f2d3d;
+            color: white;
+            padding: 20px 32px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            flex-wrap: wrap;
+            font-size: 14px;
+        }
+
+        footer .footer-left img {
+            height: 26px;
+        }
+
+        footer .footer-right {
+            display: flex;
+            gap: 16px;
+        }
+
+        footer .footer-right a {
+            color: #fff;
+            text-decoration: none;
+        }
+
+        footer .footer-right a:hover {
+            opacity: 0.8;
+        }
+
+        @media (max-width: 768px) {
+
+            .header,
+            footer {
+                flex-direction: column;
+                align-items: flex-start;
+                gap: 12px;
+            }
+
+            #swagger-ui {
+                padding: 12px;
+            }
+        }
+    </style>
+</head>
+
+<body>
+
+    <div class="header">
+        <div class="header-left">
+            <img src="https://cdn-email.s3.us-east-1.amazonaws.com/images/pay2b-logo-header.png" alt="Pay2B Logo" />
+            <h1>API Reference</h1>
+        </div>
+    </div>
+
+    <div id="swagger-ui"></div>
+
+    <footer>
+        <div class="footer-left">
+            <img src="https://cdn-email.s3.us-east-1.amazonaws.com/images/pay2b-logo-header.png" alt="Pay2B Logo" />
+        </div>
+        <div class="footer-right">
+            <a href="https://www.linkedin.com/company/pay2b" target="_blank">LinkedIn</a>
+            <a href="https://www.instagram.com/pay2b.oficial" target="_blank">Instagram</a>
+            <a href="https://www.pay2b.com.br/politica-de-privacidade" target="_blank">Política de privacidade</a>
+        </div>
+    </footer>
+
+    <script>
+        window.onload = () => {
+            SwaggerUIBundle({
+                url: "/docs/openapi.yaml",
+                dom_id: "#swagger-ui",
+                deepLinking: true,
+                presets: [
+                    SwaggerUIBundle.presets.apis,
+                    SwaggerUIStandalonePreset
+                ],
+                layout: "StandaloneLayout",
+                docExpansion: "none",
+                operationsSorter: "alpha"
+            });
+        };
+    </script>
+</body>
+
+</html>

package/lib/router.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const multer = require('multer');
+
+class Router {
+
+    constructor(app) {
+        this.app = app;
+        const storage = multer.memoryStorage();
+        this.upload = multer({ storage });
+    }
+
+    addRoute(route, handler) {
+        const middleware = [];
+
+        // Adiciona o middleware de upload de arquivos se a propriedade 'enableUploader' estiver definida
+        if (route.enableUploader) {
+            middleware.push(this.upload.single(route.uploadFieldName || 'file'));
+        }
+
+        middleware.push((request, response, next) => {
+            handler.handleRequest(request, response, next);
+        });
+
+        this.app[route.getMethod()](route.getPath(), middleware);
+    }
+}
+
+module.exports = Router;

package/lib/security-validation.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var Step = require('step');
+var jwtUtil = require('./jwt-util');
+
+var securityValidation = (function() {
+
+    function execute(context, callback) {
+
+        if (context.service.security) {
+
+            var xAccessToken = context.headers['x-access-token'];
+
+            Step(
+                function() {
+                    jwtUtil.validateAccessToken(xAccessToken, this);
+                },
+                function(error, decodedPayload) {
+                    if (!error) {
+                        updateContext(context, decodedPayload);
+                    }
+                    return callback(error);
+                }
+            );
+
+        } else {
+            return callback();
+        }
+
+    }
+
+    function updateContext(context, decodedPayload) {
+        context.security.setCustomerUUID(decodedPayload.uuid);
+        context.security.setDeviceDNA(decodedPayload.deviceDNA);
+        context.security.setDevicePublicKeyDisgest(decodedPayload.devicePublicKeyDisgest);
+        context.security.setAccessToken(decodedPayload.accessToken);
+    }
+
+    return {
+        execute: execute
+    };
+
+})();
+
+
+module.exports = securityValidation;