heimdall-api-platform 1.0.4

package/lib/operations/abstract-operation.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const _ = require("underscore");
+const Const = require("../commons-const");
+const Util = require("../commons-util");
+const { Errors } = require("../commons-errors");
+const BaseContext = require("../models/base-context");
+
+class AbstractOperation extends BaseContext {
+    constructor(uuid, context) {
+        super(uuid, context);
+    }
+
+    execute(flowStepToUpdate, context, callbackFromOrchestrationFlow) {
+        this.init();
+        this.doExecute({ context: context, flowStep: flowStepToUpdate }, (error, result) => {
+            this.end();
+            this.loggingResponse();
+            this.handleResponse(error, result, flowStepToUpdate, callbackFromOrchestrationFlow);
+        });
+    }
+
+    executeFunction(inputData, context, callbackStepOperation) {
+        this.init();
+        this.inputData = _.clone(inputData); //OBRIGAR A RETORNAR O OBJETO ALTERDO
+        this.doExecuteFunction(inputData, context, (error, result) => {
+            this.end();
+            this.loggingResponse();
+            callbackStepOperation(error, result);
+        });
+    }
+
+    handleResponse(error, result, flowStepToUpdate, callbackFromOrchestrationFlow) {
+        flowStepToUpdate.responseHeaders = this.responseHeaders;
+
+        if (error) {
+            let objectError = Errors.handleError(Util.parseJSON(error || {}));
+            flowStepToUpdate.statusCode = objectError.responseCode;
+            flowStepToUpdate.error = true;
+            if (flowStepToUpdate.operation.type === "function") {
+                flowStepToUpdate.setResult(Util.tryParseJSON(objectError));
+            } else {
+                flowStepToUpdate.setResult(
+                    Util.tryParseJSON(flowStepToUpdate.operation.encapsuleError || true ? objectError : error)
+                );
+            }
+            callbackFromOrchestrationFlow(objectError, null);
+        } else {
+            flowStepToUpdate.statusCode = Const.HTTP_STATUS.OK;
+            flowStepToUpdate.error = false;
+            flowStepToUpdate.setResult(Util.tryParseJSON(result));
+            callbackFromOrchestrationFlow(null, Util.tryParseJSON(result));
+        }
+    }
+
+    loggingResponse() {
+        Util.info(
+            `stage=end method=AbstractOperation.loggingResponse operation function flow(${this.type.toUpperCase()}) name=${this.name}`,
+            _.extend(this.getDefaultResponse(), { result: Util.obfuscationJSON(this.getResult()) })
+        );
+    }
+
+    getDefaultResponse() {
+        return {
+            flowStepUuid: this.uuid,
+            contextUuid: this.context.uuid,
+            functionName: this.name,
+            duration: this.timers.duration,
+        };
+    }
+}
+
+module.exports = AbstractOperation;

package/lib/operations/function.js

