@blazedpath/commons 0.3.1 → 0.4.0

package/blz-core/index.js

@@ -0,0 +1,364 @@
+module.exports = {
+    errorUndefinedArgument: function (argName) {
+        let err = new Error();
+        err.code = 'UndefinedArgument';
+        err.data = { argName: argName };
+        return err;
+    },
+    errorInvalidConversion: function (value, targetType) {
+        let err = new Error();
+        err.code = 'InvalidConversion';
+        err.data = { value: value, targetType: targetType };
+        return err;
+    },
+    compare: function (value1, value2) { // TODO: Sort require for objects
+        if (value1 === null && value2 === null)
+            return 0;
+        if (value1 === null && value2 !== null)
+            return -1;
+        if (value1 !== null && value2 === null)
+            return 1;
+        let value1Type = toString.call(value1);
+        let value2Type = toString.call(value2);
+        let value1ToCompare = null;
+        let value2ToCompare = null;
+        if ((value1Type === '[object String]' && value2Type === '[object String]') ||
+            (value1Type === '[object Number]' && value2Type === '[object Number]')) {
+            value1ToCompare = value1;
+            value2ToCompare = value2;
+        }
+        else if (value1Type === '[object Boolean]' && value2Type === '[object Boolean]') {
+            value1ToCompare = value1 ? 1 : 0;
+            value2ToCompare = value2 ? 1 : 0;
+        }
+        else if (value1Type === '[object Date]' && value2Type === '[object Date]') {
+            value1ToCompare = value1.getTime();
+            value2ToCompare = value2.getTime();
+        }
+        else if (value1Type === '[object Object]' && value2Type === '[object Object]') {
+            value1ToCompare = JSON.stringify(value1);
+            value2ToCompare = JSON.stringify(value2);
+        }
+        else if (value1Type === '[object Array]' && value2Type === '[object Array]') {
+            let result = this.compare(value1.length, value2.length);
+            if (result !== 0)
+                return result;
+            for (let i = 0; i < value1.length; i++) {
+                let item1 = value1[i];
+                let item2 = value2[i];
+                result = this.compare(item1, item2);
+                if (result !== 0)
+                    return result;
+            }
+            return 0;
+        }
+        else {
+            if (value1Type === '[object String]')
+                value1ToCompare = value1;
+            else if (value1Type === '[object Number]')
+                value1ToCompare = value1.toString();
+            else if (value1Type === '[object Boolean]')
+                value1ToCompare = value1 ? '1' : '0';
+            else if (value1Type === '[object Date]')
+                value1ToCompare = value1.toJSON();
+            else
+                value1ToCompare = value1.toString();
+            if (value2Type === '[object String]')
+                value2ToCompare = value2;
+            else if (value2Type === '[object Number]')
+                value2ToCompare = value2.toString();
+            else if (value2Type === '[object Boolean]')
+                value2ToCompare = value2 ? '1' : '0';
+            else if (value2Type === '[object Date]')
+                value2ToCompare = value2.toJSON();
+            else
+                value2ToCompare = value2.toString();
+        }
+        if (value1ToCompare === value2ToCompare)
+            return 0;
+        else if (value1ToCompare < value2ToCompare)
+            return -1;
+        else if (value1ToCompare > value2ToCompare)
+            return 1;
+        else
+            return null;
+    },
+    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;
+    },
+    apply: function (obj1, obj2) {
+        let result = null;
+        if (obj1) {
+            result = {};
+            for (let key in obj1) {
+                result[key] = obj1[key];
+            }
+            if (obj2) {
+                for (let key in obj2) {
+                    result[key] = obj2[key];
+                }
+            }
+        }
+        return result;
+    },
+    base64Decode: function (value) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        return Buffer.from(value, 'base64');
+    },
+    base64Encode: function (value) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        return Buffer.from(value).toString('base64');
+    },
+    convertToBinary: function (value) {
+        if (value == null)
+            return null;
+        if (value && value.type === 'Buffer')
+            return Buffer.from(value);
+        if (Buffer.isBuffer(value))
+            return value;
+        if (Array.isArray(value) || typeof value === 'string')
+            return Buffer.from(value);
+        throw this.errorInvalidConversion(value, 'binary');
+    },
+    convertToBoolean: function (value) {
+        if (value === null)
+            return null;
+        let valueType = toString.call(value);
+        if (valueType === '[object String]') {
+            if (value === '1' || value.toUpperCase() === 'T' || value.toUpperCase() === 'TRUE' || value.toUpperCase() === 'Y' || value.toUpperCase() === 'YES')
+                return true;
+            if (value === '0' || value.toUpperCase() === 'F' || value.toUpperCase() === 'FALSE' || value.toUpperCase() === 'N' || value.toUpperCase() === 'NO')
+                return false;
+        }
+        if (valueType === '[object Number]') {
+            if (value === 1)
+                return true;
+            if (value === 0)
+                return false;
+        }
+        if (valueType === '[object Boolean]')
+            return value;
+        throw this.errorInvalidConversion(value, 'boolean');
+    },
+    convertToDate: function (value) {
+        if (value === null)
+            return null;
+        let valueType = toString.call(value);
+        if (valueType === '[object String]') {
+            let matchDate = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(value);
+            if (matchDate)
+                return new Date(Date.UTC(Number(matchDate[1]), Number(matchDate[2]) - 1, Number(matchDate[3]), 0, 0, 0, 0));
+            let matchDatetimeUtc = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+            if (matchDatetimeUtc)
+                return new Date(Date.UTC(Number(matchDatetimeUtc[1]), Number(matchDatetimeUtc[2]) - 1, Number(matchDatetimeUtc[3]), 0, 0, 0, 0));
+            let matchDatetimeZone = /^(\d{4})-(\d{1,2})-(\d{1,2})[T\s](\d{1,2}):(\d{1,2}):(\d{1,2})(?:\.(\d+))?([+-]\d{2}:\d{2})?$/.exec(value);
+            if (matchDatetimeZone) // timezone
+                return new Date(Date.UTC(Number(matchDatetimeZone[1]), Number(matchDatetimeZone[2]) - 1, Number(matchDatetimeZone[3]), 0, 0, 0, 0));
+        }
+        if (valueType === '[object Date]') {
+            return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate(), 0, 0, 0, 0));
+        }
+        throw this.errorInvalidConversion(value, 'date');
+    },
+    convertToDatetime: function (value) {
+        if (value === null)
+            return null;
+        let valueType = toString.call(value);
+        if (valueType === '[object String]') {
+            let matchDatetimeUtc = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+            if (matchDatetimeUtc && matchDatetimeUtc[7] !== undefined) {
+                return new Date(Date.UTC(Number(matchDatetimeUtc[1]), Number(matchDatetimeUtc[2]) - 1, Number(matchDatetimeUtc[3]), Number(matchDatetimeUtc[4]), Number(matchDatetimeUtc[5]), Number(matchDatetimeUtc[6] || 0), this.convertMilliseconds(matchDatetimeUtc[7])));
+            }
+            let matchDatetimeZone = /^(\d{4})-(\d{1,2})-(\d{1,2})[T\s](\d{1,2}):(\d{1,2}):(\d{1,2})(?:\.(\d+))?([+-]\d{2}:\d{2})?$/.exec(value);
+            if (matchDatetimeZone) { // timezone
+                let year = Number(matchDatetimeZone[1]);
+                let month = Number(matchDatetimeZone[2]) - 1; // Month is zero-based in JavaScript Date
+                let day = Number(matchDatetimeZone[3]);
+                let hour = Number(matchDatetimeZone[4]);
+                let minute = Number(matchDatetimeZone[5]);
+                let second = Number(matchDatetimeZone[6] || 0);
+                let millisecond = this.convertMilliseconds(matchDatetimeZone[7]);
+                let timezoneOffset = matchDatetimeZone[8];
+                if (timezoneOffset) {
+                    let offsetSign = timezoneOffset[0] === "+" ? 1 : -1;
+                    let [offsetHour, offsetMinute] = timezoneOffset.slice(1).split(":").map(Number);
+                    hour -= offsetSign * offsetHour;
+                    minute -= offsetSign * offsetMinute;
+                }
+                return new Date(Date.UTC(year, month, day, hour, minute, second, millisecond));
+            }
+            else {
+                const probableDate = new Date(value)
+                if (probableDate.toString() !== 'Invalid Date') {
+                    return probableDate
+                }
+            }
+        }
+        if (valueType === '[object Date]') {
+            return value;
+        }
+        throw this.errorInvalidConversion(value, 'datetime');
+    },
+    convertToDecimal: function (value) {
+        if (value === null)
+            return null;
+        let valueType = toString.call(value);
+        if (valueType === '[object String]' && value !== '' && !isNaN(value))
+            return Number(value);
+        if (valueType === '[object Number]')
+            return value;
+        if (valueType === '[object Boolean]')
+            return value ? 1 : 0;
+        throw this.errorInvalidConversion(value, 'decimal');
+    },
+    convertToInteger: function (value) {
+        if (value === null)
+            return null;
+        let valueType = toString.call(value);
+        if (valueType === '[object String]' && value !== '' && !isNaN(value))
+            return Math.round(Number(value));
+        if (valueType === '[object Number]')
+            return Math.round(value);
+        if (valueType === '[object Boolean]')
+            return value ? 1 : 0;
+        throw this.errorInvalidConversion(value, 'integer');
+    },
+    convertToString: function (value) {
+        if (value === null)
+            return null;
+        let valueType = toString.call(value);
+        if (valueType === '[object String]')
+            return value;
+        if (valueType === '[object Number]')
+            return value.toString();
+        if (valueType === '[object Uint8Array]')
+            return value.toString();
+        if (valueType === '[object Boolean]')
+            return value ? 'true' : 'false';
+        if (valueType === '[object Date]')
+            return value.toJSON();
+        if (valueType === '[object Object]' && value.type === 'Buffer' && value.data)
+            return Buffer.from(value.data).toString();
+        throw this.errorInvalidConversion(value, 'string');
+    },
+    convertToTime: function (value) {
+        if (value === null)
+            return null;
+        let valueType = toString.call(value);
+        if (valueType === '[object String]') {
+            let matchTime = /^(\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?$/.exec(value);
+            if (matchTime)
+                return new Date(Date.UTC(1970, 0, 1, Number(matchTime[1]), Number(matchTime[2]), Number(matchTime[3]), this.convertMilliseconds(matchTime[4])));
+            let matchDatetime = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+            if (matchDatetime)
+                return new Date(Date.UTC(1970, 0, 1, Number(matchDatetime[4]), Number(matchDatetime[5]), Number(matchDatetime[6] || 0), this.convertMilliseconds(matchDatetime[7])));
+        }
+        if (valueType === '[object Date]') {
+            return new Date(Date.UTC(1970, 0, 1, value.getUTCHours(), value.getUTCMinutes(), value.getUTCSeconds(), value.getUTCMilliseconds()));
+        }
+        throw this.errorInvalidConversion(value, 'time');
+    },
+    entries: function( obj ) {
+        if( obj === undefined ) throw this.errorUndefinedArgument( 'obj' );
+        if( obj === null ) return null
+        return Object.entries( obj )
+    },
+    format: function (value, format) {
+        if (typeof Blz !== 'undefined' && Blz.format) {
+            return Blz.format(value, format);
+        }
+        if (value != null && value.toString) {
+            return value.toString();
+        }
+        return '';
+    },
+    htmlEncode: function (value) {
+        if (value)
+            return value.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/'/g,'&apos;').replace(/"/g,'&quot;');
+        else
+            return value;
+    },
+    htmlDecode: function (value) {
+        if (value)
+            return value.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&apos;/g,'\'').replace(/&quot;/g,'"');
+        else
+            return value;
+    },
+    if: function( condition, valueIfConditionIsTrue, valueIfConditionIsFalse ) {
+        return condition ? valueIfConditionIsTrue : valueIfConditionIsFalse
+    },
+    isNotNull: function (value) {
+        return value !== null && value !== undefined;
+    },
+    isNull: function (value) {
+        return value === null || value === undefined;
+    },
+    isNullOrValue: function (value, valueToCompare) {
+        return value === null || value === undefined || this.compare(value, valueToCompare) === 0;
+    },
+    jsonParse: function (value) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        let obj = JSON.parse(value);
+        return obj;
+    },
+    jsonStringify: function (value, spaces) {
+        if (value === undefined)
+            throw this.errorUndefinedArgument('value');
+        if (value === null)
+            return null;
+        if (spaces === undefined || spaces === null)
+            return JSON.stringify(value);
+        else
+            return JSON.stringify(value, null, spaces);
+    },
+    keys: function( obj ) {
+        if( obj === undefined ) throw this.errorUndefinedArgument( 'obj' );
+        if( obj === null ) return null
+        return Object.keys( obj )
+    },
+    map: function( source, fnSelection ) {
+        if( Array.isArray( source ) ) { // list
+            const resultArray = new Array( source.length );
+            for( let i = 0; i < source.length; ++i ) {
+                const item = source[ i ]
+                resultArray[ i ] = fnSelection( item )
+            }
+            return resultArray
+        }
+        else if( source ) { // obj
+            return fnSelection( source );
+        }
+        return null;
+    },
+    nvl: function (value, replacementValue) {
+        return value !== null && value !== undefined ? value : replacementValue;
+    },
+    urlEncode: function (value) {
+        return encodeURIComponent(value);
+    },
+    urlDecode: function (value) {
+        return decodeURIComponent(value);
+    },
+    values: function( obj ) {
+        if( obj === undefined ) throw this.errorUndefinedArgument( 'obj' );
+        if( obj === null ) return null
+        return Object.values( obj )
+    }
+};

