@nextage/nx-frame-be 1.0.1

package/build/common/utils.js

@@ -0,0 +1,1100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileSync = exports.sortBy = exports.deleteKey = exports.flattenArray = exports.getCtxUser = exports.forceGC = exports.logMemory = exports.logClassCtx = exports.uuid = exports.getDatePeriod = exports.getTimeValues = exports.getDateValues = exports.getDateDiff = exports.dateFormat = exports.toMoment = exports.toDate = exports.isValidDateStr = exports.toFilterDatePeriod = exports.parseTypedString = exports.capitalize = exports.jsonToStr = exports.strToJson = exports.dotObj = exports.dottedKeys = exports.percentDiff = exports.findDeep = exports.mergeArraysByKey = exports.hasKeys = exports.isEmpty = exports.containsArrayValue = exports.contains = exports.isEmail = exports.isBase64 = exports.isDefined = exports.isUndefined = exports.isNil = exports.isNotNull = exports.isNumber = exports.isString = exports.isBoolean = exports.isDate = exports.isFunction = exports.isObject = exports.baseComparatorReverse = exports.baseComparator = exports.randomString = exports.validateJwt = exports.generateJwt = exports.prodMode = exports.devMode = void 0;
+exports.validDataUrl = exports.getLastChildren = exports.getLastChild = exports.intersectArraysBy = exports.intersectArrays = exports.arrayToggle = exports.arrayPushUniq = exports.arrayPushRef = exports.addDirectoryToZip = exports.zipFolderStream = exports.zipFolder = exports.checkCommonPassword = exports.checkPasswordComplexity = exports.scheduleJobs = exports.scheduleJob = exports.parseUserAgent = exports.filterObject = exports.generateRandomBuffer = exports.generateRandomHex = exports.resizeBuffer = exports.initObjectWithProperty = exports.initObjectFromDotNotation = exports.chunkString = exports.encodeString = exports.isEqual = exports.hasAttr = exports.setAttr = exports.getAttr = exports.clone = exports.merge = exports.uniqBy = exports.union = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const moment_1 = __importDefault(require("moment"));
+const fs_1 = __importDefault(require("fs"));
+const jszip_1 = __importDefault(require("jszip"));
+const crypto_1 = __importDefault(require("crypto"));
+const node_schedule_1 = __importDefault(require("node-schedule"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const ua_parser_js_1 = __importDefault(require("ua-parser-js"));
+const uuid_1 = require("uuid");
+const uuid_2 = require("uuid");
+const constants_1 = require("./constants");
+const enums_1 = require("./enums");
+const mongo_utils_1 = require("./base/mongo-utils");
+// import COMMON_PWD from '../assets/common-pwd-100k.json';
+function devMode() {
+    return process.env.NODE_ENV === enums_1.AppMode.DEV;
+}
+exports.devMode = devMode;
+function prodMode() {
+    return process.env.NODE_ENV === enums_1.AppMode.PROD;
+}
+exports.prodMode = prodMode;
+/**
+ *
+ * @param {*} jti
+ */
+function generateJwt(sub, jti, iss, signOpts = {}, secret) {
+    if (!secret)
+        secret = process.env.JWT_SECRET;
+    if (!signOpts)
+        signOpts = {};
+    if (!signOpts.expiresIn)
+        signOpts.expiresIn = process.env.TOKEN_VALIDITY_DAYS ? `${process.env.TOKEN_VALIDITY_DAYS}d` : `${process.env.JWT_VALIDITY || '8h'}`;
+    if (!signOpts.algorithm && process.env.JWT_ALGORITHM)
+        signOpts.algorithm = process.env.JWT_ALGORITHM;
+    if (!signOpts.algorithm)
+        throw new Error('JWT Algorithm is not defined');
+    if (!secret)
+        throw new Error('Missing JWT secret');
+    return jsonwebtoken_1.default.sign({
+        sub, jti, iss
+    }, secret, signOpts);
+}
+exports.generateJwt = generateJwt;
+/**
+ *
+ * @param {*} token
+ */
+function validateJwt(token, options = {}, secret) {
+    if (!secret)
+        secret = process.env.JWT_SECRET;
+    return jsonwebtoken_1.default.verify(token, secret, options);
+}
+exports.validateJwt = validateJwt;
+/**
+ *
+ * @param {*} size
+ */
+function randomString(size = 21) {
+    return crypto_1.default.randomBytes(size)
+        .toString('base64')
+        .slice(0, size);
+}
+exports.randomString = randomString;
+/**
+ *
+ * @param {*} a
+ * @param {*} b
+ * @param {*} key
+ */
+function baseComparator(a, b, key) {
+    let value1 = key ? key.split('.').reduce((o, i) => o[i] || '', a) : a;
+    let value2 = key ? key.split('.').reduce((o, i) => o[i] || '', b) : b;
+    if (value1 < value2)
+        return -1;
+    if (value1 > value2)
+        return 1;
+    return 0;
+}
+exports.baseComparator = baseComparator;
+/**
+ *
+ * @param {*} a
+ * @param {*} b
+ * @param {*} key
+ */
+function baseComparatorReverse(a, b, key) {
+    let value1 = key ? key.split('.').reduce((o, i) => o[i] || '', a) : a;
+    let value2 = key ? key.split('.').reduce((o, i) => o[i] || '', b) : b;
+    if (value1 < value2)
+        return 1;
+    if (value1 > value2)
+        return -1;
+    return 0;
+}
+exports.baseComparatorReverse = baseComparatorReverse;
+/**
+ * Returns if a value is an object
+ *
+ * @param {*} value
+ */
+function isObject(value) {
+    return lodash_1.default.isObject(value);
+}
+exports.isObject = isObject;
+/**
+ * Returns if a value is a function
+ *
+ * @param {*} value
+ */
+function isFunction(value) {
+    return lodash_1.default.isFunction(value);
+}
+exports.isFunction = isFunction;
+/**
+ * Returns if a value is a date
+ *
+ * @param {*} value
+ */
+function isDate(value) {
+    return lodash_1.default.isDate(value);
+}
+exports.isDate = isDate;
+/**
+ * Returns if a value is a boolean
+ *
+ * @param {*} value
+ */
+function isBoolean(value) {
+    return lodash_1.default.isBoolean(value);
+}
+exports.isBoolean = isBoolean;
+/**
+ * Returns if a value is a string
+ *
+ * @param {*} value
+ */
+function isString(value) {
+    return lodash_1.default.isString(typeof value === 'string');
+}
+exports.isString = isString;
+/**
+ * Returns if a value is a number
+ *
+ * @param value
+ */
+function isNumber(value) {
+    return lodash_1.default.isNumber(value);
+}
+exports.isNumber = isNumber;
+/**
+ * Returns if a value is not null and not undefined
+ *
+ * @param {*} value
+ */
+function isNotNull(value) {
+    return !lodash_1.default.isNil(value);
+}
+exports.isNotNull = isNotNull;
+/**
+ *
+ * @param value
+ * @returns
+ */
+function isNil(value) {
+    return lodash_1.default.isNil(value);
+}
+exports.isNil = isNil;
+/**
+ * Returns if a value is null or undefined
+ *
+ * @param {*} value
+ */
+function isUndefined(value) {
+    return lodash_1.default.isUndefined(value);
+}
+exports.isUndefined = isUndefined;
+/**
+ * Returns if a value is defined
+ *
+ * @param {*} value
+ */
+function isDefined(value) {
+    return !isUndefined(value);
+}
+exports.isDefined = isDefined;
+/**
+ *
+ * @param {*} v
+ * @param {*} opts
+ * @returns
+ */
+function isBase64(value, opts = {}) {
+    if (!isString(value))
+        return false;
+    // if (value instanceof Boolean || typeof value === 'boolean')
+    //   return false;
+    if (!opts.allowEmpty && value === '')
+        return false;
+    var regex = '(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\/]{3}=)?';
+    var mimeRegex = '(data:\\w+\\/[a-zA-Z\\+\\-\\.]+;base64,)';
+    if (opts.mimeRequired === true)
+        regex = `${mimeRegex}${regex}`;
+    else if (opts.allowMime === true)
+        regex = `${mimeRegex}?${regex}`;
+    if (opts.paddingRequired === false)
+        regex = '(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}(==)?|[A-Za-z0-9+\\/]{3}=?)?';
+    return new RegExp('^' + regex + '$', 'gi').test(value);
+}
+exports.isBase64 = isBase64;
+/**
+ * Returns if value is a valid email
+ *
+ * @param {*} value
+ * @returns
+ */
+function isEmail(value) {
+    return isString(value) && constants_1.REGEX.email.test(value);
+}
+exports.isEmail = isEmail;
+/**
+ * Returns true if array contains value
+ *
+ * @param {*} value
+ */
+function contains(arr, value) {
+    return Array.isArray(arr) && arr.indexOf(value) !== -1;
+}
+exports.contains = contains;
+/**
+ * Returns true if array contains value
+ *
+ * @param {*} value
+ */
+function containsArrayValue(arr, value) {
+    if (!Array.isArray(value))
+        return contains(arr, value);
+    return value.some(v => contains(arr, v));
+}
+exports.containsArrayValue = containsArrayValue;
+/**
+ * Returns true if empty object or array
+ *
+ * @param {*} item
+ */
+function isEmpty(item) {
+    if (Array.isArray(item))
+        return !item.length;
+    return !hasKeys(item);
+}
+exports.isEmpty = isEmpty;
+/**
+ * Returns true if obj is not empty
+ *
+ * @param {*} value
+ */
+function hasKeys(obj) {
+    return !!(obj && Object.keys(obj).length);
+}
+exports.hasKeys = hasKeys;
+/**
+ *
+ * @param {*} key
+ * @param {*} arrays
+ */
+function mergeArraysByKey(key, arrays) {
+    let flat = arrays.reduce((acc, it) => [...acc, ...it], []);
+    return flat.reduce((acc, curr) => {
+        let existing = acc.find((elem) => isEqual(getAttr(elem, key), getAttr(curr, key)));
+        if (existing)
+            Object.assign(existing, curr);
+        else
+            acc.push(curr);
+        return acc;
+    }, []);
+}
+exports.mergeArraysByKey = mergeArraysByKey;
+/**
+ *
+ * @param data
+ * @param obj
+ */
+function findDeep(data, attr, obj) {
+    return data.find((e) => {
+        for (let k in obj) {
+            if (e[k] !== obj[k])
+                return (e[attr]) ? findDeep(e[attr], attr, obj) : false;
+        }
+        return true;
+    });
+}
+exports.findDeep = findDeep;
+/**
+ * Percentage Difference between two numbers
+ *
+ * @param  {int}     base  First and original number
+ * @param  {int}     peak  Second new number to differentiate
+ * @param  {boolean} round Round return value to nearest whole numer?
+ * @return {int}     Percentage difference between lowest and highest number
+ */
+function percentDiff(base, peak, round = false) {
+    const diff = (peak - base) / base * 100;
+    return round ? Math.round(diff) : diff;
+}
+exports.percentDiff = percentDiff;
+;
+/**
+ *
+ * @param {*} obj
+ */
+function dottedKeys(obj) {
+    if (!isObject(obj) || Array.isArray(obj))
+        return [];
+    let keys = Object.keys(obj);
+    //let key = keys.reduce((acc, v) => acc.concat(obj[v]), '');
+    keys.forEach((key, index) => {
+        let subKeys = dottedKeys(obj[key]);
+        if (Array.isArray(subKeys)) {
+            subKeys = subKeys.map(subKey => subKey = `${key}.${subKey}`);
+            keys.splice(index, 1, ...subKeys);
+        }
+    });
+    return keys;
+}
+exports.dottedKeys = dottedKeys;
+/**
+ *
+ * @param {*} obj
+ */
+function dotObj(obj) {
+    let dotted = {};
+    let keys = dottedKeys(obj).reduce((acc, value) => acc.concat(value), []);
+    keys.forEach(key => {
+        dotted[key.replace(/\'/g, '')] = key.split('.').reduce((o, i) => {
+            return o[i] || null;
+        }, obj);
+    });
+    return dotted;
+}
+exports.dotObj = dotObj;
+/**
+ * json string parsed to object with regex values management
+ *
+ * @param {*} objStr
+ */
+function strToJson(str) {
+    return JSON.parse(str, (k, v) => parseTypedString(v));
+}
+exports.strToJson = strToJson;
+/**
+ * json object parsed to string with regex values management
+ *
+ * @param {*} obj
+ */
+function jsonToStr(obj) {
+    return JSON.stringify(obj, (k, v) => v instanceof RegExp ? `__REXP__${v.toString()}` : v);
+}
+exports.jsonToStr = jsonToStr;
+/**
+ * Capitalize first char of string
+ * @param text
+ */
+function capitalize(text) {
+    if (!text)
+        return '';
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+exports.capitalize = capitalize;
+/**
+ * Parse string value type coded
+ */
+function parseTypedString(value) {
+    if (!isString(value))
+        return value;
+    let match = value.match(new RegExp('^__REXP__/(.*?)/([gimy]*)$'));
+    if (match)
+        return new RegExp(match[1]);
+    match = value.match(new RegExp('^__UNDEFINED__([gimy]*)$'));
+    if (match)
+        return undefined;
+    match = value.match(new RegExp('^__OID__/(.*?)/([gimy]*)$'));
+    if (match)
+        return (0, mongo_utils_1.toObjectId)(match[1]);
+    match = value.match(new RegExp('^__PERIOD__/(.*?)/([gimy]*)$'));
+    if (match) {
+        let period = JSON.parse(match[1]);
+        return toFilterDatePeriod(period[0], period[1]);
+    }
+    match = value.match(new RegExp('^__DATE__/(.*?)/([gimy]*)$'));
+    return match ? toDate(match[1]) : value;
+}
+exports.parseTypedString = parseTypedString;
+/**
+ *
+ * @param {*} period
+ * @param {*} year
+ */
+function toFilterDatePeriod(period, year) {
+    let values = getDatePeriod(period, year);
+    return values ? { $gte: values[0], $lt: values[1] } : {};
+}
+exports.toFilterDatePeriod = toFilterDatePeriod;
+/**
+ * Returns if string is valid date
+ *
+ * @param {*} value
+ */
+function isValidDateStr(value, format = 'YYYY-MM-DD') {
+    const date = toMoment(value);
+    return date.isValid() && value === date.format('YYYY-MM-DD');
+}
+exports.isValidDateStr = isValidDateStr;
+/**
+ *
+ * @param {*} value
+ */
+function toDate(value, format = 'YYYY-MM-DD') {
+    if (!value)
+        return new Date();
+    if (Array.isArray(value))
+        return value.map(v => toDate(v, format));
+    return (value instanceof Date) ? value : toMoment(value, format, true).toDate();
+}
+exports.toDate = toDate;
+/**
+ *
+ * @param {*} value
+ * @param {*} format
+ */
+function toMoment(value, format, utc = false) {
+    if (utc)
+        return moment_1.default.utc(value, format);
+    return (0, moment_1.default)(value, format);
+}
+exports.toMoment = toMoment;
+/**
+ *
+ * @param {*} value
+ * @param {*} format
+ */
+function dateFormat(value, format) {
+    return toMoment(value).format(format);
+}
+exports.dateFormat = dateFormat;
+/**
+ *
+ * @param {*} d1
+ * @param {*} d2
+ * @param {*} period
+ */
+function getDateDiff(d1, d2, period = 'days') {
+    return toMoment(d2).diff(d1, period);
+}
+exports.getDateDiff = getDateDiff;
+/**
+ *
+ * @param {*} date
+ * @param {*} utc
+ */
+function getDateValues(date, utc = true) {
+    if (!date)
+        return {};
+    date = toMoment(date, undefined, utc);
+    return { day: date.date(), month: date.month(), year: date.year() };
+}
+exports.getDateValues = getDateValues;
+/**
+ *
+ * @param {*} date
+ * @param {*} utc
+ */
+function getTimeValues(date, utc = true) {
+    if (!date)
+        return {};
+    date = toMoment(date, undefined, utc);
+    return { hour: date.hour(), minute: date.minute(), seconds: date.seconds() };
+}
+exports.getTimeValues = getTimeValues;
+/**
+ *
+ * @param {*} period
+ * @param {*} year
+ * @param {*} momentValue
+ */
+function getDatePeriod(period, year, momentValue = false) {
+    if (!year)
+        year = (0, moment_1.default)().year();
+    let values = [], modq;
+    switch (period) {
+        case enums_1.DatePeriod.CURR_WEEK:
+            values = [moment_1.default.utc().startOf('isoWeek'), moment_1.default.utc().endOf('isoWeek')];
+            break;
+        case enums_1.DatePeriod.LAST_WEEK:
+            values = [moment_1.default.utc().subtract(1, 'week').startOf('isoWeek'), moment_1.default.utc().subtract(1, 'week').endOf('isoWeek')];
+            break;
+        case enums_1.DatePeriod.CURR_MONTH:
+            values = [moment_1.default.utc().startOf('month'), moment_1.default.utc().endOf('month')];
+            break;
+        case enums_1.DatePeriod.LAST_MONTH:
+            values = [moment_1.default.utc().subtract(1, 'month').startOf('month'), moment_1.default.utc().subtract(1, 'month').endOf('month')];
+            break;
+        case enums_1.DatePeriod.CURR_QUARTER:
+            values = [moment_1.default.utc().startOf('quarter'), moment_1.default.utc().endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.LAST_QUARTER:
+            values = [moment_1.default.utc().subtract(1, 'quarter').startOf('quarter'), moment_1.default.utc().subtract(1, 'quarter').endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.QUARTER_1:
+            values = [moment_1.default.utc().year(year).quarter(1).startOf('quarter'), moment_1.default.utc().year(year).quarter(1).endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.QUARTER_2:
+            values = [moment_1.default.utc().year(year).quarter(2).startOf('quarter'), moment_1.default.utc().year(year).quarter(2).endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.QUARTER_3:
+            values = [moment_1.default.utc().year(year).quarter(3).startOf('quarter'), moment_1.default.utc().year(year).quarter(3).endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.QUARTER_4:
+            values = [moment_1.default.utc().year(year).quarter(4).startOf('quarter'), moment_1.default.utc().year(year).quarter(4).endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.CURR_SEMESTER:
+            modq = (0, moment_1.default)().quarter() % 2;
+            values = [moment_1.default.utc().subtract(1 - modq, 'quarter').startOf('quarter'), moment_1.default.utc().add(modq, 'quarter').endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.LAST_SEMESTER:
+            modq = 3 - ((0, moment_1.default)().quarter() % 2); // 4-(moment().quarter()%2+1)
+            values = [moment_1.default.utc().subtract(modq, 'quarter').startOf('quarter'), moment_1.default.utc().subtract(modq + 1, 'quarter').endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.SEMESTER_1:
+            values = [moment_1.default.utc().year(year).startOf('year'), moment_1.default.utc().year(year).quarter(2).endOf('quarter')];
+            break;
+        case enums_1.DatePeriod.SEMESTER_2:
+            values = [moment_1.default.utc().year(year).quarter(3).startOf('quarter'), moment_1.default.utc().year(year).endOf('year')];
+            break;
+        case enums_1.DatePeriod.CURR_YEAR:
+            values = [moment_1.default.utc().startOf('year'), moment_1.default.utc().endOf('year')];
+            break;
+        case enums_1.DatePeriod.LAST_YEAR:
+            values = [moment_1.default.utc().subtract(1, 'year').startOf('year'), moment_1.default.utc().subtract(1, 'year').endOf('year')];
+            break;
+        case enums_1.DatePeriod.YEAR:
+            values = [moment_1.default.utc().year(year).startOf('year'), moment_1.default.utc().year(year).endOf('year')];
+            break;
+        default:
+            break;
+    }
+    if (momentValue)
+        return values;
+    return [values[0].toDate(), values[1].toDate()];
+}
+exports.getDatePeriod = getDatePeriod;
+/**
+ *
+ * @param {*} value value to be checked
+ */
+function uuid(value) {
+    return value && (0, uuid_2.validate)(value) ? value : (0, uuid_1.v4)();
+}
+exports.uuid = uuid;
+/**
+ *
+ * @param {*} obj
+ */
+function logClassCtx(obj, method) {
+    var _a;
+    if (!((_a = obj === null || obj === void 0 ? void 0 : obj.constructor) === null || _a === void 0 ? void 0 : _a.name))
+        return {};
+    return { context: obj.constructor.name, method };
+}
+exports.logClassCtx = logClassCtx;
+/**
+ *
+ * @param obj
+ * @param logger
+ */
+function logMemory(obj, logger = constants_1.APP.logger) {
+    let used = process.memoryUsage();
+    let memStr = [];
+    for (let key in used)
+        memStr.push(`${key}: ${Math.round(used[key] / 1024 / 1024 * 100) / 100} MB`);
+    logger.debug(`Memory usage %s`, memStr.join(', '), logClassCtx(obj));
+}
+exports.logMemory = logMemory;
+/**
+ *
+ * @param logger
+ */
+function forceGC(logger = constants_1.APP.logger) {
+    if (global.gc)
+        global.gc();
+    else
+        logger.warn('No GC hook! Start your program as `node --expose-gc app.js`.');
+}
+exports.forceGC = forceGC;
+/**
+ *
+ * @param {*} ctx
+ */
+function getCtxUser(ctx) {
+    return (ctx && ctx.user) ? ctx.user : null;
+}
+exports.getCtxUser = getCtxUser;
+/**
+ *
+ */
+function flattenArray(arr, parseMethod) {
+    return arr.reduce((flat, toFlatten) => {
+        if (Array.isArray(toFlatten))
+            return flat.concat(flattenArray(toFlatten, parseMethod));
+        return flat.concat(parseMethod ? parseMethod(toFlatten) : toFlatten);
+    }, []);
+}
+exports.flattenArray = flattenArray;
+/**
+ *
+ * @param {*} obj
+ * @param {*} path
+ * @param {*} cloneKey
+ */
+function deleteKey(obj, path, cloneKey) {
+    const _obj = cloneKey ? clone(obj) : obj;
+    const keys = path.split('.');
+    keys.reduce((acc, key, index) => {
+        if (index === keys.length - 1) {
+            delete acc[key];
+            return true;
+        }
+        return acc[key];
+    }, _obj);
+    return _obj;
+}
+exports.deleteKey = deleteKey;
+/**
+ *
+ * @param array
+ * @param properties
+ */
+function sortBy(array, properties) {
+    if (properties && !Array.isArray(properties))
+        properties = [properties];
+    return array.sort((a, b) => {
+        if (!properties) {
+            if (a > b)
+                return 1;
+            if (a < b)
+                return -1;
+        }
+        for (let i = 0; i < properties.length; i++) {
+            let valueA = getAttr(a, properties[i]);
+            let valueB = getAttr(b, properties[i]);
+            if (valueA > valueB)
+                return 1;
+            else if (valueA < valueB)
+                return -1;
+        }
+        return 0;
+    });
+}
+exports.sortBy = sortBy;
+/**
+ *
+ * @param {*} path
+ * @returns
+ */
+function readFileSync(path) {
+    if (!path || path.indexOf('/') === -1)
+        return path;
+    return fs_1.default.existsSync(path) ? fs_1.default.readFileSync(path).toString().trim() : '';
+}
+exports.readFileSync = readFileSync;
+/**
+ *
+ * @param {*} arr1
+ * @param {*} arr2
+ * @returns
+ */
+function union(arr1, arr2) {
+    return lodash_1.default.union(arr1, arr2);
+}
+exports.union = union;
+/**
+ *
+ * @param {*} arr
+ * @param {*} iteratee
+ * @returns
+ */
+function uniqBy(arr, iteratee) {
+    return lodash_1.default.uniqBy(arr, iteratee);
+}
+exports.uniqBy = uniqBy;
+/**
+ *
+ * @param {*} obj1
+ * @param {*} obj2
+ * @returns
+ */
+function merge(obj1, obj2) {
+    if (!isObject(obj1) || !isObject(obj2))
+        return;
+    return lodash_1.default.merge(obj1, obj2);
+}
+exports.merge = merge;
+/**
+ *
+ * @param data
+ */
+function clone(data) {
+    if (!data)
+        return;
+    return lodash_1.default.cloneDeep(data);
+}
+exports.clone = clone;
+/**
+ *
+ * @param object
+ * @param path
+ */
+function getAttr(object, path) {
+    return lodash_1.default.get(object, path);
+}
+exports.getAttr = getAttr;
+/**
+ *
+ * @param object
+ * @param path
+ * @param value
+ */
+function setAttr(object, path, value) {
+    return lodash_1.default.set(object, path, value);
+}
+exports.setAttr = setAttr;
+/**
+ *
+ * @param object
+ * @param path
+ */
+function hasAttr(object, path) {
+    return lodash_1.default.has(object, path);
+}
+exports.hasAttr = hasAttr;
+/**
+ *
+ * @param value1
+ * @param value2
+ */
+function isEqual(value1, value2) {
+    return lodash_1.default.isEqual(value1, value2);
+}
+exports.isEqual = isEqual;
+/**
+ *
+ * @param {*} value
+ * @param {*} from
+ * @param {*} to
+ */
+function encodeString(value, from = 'base64', to = 'utf8') {
+    return value ? Buffer.from(value, from).toString(to) : value;
+}
+exports.encodeString = encodeString;
+/**
+ * Split a string into chunks by specified size
+ * @param {String} stringToChunk The string to split
+ * @param {number} size the size of character to use to split the string
+ */
+function chunkString(stringToChunk, size) {
+    let result = [];
+    let chars = String(stringToChunk).split('');
+    for (let i = 0; i < (String(stringToChunk).length / size); i++)
+        result = result.concat(chars.slice(i * size, (i + 1) * size).join(''));
+    return result;
+}
+exports.chunkString = chunkString;
+/**
+ * Initialize an object by a given dot notation structure
+ * eg.
+ *  'service.url' -> { service: { url: value } }
+ * @param {String} path the dot notation string representation of property
+ * @param {*} value the value to be used
+ */
+function initObjectFromDotNotation(path, value) {
+    return setAttr({}, path, value);
+}
+exports.initObjectFromDotNotation = initObjectFromDotNotation;
+/**
+ * Initialize an object with a dot notation property name
+ * eg.
+ *  'service.url' -> { "service.url": value }
+ * @param {String} path
+ * @param {*} value
+ */
+function initObjectWithProperty(path, value) {
+    const obj = {};
+    obj[path] = value;
+    return obj;
+}
+exports.initObjectWithProperty = initObjectWithProperty;
+/**
+ * Resize phrase Buffer by given size
+ * @param   { Buffer } phrase
+ * @param   { number } size
+ * @returns { Buffer } Given size buffer based on given phrase buffer
+ */
+function resizeBuffer(buffer, size) {
+    const resizedBuffer = Buffer.allocUnsafe(size);
+    buffer.copy(resizedBuffer);
+    return resizedBuffer;
+}
+exports.resizeBuffer = resizeBuffer;
+/**
+ * Generate a random Hex string (using sha256 HASH Algorithm)
+ * @returns { Buffer } Buffer representation of hash
+ */
+function generateRandomHex() {
+    return crypto_1.default.createHash("sha256").update((0, uuid_1.v4)()).digest();
+}
+exports.generateRandomHex = generateRandomHex;
+/**
+ * Generate random buffer of specified size
+ * @param { number } bitSize bit size of the buffer
+ * @returns { Buffer } Given size random Buffer
+ */
+function generateRandomBuffer(bitSize) {
+    const size = bitSize / 8;
+    const phrase = generateRandomHex();
+    return resizeBuffer(phrase, size);
+}
+exports.generateRandomBuffer = generateRandomBuffer;
+/**
+ * Use object to filter another object
+ * @param {*} obj
+ * @param {*} filterObj
+ */
+function filterObject(obj, filterObj) {
+    if (!isObject(filterObj) || !isObject(obj))
+        return obj;
+    filterObj = dotObj(filterObj);
+    for (let k in filterObj) {
+        let value = getAttr(obj, k);
+        if (lodash_1.default.isObject(value))
+            value = value.toString();
+        if (value !== filterObj[k])
+            return;
+    }
+    return obj;
+}
+exports.filterObject = filterObject;
+/**
+ *
+ * @param {*} request
+ */
+function parseUserAgent(req) {
+    const ua = new ua_parser_js_1.default(getAttr(req, 'headers.user-agent'));
+    return ua.getResult();
+}
+exports.parseUserAgent = parseUserAgent;
+/**
+ *
+ * @param {*} rule
+ * @param {*} options
+ * @param {*} method
+ */
+function scheduleJob(rule, { recurrence, startTime, endTime }, method = () => console.log('Scheduled job', new Date())) {
+    if (!rule)
+        return null;
+    if (recurrence && isObject(rule) && !isDate(rule)) {
+        console.log('recurrence job');
+        rule = Object.assign(new node_schedule_1.default.RecurrenceRule(), rule);
+    }
+    // set up job start/end time
+    if (startTime || endTime) {
+        rule = { rule };
+        if (startTime)
+            rule.start = (0, moment_1.default)(startTime, 'HH:mm').toDate();
+        if (endTime)
+            rule.end = (0, moment_1.default)(endTime, 'HH:mm').toDate();
+    }
+    return node_schedule_1.default.scheduleJob(rule, method);
+}
+exports.scheduleJob = scheduleJob;
+/**
+ * Schedule multiple jobs.
+ * Input rules have following format:
+ * { rule (string/obj), recurrence (bool), method (function) }
+ *
+ * Example:
+ *   let jobs = scheduleJobs([
+ *     { rule: { minute: 56 }, options: { recurrence: true }, method: () => { console.log('JOB AT MIN 56!') } },
+ *     { rule: '* * * * *',    options: { recurrence: true }, method: () => { console.log('JOB EVERY MINUTE!') } },
+ *     { rule: '* * * * *',    options: { recurrence: true, startTime: '10:55' }, method: () => { console.log('JOB EVERY MINUTE after 10:53!') } }
+ *   ]);
+ *
+ * @param {*} rules array of rules objects
+ */
+function scheduleJobs(rules = []) {
+    let jobs = [];
+    rules.forEach(({ rule, options, method }) => {
+        const job = scheduleJob(rule, options, method);
+        if (job)
+            jobs.push(job);
+    });
+    return jobs;
+}
+exports.scheduleJobs = scheduleJobs;
+/**
+ * Test password security / complexity criteria
+ *
+ * @param {*} pwd
+ * @returns
+ */
+function checkPasswordComplexity(pwd) {
+    return constants_1.REGEX.pwd.test(pwd);
+}
+exports.checkPasswordComplexity = checkPasswordComplexity;
+/**
+ * Test password security / complexity criteria
+ *
+ * @param {*} pwd
+ * @returns
+ */
+function checkCommonPassword(commonPwds, pwd) {
+    return !commonPwds.some(p => p === pwd);
+}
+exports.checkCommonPassword = checkCommonPassword;
+/**
+ * Zip and save a folder
+ *
+ * @param {*} path
+ * @param {*} name
+ * @param {*} callback
+ */
+function zipFolder(path, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stream = zipFolderStream(path, name);
+        return new Promise((resolve, reject) => {
+            stream.pipe(fs_1.default.createWriteStream(`${path}/${name}.zip`))
+                .on('finish', resolve);
+        });
+    });
+}
+exports.zipFolder = zipFolder;
+/**
+ *
+ * @param {*} path
+ * @param {*} name
+ * @param {*} stream
+ * @param {*} callback
+ */
+function zipFolderStream(path, name) {
+    // https://cheatcode.co/tutorials/how-to-create-and-download-a-zip-file-with-node-js-and-javascript#creating-a-zip-archive-with-jszip
+    const zip = addDirectoryToZip(path, name, new jszip_1.default());
+    return zip.generateNodeStream({ type: 'nodebuffer', streamFiles: true });
+}
+exports.zipFolderStream = zipFolderStream;
+/**
+ * Add files to zip object
+ *
+ * @param {*} dir
+ * @param {*} zip
+ * @param {*} callback
+ */
+function addDirectoryToZip(path, dir, zip) {
+    if (!dir || !zip)
+        return zip; //callback();
+    const dirPath = `${path}/${dir}`;
+    const content = fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+    for (let { name } of content) {
+        const file = `${dirPath}/${name}`;
+        if (fs_1.default.statSync(file).isFile()) {
+            const data = fs_1.default.readFileSync(file, { encoding: 'utf-8' });
+            zip.file(`${dir}/${name}`, data);
+        }
+        else if (fs_1.default.statSync(file).isDirectory())
+            addDirectoryToZip(path, `${dir}/${name}`, zip);
+    }
+    return zip;
+}
+exports.addDirectoryToZip = addDirectoryToZip;
+/**
+ * Push in array and return value
+ *
+ * @param {*} arr
+ * @param {*} value
+ * @returns
+ */
+function arrayPushRef(arr = [], value) {
+    if (!value || !Array.isArray(arr))
+        return;
+    arr.push(value);
+    return value;
+}
+exports.arrayPushRef = arrayPushRef;
+/**
+ *
+ * @param {*} arr
+ * @param {*} item
+ * @param {*} attr
+ * @returns
+ */
+function arrayPushUniq(arr = [], item, attr) {
+    if (!item || !Array.isArray(arr) || !attr)
+        return;
+    if (!arr.some(ai => getAttr(ai, attr) === getAttr(item, attr)))
+        arr.push(item);
+}
+exports.arrayPushUniq = arrayPushUniq;
+/**
+ *
+ * @param {*} arr
+ * @param {*} item
+ * @param {*} attr
+ * @returns
+ */
+function arrayToggle(arr = [], item, attr) {
+    if (!item || !Array.isArray(arr) || !attr)
+        return;
+    const idx = arr.findIndex(ai => getAttr(ai, attr) === getAttr(item, attr));
+    if (idx !== -1)
+        arr.splice(idx, 1);
+    else
+        arr.push(item);
+}
+exports.arrayToggle = arrayToggle;
+/**
+ *
+ * @param {*} arrays
+ * @returns
+ */
+function intersectArrays(arrays = []) {
+    return lodash_1.default.intersection(...arrays);
+}
+exports.intersectArrays = intersectArrays;
+/**
+ *
+ * @param {*} arrays
+ * @returns
+ */
+function intersectArraysBy(arr = [], iteratee) {
+    return lodash_1.default.intersectionWith(...arr, iteratee);
+}
+exports.intersectArraysBy = intersectArraysBy;
+/**
+ * Get last child in a tree like structure array
+ * { _id: '', children: [{ _id: '', parent: '', children: [...] }]}
+ *
+ * @param {*} item
+ * @param {*} attr
+ * @param {*} arr
+ * @returns
+ */
+function getLastChild(item, attr = 'id', arr = []) {
+    if (!item)
+        return;
+    const child = arr.find(ai => ai.parent === item[attr]);
+    return child ? getLastChild(child, attr, arr) : item;
+}
+exports.getLastChild = getLastChild;
+/**
+ *  * Get an array with last childern in a tree like structure array
+ * { _id: '', children: [{ _id: '', parent: '', children: [...] }]}
+ *
+ * @param {*} item
+ * @param {*} attr
+ * @param {*} arr
+ * @returns
+ */
+function getLastChildren(items, attr = 'id', arr = []) {
+    if (!items || !items.length)
+        return [];
+    const children = [];
+    items.forEach(item => {
+        children.push(...getLastChildren(arr.filter(ai => ai.parent === item[attr]), attr, arr));
+    });
+    // const child = arr.filter(ai => ai.parent === item[attr]);
+    return children.length ? children : items;
+}
+exports.getLastChildren = getLastChildren;
+/**
+ *
+ * @param {*} str
+ * @returns
+ */
+function validDataUrl(str) {
+    return constants_1.REGEX.dataurl.test((str || '').trim());
+}
+exports.validDataUrl = validDataUrl;