@@ -0,0 +1,143 @@
+"use strict";
+
+const FunctionFactory = require("../factory/function-factory");
+const AbstractOperation = require("./abstract-operation");
+const Const = require("../commons-const");
+const { CreateFunctionError } = require("../commons-errors");
+const Util = require("../commons-util");
+const { v4: uuidv4 } = require("uuid");
+
+class Function extends AbstractOperation {
+    constructor(options, context) {
+        super(uuidv4(), context);
+        this.type = options.type;
+        this.name = options.functionName;
+        this.dir = options.dir;
+        this.function = FunctionFactory.createFunctionByName(options);
+        this.sourceCode = this.function.handle.toString();
+    }
+
+    //Flow
+    doExecute(options, callbackAbstractOperation) {
+        Util.info(`stage=init method=Function.doExecute operation function name=${this.name}`, {
+            uuid: this.uuid,
+            flowStepUuid: options.flowStep.uuid,
+            contextUuid: options.context.uuid,
+            sourceCode: Util.stringifyInfo(this.sourceCode),
+        });
+
+        try {
+            this.handleFunctionFlow(options.context, callbackAbstractOperation);
+        } catch (error) {
+            Util.error(`stage=error method=Function.doExecute operation function flow name=${this.name}`, error);
+            this.handleFunctionError(error, callbackAbstractOperation);
+        }
+    }
+
+    //Function part of Flow
+    doExecuteFunction(options, context, callbackAbstractOperation) {
+        Util.info(`stage=init method=Function.doExecuteFunction operation function name=${this.name}`, {
+            uuid: this.uuid,
+            contextUuid: context.uuid,
+            sourceCode: Util.stringifyInfo(this.sourceCode),
+        });
+
+        try {
+            this.handleFunction(options, context, callbackAbstractOperation);
+        } catch (error) {
+            Util.error(`stage=error method=Function.doExecuteFunction operation function name=${this.name}`, error);
+            this.handleFunctionError(error, callbackAbstractOperation);
+        }
+    }
+
+    //Function part of Flow
+    doExecuteFunctionWithoutCallback(options, context) {
+        Util.info(`stage=init method=Function.doExecuteFunctionWithoutCallback operation function name=${this.name}`, {
+            uuid: this.uuid,
+            contextUuid: context.uuid,
+            sourceCode: Util.stringifyInfo(this.sourceCode),
+        });
+
+        try {
+            this.function.handle(options, context);
+        } catch (error) {
+            Util.error(`stage=error method=Function.doExecuteFunctionWithoutCallback operation function name=${this.name}`, error);
+        }
+    }
+
+    handleFunctionFlow(context, callbackAbstractOperation) {
+        let result = this.function.handle(context);
+
+        this.validateResponse(result, callbackAbstractOperation);
+    }
+
+    handleFunction(options, context, callbackAbstractOperation) {
+        let result = this.function.handle(options, context);
+
+        this.validateResponse(result, callbackAbstractOperation);
+    }
+
+    validateResult(result) {
+        let resultValidated = result || "";
+
+        if (!typeof resultValidated === "string") {
+            if (!resultValidated.hasOwnProperty("statusCode")) {
+                resultValidated.statusCode = Const.HTTP_STATUS.OK;
+            }
+        }
+
+        return resultValidated;
+    }
+
+    validateResponse(result, callbackAbstractOperation) {
+        let resultValidated = this.validateResult(result);
+
+        switch (resultValidated.constructor) {
+            case Promise:
+                result
+                    .then((resultPromises) => {
+                        this.statusCode = (resultPromises || {}).statusCode || Const.HTTP_STATUS.OK;
+                        this.error = false;
+                        if ((resultPromises || {}).statusCode !== undefined) {
+                            delete resultPromises["statusCode"];
+                        }
+                        this.setResult(resultPromises || null);
+                        callbackAbstractOperation(null, resultPromises || null);
+                    })
+                    .catch((errorPromises) => {
+                        let objectError = new CreateFunctionError(errorPromises);
+                        this.statusCode = objectError.responseCode;
+                        this.error = true;
+                        this.setResult(Util.tryParseJSON(objectError));
+                        callbackAbstractOperation(errorPromises, null);
+                    });
+                break;
+            case Object:
+                this.statusCode = result.statusCode || Const.HTTP_STATUS.OK;
+                this.error = false;
+                delete result["statusCode"];
+                this.setResult(result || {});
+                callbackAbstractOperation(null, result);
+                break;
+            case String:
+                this.statusCode = Const.HTTP_STATUS.OK;
+                this.error = false;
+                this.setResult(result || "");
+                callbackAbstractOperation(null, result);
+                break;
+            default:
+                callbackAbstractOperation(null, result);
+                break;
+        }
+    }
+
+    handleFunctionError(error, callbackAbstractOperation) {
+        let objectError = new CreateFunctionError(error);
+        this.statusCode = objectError.responseCode;
+        this.error = true;
+        this.setResult(Util.tryParseJSON(objectError));
+        callbackAbstractOperation(objectError, null);
+    }
+}
+
+module.exports = Function;

package/lib/operations/http.js

