我的nodejs工具函数集

const jsonfile = require('jsonfile');   
const json2csv = require('json2csv');  
const ASCII = 'ascii';
const BASE64 = 'base64';

const getObjectByKey = function getObjectByKey(arrayObjects = []) {
    if (Array.isArray(arrayObjects)) {
        return function parseObjectByKey(key, keyTransform = identity, suffix = '') {
            const objectByKey = {};
            arrayObjects.forEach(item => {
                const itemKeyValue = item[key];
                if (typeof itemKeyValue !== 'undefined') {
                    const objKey = suffix !== '' ? itemKeyValue + suffix : itemKeyValue;
                    const transformedKey = keyTransform(objKey);
                    objectByKey[transformedKey] = item;
                }
            });
            return objectByKey;
        };
    }
    throw new Error('Please provide array of objects');
};

/**
 * writes a file with the data provided and returns the newly generated file name
 * @param fileName - FileName along with the path details
 * @param fileData
 */
const writeFile = function writeFile(fileName, fileData, writeFileSeparator) {
    if (fileName) {
        const separator = (_.isString(writeFileSeparator) ?
            writeFileSeparator : IBConstantsService.JSON_WRITE_FILE_SEPARATOR
        );
        return new Promise((resolve, reject) => {
            jsonfile.writeFile(fileName, fileData, separator, (err) => {
                try {
                    if (err) {
                        throw new Error(err);
                    }
                    resolve(fileName);
                } catch (exception) {
                    reject(exception.message);
                }
            });
        });
    }
    return Promise.reject('Utils.js | writeFile |File Name is not provided. Please check');
};

const getCsvData = function getCsvData(config, csvPrefix) {
    if (!_.isNil(config)) {
        return new Promise((resolve, reject) => {
            json2csv(config, (err, csv) => {
                if (err) {
                    reject(err);
                }
                const prefix = _.isNil(csvPrefix) ? '' : csvPrefix;
                const resultingCsv = prefix + csv;
                resolve(resultingCsv);
            });
        });
    }
    return Promise.reject('Data not available. Please check');
};

const readFile = function readFile(fileName) {
    if (_.trim(fileName) !== '') {
        return new Promise((resolve, reject) => {
            jsonfile.readFile(fileName, (error, data) => {
                if (error) {
                    console.error('--- Utils.js | readFile | Error received ----');
                    console.error({ error });
                    reject({
                        errorCode: 'FILE_NOT_FOUND',
                        error
                    });
                }
                resolve(data);
            });
        });
    }
    return Promise.reject({
        errorCode: IBConstantsService.ERR_FILE_NOT_FOUND,
        error: ConfigUIService.getErrorInfo(IBConstantsService.ERR_FILE_NOT_FOUND)
    });
};

const readFileSync = function readFileSync(fileName, options = {}) {
    let fileData;
    if (!_.isNil(fileName)) {
        fileData = jsonfile.readFileSync(fileName, options);
    }
    return fileData;
};

const errorHandler = function errorHandler(data) {
    if (data && data.exception) {
        const message = data.errorMessage ? data.errorMessage : data.exception;
        let errorMessage = message;
        if (message.includes(IBConstantsService.EXCEEDS_THRESHOLD)) {
            errorMessage = getErrorMessages(IBConstantsService.TOO_MANY_RECORDS);
            // 'Too many records sent by Kylin. Please narrow your criteria';
        } else if (message.includes(IBConstantsService.UNAUTHORIZED_KYLIN_RESPONSE)) {
            errorMessage = getErrorMessages(IBConstantsService.UNAUTHORIZED_ACCESS);
        }
        return {
            errorType: data.errorType,
            errorMessage,
            statusCode: data.statusCode
        };
    }
    console.warn(' No data provided. Please check.');
};

/**
 * Will encrypt base64
 * @param stringToEncrypt
 * @returns {string|*}
 */
const encryptBase64 = function encryptBase64(stringToEncrypt) {
    if (!stringToEncrypt) {
        return;
    }
    return Buffer.from(stringToEncrypt).toString(BASE64);
};

/**
 * Will decrypt base64
 * @param stringToDecrypt
 * @returns {string|*}
 */
const decryptBase64 = function decryptBase64(stringToDecrypt) {
    if (!stringToDecrypt) {
        return;
    }
    return Buffer.from(stringToDecrypt, BASE64).toString(ASCII);
};