heimdall-api-platform 1.0.4

package/lib/models/base-context.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const Const = require('../commons-const');
+const { performance } = require('perf_hooks');
+const Util = require('../commons-util');
+const _ = require('underscore')
+
+class BaseContext {
+
+    constructor(uuid, context) {
+        this.uuid = uuid;
+        this.context = context || {};
+        this.statusCode = Const.HTTP_STATUS.OK;
+        //InfoTime
+        this.timers = {
+            created: {
+                at: new Date().toISOString(),
+                ms: performance.now()
+            },
+            started: {
+                at: Util.defaultDateISOString(),
+                ms: 0
+            },
+            finished: {
+                at: Util.defaultDateISOString(),
+                ms: 0
+            },
+            duration: 0
+        };
+        this.error = false;
+        this.executed = false;
+        //Result (Error|Success)
+        this.inputData = {};
+        this.responseHeaders = {};
+        this.result = {};
+    };
+
+    setContext(context) {
+        this.context = context;
+    };
+
+    init() {
+        this.timers.started.ms = performance.now();
+        this.timers.started.at = new Date().toISOString();
+    };
+
+    end() {
+        this.executed = true;
+        this.timers.finished.ms = performance.now();
+        this.timers.finished.at = new Date().toISOString();
+        this.timers.duration = parseFloat((this.timers.finished.ms - this.timers.started.ms).toFixed(4));
+    };
+
+    getResult() {
+        return this.result;
+    };
+
+    //Return JSON to Client
+    getResultJSON() {
+        return Util.stringifyInfo(this.result);
+    }
+
+    setResult(result) {
+        this.result = result || {};
+    };
+
+    addResult(result) {
+        this.result = _.extend(this.result, result);
+    };
+
+    hasResult() {
+        return !(Object.keys(this.result).length === 0 && this.result.constructor === Object);
+    };
+
+}
+
+module.exports = BaseContext;

package/lib/models/elastic-index-data.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const Util = require('../commons-util');
+const FlowIndexed = require('./flow-indexed');
+
+class ElasticIndexData {
+
+   constructor(context) {
+        this.uuid = context.uuid;
+        this.request = {
+            url: {
+                protocol: context.request.secure ? "https:" : "http:",
+                hostname: context.request.hostname,
+                port: context.request.connection.localPort,
+                path: context.request.path,
+                full: `${context.request.secure ? "https:" : "http:"}//${context.request.hostname}${context.request.path}`
+            },
+            socket: {
+                remoteAddress: context.request.socket.remoteAddress,
+                encrypted: context.request.secure
+            },
+            httpVersion: context.request.httpVersion,
+            method: context.request.method,
+            body: Util.stringifyInfo(context.request.body || {}),
+            query: Util.stringifyInfo(context.query || {}),
+            params: Util.stringifyInfo(context.params || {}),
+            headers: context.headers || {}
+        };
+        this.service = {
+            name: context.service.name,
+            description: context.service.description,
+            method: context.service.method,
+            security: context.service.security,
+            indexedResult: context.service.indexedResult,
+            authorizationToken: context.security.authorizationToken || {},
+            responseHeaders: Util.stringifyInfo(context.service.responseHeaders),
+            totalFlows: context.service.flow.length,
+        };
+
+        if (context.service.indexedResult == true ||
+            context.error == true) {
+            this.service.flows = this.generateFlow(context.service.flow, context.service.indexedResult);
+        };
+
+        let result = '';
+
+        if (context.service.indexedResult == true ||
+            context.error == true) {
+            if (context.hasResult())
+                result = Util.stringifyInfo(context.result);
+        };
+
+        this.response = {
+            statusCode: context.response.statusCode,
+            headers: Util.stringifyInfo(context.response.getHeaders()),
+            result: result
+        };
+
+        this.timers = context.timers;
+    };
+
+    generateFlow(flows, indexedResult) {
+
+        let objectFlow = {};
+
+        flows.map((flow, index) => {
+            objectFlow[index + 1] = new FlowIndexed(flow, indexedResult);
+        });
+
+        return objectFlow;
+
+    }
+
+};
+
+module.exports = ElasticIndexData;

