@reldens/utils 0.30.0 → 0.31.0

package/index.js

@@ -11,6 +11,7 @@ module.exports = {
     EventsManagerSingleton: new EventsManager(),
     ErrorManager: require('./lib/error-manager'),
     InteractionArea: require('./lib/interaction-area'),
+    SchemaValidator: require('./lib/schema-validator'),
     Logger: require('./lib/logger'),
     sc: require('./lib/shortcuts')
 };

package/lib/schema-validator.js

@@ -0,0 +1,116 @@
+/**
+ *
+ * Reldens - SchemaValidator
+ *
+ * This module is to validate objects properties at runtime.
+ *
+ */
+
+const sc = require('./shortcuts');
+const Logger = require('./logger');
+
+class SchemaValidator
+{
+
+    constructor(schema)
+    {
+        this.schema = schema;
+    }
+
+    /**
+     * Sample schema:
+     * {
+     *     prop: {type: 'string', min: 1},
+     *     prop2: {type: 'object', nested: {
+     *         anotherProp: {type: 'int', float: 1}
+     *     }}
+     * }
+     *
+     * @param obj
+     * @param schema
+     * @returns {boolean}
+     */
+    validate(obj, schema = false)
+    {
+        if(!schema){
+            schema = this.schema;
+        }
+        if (!sc.isObject(schema)){
+            Logger.debug('No schema provided.');
+            return false;
+        }
+        for(let i of Object.keys(schema)){
+            let validate = schema[i];
+            if(!this.isValidSchema(obj[i], validate, i)){
+                return false;
+            }
+            if(validate.nested){
+                if(!this.validate(obj[i], validate.nested)){
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    isValidSchema(obj, schema, objectKey)
+    {
+        if(!schema ||!schema.type){
+            Logger.debug('No schema type provided.', schema, obj, objectKey);
+            return false;
+        }
+        switch(schema.type){
+            case 'string':
+                if(!sc.isString(obj)){
+                    Logger.debug('Object is not a string.', objectKey, obj, schema);
+                    return false;
+                }
+                break;
+            case 'int':
+                if(!sc.isInt(obj)){
+                    Logger.debug('Object is not an integer.', objectKey, obj, schema);
+                    return false;
+                }
+                break;
+            case 'float':
+                if(!sc.isFloat(obj)){
+                    Logger.debug('Object is not a float.', objectKey, obj, schema);
+                    return false;
+                }
+                break;
+            case 'boolean':
+                if(!sc.isBoolean(obj)){
+                    Logger.debug('Object is not a boolean.', objectKey, obj, schema);
+                    return false;
+                }
+                break;
+            case 'object':
+                if(!sc.isObject(obj)){
+                    Logger.debug('Object is not an object.', objectKey, obj, schema);
+                    return false;
+                }
+                break;
+            case 'array':
+                if(!sc.isArray(obj)){
+                    Logger.debug('Object is not an array.', objectKey, obj, schema);
+                    return false;
+                }
+                if(schema.valuesType){
+                    for(let i of obj){
+                        if(!this.isValidSchema(i, {type: schema.valuesType}, objectKey)){
+                            Logger.debug('Invalid array value.', i, schema);
+                            return false;
+                        }
+                    }
+                }
+                break;
+            default:
+                Logger.debug('Invalid schema type provided.', schema.type);
+                return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.SchemaValidator = SchemaValidator;

package/lib/shortcuts.js

@@ -57,6 +57,32 @@ class Shortcuts
         return this.isObject(obj) && property && 'function' === typeof obj[property];
     }
 
+    isString(value)
+    {
+        return 'string' === typeof value;
+    }
+
+    isInt(value)
+    {
+        if('number' !== typeof value){
+            return false;
+        }
+        return Number.isInteger(value);
+    }
+
+    isFloat(value)
+    {
+        if('number' !== typeof value){
+            return false;
+        }
+        return Number(value) === value && 0 !== value % 1;
+    }
+
+    isBoolean(value)
+    {
+        return 'boolean' === typeof value;
+    }
+
     deepMergeProperties(target, source)
     {
         if(!this.isObject(target) || !this.isObject(source)){

package/package.json

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