@reldens/utils 0.46.0 → 0.48.0

package/lib/env-var.js

@@ -4,12 +4,14 @@
  *
  */
 
+const sc = require('./shortcuts');
+
 class EnvVar
 {
 
     string(obj, key, defaultValue)
     {
-        const val = obj[key];
+        let val = obj[key];
         if('string' === typeof val){
             return val;
         }
@@ -18,7 +20,7 @@ class EnvVar
 
     nonEmptyString(obj, key, defaultValue)
     {
-        const val = obj[key];
+        let val = obj[key];
         if('string' === typeof val && '' !== val.trim()){
             return val;
         }
@@ -27,16 +29,17 @@ class EnvVar
 
     number(obj, key, defaultValue)
     {
-        const val = obj[key];
-        if(!isNaN(Number(val)) && '' !== val && null !== val){
-            return Number(val);
+        let val = obj[key];
+        let parsed = sc.parseNumber(val);
+        if(parsed){
+            return parsed;
         }
         return defaultValue;
     }
 
     boolean(obj, key, defaultValue)
     {
-        const val = obj[key];
+        let val = obj[key];
         if('true' === val || '1' === val){
             return true;
         }
@@ -46,6 +49,51 @@ class EnvVar
         return defaultValue;
     }
 
+    array(obj, key, defaultValue, separator = ',')
+    {
+        let val = obj[key];
+        let parsed = sc.splitToArray(val, separator);
+        if(parsed){
+            return parsed;
+        }
+        return defaultValue;
+    }
+
+    url(obj, key, defaultValue)
+    {
+        let val = obj[key];
+        if(!sc.isString(val)){
+            return defaultValue;
+        }
+        if(sc.isValidUrl(val)){
+            return val;
+        }
+        return defaultValue;
+    }
+
+    json(obj, key, defaultValue)
+    {
+        let val = obj[key];
+        if(!sc.isString(val)){
+            return defaultValue;
+        }
+        return sc.parseJson(val, defaultValue);
+    }
+
+    integer(obj, key, defaultValue, min, max)
+    {
+        let val = this.number(obj, key, defaultValue);
+        if(val !== defaultValue && sc.isValidInteger(val, min, max)){
+            return val;
+        }
+        return defaultValue;
+    }
+
+    port(obj, key, defaultValue)
+    {
+        return this.integer(obj, key, defaultValue, 1, 65535);
+    }
+
 }
 
 module.exports = new EnvVar();

package/lib/events-manager.js

@@ -28,8 +28,21 @@ class AwaitEventEmitterExtended extends AwaitEventEmitter
         this.debug = false;
     }
 
+    validateEventKey(eventKey)
+    {
+        return !sc.hasDangerousKeys(null, eventKey);
+    }
+
     onWithKey(eventName, callback, uniqueRemoveKey, masterKey)
     {
+        if(!this.validateEventKey(eventName) || !this.validateEventKey(uniqueRemoveKey)){
+            Logger.critical('Invalid event key detected: '+eventName+' or '+uniqueRemoveKey);
+            return false;
+        }
+        if(masterKey && !this.validateEventKey(masterKey)){
+            Logger.critical('Invalid master key detected: '+masterKey);
+            return false;
+        }
         if(
             sc.hasOwn(this.eventsByRemoveKeys, uniqueRemoveKey)
             || (
@@ -62,6 +75,14 @@ class AwaitEventEmitterExtended extends AwaitEventEmitter
      */
     offWithKey(uniqueRemoveKey, masterKey)
     {
+        if(!this.validateEventKey(uniqueRemoveKey)){
+            Logger.critical('Invalid remove key detected: '+uniqueRemoveKey);
+            return false;
+        }
+        if(masterKey && !this.validateEventKey(masterKey)){
+            Logger.critical('Invalid master key detected: '+masterKey);
+            return false;
+        }
         if(masterKey && !sc.hasOwn(this.eventsByRemoveKeys, masterKey)){
             Logger.debug('Event not found by masterKey "'+masterKey+'".');
             return false;
@@ -74,8 +95,16 @@ class AwaitEventEmitterExtended extends AwaitEventEmitter
             ? this.eventsByRemoveKeys[masterKey][uniqueRemoveKey]
             : this.eventsByRemoveKeys[uniqueRemoveKey];
 
+        if(!this.validateEventKey(eventToRemove.eventName)){
+            Logger.critical('Invalid event name in stored event: '+eventToRemove.eventName);
+            return false;
+        }
         let dataArr = this.listeners(eventToRemove.eventName);
         let currentListenerIndex = dataArr.indexOf(eventToRemove.callback);
+        if(-1 === currentListenerIndex){
+            Logger.debug('Event listener not found in _events array.');
+            return false;
+        }
         this._events[eventToRemove.eventName].splice(currentListenerIndex, 1);
         if(0 === this._events[eventToRemove.eventName].length){
             delete this._events[eventToRemove.eventName];
@@ -95,6 +124,10 @@ class AwaitEventEmitterExtended extends AwaitEventEmitter
      */
     offByMasterKey(masterKey)
     {
+        if(!this.validateEventKey(masterKey)){
+            Logger.critical('Invalid master key detected: '+masterKey);
+            return false;
+        }
         if(!sc.hasOwn(this.eventsByRemoveKeys, masterKey)){
             Logger.debug('Events not found by masterKey "'+masterKey+'".');
             return false;
@@ -104,8 +137,14 @@ class AwaitEventEmitterExtended extends AwaitEventEmitter
         Logger.debug('Removing events by masterKey: '+masterKey, Object.keys(this.eventsByRemoveKeys[masterKey]));
         for(let uniqueRemoveKey of Object.keys(this.eventsByRemoveKeys[masterKey])){
             let eventToRemove = this.eventsByRemoveKeys[masterKey][uniqueRemoveKey];
+            if(!this.validateEventKey(eventToRemove.eventName)){
+                continue;
+            }
             let dataArr = this.listeners(eventToRemove.eventName);
             let currentListenerIndex = dataArr.indexOf(eventToRemove.callback);
+            if(-1 === currentListenerIndex){
+                continue;
+            }
             this._events[eventToRemove.eventName].splice(currentListenerIndex, 1);
             if(0 === this._events[eventToRemove.eventName].length){
                 delete this._events[eventToRemove.eventName];
@@ -116,7 +155,11 @@ class AwaitEventEmitterExtended extends AwaitEventEmitter
 
     on(key, callback)
     {
-        if(this.debug !== false){
+        if(!this.validateEventKey(key)){
+            Logger.critical('Invalid event key detected: '+key);
+            return false;
+        }
+        if(false !== this.debug){
             this.logDebugEvent(key, 'Listen');
         }
         super.on(key, callback);
@@ -124,7 +167,11 @@ class AwaitEventEmitterExtended extends AwaitEventEmitter
 
     async emit(key, ...args)
     {
-        if(this.debug !== false){
+        if(!this.validateEventKey(key)){
+            Logger.critical('Invalid event key detected: '+key);
+            return false;
+        }
+        if(false !== this.debug){
             this.logDebugEvent(key, 'Fire');
         }
         await super.emit(key, ...args);

package/lib/logger.js

@@ -4,6 +4,8 @@
  *
  */
 
+const sc = require('./shortcuts');
+
 class Logger
 {
 
@@ -21,15 +23,14 @@ class Logger
 
     constructor()
     {
-        // @TODO - BETA
-        //   - Implement different log systems (console.log, files logs, db log?).
-        //   - Implement notifications system (email?), and make it configurable for the different log levels.
         let context = this.context();
-        this.enableTraceBack = '';
-        this.logLevelBack = 3;
-        this.forcedDisabled = Boolean(context.RELDENS_FORCED_DISABLED_LOGS || false);
-        this.addTimeStamp = Boolean(context.RELDENS_INCLUDE_LOGS_TIMESTAMP || true);
+        this.enableTraceBack = sc.get(context, 'RELDENS_LOGS_ENABLE_TRACE_BACK', '');
+        this.logLevelBack = sc.get(context, 'RELDENS_LOGS_LEVEL_BACK', 3);
         this.callback = false;
+        this.forcedDisabled = Boolean(sc.get(context, 'RELDENS_LOGS_FORCED_DISABLED', false));
+        this.addTimeStamp = Boolean(sc.get(context, 'RELDENS_LOGS_INCLUDE_TIMESTAMP', true));
+        this.maxLogArgLength = sc.get(context, 'RELDENS_LOGS_MAX_ARGUMENT_LENGTH', 1000);
+        this.maxStackTraceLength = sc.get(context, 'RELDENS_LOGS_MAX_STACK_TRACE_LENGTH', 2000);
     }
 
     context()
@@ -94,7 +95,8 @@ class Logger
     log(levelLabel, ...args)
     {
         let date = !this.addTimeStamp ? '' : (new Date()).toISOString().slice(0, 19).replace('T', ' ')+' - ';
-        this.logWithCallback(date+levelLabel.toUpperCase()+' -', ...args);
+        let sanitizedArgs = args.map(arg => sc.isString(arg) ? sc.cleanMessage(arg, this.maxLogArgLength) : arg);
+        this.logWithCallback(date+levelLabel.toUpperCase()+' -', ...sanitizedArgs);
         if(-1 !== this.enableTraceFor().indexOf('all') || -1 !== this.enableTraceFor().indexOf(levelLabel)){
             if('function' !== typeof Error?.captureStackTrace){
                 this.logWithCallback('Error.captureStackTrace is not available.', typeof Error?.captureStackTrace);
@@ -102,7 +104,8 @@ class Logger
             }
             let stackHolder = {};
             Error.captureStackTrace(stackHolder, levelLabel);
-            this.logWithCallback(stackHolder.stack);
+            let sanitizedStack = sc.cleanMessage(stackHolder.stack, this.maxStackTraceLength);
+            this.logWithCallback(sanitizedStack);
         }
         return this;
     }

package/lib/schema-validator.js

@@ -43,6 +43,13 @@ class SchemaValidator extends ValidatorInterface
         }
         for(let i of Object.keys(schema)){
             let validate = schema[i];
+            if(validate.required && !sc.hasOwn(obj, i)){
+                Logger.debug('Required property missing.', i);
+                return false;
+            }
+            if(!sc.hasOwn(obj, i) && !validate.required){
+                continue;
+            }
             if(!this.isValidSchema(obj[i], validate, i)){
                 return false;
             }
@@ -61,12 +68,36 @@ class SchemaValidator extends ValidatorInterface
             Logger.debug('No schema type provided.', schema, obj, objectKey);
             return false;
         }
+        if(schema.custom && sc.isFunction(schema.custom)){
+            if(!schema.custom(obj)){
+                Logger.debug('Custom validation failed.', objectKey, obj, schema);
+                return false;
+            }
+        }
+        if(schema.enum && sc.isArray(schema.enum)){
+            if(-1 === schema.enum.indexOf(obj)){
+                Logger.debug('Value not in enum.', objectKey, obj, schema.enum);
+                return false;
+            }
+        }
         switch(schema.type){
             case 'string':
                 if(!sc.isString(obj)){
                     Logger.debug('Object is not a string.', objectKey, obj, schema);
                     return false;
                 }
+                if(schema.min && obj.length < schema.min){
+                    Logger.debug('String too short.', objectKey, obj.length, schema.min);
+                    return false;
+                }
+                if(schema.max && obj.length > schema.max){
+                    Logger.debug('String too long.', objectKey, obj.length, schema.max);
+                    return false;
+                }
+                if(schema.pattern && !schema.pattern.test(obj)){
+                    Logger.debug('String pattern mismatch.', objectKey, obj, schema.pattern);
+                    return false;
+                }
                 break;
             case 'number':
                 if(!sc.isInt(obj)){
@@ -75,18 +106,42 @@ class SchemaValidator extends ValidatorInterface
                         return false;
                     }
                 }
+                if(schema.min && obj < schema.min){
+                    Logger.debug('Number too small.', objectKey, obj, schema.min);
+                    return false;
+                }
+                if(schema.max && obj > schema.max){
+                    Logger.debug('Number too large.', objectKey, obj, schema.max);
+                    return false;
+                }
                 break;
             case 'int':
                 if(!sc.isInt(obj)){
                     Logger.debug('Object is not an integer.', objectKey, obj, schema);
                     return false;
                 }
+                if(schema.min && obj < schema.min){
+                    Logger.debug('Integer too small.', objectKey, obj, schema.min);
+                    return false;
+                }
+                if(schema.max && obj > schema.max){
+                    Logger.debug('Integer too large.', objectKey, obj, schema.max);
+                    return false;
+                }
                 break;
             case 'float':
                 if(!sc.isFloat(obj)){
                     Logger.debug('Object is not a float.', objectKey, obj, schema);
                     return false;
                 }
+                if(schema.min && obj < schema.min){
+                    Logger.debug('Float too small.', objectKey, obj, schema.min);
+                    return false;
+                }
+                if(schema.max && obj > schema.max){
+                    Logger.debug('Float too large.', objectKey, obj, schema.max);
+                    return false;
+                }
                 break;
             case 'boolean':
                 if(!sc.isBoolean(obj)){
@@ -105,6 +160,14 @@ class SchemaValidator extends ValidatorInterface
                     Logger.debug('Object is not an array.', objectKey, obj, schema);
                     return false;
                 }
+                if(schema.min && obj.length < schema.min){
+                    Logger.debug('Array too short.', objectKey, obj.length, schema.min);
+                    return false;
+                }
+                if(schema.max && obj.length > schema.max){
+                    Logger.debug('Array too long.', objectKey, obj.length, schema.max);
+                    return false;
+                }
                 if(schema.valuesType){
                     for(let i of obj){
                         if(!this.isValidSchema(i, {type: schema.valuesType}, objectKey)){

package/lib/shortcuts.js

@@ -47,6 +47,11 @@ class Shortcuts
         return -1 !== dataArray.indexOf(value);
     }
 
+    isNotEmptyArray(dataArray)
+    {
+        return (this.isArray(dataArray) && 0 < dataArray.length);
+    }
+
     isFunction(callback)
     {
         return (callback && 'function' === typeof callback);
@@ -88,12 +93,32 @@ class Shortcuts
         return 'boolean' === typeof value;
     }
 
+    hasDangerousKeys(obj, key = null)
+    {
+        let dangerousKeys = ['__proto__', 'constructor', 'prototype'];
+        if(key){
+            return -1 !== dangerousKeys.indexOf(key);
+        }
+        if(!this.isObject(obj)){
+            return false;
+        }
+        for(let dangerousKey of dangerousKeys){
+            if(this.hasOwn(obj, dangerousKey)){
+                return true;
+            }
+        }
+        return false;
+    }
+
     deepMergeProperties(target, source)
     {
         if(!this.isObject(target) || !this.isObject(source)){
             return false;
         }
         for(let key of Object.keys(source)){
+            if(this.hasDangerousKeys(null, key)){
+                continue;
+            }
             if(this.isObject(source[key])){
                 if(!this.hasOwn(target, key)){
                     target[key] = source[key];
@@ -152,8 +177,8 @@ class Shortcuts
         if(!sortField){
             return collection;
         }
-        let directionValue = 'act' === direction ? 1 : -1;
-        let directionOpposite = 'act' === direction ? -1 : 1;
+        let directionValue = 'asc' === direction ? 1 : -1;
+        let directionOpposite = 'asc' === direction ? -1 : 1;
         return collection.sort((a, b) => {
             return a[sortField] > b[sortField] ? directionValue : directionOpposite;
         });
@@ -177,11 +202,16 @@ class Shortcuts
 
     parseJson(jsonString, defaultReturn = false)
     {
+        let parsed;
         try {
-            return JSON.parse(jsonString);
+            parsed = JSON.parse(jsonString);
         } catch (e) {
             return defaultReturn;
         }
+        if(this.hasDangerousKeys(parsed)){
+            return defaultReturn;
+        }
+        return parsed;
     }
 
     deepJsonClone(obj)
@@ -302,7 +332,7 @@ class Shortcuts
         let obj = {};
         for(let [key, value] of formData){
             if(obj[key] !== undefined){
-                if(!Array.isArray(obj[key])){
+                if(!this.isArray(obj[key])){
                     obj[key] = [obj[key]];
                 }
                 obj[key].push(value);
@@ -316,7 +346,7 @@ class Shortcuts
     removeFromArray(valuesArray, removeValues)
     {
         return valuesArray.filter((value) => {
-            return removeValues.indexOf(value) === -1;
+            return -1 === removeValues.indexOf(value);
         });
     }
 
@@ -404,7 +434,7 @@ class Shortcuts
         if(!message){
             return '';
         }
-        let text = message.toString().replace(/\\/g, '');
+        let text = message.replace(/\\/g, '').replace(/[\r\n\t]/g, ' ');
         if(0 < characterLimit){
             return text.substring(0, characterLimit);
         }
@@ -413,8 +443,7 @@ class Shortcuts
 
     slugify(text)
     {
-        return (text || '')
-            .replace(/&/g, ' and ')
+        return (text || '').replace(/&/g, ' and ')
             .replace(/[^a-zA-Z0-9]/g, ' ')
             .trim()
             .replace(/\s+/g, '-')
@@ -423,8 +452,7 @@ class Shortcuts
 
     isValidIsoCode(isoCode)
     {
-        let isoLanguageCodeRegex = /^[a-zA-Z]{2}$/;
-        return isoLanguageCodeRegex.test(isoCode);
+        return (/^[a-zA-Z]{2}$/).test(isoCode);
     }
 
     sanitize(input)
@@ -432,32 +460,207 @@ class Shortcuts
         if(!input){
             return '';
         }
-        return input
-            .replace(/&(?![a-zA-Z0-9#]+;)/g, '&amp;')
+        return input.replace(/&/g, '&amp;')
             .replace(/</g, '&lt;')
             .replace(/>/g, '&gt;')
             .replace(/"/g, '&quot;')
             .replace(/'/g, '&#x27;')
             .replace(/\//g, '&#x2F;')
-            .replace(/`/g, '&#x60;');
+            .replace(/`/g, '&#x60;')
+            .replace(/\(/g, '&#x28;')
+            .replace(/\)/g, '&#x29;');
     }
 
     sanitizeUrl(url)
     {
-        if(!url){
+        if(!url || !this.isString(url) || 2048 < url.length){
             return '';
         }
         let sanitized = url.trim();
-        let urlPattern = /^(?:https?:\/\/|mailto:|tel:|#|\/|\.\/|\.\.\/)/i;
+        let urlPattern = /^https?:\/\/(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(?::[1-9][0-9]{0,4})?(?:\/(?:[\w\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*(?:\?(?:[\w\-._~!$&'()*+,;=:@/?]|%[0-9A-Fa-f]{2})*)?(?:#(?:[\w\-._~!$&'()*+,;=:@/?]|%[0-9A-Fa-f]{2})*)?$/;
         if(!urlPattern.test(sanitized)){
             return '';
         }
-        return sanitized
-            .replace(/javascript:/gi, '')
+        return sanitized.replace(/javascript:/gi, '')
             .replace(/data:/gi, '')
             .replace(/vbscript:/gi, '');
     }
 
+    camelCase(str)
+    {
+        if(!this.isString(str) || 0 === str.length){
+            return str;
+        }
+        return str.replace(/[_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '');
+    }
+
+    capitalizedCamelCase(str)
+    {
+        if(!this.isString(str) || 0 === str.length){
+            return str;
+        }
+        let camelStr = this.camelCase(str);
+        return camelStr.charAt(0).toUpperCase() + camelStr.slice(1);
+    }
+
+    kebabCase(str)
+    {
+        return str.replace(/[_\s]+/g, '-');
+    }
+
+    capitalize(str)
+    {
+        if(!this.isString(str) || 0 === str.length){
+            return str;
+        }
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    }
+
+    chunk(array, size)
+    {
+        if(!this.isArray(array) || 0 >= size){
+            return [];
+        }
+        let result = [];
+        for(let i = 0; i < array.length; i += size){
+            result.push(array.slice(i, i + size));
+        }
+        return result;
+    }
+
+    flatten(array, depth = 1)
+    {
+        if(!this.isArray(array)){
+            return [];
+        }
+        return array.flat(depth);
+    }
+
+    unique(array)
+    {
+        if(!this.isArray(array)){
+            return [];
+        }
+        return [...new Set(array)];
+    }
+
+    clamp(value, min, max)
+    {
+        if(!this.isNumber(value) || !this.isNumber(min) || !this.isNumber(max)){
+            return value;
+        }
+        return Math.min(Math.max(value, min), max);
+    }
+
+    truncate(str, length, suffix = '...')
+    {
+        if(!this.isString(str) || str.length <= length){
+            return str;
+        }
+        return str.substring(0, length) + suffix;
+    }
+
+    pickProps(obj, props)
+    {
+        if(!this.isObject(obj) || !this.isArray(props)){
+            return {};
+        }
+        let result = {};
+        for(let prop of props){
+            if(this.hasDangerousKeys(null, prop)){
+                continue;
+            }
+            if(this.hasOwn(obj, prop)){
+                result[prop] = obj[prop];
+            }
+        }
+        return result;
+    }
+
+    omitProps(obj, props)
+    {
+        if(!this.isObject(obj) || !this.isArray(props)){
+            return obj;
+        }
+        let result = {};
+        for(let key of Object.keys(obj)){
+            if(-1 === props.indexOf(key)){
+                result[key] = obj[key];
+            }
+        }
+        return result;
+    }
+
+    debounce(func, wait)
+    {
+        if(!this.isFunction(func) || !this.isNumber(wait)){
+            return func;
+        }
+        let timeout;
+        return function executedFunction(...args) {
+            let later = () => {
+                clearTimeout(timeout);
+                func.apply(this, args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    }
+
+    throttle(func, limit)
+    {
+        if(!this.isFunction(func) || !this.isNumber(limit)){
+            return func;
+        }
+        let inThrottle;
+        return function executedFunction(...args) {
+            if(!inThrottle){
+                func.apply(this, args);
+                inThrottle = true;
+                setTimeout(() => inThrottle = false, limit);
+            }
+        };
+    }
+
+    isValidUrl(url)
+    {
+        if(!this.isString(url) || 2048 < url.length){
+            return false;
+        }
+        let urlPattern = /^https?:\/\/(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(?::[1-9][0-9]{0,4})?(?:\/(?:[\w\-._~!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})*)*(?:\?(?:[\w\-._~!$&'()*+,;=:@/?]|%[0-9A-Fa-f]{2})*)?(?:#(?:[\w\-._~!$&'()*+,;=:@/?]|%[0-9A-Fa-f]{2})*)?$/;
+        return urlPattern.test(url);
+    }
+
+    isValidInteger(value, min, max)
+    {
+        if(!this.isNumber(value) || !Number.isInteger(value)){
+            return false;
+        }
+        if('number' === typeof min && value < min){
+            return false;
+        }
+        if('number' === typeof max && value > max){
+            return false;
+        }
+        return true;
+    }
+
+    parseNumber(value)
+    {
+        if(!isNaN(Number(value)) && '' !== value && null !== value){
+            return Number(value);
+        }
+        return null;
+    }
+
+    splitToArray(str, separator = ',')
+    {
+        if(!this.isString(str) || '' === str.trim()){
+            return null;
+        }
+        return str.split(separator).map(item => item.trim()).filter(item => '' !== item);
+    }
+
 }
 
 module.exports = new Shortcuts();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/utils",
     "scope": "@reldens",
-    "version": "0.46.0",
+    "version": "0.48.0",
     "description": "Reldens - Utils",
     "author": "Damian A. Pastorini",
     "license": "MIT",