package/lib/models/flow-context.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const OperationFlowFactory = require('../factory/operation-flow-factory');
+const BaseContext = require('./base-context');
+const { v4: uuidv4 } = require('uuid');
+const Const = require('../commons-const');
+class FlowContext extends BaseContext {
+
+    constructor(options, context) {
+
+        super(uuidv4(), context);
+        this.resultVariable = options.resultVariable || '.';
+        this.skipErrors = options.skipErrors || false;
+        this.propagateResult = options.propagateResult || false;
+        this.cacheEnable = options.cacheEnable || false;
+        this.condition = this.generateCondition(options);
+        this.validation = options.validation || "true";
+        this.cacheTtl = options.cacheTtl || 0;
+        this.cacheTtlExpression = options.cacheTtlExpression || '';
+        this.cacheName = options.cacheName || '';
+        this.cacheKey = options.cacheKey || '';
+        this.operation = OperationFlowFactory.createOperationByType(options.operation, this);
+    };
+
+    generateCondition(options) {
+
+        let condition = (options.condition || '');
+
+        if (condition.constructor.name == Const.OBJECT_TYPE.OBJECT) {
+
+            condition.whenFail = condition.whenFail || {};
+
+            return {
+                compileExpression: options.condition.compileExpression || "true",
+                whenFail: {
+                    responseHeaders: options.condition.whenFail.responseHeaders || {},
+                    error: options.condition.whenFail.error || false,
+                    result: options.condition.whenFail.result || {},
+                    statusCode: options.condition.whenFail.statusCode || 200
+                }
+            };
+        };
+
+        return {
+            compileExpression: condition || "true",
+            whenFail: {
+                responseHeaders: {},
+                error: false,
+                result: {},
+                statusCode: 200
+            }
+        };
+
+    }
+
+};
+
+module.exports = FlowContext;

package/lib/models/flow-indexed.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const Util = require('../commons-util');
+const Const = require('../commons-const');
+const OperationHttpIndexed = require('./operation-http-indexed');
+const OperationFunctionIndexed = require('./operation-function-indexed');
+const OperationMockIndexed = require('./operation-mock-indexed');
+
+class FlowIndexed {
+
+    constructor(flow, indexedResult) {
+        //DADOS GERAIS
+        this.uuid = flow.uuid;
+        this.hasError = flow.error;
+        this.executed = flow.executed;
+        this.statusCode = flow.statusCode;
+        //COMPORTAMENTO
+        this.behavior = {
+            propagateResultToBody: flow.propagateResult,
+            skipErrors: flow.skipErrors,
+            resultVariable: flow.resultVariable,
+            executeConditions: {
+                condition: flow.condition,
+                validation: flow.validation
+            }
+        };
+        //CACHE
+        this.configCache = {
+            enable: flow.cacheEnable,
+            key: flow.cacheKey || '',
+            name: flow.cacheName || '',
+            ttl: flow.cacheTtl
+        };
+        //OPERACAO DO FLOW
+        this.generateType(flow.operation, indexedResult);
+        //RESULTADO
+        this.result = indexedResult ? Util.stringifyInfo(flow.result) : '';
+        //TIMERS
+        this.duration = flow.timers.duration
+    };
+
+    generateType(operation, indexedResult) {
+
+        switch (operation.type) {
+            case Const.FLOW_OPERATION_TYPE.HTTP:
+                this.operationHttp = new OperationHttpIndexed(operation, indexedResult);
+                break
+            case Const.FLOW_OPERATION_TYPE.FUNCTION:
+                this.operationFunction = new OperationFunctionIndexed(operation, indexedResult);
+                break
+            case Const.FLOW_OPERATION_TYPE.MOCK:
+                this.operationMock = new OperationMockIndexed(operation, indexedResult);
+                break
+            default:
+                break;
+        };
+
+    };
+
+};
+
+module.exports = FlowIndexed;