@@ -0,0 +1,286 @@
+"use strict";
+
+const Util = require("../commons-util");
+const Env = require("../environment").application;
+const Step = require("step");
+const _ = require("underscore");
+
+const ClientFactory = require("../factory/client-factory");
+const Const = require("../commons-const");
+const { Errors } = require("../commons-errors");
+const AbstractOperation = require("./abstract-operation");
+const { v4: uuidv4 } = require("uuid");
+const TransformationFunctionFactory = require("../factory/transformation-function-factory");
+
+_.templateSettings = {
+    interpolate: /\{\{(.+?)\}\}/g,
+};
+
+class Http extends AbstractOperation {
+    constructor(options, flowContext) {
+        super(uuidv4(), flowContext);
+
+        this.type = options.type || Const.FLOW_OPERATION_TYPE.HTTP;
+        this.path = options.path || "";
+        this.method = options.method || Const.HTTP_METHOD.GET;
+        this.body = options.body || "";
+        this.mergedHeaders = options.mergedHeaders == undefined ? false : options.mergedHeaders;
+        this.encapsuleError = options.encapsuleError == undefined ? true : options.encapsuleError;
+        this.httpClient = ClientFactory.createByName(options.clientName);
+        this.headers = options.headers || {};
+        this.name = options.clientName;
+        this.headersTransformation = TransformationFunctionFactory.create(options.headersTransformation, this);
+        this.requestTransformation = TransformationFunctionFactory.create(options.requestTransformation, this);
+        this.responseTransformation = TransformationFunctionFactory.create(options.responseTransformation, this);
+        this.ifResponseError = TransformationFunctionFactory.create(options.ifResponseError, this);
+        this.onError = TransformationFunctionFactory.create(options.onError, this);
+        this.onSuccess = TransformationFunctionFactory.create(options.onSuccess, this);
+    }
+
+    doExecute(options, callbackAbstractOperation) {
+        
+        let self = this;
+
+        let context = options.context;
+
+        let optionsInvoke = {
+            path: this.compilePath(this.path, context),
+            method: this.method,
+            query: context.query,
+            body: this.compileBody(context.body, context),
+            params: context.params,
+            headers: this.headers,
+            uuid: this.uuid,
+            flowStepUuid: options.flowStep.uuid,
+            contextUuid: context.uuid,
+            name: this.name,
+            type: this.type.toUpperCase(),
+            request: context.request,
+            service: options.flowStep.service,
+        };
+
+        Util.info(
+            `stage=init method=Http.doExecute Options (Before Transformation) operation flow(${optionsInvoke.type}) name=${optionsInvoke.name}`,
+            {
+                uuid: optionsInvoke.uuid,
+                flowStepUuid: optionsInvoke.flowStepUuid,
+                contextUuid: optionsInvoke.contextUuid,
+                method: optionsInvoke.method,
+                path: optionsInvoke.path,
+                body: Util.isJSONValid(optionsInvoke.body) ? Util.obfuscationJSON(optionsInvoke.body) : {},
+                form: optionsInvoke.form || {},
+                query: optionsInvoke.qs || {},
+                headers: Util.obfuscationJSON(optionsInvoke.headers || {}),
+            }
+        );
+
+        Step(
+            function () {
+                self.prepareHeaders(optionsInvoke, context, this);
+            },
+            function (error) {
+                Util.throwErrorIfItExists(error);
+                self.headersTransformation.doExecuteFunction(optionsInvoke.headers, context, this);
+            },
+            function (error, headersTransformed) {
+                Util.throwErrorIfItExists(error);
+                //CLONAR PARA OBRIGAR A FUNCTION RETORNAR O VALOR
+                optionsInvoke.headers = headersTransformed || optionsInvoke.headers;
+                self.requestTransformation.doExecuteFunction(_.clone(optionsInvoke), context, this);
+            },
+            function (error, optionsInvokeTransformed) {
+                Util.throwErrorIfItExists(error);
+                self.invokeService(optionsInvokeTransformed || optionsInvoke, this);
+            },
+            function (error, response) {
+                self.handleHttpResponse(error, response, this);
+            },
+            function (error, result) {
+                if (error) {
+                    self.onError.doExecuteFunctionWithoutCallback(error, context);
+
+                    if (self.context.skipErrors) {
+                        self.responseTransformation.doExecuteFunction(error, context, (error, result) => {
+                            this(null, error || result);
+                        });
+                    } else {
+                        self.responseTransformation.doExecuteFunction(error, context, (error, result) => {
+                            this(error || result, null);
+                        });
+                    }
+                } else {
+                    self.onSuccess.doExecuteFunctionWithoutCallback(result, context);
+                    self.responseTransformation.doExecuteFunction(result, context, this);
+                }
+            },
+            function (error, result) {
+                callbackAbstractOperation(error, result);
+            }
+        );
+    }
+
+    invokeService(optionsInvoke, callbackStep) {
+        Util.info(
+            `stage=init method=Http.invokeService Options (Before Transformation) operation flow(${optionsInvoke.type}) name=${optionsInvoke.name}`,
+            {
+                uuid: optionsInvoke.uuid,
+                flowStepUuid: optionsInvoke.flowStepUuid,
+                contextUuid: optionsInvoke.contextUuid,
+                method: optionsInvoke.method,
+                path: optionsInvoke.path,
+                body: Util.isJSONValid(optionsInvoke.body) ? Util.obfuscationJSON(optionsInvoke.body) : {},
+                form: optionsInvoke.form || {},
+                query: optionsInvoke.qs || {},
+                headers: Util.obfuscationJSON(optionsInvoke.headers || {}),
+            }
+        );
+
+        this.httpClient.execute(optionsInvoke, callbackStep);
+    }
+
+    handleHttpResponse(error, response, callbackStep) {
+        let responseHeaders = response && response.hasOwnProperty("headers") ? response.headers : {};
+
+        if (error) {
+            let objectError = Errors.handleError(Util.parseJSON(error || {}));
+            this.statusCode = objectError.responseCode;
+            this.responseHeaders = responseHeaders;
+            this.error = true;
+            this.setResult(Util.tryParseJSON(error));
+            callbackStep(error, null);
+        } else {
+            this.statusCode = response.status;
+            this.error = false;
+            this.responseHeaders = responseHeaders;
+            this.setResult(Util.tryParseJSON(response.data));
+            callbackStep(null, this.getResult());
+        }
+    }
+
+    //Override from AbstractOperation handleResponse
+    //Update flowStep from operation
+    handleResponse(error, result, flowStep, callbackFromOrchestrationFlow) {
+        flowStep.statusCode = this.statusCode;
+        flowStep.error = this.error;
+        flowStep.responseHeaders = this.responseHeaders;
+
+        if (error) {
+            let objectError = Errors.handleError(Util.parseJSON(error || {}));
+            flowStep.setResult(Util.tryParseJSON(flowStep.operation.encapsuleError ? objectError : error));
+            callbackFromOrchestrationFlow(objectError, null);
+        } else {
+            flowStep.setResult(Util.tryParseJSON(result));
+            callbackFromOrchestrationFlow(null, Util.tryParseJSON(result));
+        }
+    }
+
+    prepareHeaders(optionsInvoke, context, callbackStep) {
+        try {
+            optionsInvoke.headers = this.compileHeaders(optionsInvoke.headers, context);
+
+            //ADD ROUTE CONTEXT UUID
+            optionsInvoke.headers = _.extend(optionsInvoke.headers, {
+                [Const.HEADERS.X_REQUEST_UUID_NAME]: context.uuid,
+            });
+
+            //ADD WHITE LABEL UUID
+            if (context.headers[Const.HEADERS.X_WHITE_LABEL_UUID_NAME]) {
+                optionsInvoke.headers = _.extend(optionsInvoke.headers, {
+                    [Const.HEADERS.X_WHITE_LABEL_UUID_NAME]: context.headers[Const.HEADERS.X_WHITE_LABEL_UUID_NAME],
+                });
+            }
+
+            //TODO: ADICIONAR ESSA LINHA EM UMA TRANSFORMACAO DE HEADER
+            if (context.security.customerUUID) {
+                optionsInvoke.headers = _.extend(optionsInvoke.headers, {
+                    [Const.HEADERS.X_CUSTOMER_UUID_NAME]: context.security.customerUUID,
+                });
+            }
+
+            callbackStep();
+        } catch (error) {
+            Util.error(`stage=error method=Http.prepareHeaders headers=${optionsInvoke.headers} error`, error);
+            callbackStep(error);
+        }
+    }
+
+    compileBody(body, context) {
+        let bodyCompiled = Util.underscore().clone(body);
+
+        if (this.body.indexOf("{{") !== -1) {
+            try {
+                let compiled = _.template(this.body);
+                bodyCompiled = compiled(this.getCompileContext(context));
+                Util.info("stage=info method=Http.compileBody result", {
+                    body: body,
+                    bodyCompiled: bodyCompiled,
+                });
+            } catch (error) {
+                Util.error(`stage=error method=Http.compileBody body=${body} error`, error);
+            }
+        }
+
+        return bodyCompiled;
+    }
+
+    compilePath(path, context) {
+        let pathCompiled = _.clone(path);
+
+        if (path.indexOf("{{") !== -1) {
+            try {
+                let compiled = _.template(path);
+                pathCompiled = compiled(this.getCompileContext(context));
+                Util.info("stage=info method=Http.compilePath result", {
+                    path: path,
+                    pathCompiled: pathCompiled,
+                });
+            } catch (error) {
+                Util.error(`stage=error method=Http.compilePath path=${path}, error=${error}`);
+            }
+        }
+
+        return pathCompiled;
+    }
+
+    getCompileContext(context) {
+        return _.extend(context, {
+            env: Env,
+        });
+    }
+
+    compileHeaders(headers, context) {
+        
+        let compiledHeaders = _.clone(headers);
+
+        for (let index in headers) {
+            let header = headers[index];
+            if (header && header.indexOf("{{") !== -1) {
+                try {
+                    let compiled = _.template(header);
+                    compiledHeaders[index] = compiled(this.getCompileContext(context));
+                    Util.info("stage=info method=Http.compileHeaders header", {
+                        header: header,
+                        compiledHeader: compiledHeaders[index],
+                    });
+                } catch (error) {
+                    Util.error(`stage=error method=Http.compileHeaders header=${header}, error=${error}`);
+                    return compiledHeaders;
+                }
+            }
+        }
+
+        if (this.mergedHeaders === true) compiledHeaders = _.extend(compiledHeaders, context.headers);
+
+        let requestCookie = context.headers[Const.HEADERS.COOKIE.toLocaleLowerCase()] || {};
+
+        if (Util.nonNull(requestCookie)) {
+            compiledHeaders = _.extend(compiledHeaders, {
+                [Const.HEADERS.COOKIE.toLocaleLowerCase()]: requestCookie,
+            });
+        }
+
+        return compiledHeaders;
+    }
+}
+
+module.exports = Http;