package/blz-cryptography/index.js

@@ -0,0 +1,54 @@
+const CryptoJs = require('crypto-js');
+
+module.exports = {
+    encrypt: function (value, secret, algorithm) {
+        switch (algorithm) {
+            case 'MD5': {
+                return CryptoJs.MD5(value).toString();
+            }
+            case 'SHA1': {
+                return CryptoJs.SHA1(value).toString();
+            }
+            case 'SHA256': {
+                return CryptoJs.SHA256(value).toString();
+            }
+            case 'SHA384': {
+                return CryptoJs.SHA384(value).toString();
+            }
+            case 'SHA512': {
+                return CryptoJs.SHA512(value).toString();
+            }
+            case 'HMAC-MD5': {
+                return CryptoJs.HmacMD5(value, secret).toString();
+            }
+            case 'HMAC-SHA1': {
+                return CryptoJs.HmacSHA1(value, secret).toString();
+            }
+            case 'HMAC-SHA256': {
+                return CryptoJs.HmacSHA256(value, secret).toString();
+            }
+            case 'HMAC-SHA384': {
+                return CryptoJs.HmacSHA384(value, secret).toString();
+            }
+            case 'HMAC-SHA512': {
+                return CryptoJs.HmacSHA512(value, secret).toString();
+            }
+            case 'AES': {
+                return CryptoJs.AES.encrypt(value, secret).toString();
+            }
+            default: {
+                throw new Error('Invalid encryption algorithm');
+            }
+        }
+    },
+    decrypt: function (encryptedValue, secret, algorithm) {
+        switch (algorithm) {
+            case 'AES': {
+                return CryptoJs.AES.decrypt(encryptedValue, secret).toString(CryptoJs.enc.Utf8);
+            }
+            default: {
+                throw new Error('Invalid encryption algorithm');
+            }
+        }
+    }
+};