heimdall-api-platform 1.0.4 → 1.0.6

package/lib/operations/abstract-operation.js

@@ -1,73 +0,0 @@
-"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

@@ -1,143 +0,0 @@
-"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

@@ -1,286 +0,0 @@
-"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

@@ -1,34 +0,0 @@
-"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

@@ -1,151 +0,0 @@
-"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;