robbyson-library/robbyson-logger/index.js

const interceptor = require('./lib/interceptor');
const Logger = require('./lib/logger');
const utils = require('./lib/utils');
const defaultResponseProcessor = require('./lib/default-response-processor');
const LogStatusType = require('../utils/log-status-type');
const _ = require('lodash');

const logger = new Logger();
const baseConfig = {
    serviceName: '',
    protectedFields: [
        'password',
        'currentPassword',
        'newPassword',
        'confirmationNewPassword',
    ],
    skip: [],
    responseProcessor: defaultResponseProcessor
};
let config;

const getType = (req) => {
    const createMethods = [ 'POST' ];
    const updateMethods = [ 'PUT', 'PATCH' ];
    const deleteMethods = [ 'DELETE' ];
    const readMethods = [ 'GET' ];
    switch (true) {
        case createMethods.indexOf(req.method) >= 0:
            return 'Service Create';
        case updateMethods.indexOf(req.method) >= 0:
            return 'Service Update';
        case deleteMethods.indexOf(req.method) >= 0:
            return 'Service Delete';
        case readMethods.indexOf(req.method) >= 0:
            return 'Service Read';
        default:
            return 'Service Read';
    }
};

const getData = req => {
    return Object.assign({},
        req.query,
        req.params,
        req.body
    );
};

// removes object keys with "." in values and replace for the same thing but kebabCased
const mongoiseKeys = data => {
    if (_.isArray(data)) {
        return data;
    }

    return Object.keys(data).reduce((accumulator, key) => {
        const objKey = (key.indexOf('.') >= 0) ? _.kebabCase(key) : key
        accumulator[objKey] = data[key];

        return accumulator;
    }, {});
};

const clearProtectedData = data => {
    if (_.isArray(data)) {
        return data;
    }

    return _.omit(data, config.protectedFields);
};

const executeResponseProcessor = (data, req) => {
    const processedData = config.responseProcessor(data, req);
    if (typeof data !== 'object') {
        console.log('data processor return must be an object');
        throw new Error('data processor return must be an object');
    }

    return _.omit(processedData);
};

const normalizeData = _.flow(
    mongoiseKeys,
    clearProtectedData,
);

const shouldLog = req => {
    const allowedAction = req.method !== 'OPTIONS';
    const allowedPath = !config.skip.some(pathToSkip => new RegExp(pathToSkip).test(req.originalUrl));
    return allowedAction && allowedPath;
}

const logRequest = (req, res) => {
    if (!shouldLog(req)) {
        return false;
    }

    const type = getType(req);
    const data = getData(req);
    const result = 'trying';
    const reason = `${config.serviceName} - ${req.originalUrl}`;
    const system_id = req.system_id || _.get(req, 'user.system_id');
    const contractorId = req.contractor_id;

    if (!system_id) {
        console.warn('you must pass system_id to be able to log it', req.originalUrl);
        return false;
    }

    const promise = contractorId ?
        logger.log(type, reason, _.omit(normalizeData(data)), result, system_id, contractorId) :
        logger.broadcast(type, reason, _.omit(normalizeData(data)), result, system_id);

    return promise.catch(error => handleError(error, config));
};

const logResponse = (req, response, result) => {
    if (!shouldLog(req)) {
        return false;
    }

    const type = getType(req);
    const data = typeof response === 'object' ? response : { response };
    const reason = `${config.serviceName} - ${req.originalUrl}`;
    const system_id = req.system_id || _.get(req, 'user.system_id');
    const contractorId = req.contractor_id || _.get(data, 'contractor_id');

    if (!system_id) {
        console.warn('you must pass system_id to be able to log it', req.originalUrl);
        return false;
    }


    const promise = contractorId ?
        logger.log(type, reason, executeResponseProcessor(normalizeData(data), req), result, system_id, contractorId) :
        logger.broadcast(type, reason, executeResponseProcessor(normalizeData(data), req), result, system_id);

    return promise.catch(error => handleError(error, config));
};

const configureLogResponse = (req, res) => {
    interceptor.getResponseBody(res).then(responseBody => {
        const response = utils.parseResponse(responseBody);
        const responseStatus = _.get(response, 'statusLog[0].type') || LogStatusType.SUCCESS;
        const data = _.get(response, 'data') || _.get(response, 'statusLog[0]') || response;

        const status = responseStatus === LogStatusType.SUCCESS ? 'success' : 'error';
        logResponse(req, data, status);
    });
};

const configure = customConfig => (req, res, next) => {
    try {
        config = Object.assign({}, baseConfig, customConfig);

        logger.setRequestMetaData(interceptor.getRequestMetadata(req));
        logRequest(req, res);
        configureLogResponse(req, res);
    } catch (error) {
        handleError(error, config);
    }

    next();
};

const handleError = (error, config) => {
    const errorCode = _.get(error, 'code');
    console.error(`there was an error when logging ${config.serviceName}. code:`, errorCode);
};

module.exports = {
    configure,
    logger,
};