@blazedpath/commons 0.3.1 → 0.4.0

package/blz-rds-postgres/base.js

@@ -0,0 +1,861 @@
+const toString = Object.prototype.toString;
+const dayjs = require("dayjs");
+const utc = require('dayjs/plugin/utc')
+const _ = require('underscore');
+const scalarProperty = _.property(['scalaroutput']);
+const Fs = require('fs-extra');
+const pgsql_ast_parser = require('pgsql-ast-parser');
+dayjs.extend(utc);
+module.exports = {
+    isArray: function (value) {
+        return _.isArray(value)
+    },
+    first: function (array) {
+        return _.first(array);
+    },
+    isEmpty: function (value) {
+        return _.isEmpty(value);
+    },
+    scalarOutput: function (rs) {
+        return scalarProperty(_.first(rs.rows));
+    },
+    convertValueToDb: function (value) {
+        if (_.isUndefined(value)) {
+            return null;
+        }
+        if (_.isNull(value)) {
+            return null;
+        }
+        if (value === true) {
+            return 1;
+        }
+        if (value === false) {
+            return 0;
+        }
+        let datetime = this.tryDatetime(value);
+        if (datetime) {
+            if (dayjs(datetime).utc().format("YYYY-MM-DD") === "1970-01-01") {
+                return dayjs(datetime).utc().format("HH:mm:ss");
+            }
+            return datetime;
+        }
+        return value;
+    },
+    replace: function (string, search, replace) {
+        return string.split(search).join(replace)
+    },
+    error: function (code, data, innerError = new Error("UndefinedError")) {
+        let err = new Error(`${code} ${innerError.message}`);
+        err.code = code;
+        err.data = data;
+        err.innerError = innerError;
+        return err;
+    },
+    convertSqlAndParameters: function (sql, rdsParameters, options) {
+        let query = sql;
+        for (let i = rdsParameters.length; i > 0; i--) {
+            let { name } = rdsParameters[i - 1];
+            query = this.replace(query, `:${name}`, `$${i}`);
+        }
+        const parameters = []
+        for (let i = 0, length = rdsParameters.length; length > i; i++) {
+            let { name, value } = rdsParameters[i];
+            const parameter = this.convertValueToDb(value);
+            parameters.push(parameter)
+
+        }
+        // let parameters = rdsParameters.map(({value}) => {
+        //     return this.convertValueToDb(value);
+        // });
+        return { query, parameters };
+    },
+    errorUndefinedArgument: function (argName) {
+        return this.error('UndefinedArgument', { argName: argName });
+    },
+    tryString: function (value) {
+        if (toString.call(value) === '[object String]')
+            return value;
+        else
+            return null;
+    },
+    tryInteger: function (value) {
+        if (toString.call(value) === '[object Number]' && value === parseInt(value))
+            return value;
+        else
+            return null;
+    },
+    tryDecimal: function (value) {
+        if (toString.call(value) === '[object Number]')
+            return value;
+        else
+            return null;
+    },
+    tryBoolean: function (value) {
+        if (toString.call(value) === '[object Boolean]')
+            return value;
+        else
+            return null;
+    },
+    tryDatetime: function (value) {
+        let strType = toString.call(value);
+        if (strType === '[object Date]') {
+            return value;
+        }
+        else if (strType === '[object String]') {
+            let match = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+            if (match) {
+                const probableDate = new Date(value);
+                if (probableDate.toString() !== 'Invalid Date') {
+                    return probableDate;
+                }
+            }
+        }
+        return null;
+    },
+    tryDate: function (value) {
+        let strType = toString.call(value);
+        if (strType === '[object Date]') {
+            return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate(), 0, 0, 0, 0));
+        }
+        else if (strType === '[object String]') {
+            let match = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(value);
+            if (match && match[3] !== undefined) {
+                return new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), 0, 0, 0, 0));
+            } else {
+                const probableDate = new Date(value);
+                if (probableDate.toString() !== 'Invalid Date') {
+                    return datetime.toISOString().split('T')[0];
+                }
+            }
+        }
+        return null;
+    },
+    tryTime: function (value) {
+        let convertMilliseconds = function (strMilliseconds) {
+            if (strMilliseconds) {
+                if (strMilliseconds.length < 3)
+                    strMilliseconds = strMilliseconds.padEnd(3, '0');
+                if (strMilliseconds.length > 3)
+                    strMilliseconds = strMilliseconds.substr(0, 3);
+                return Number(strMilliseconds);
+            }
+            else
+                return 0;
+        };
+        let strType = toString.call(value);
+        if (strType === '[object Date]') {
+            return new Date(Date.UTC(1970, 0, 1, value.getUTCHours(), value.getUTCMinutes(), value.getUTCSeconds(), value.getUTCMilliseconds()));
+        }
+        else if (strType === '[object String]') {
+            let match = /^(\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?$/.exec(value);
+            if (match && match[3] !== undefined) {
+                return new Date(Date.UTC(1970, 0, 1, Number(match[1]), Number(match[2]), Number(match[3]), convertMilliseconds(match[4])));
+            } else {
+                const probableDate = new Date(value);
+                if (probableDate.toString() !== 'Invalid Date') {
+                    return datetime.toISOString().split('T')[1];
+                }
+            }
+        }
+        return null;
+    },
+    tryBinary: function (value) {
+        if (Buffer.isBuffer(value)) {
+            return value;
+        }
+        else if (Array.isArray(value)) {
+            return Buffer.from(value);
+        }
+        return null;
+    },
+    tryObject: function (value) {
+        if (toString.call(value) === '[object Object]')
+            return value;
+        else
+            return null;
+    },
+    tryArray: function (value) {
+        if (toString.call(value) === '[object Array]')
+            return value;
+        else
+            return null;
+    },
+    ensureString: function (value) {
+        let string = this.tryString(value);
+        if (string !== null)
+            return string;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'string' });
+    },
+    ensureInteger: function (value) {
+        let integer = this.tryInteger(value);
+        if (integer !== null)
+            return integer;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'integer' });
+    },
+    ensureDecimal: function (value) {
+        let decimal = this.tryDecimal(value);
+        if (decimal !== null)
+            return decimal;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'decimal' });
+    },
+    ensureBoolean: function (value) {
+        let boolean = this.tryBoolean(value);
+        if (boolean !== null)
+            return boolean;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'boolean' });
+    },
+    ensureDatetime: function (value) {
+        let datetime = this.tryDatetime(value);
+        if (datetime !== null)
+            return datetime;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'datetime' });
+    },
+    ensureDate: function (value) {
+        let date = this.tryDate(value);
+        if (date !== null)
+            return date;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'date' });
+    },
+    ensureTime: function (value) {
+        let time = this.tryTime(value);
+        if (time !== null)
+            return time;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'time' });
+    },
+    ensureBinary: function (value) {
+        let binary = this.tryBinary(value);
+        if (binary !== null)
+            return binary;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'binary' });
+    },
+    ensureObject: function (value) {
+        let object = this.tryObject(value);
+        if (object !== null)
+            return array;
+        else
+            throw this.error('UnexpectedType', { value: object, expectedType: 'object' });
+    },
+    ensureArray: function (value) {
+        let array = this.tryArray(value);
+        if (array !== null)
+            return array;
+        else
+            throw this.error('UnexpectedType', { value: value, expectedType: 'array' });
+    },
+    convertToString: function (value) {
+        if (value === null)
+            return null;
+        let string = this.tryString(value);
+        if (string !== null)
+            return string;
+        let integer = this.tryInteger(value);
+        if (integer !== null)
+            return integer.toString();
+        let decimal = this.tryDecimal(value);
+        if (decimal !== null)
+            return decimal.toString();
+        let boolean = this.tryBoolean(value);
+        if (boolean !== null)
+            return boolean ? 'true' : 'false';
+        let datetime = this.tryDatetime(value);
+        if (datetime !== null)
+            return datetime.toJSON();
+        throw this.error('InvalidConversion', { value: value, targetType: 'string' });
+    },
+    convertToInteger: function (value) {
+        if (value === null)
+            return null;
+        let integer = this.tryInteger(value);
+        if (integer !== null)
+            return integer;
+        let string = this.tryString(value);
+        if (string !== null && !isNaN(string))
+            return Math.round(Number(string));
+        let decimal = this.tryDecimal(value);
+        if (decimal !== null)
+            return Math.round(decimal);
+        let boolean = this.tryBoolean(value);
+        if (boolean !== null)
+            return boolean ? 1 : 0;
+        throw this.error('InvalidConversion', { value: value, targetType: 'integer' });
+    },
+    convertToDecimal: function (value) {
+        if (value === null)
+            return null;
+        let decimal = this.tryDecimal(value);
+        if (decimal !== null)
+            return decimal;
+        let string = this.tryString(value);
+        if (string !== null && !isNaN(string))
+            return Number(string);
+        let integer = this.tryInteger(value);
+        if (integer !== null)
+            return integer;
+        let boolean = this.tryBoolean(value);
+        if (boolean !== null)
+            return boolean ? 1 : 0;
+        throw this.error('InvalidConversion', { value: value, targetType: 'decimal' });
+    },
+    convertToBoolean: function (value) {
+        if (value === null)
+            return null;
+        let boolean = this.tryBoolean(value);
+        if (boolean !== null)
+            return boolean;
+        let string = this.tryString(value);
+        if (string !== null && (string === '1' || string.toUpperCase() === 'T' || string.toUpperCase() === 'TRUE' || string.toUpperCase() === 'Y' || string.toUpperCase() === 'YES'))
+            return true;
+        if (string !== null && (string === '0' || string.toUpperCase() === 'F' || string.toUpperCase() === 'FALSE' || string.toUpperCase() === 'N' || string.toUpperCase() === 'NO'))
+            return false;
+        let integer = this.tryInteger(value);
+        if (integer !== null && integer === 1)
+            return true;
+        if (integer !== null && integer === 0)
+            return false;
+        throw this.error('InvalidConversion', { value: value, targetType: 'boolean' });
+    },
+    convertToDatetime: function (value) {
+        if (value === null)
+            return null;
+        let datetime = this.tryDatetime(value);
+        if (datetime !== null)
+            return datetime;
+        throw this.error('InvalidConversion', { value: value, targetType: 'datetime' });
+    },
+    convertToDate: function (value) {
+        if (value === null)
+            return null;
+        let date = this.tryDate(value);
+        if (date !== null)
+            return date;
+        let datetime = this.tryDatetime(value);
+        if (datetime !== null)
+            return new Date(Date.UTC(datetime.getUTCFullYear(), datetime.getUTCMonth(), datetime.getUTCDate(), 0, 0, 0, 0));
+        throw this.error('InvalidConversion', { value: value, targetType: 'date' });
+    },
+    convertToTime: function (value) {
+        if (value === null)
+            return null;
+        let time = this.tryTime(value);
+        if (time !== null)
+            return time;
+        let datetime = this.tryDatetime(value);
+        if (datetime !== null)
+            return new Date(Date.UTC(1970, 0, 1, datetime.getUTCHours(), datetime.getUTCMinutes(), datetime.getUTCSeconds(), datetime.getUTCMilliseconds()));
+        throw this.error('InvalidConversion', { value: value, targetType: 'time' });
+    },
+    convertToBinary: function (value) {
+        if (value == null)
+            return null;
+        let binary = this.tryBinary(value);
+        if (binary !== null)
+            return binary;
+        throw this.error('InvalidConversion', { value: value, targetType: 'binary' });
+    },
+    convertToListOfStrings: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToString(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToString(value)];
+        }
+    },
+    convertToListOfIntegers: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToInteger(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToInteger(value)];
+        }
+    },
+    convertToListOfDecimals: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToDecimal(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToDecimal(value)];
+        }
+    },
+    convertToListOfBooleans: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToBoolean(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToBoolean(value)];
+        }
+    },
+    convertToListOfDatetimes: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToDatetime(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToDatetime(value)];
+        }
+    },
+    convertToListOfDates: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToDate(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToDate(value)];
+        }
+    },
+    convertToListOfTimes: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToTime(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToTime(value)];
+        }
+    },
+    convertToListOfBinaries: function (value) {
+        if (Array.isArray(value)) {
+            let list = [];
+            for (let i = 0; i < value.length; i++) {
+                list.push(this.convertToBinary(value[i]));
+            }
+            return list;
+        }
+        else {
+            return [this.convertToBinary(value)];
+        }
+    },
+    httpCall: function (httpRequest) {
+        return new Promise(function (response, reject) {
+            let options = {
+                method: httpRequest.method ? httpRequest.method.toLowerCase() : 'get',
+                headers: {},
+                body: httpRequest.body
+            };
+            if (httpRequest.headers)
+                for (let i = 0; i < httpRequest.headers.length; i++) {
+                    let httpHeader = httpRequest.headers[i];
+                    options.headers[httpHeader.name] = httpHeader.value;
+                }
+        });
+    },
+    isNotNull: function (value) {
+        return value !== null;
+    },
+    isNull: function (value) {
+        return value === null;
+    },
+    isNullOrValue: function (value, valueToCompare) {
+        return value === null || this.compare(value, valueToCompare) === 0;
+    },
+    nvl: function (value, replacementValue) {
+        return value !== null ? value : replacementValue;
+    },
+    get: function (objOrTuple, codePathOrIndex) {
+        if (objOrTuple === null)
+            return null;
+        else {
+            let obj = this.tryObject(objOrTuple);
+            if (obj) {
+                let posPoint = codePathOrIndex.indexOf('.');
+                if (posPoint === -1)
+                    return obj[codePathOrIndex] !== undefined ? obj[codePathOrIndex] : null;
+                else
+                    return this.get(obj[codePathOrIndex.substring(0, posPoint)], codePathOrIndex.substring(posPoint + 1, codePathOrIndex.length));
+            }
+            if (toString.call(objOrTuple) === '[object Error]') {
+                let error = objOrTuple;
+                let posPoint = codePathOrIndex.indexOf('.');
+                if (posPoint === -1)
+                    return error[codePathOrIndex] !== undefined ? error[codePathOrIndex] : null;
+                else
+                    return this.get(error[codePathOrIndex.substring(0, posPoint)], codePathOrIndex.substring(posPoint + 1, codePathOrIndex.length));
+            }
+            let tuple = this.tryArray(objOrTuple);
+            if (tuple) {
+                return tuple[codePathOrIndex];
+            }
+            return null;
+        }
+    },
+    and: function (value1, value2) {
+        return this.ensureBoolean(value1) && this.ensureBoolean(value2);
+    },
+    or: function (value1, value2) {
+        return this.ensureBoolean(value1) || this.ensureBoolean(value2);
+    },
+    not: function (value) {
+        return !this.ensureBoolean(value);
+    },
+    compare: function (value1, value2) { // TODO: Sort require for objects
+        let compareClassic = function (value1, value2) {
+            if (value1 === value2)
+                return 0;
+            else if (value1 < value2)
+                return -1;
+            else if (value1 > value2)
+                return 1;
+            else
+                return null;
+        };
+        if (value1 === null && value2 === null)
+            return 0;
+        if (value1 === null && value2 !== null)
+            return -1;
+        if (value1 !== null && value2 === null)
+            return 1;
+        let string1 = this.tryString(value1);
+        let string2 = this.tryString(value2);
+        if (string1 !== null && string2 !== null)
+            return compareClassic(string1, string2);
+        let decimal1 = this.tryDecimal(value1);
+        let decimal2 = this.tryDecimal(value2);
+        if (decimal1 !== null && decimal2 !== null)
+            return compareClassic(decimal1, decimal2);
+        let boolean1 = this.tryBoolean(value1);
+        let boolean2 = this.tryBoolean(value2);
+        if (boolean1 !== null && boolean2 !== null)
+            return compareClassic(boolean1, boolean2);
+        let datetime1 = this.tryDatetime(value1);
+        let datetime2 = this.tryDatetime(value2);
+        if (datetime1 !== null && datetime2 !== null)
+            return compareClassic(datetime1.toJSON(), datetime2.toJSON());
+        let date1 = this.tryDate(value1);
+        let date2 = this.tryDate(value2);
+        if (date1 !== null && date2 !== null)
+            return compareClassic(date1.toJSON(), date2.toJSON());
+        let time1 = this.tryTime(value1);
+        let time2 = this.tryTime(value2);
+        if (time1 !== null && time2 !== null)
+            return compareClassic(time1.toJSON(), time2.toJSON());
+        let array1 = this.tryArray(value1);
+        let array2 = this.tryArray(value2);
+        if (array1 !== null && array2 !== null) {
+            let result;
+            result = compareClassic(array1.length, array2.length);
+            if (result !== 0)
+                return result;
+            for (let i = 0; i < array1.length; i++) {
+                if (result === 0) {
+                    let item1 = array1[i];
+                    let item2 = array2[i];
+                    result = this.compare(item1, item2);
+                }
+            }
+            return result;
+        }
+        let binary1 = this.tryBinary(value1);
+        let binary2 = this.tryBinary(value2);
+        if (binary1 !== null && binary2 !== null)
+            return Buffer.compare(binary1, binary2);
+        let obj1 = this.tryObject(value1);
+        let obj2 = this.tryObject(value2);
+        if (obj1 !== null && obj2 !== null) {
+            ////Only other option is we have object. JsonStringify is more performant than deepAssert by 42%
+            return compareClassic(JSON.stringify(obj1), JSON.stringify(obj2));
+        }
+        return null;
+    },
+    equals: function (value1, value2) {
+        return this.compare(value1, value2) === 0;
+    },
+    notEquals: function (value1, value2) {
+        return this.compare(value1, value2) !== 0;
+    },
+    greater: function (value1, value2) {
+        return this.compare(value1, value2) > 0;
+    },
+    less: function (value1, value2) {
+        return this.compare(value1, value2) < 0;
+    },
+    greaterOrEqual: function (value1, value2) {
+        return this.compare(value1, value2) >= 0;
+    },
+    lessOrEqual: function (value1, value2) {
+        return this.compare(value1, value2) <= 0;
+    },
+    concat: function (value1, value2) {
+        if (value1 === null)
+            return value2;
+        if (value2 === null)
+            return value1;
+        let string1 = this.ensureString(value1);
+        let string2 = this.ensureString(value2);
+        return string1 + string2;
+    },
+    add: function (value1, value2) {
+        if (value1 === null)
+            return value2;
+        if (value2 === null)
+            return value1;
+        let integer1 = this.tryInteger(value1);
+        let integer2 = this.tryInteger(value2);
+        if (integer1 !== null && integer2 !== null)
+            return integer1 + integer2;
+        let decimal1 = this.ensureDecimal(value1);
+        let decimal2 = this.ensureDecimal(value2);
+        return decimal1 + decimal2;
+    },
+    subtract: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return value1;
+        let integer1 = this.tryInteger(value1);
+        let integer2 = this.tryInteger(value2);
+        if (integer1 !== null && integer2 !== null)
+            return integer1 - integer2;
+        let decimal1 = this.ensureDecimal(value1);
+        let decimal2 = this.ensureDecimal(value2);
+        return decimal1 - decimal2;
+    },
+    multiply: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return null;
+        let integer1 = this.tryInteger(value1);
+        let integer2 = this.tryInteger(value2);
+        if (integer1 !== null && integer2 !== null)
+            return integer1 * integer2;
+        let decimal1 = this.ensureDecimal(value1);
+        let decimal2 = this.ensureDecimal(value2);
+        return decimal1 * decimal2;
+    },
+    divide: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        let decimal1 = this.ensureDecimal(value1);
+        let decimal2 = this.ensureDecimal(value2);
+        if (decimal2 === 0)
+            throw this.error('DivisionByZero');
+        return decimal1 / decimal2;
+    },
+    remainder: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        let decimal1 = this.ensureDecimal(value1);
+        let decimal2 = this.ensureDecimal(value2);
+        if (decimal2 === 0)
+            throw this.error('DivisionByZero');
+        return decimal1 % decimal2;
+    },
+    lessUnary: function (value) {
+        if (value === null)
+            return null;
+        let integer = this.tryInteger(value);
+        if (integer !== null)
+            return -integer;
+        let decimal = this.ensureDecimal(value);
+        return -decimal;
+    },
+    datetimeAdd: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return value1;
+        let datetime = this.ensureDatetime(value1);
+        let milliseconds = this.ensureInteger(value2);
+        return new Date(Date.UTC(datetime.getUTCFullYear(), datetime.getUTCMonth(), datetime.getUTCDate(), datetime.getUTCHours(), datetime.getUTCMinutes(), datetime.getUTCSeconds(), datetime.getUTCMilliseconds() + milliseconds));
+    },
+    datetimeDiff: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return value1;
+        let datetime1 = this.ensureDatetime(value1);
+        let datetime2 = this.ensureDatetime(value2);
+        return datetime1 - datetime2;
+    },
+    dateAdd: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return value1;
+        let date = this.ensureDate(value1);
+        let days = this.ensureInteger(value2);
+        return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days, 0, 0, 0, 0));
+    },
+    dateDiff: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return value1;
+        let date1 = this.ensureDate(value1);
+        let date2 = this.ensureDate(value2);
+        return (date1 - date2) / 86400000;
+    },
+    timeAdd: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return value1;
+        let time = this.ensureTime(value1);
+        let milliseconds = this.ensureInteger(value2);
+        return new Date(Date.UTC(1970, 0, 1, time.getUTCHours(), time.getUTCMinutes(), time.getUTCSeconds(), time.getUTCMilliseconds() + milliseconds));
+    },
+    timeDiff: function (value1, value2) {
+        if (value1 === null)
+            return null;
+        if (value2 === null)
+            return value1;
+        let time1 = this.ensureTime(value1);
+        let time2 = this.ensureTime(value2);
+        return time1 - time2;
+    },
+    jsonParse: function (value) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        let obj = JSON.parse(this.ensureString(value));
+        return obj;
+    },
+    jsonStringify: function (value, spaces) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        if (spaces === undefined || spaces === null) {
+            let stringified = JSON.stringify(value);
+            return stringified;
+        } else {
+            let identSpaces = this.ensureInteger(spaces);
+            let stringified = JSON.stringify(value, null, identSpaces);
+            return stringified;
+        }
+    },
+    base64Decode: function (value) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        let ensuredString = this.ensureString(value);
+        return Buffer.from(ensuredString, 'base64');
+    },
+    base64Encode: function (value) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        let ensuredBinary = this.ensureBinary(value);
+        return Buffer.from(ensuredBinary).toString('base64');
+    },
+    apply: function (obj1, obj2) {
+        let result = {};
+        if (obj1 === null)
+            return null;
+        let obj1Ok = this.tryObject(obj1);
+        if (obj1Ok === null)
+            throw fnError('InvalidObject', { value: obj1 });
+        for (let key in obj1Ok) {
+            result[key] = obj1Ok[key];
+        }
+        if (obj2 !== null) {
+            let obj2Ok = this.tryObject(obj2);
+            if (obj2Ok === null)
+                throw fnError('InvalidObject', { value: obj2 });
+            for (let key in obj2Ok) {
+                result[key] = obj2Ok[key];
+            }
+        }
+        return result;
+    },
+    stringFormat: function () {
+        if (arguments.length === 0) {
+            return null;
+        }
+        else if (arguments.length === 1) {
+            return arguments[0];
+        }
+        else {
+            let result = arguments[0];
+            for (let i = 1; i < arguments.length; i++) {
+                result = result.split('%' + i + '$s').join(arguments[i]);
+            }
+            return result;
+        }
+    },
+    loadResource: function (name) {
+        return Promise.resolve()
+            .then(function () {
+                if (name.indexOf('.') === -1) {
+                    return require('../resources/main/' + name + '.json');
+                }
+                else {
+                    let nameParts = name.split('.');
+                    return require('../resources/edges/' + nameParts[0] + '/' + nameParts[1] + '.json');
+                }
+            });
+    },
+    existsPath: async function (sourcePath) {
+        const fullPath = this.resolvePath(sourcePath)
+        return new Promise((resolve) => {
+            Fs.access(fullPath, (err) => {
+                if (err) {
+                    resolve(false)
+                } else {
+                    resolve(true)
+                }
+            })
+        })
+    },
+    resolvePath: function (source) {
+        const _source = source.trim()
+        if (_source.startsWith('.')) {
+            return Path.join(process.cwd(), source)
+        }
+        if (_source.startsWith('~')) {
+            return _source.replace('~', process.env.HOME)
+        }
+        return source
+    },
+    readFile: async function (filePath) {
+        const fullPath = this.resolvePath(filePath)
+        if (!await this.existsPath(fullPath)) {
+            return null
+        }
+        return new Promise((resolve, reject) => {
+            Fs.readFile(fullPath, (err, data) => err ? reject(err) : resolve(data.toString('utf8')))
+        })
+    },
+    checkPostgresSQL: function (sql) {
+        try {
+            const ast = pgsql_ast_parser.parse(sql);
+            return { safe: true };
+        } catch (err) {
+            return { safe: false, reason: `PostgreSQL parser error: ${err.message}` };
+        }
+    }
+};