package/lib/models/operation-function-indexed.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const Util = require('../commons-util');
+
+class OperationFunctionIndexed {
+
+    constructor(operation, indexedResult) {
+        //DADOS GERAIS
+        this.uuid = operation.uuid;
+        this.name = operation.name;
+        this.type = operation.type;
+        this.sourceCode = operation.sourceCode;
+        this.hasError = operation.error;
+        this.executed = operation.executed;
+        this.statusCode = operation.statusCode;
+        this.result = (indexedResult || operation.error) ? Util.stringifyInfo(operation.result) : '';
+        this.duration = operation.timers.duration
+    };
+
+};
+
+module.exports = OperationFunctionIndexed;

package/lib/models/operation-function-transformation-indexed.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Util = require('../commons-util');
+
+class OperationFunctionTransformationIndexed {
+
+    constructor(operation, indexedResult) {
+        //DADOS GERAIS
+        this.uuid = operation.uuid;
+        this.name = operation.name;
+        this.type = operation.type;
+        this.sourceCode = operation.sourceCode;
+        this.hasError = operation.error;
+        this.executed = operation.executed;
+        this.statusCode = operation.statusCode;
+        this.inputData = indexedResult ? Util.stringifyInfo(operation.inputData) : '';
+        this.result = (indexedResult || operation.error) ? Util.stringifyInfo(operation.result) : '';
+        this.duration = operation.timers.duration
+    };
+
+};
+
+module.exports = OperationFunctionTransformationIndexed;

package/lib/models/operation-http-indexed.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const Util = require('../commons-util');
+const Const = require('../commons-const');
+const OperationFuncTransIndexed = require('./operation-function-transformation-indexed');
+
+class OperationHttpIndexed {
+
+    constructor(operation, indexedResult) {
+        //DADOS GERAIS
+        this.uuid = operation.uuid;
+        this.name = operation.name;
+        this.type = operation.type;
+        this.method = operation.method;
+        this.path = operation.path;
+        this.hasError = operation.error;
+        this.executed = operation.executed;
+        this.statusCode = operation.statusCode;
+        this.headers = operation.headers
+        this.mergedHeaders = operation.mergedHeaders;
+        this.httpConfigClient = Util.stringifyInfo(operation.httpClient);
+
+        this.functions = {
+            headersTransformation: new OperationFuncTransIndexed(operation.headersTransformation, indexedResult),
+            requestTransformation: new OperationFuncTransIndexed(operation.requestTransformation, indexedResult),
+            responseTransformation: new OperationFuncTransIndexed(operation.responseTransformation, indexedResult),
+            onError: new OperationFuncTransIndexed(operation.onError, indexedResult),
+            onSuccess: new OperationFuncTransIndexed(operation.onSuccess, indexedResult),
+        };
+
+        this.result = (indexedResult || operation.error) ? Util.stringifyInfo(operation.result) : '';
+        this.duration = operation.timers.duration
+
+    };
+
+};
+
+module.exports = OperationHttpIndexed;

package/lib/models/operation-mock-indexed.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const Util = require('../commons-util');
+
+class OperationMockIndexed {
+
+    constructor(operation, indexedResult) {
+        //DADOS GERAIS
+        this.uuid = operation.uuid;
+        this.description = operation.description || '';
+        this.type = operation.type;
+        this.file = operation.file;
+        this.hasError = operation.error;
+        this.executed = operation.executed;
+        this.statusCode = operation.statusCode;
+        this.result = (indexedResult || operation.error) ? Util.stringifyInfo(operation.result) : '';
+        this.duration = operation.timers.duration
+    };
+
+};
+
+module.exports = OperationMockIndexed;

