@reldens/utils 0.29.0 → 0.31.0

package/index.js

@@ -11,7 +11,7 @@ module.exports = {
     EventsManagerSingleton: new EventsManager(),
     ErrorManager: require('./lib/error-manager'),
     InteractionArea: require('./lib/interaction-area'),
-    FileHandler: require('./lib/file-handler'),
+    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.29.0",
+    "version": "0.31.0",
     "description": "Reldens - Utils",
     "author": "Damian A. Pastorini",
     "license": "MIT",

package/lib/file-handler.js

@@ -1,88 +0,0 @@
-/**
- *
- * Reldens - FileHandler
- *
- */
-
-const fs = require('fs');
-const path = require('path');
-const Logger = require('./logger');
-
-class FileHandler
-{
-
-    constructor()
-    {
-        this.encoding = 'utf8';
-    }
-
-    joinPaths(...paths)
-    {
-        return path.join(...paths);
-    }
-
-    copyFile(from, to, folder)
-    {
-        if(!this.exists(from)){
-            return false;
-        }
-        if(!this.exists(folder)){
-            return false;
-        }
-        fs.copyFileSync(from, path.join(folder, to));
-    }
-
-    createFolder(folderPath)
-    {
-        fs.mkdirSync(folderPath, { recursive: true });
-    }
-
-    readFile(filePath)
-    {
-        return fs.readFileSync(filePath);
-    }
-
-    async writeFile(fileName, content)
-    {
-        return fs.writeFile(fileName, content, this.encoding, (err) => {
-            if(err){
-                Logger.error('Error saving the file:', err);
-                return false;
-            }
-            Logger.info('The file has been saved! New file name: '+fileName);
-            return true;
-        });
-    }
-
-    exists(fullPath)
-    {
-        if(!fs.existsSync(fullPath)){
-            Logger.info(`File or folder "${fullPath}" does not exist.`);
-            return false;
-        }
-        return true;
-    }
-
-    removeByPath(fullPath)
-    {
-        if(!this.exists(fullPath)){
-            return false;
-        }
-        let stats = fs.statSync(fullPath);
-        if(stats.isFile()){
-            fs.unlinkSync(fullPath);
-            Logger.info(`File "${fullPath}" has been removed.`);
-            return true;
-        }
-        if(stats.isDirectory()){
-            fs.rmdirSync(fullPath, { recursive: true }); // Remove folder recursively
-            Logger.info(`Folder "${fullPath}" has been removed.`);
-            return true;
-        }
-        Logger.warning(`"${fullPath}" is neither a file nor a folder.`);
-        return false;
-    }
-
-}
-
-module.exports = FileHandler;