package/lib/operations/mock.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const fs = require("fs");
+const _ = require("underscore");
+const AbstractOperation = require("./abstract-operation");
+const { v4: uuidv4 } = require("uuid");
+const Util = require("../commons-util");
+
+class Mock extends AbstractOperation {
+    constructor(options, flowContext) {
+        super(uuidv4(), flowContext);
+
+        if (!options.file) throw "The attribute 'file' is not defined in mock operation";
+
+        this.type = options.type;
+        this.description = options.description || "";
+        this.name = options.file;
+        this.file = `${process.cwd()}/mocks/${options.file}`;
+    }
+
+    doExecute(options, callback) {
+        Util.info(`stage=init method=Mock.doExecute file=${this.name} options`, {
+            uuid: this.uuid,
+            flowStepUuid: options.flowStep.uuid,
+            contextUuid: options.context.uuid,
+        });
+
+        fs.readFile(_.template(this.file)(options.context), (error, result) => {
+            callback(error, JSON.parse(result));
+        });
+    }
+}
+
+module.exports = Mock;

package/lib/operations/monitor-check.js

@@ -0,0 +1,151 @@
+"use strict";
+
+const Util = require("../commons-util");
+const Step = require("step");
+const _ = require("underscore");
+const ClientFactory = require("../factory/client-factory");
+const Const = require("../commons-const");
+const { Errors } = require("../commons-errors");
+const AbstractOperation = require("./abstract-operation");
+const { v4: uuidv4 } = require("uuid");
+
+_.templateSettings = {
+    interpolate: /\{\{(.+?)\}\}/g,
+};
+
+class MonitorCheck extends AbstractOperation {
+    constructor(options, flowContext) {
+        super(uuidv4(), flowContext);
+
+        this.type = options.type;
+        this.path = options.path || "";
+        this.method = options.method || Const.HTTP_METHOD.GET;
+        this.httpClient = ClientFactory.createByName(options.clientName);
+        this.headers = options.headers || {};
+        this.name = options.clientName;
+    }
+
+    doExecute(options, callbackAbstractOperation) {
+        let self = this;
+
+        let context = options.context;
+
+        let optionsInvoke = {
+            path: this.compilePath(this.path, context),
+            method: this.method,
+            query: context.query,
+            body: context.body,
+            params: context.params,
+            headers: this.compileHeaders(this.headers, context),
+            monitor: true,
+        };
+
+        Step(
+            function () {
+                self.invokeService(optionsInvoke, options, this);
+            },
+            function (error, response) {
+                self.handleHttpResponse(error, response, this);
+            },
+            function (error, result) {
+                callbackAbstractOperation(error, result);
+            }
+        );
+    }
+
+    invokeService(optionsInvoke, options, callbackStep) {
+        Util.info(`Request operation flow(${this.type.toUpperCase()}) name=${this.name}`, {
+            flowStepUuid: options.flowStep.uuid,
+            contextUuid: options.context.uuid,
+            method: optionsInvoke.method,
+            path: optionsInvoke.path,
+            body: Util.isJSONValid(optionsInvoke.body) ? Util.obfuscationJSON(optionsInvoke.body) : {},
+            form: optionsInvoke.form || {},
+            query: optionsInvoke.qs || {},
+            headers: Util.obfuscationJSON(optionsInvoke.headers),
+            timeout: optionsInvoke.timeout,
+        });
+
+        this.httpClient.execute(optionsInvoke, callbackStep);
+    }
+
+    handleHttpResponse(error, response, callbackStep) {
+        let responseHeaders = response && response.hasOwnProperty("headers") ? response.headers : {};
+
+        if (error) {
+            let objectError = Errors.handleError(Util.parseJSON(error || {}));
+            this.statusCode = objectError.responseCode;
+            this.responseHeaders = responseHeaders;
+            this.error = true;
+            this.setResult(Util.tryParseJSON(objectError));
+            callbackStep(error, null);
+        } else {
+            this.statusCode = response.statusCode;
+            this.error = false;
+            this.responseHeaders = responseHeaders;
+            this.setResult(Util.tryParseJSON(response.data));
+            callbackStep(null, this.getResult());
+        }
+    }
+
+    handleResponse(error, result, flowStep, callbackFromOrchestrationFlow) {
+        if (error) {
+            let objectError = Errors.handleError(Util.parseJSON(error || {}));
+            flowStep.statusCode = objectError.responseCode;
+            flowStep.error = true;
+            flowStep.responseHeaders = this.responseHeaders;
+            flowStep.setResult(Util.tryParseJSON(objectError));
+            callbackFromOrchestrationFlow(objectError, null);
+        } else {
+            flowStep.statusCode = Const.HTTP_STATUS.OK;
+            flowStep.error = false;
+            flowStep.responseHeaders = this.responseHeaders;
+            flowStep.setResult(Util.tryParseJSON(result));
+            callbackFromOrchestrationFlow(null, Util.tryParseJSON(result));
+        }
+    }
+
+    compilePath(path, context) {
+        let pathCompiled = _.clone(path);
+
+        if (path.indexOf("{{") !== -1) {
+            try {
+                let compiled = _.template(path);
+                pathCompiled = compiled(context);
+                Util.info("Compile path", {
+                    path: path,
+                    pathCompiled: pathCompiled,
+                });
+            } catch (error) {
+                Util.error(`Error to compile path=${path}, error=${error}`);
+            }
+        }
+
+        return pathCompiled;
+    }
+
+    compileHeaders(headers, context) {
+        let compiledHeaders = _.clone(headers);
+
+        for (let index in headers) {
+            let header = headers[index];
+            if (header && header.indexOf("{{") !== -1) {
+                try {
+                    let compiled = _.template(header);
+                    compiledHeaders[index] = compiled(context);
+                    Util.info("Compile header", {
+                        header: header,
+                        compiledHeader: compiledHeaders[index],
+                    });
+                } catch (error) {
+                    Util.error(`Error to compile header=${header}, error=${error}`);
+                    return compiledHeaders;
+                }
+            }
+        }
+
+        return compiledHeaders;
+    }
+}
+
+module.exports = MonitorCheck;