package/lib/models/route-context.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { v4: uuidv4 } = require('uuid');
+const _ = require('underscore');
+const SecurityRoute = require('./security-route');
+const Const = require('../commons-const');
+const BaseContext = require('./base-context');
+const ServiceContext = require('./service-context');
+const Util = require('../commons-util');
+
+class RouteContext extends BaseContext {
+
+    //Request e response devem manter a referencia
+    constructor(request, response, next, serviceOptions, orchestrator) {
+        super(uuidv4(), {});
+        this.next = next;
+        this.orchestrator = orchestrator;
+        this.service = new ServiceContext(serviceOptions, this);
+        this.statusCode = this.service.statusCode || Const.HTTP_STATUS.OK;
+        this.security = new SecurityRoute();
+        this.request = request;
+        this.response = response;
+        this.body = Util.underscore().clone(request.body) || {};
+        this.query =  Util.underscore().clone(request.query) || {};
+        this.params = _.omit(request.params, Object.keys(request.query)) || {};
+        this.headers =  Util.underscore().clone(request.headers) || {};
+        this.attemptsIndex = 0;
+        this.statusCode = Const.HTTP_STATUS.OK
+    };
+
+    setBody(body) {
+        this.body = body;
+    };
+
+    getBody() {
+        return this.body;
+    };
+
+    getHeaders() {
+        this.headers;
+    };
+
+    setHeaders(headers) {
+        _.extend(this.headers, headers);
+    };
+
+    getResponseHeaders() {
+        this.responseHeaders;
+    };
+
+    setResponseHeaders(headers) {
+        _.extend(this.responseHeaders, headers);
+    };
+
+    setParams(params) {
+        _.extend(this.params, params);
+    };
+
+    setQuery(query) {
+        _.extend(this.query, query);
+    };
+
+    getQuery() {
+        return this.query;
+    };
+
+}
+
+module.exports = RouteContext;

package/lib/models/security-route.js

@@ -0,0 +1,41 @@
+'use strict';
+
+class SecurityRoute {
+    constructor() {
+        this.encryptionKey = null;
+        this.publicKey = null;
+        this.customerUUID = null;
+        this.devicePublicKeyDisgest = null;
+        this.accessToken = null;
+        this.deviceDNA = null;
+
+    }
+
+    setCustomerUUID(customerUUID) {
+        this.customerUUID = customerUUID;
+    };
+
+    setEncryptionKey(encryptionKey) {
+        this.encryptionKey = encryptionKey;
+    };
+
+    setPublicKey(publicKey) {
+        this.publicKey = publicKey;
+    };
+
+    setDevicePublicKeyDisgest(devicePublicKeyDisgest) {
+        this.devicePublicKeyDisgest = devicePublicKeyDisgest;
+    };
+
+    setAccessToken(accessToken) {
+        this.accessToken = accessToken;
+    };
+
+    setDeviceDNA(deviceDNA) {
+        this.deviceDNA = deviceDNA;
+    };
+
+}
+
+
+module.exports = SecurityRoute;

package/lib/models/service-context.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const FlowContext = require('./flow-context');
+const BaseContext = require('./base-context');
+const { v4: uuidv4 } = require('uuid');
+const _ = require('underscore');
+
+class ServiceContext extends BaseContext {
+
+    constructor(options, context) {
+        super(uuidv4(), context);
+        this.name = options.name || '';
+        this.description = options.description || '';
+        this.route = options.route || '';
+        this.scope = options.scope;
+        this.method = options.method.toLowerCase() || 'get';
+        this.security = options.security || false;
+        this.responseHeaders = options.responseHeaders || {};
+        this.flow = createFlows(options.flow, this);
+        this.previousFlow = {};
+        this.currentFlow = {
+            getResult: function () { return null }
+        };
+        this.indexedResult = options.indexedResult || false;
+        this.headers = {};
+        this.responseHeaders = options.responseHeaders || {};
+        this.rawOptions = options;
+        this.authScheme = options.authScheme || {};
+        this.parameters = options.parameters || {};
+        this.requestBody = options.requestBody || {};
+        this.responses = options.responses || {};
+    };
+
+    setCurrentFlow(currentFlow) {
+        this.previousFlow = this.currentFlow;
+        this.currentFlow = currentFlow;
+    }
+
+    getCurrentFlow() {
+        return this.currentFlow;
+    };
+
+    getPreviousFlow() {
+        return this.previousFlow;
+    };
+
+    getTotalFlow() {
+        return this.flow.length;
+    };
+
+    addHeaders(headers) {
+        this.headers = _.extend(this.headers, headers);
+    };
+
+};
+
+function createFlows(flows, context) {
+
+    return flows.map(flow => {
+        return new FlowContext(flow, context);
+    });
+
+};
+
+module.exports = ServiceContext;

package/lib/models/service-group.js

@@ -0,0 +1,15 @@
+'use strict';
+
+class ServiceGroup {
+
+    constructor(options) {
+        this.description = options.description;
+        this.basePath = options.basePath;
+        this.validatePath = options.validatePath === undefined ? true : false;
+        this.services = options.services;
+        this.version = options.version;
+    };
+
+}
+
+module.exports = ServiceGroup;

package/lib/models/service-route.js

@@ -0,0 +1,23 @@
+'use strict';
+
+class ServiceRoute {
+    
+    constructor(options) {
+        //Validate path windows
+        this.path = process.platform === "win32" ? options.path.replace(/\\/g, "/") : options.path;
+        this.security = options.security || false;
+        this.method = options.method.toLowerCase();
+        this.enableUploader = options.enableUploader || false;
+        this.uploadFieldName = options.uploadFieldName || 'file';
+    }
+
+    getPath() {
+        return this.path;
+    };
+
+    getMethod() {
+        return this.method;
+    };
+}
+
+module.exports = ServiceRoute;

package/lib/models/splunk-data.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const Util = require('../commons-util');
+const X_AUTHORIZATION = 'x-authorization';
+
+class SplunkData {
+
+    constructor(context) {
+        this.uuid = context.uuid;
+        this.request = {
+            url: {
+                protocol: context.request.isSecure() ? "https:" : "http:",
+                hostname: context.request.headers.host,
+                port: context.request.connection.localPort,
+                path: context.request.getPath(),
+                full: `${context.request.isSecure() ? "https:" : "http:"}//${context.request.headers.host}${context.request.getPath()}`
+            },
+            socket: {
+                remoteAddress: context.request.socket.remoteAddress,
+                encrypted: context.request.isSecure()
+            },
+            httpVersion: context.request.httpVersion,
+            method: context.request.method,
+            body: Util.stringifyInfo(context.request.body || {}),
+            query: Util.stringifyInfo(context.query || {}),
+            params: Util.stringifyInfo(context.params || {}),
+            headers: this.hideSensitiveHeaders(context.headers) || {}
+        };
+        this.service = {
+            name: context.service.name,
+            description: context.service.description,
+            authorizationToken: context.security.authorizationToken || {}
+        };
+
+        let result = '';
+        if (context.error == true) {
+
+            if (context.hasResult()) {
+                result = Util.stringifyInfo(context.result);
+            }
+
+        };
+
+        this.response = {
+            statusCode: context.response.statusCode,
+            headers: Util.stringifyInfo(context.response.getHeaders()),
+            result: result
+        };
+
+        this.timers = context.timers;
+    };
+
+    hideSensitiveHeaders(headers) {
+        try {
+
+            if (headers.hasOwnProperty(X_AUTHORIZATION)) {
+                let splited_authorization = headers[X_AUTHORIZATION].split(" ");
+                headers[X_AUTHORIZATION] = splited_authorization[0] + " " + Util.replaceCharsForAsterisks(splited_authorization[1]);
+            }
+            
+        } catch (error) {
+            Util.error(`Error on hode sensitive headers: ${JSON.stringify(error)}`)
+        }
+
+        return headers;
+        
+    }
+};
+
+module.exports = SplunkData;