@awesomeness-js/utils 1.1.7 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@awesomeness-js/utils",
-	"version": "1.1.7",
+	"version": "1.1.8",
 	"description": "Awesomeness - Utils",
 	"repository": {
 		"type": "git",

package/src/utils/clean.js

@@ -9,7 +9,22 @@ import cleanString from '../clean/string.js';
 import cleanTimestamp from '../clean/timestamp.js';
 import cleanUUID from '../clean/uuid.js';
 
-function cleanArray(arr, schema = {}, testMode = false){
+const knownTypesToClean = [
+	'boolean',
+	'integer',
+	'number',
+	'string',
+	'timestamp',
+	'uuid',
+	'object',
+	'array'
+];
+
+function cleanArray(arr, schema = {}, {
+	testMode = false,
+	allOrNothing = false,
+	path = ''
+} = {}){
 
 	try {
 
@@ -25,97 +40,153 @@ function cleanArray(arr, schema = {}, testMode = false){
 		validateSchema(schema);
     
 		const cleanArrayItems = [];
-    
+		const errors = {};
+
 		const supposedToBeType = schema.items.type;
     
 		arr.forEach( (item, key) => {
+
+			let cleanedItem;
+
+			try {
+
+				const itemType = thingType(item);
     
-			const itemType = thingType(item);
-    
-    
-			if(itemType !== supposedToBeType){
-    
-				throw {
-					message: 'type invalid',
-					itemType,
-					supposedToBeType
-				};
-    
-			}
-    
-			let cleanedItem = item;
-    
-			if(supposedToBeType === 'boolean'){
+				if(itemType !== supposedToBeType){
+		
+					throw {
+						message: 'type invalid',
+						itemType,
+						supposedToBeType
+					};
+		
+				}
+		
+				cleanedItem = item;
 
-				cleanedItem = cleanBoolean(item); 
+				if(!knownTypesToClean.includes(supposedToBeType)){
 
-			}
+					throw {
+						message: 'Unknown type to clean in schema',
+						supposedToBeType
+					};
 
-			if(supposedToBeType === 'integer'){
+				}
 
-				cleanedItem = cleanInteger(item); 
 
-			}
+				if(testMode){ console.log(`cleaning ${supposedToBeType}`, item, schema.items); }
 
-			if(supposedToBeType === 'number'){
 
-				cleanedItem = cleanNumber(item); 
+				if(supposedToBeType === 'boolean'){
 
-			}
+					cleanedItem = cleanBoolean(item); 
 
-			if(supposedToBeType === 'string'){
+				}
 
-				cleanedItem = cleanString(item); 
+				if(supposedToBeType === 'integer'){
 
-			}
+					cleanedItem = cleanInteger(item); 
 
-			if(supposedToBeType === 'timestamp'){
+				}
 
-				cleanedItem = cleanTimestamp(item); 
+				if(supposedToBeType === 'number'){
 
-			}
+					cleanedItem = cleanNumber(item); 
 
-			if(supposedToBeType === 'uuid'){
+				}
 
-				cleanedItem = cleanUUID(item); 
+				if(supposedToBeType === 'string'){
 
-			}
-            
-			if(supposedToBeType === 'array'){
- 
-				cleanedItem = cleanArray(item, schema.items); 
-			
-			}
+					cleanedItem = cleanString(item); 
 
-			if(supposedToBeType === 'object'){
- 
-				cleanedItem = cleanObject(item, schema.items); 
-			
-			}
+				}
 
-			if(cleanedItem === null){
+				if(supposedToBeType === 'timestamp'){
 
-				if(schema.required === true){
+					cleanedItem = cleanTimestamp(item); 
 
-					throw {
-						message: 'required item is null',
-						item,
-						key
-					};
+				}
+
+				if(supposedToBeType === 'uuid'){
+
+					cleanedItem = cleanUUID(item); 
+
+				}
 				
-				} else {
+				if(supposedToBeType === 'array'){
+	
+					cleanedItem = cleanArray(item, schema.items, {
+						testMode,
+						allOrNothing,
+						path: path ? `${path}.${key}` : key
+					}); 
+				
+				}
 
-					return; // skip this item if it's not required and is null
+				if(supposedToBeType === 'object'){
+	
+					cleanedItem = cleanObject(item, schema.items, {
+						testMode,
+						allOrNothing,
+						path: path ? `${path}.${key}` : key
+					}); 
 				
 				}
-			
-			}
 
+				if(cleanedItem === null){
+
+					if(schema.required === true){
+
+						throw {
+							message: 'required item is null',
+							item,
+							key
+						};
+					
+					} else {
+
+						return; // skip this item if it's not required and is null
+					
+					}
+				
+				}
+
+
+			} catch(err){
+
+				if(allOrNothing){
+
+					throw err;
+
+				} else {
+
+					const errorPath = path ? `${path}[${key}]` : `[${key}]`;
+
+					errors[errorPath] = {
+						error: err,
+						value: item,
+						requirements: schema.items
+					};
+
+				}
+
+				return; // skip this item if there's an error
+
+			}
     
 			cleanArrayItems.push(cleanedItem);
     
 		});
-    
+
+		if(Object.keys(errors).length > 0){
+
+			throw {
+				message: 'Array not clean',
+				errors
+			};
+
+		}
+
 		if(cleanArrayItems.length === 0){
 
 			throw {
@@ -146,7 +217,11 @@ function cleanArray(arr, schema = {}, testMode = false){
 }
 
 
-function cleanObject(obj, schema, testMode = false){
+function cleanObject(obj, schema, {
+	testMode = false,
+	allOrNothing = false,
+	path = ''
+} = {}){
 
 	validateSchema(schema);
 
@@ -184,111 +259,142 @@ function cleanObject(obj, schema, testMode = false){
 	}
 
 	const cleanObj = {};
+	const errors = {};
 
 	// Iterate over the schema keys
 	each(obj, (value, key) => {
 
-		const valType = thingType(value);
-		const supposedToBeType = schema.properties[key].type;
+		let cleanedValue;
 
-		if(testMode){
-			console.log(`cleaning ${key}`,{
-				valType,
-				supposedToBeType,
-				value,
-			});
-		}
+		try {
 
-		if(valType !== supposedToBeType){
+			const valType = thingType(value);
+			const supposedToBeType = schema.properties[key].type;
 
-			throw {
-				message: 'type invalid',
-				valType,
-				supposedToBeType,
-				key
-			};
+			if(testMode){
+				console.log(`cleaning ${key}`,{
+					valType,
+					supposedToBeType,
+					value,
+				});
+			}
 
-		}
+			if(valType !== supposedToBeType){
 
-		let cleanedValue;
+				throw {
+					message: 'type invalid',
+					valType,
+					supposedToBeType,
+					key
+				};
 
-		const knownTypesToClean = [
-			'boolean',
-			'integer',
-			'number',
-			'string',
-			'timestamp',
-			'uuid',
-			'object',
-			'array'
-		];
+			}
 
-		if(!knownTypesToClean.includes(supposedToBeType)){
 
-			throw {
-				message: 'Unknown type to clean in schema',
-				supposedToBeType,
-				key
-			};
+			if(!knownTypesToClean.includes(supposedToBeType)){
 
-		}
+				throw {
+					message: 'Unknown type to clean in schema',
+					supposedToBeType,
+					key
+				};
 
-		
-		if(testMode){ console.log('cleaning boolean', value); }
+			}
 
+			
+			if(testMode){ console.log(`cleaning ${supposedToBeType}`, value, schema.properties[key]); }
 
-		if(supposedToBeType === 'boolean'){
 
-			cleanedValue = cleanBoolean(value, schema.properties[key]); 
+			if(supposedToBeType === 'boolean'){
 
-		}
+				cleanedValue = cleanBoolean(value, schema.properties[key]); 
 
-		if(supposedToBeType === 'integer'){
+			}
 
-			cleanedValue = cleanInteger(value, schema.properties[key]); 
+			if(supposedToBeType === 'integer'){
 
-		}
+				cleanedValue = cleanInteger(value, schema.properties[key]); 
 
-		if(supposedToBeType === 'number'){
+			}
 
-			cleanedValue = cleanNumber(value, schema.properties[key]); 
+			if(supposedToBeType === 'number'){
 
-		}
+				cleanedValue = cleanNumber(value, schema.properties[key]); 
 
-		if(supposedToBeType === 'string'){
+			}
 
-			cleanedValue = cleanString(value, schema.properties[key]); 
+			if(supposedToBeType === 'string'){
 
-		}
+				cleanedValue = cleanString(value, schema.properties[key]); 
 
-		if(supposedToBeType === 'timestamp'){
+			}
 
-			cleanedValue = cleanTimestamp(value, schema.properties[key]); 
+			if(supposedToBeType === 'timestamp'){
 
-		}
+				cleanedValue = cleanTimestamp(value, schema.properties[key]); 
 
-		if(supposedToBeType === 'uuid'){
+			}
 
-			cleanedValue = cleanUUID(value, schema.properties[key]); 
+			if(supposedToBeType === 'uuid'){
 
-		}
+				cleanedValue = cleanUUID(value, schema.properties[key]); 
 
-		if(supposedToBeType === 'object'){
+			}
 
-			cleanedValue = cleanObject(value, schema.properties[key]); 
-		
-		}
+			if(supposedToBeType === 'object'){
+
+				cleanedValue = cleanObject(value, schema.properties[key], {
+					testMode,
+					allOrNothing,
+					path: path ? `${path}.${key}` : key
+				}); 
+			
+			}
+
+			if(supposedToBeType === 'array'){
+
+				cleanedValue = cleanArray(value, schema.properties[key], {
+					testMode,
+					allOrNothing,
+					path: path ? `${path}.${key}` : key
+				}); 
+			
+			}
+
+		} catch (err) {
+
+			if(allOrNothing){
+
+				throw err;
+
+			} else {
+
+				const errorPath = path ? `${path}.${key}` : key;
+
+				errors[errorPath] = {
+					error: err,
+					value: value,
+					requirements: schema.properties[key]
+				};
+
+			}
 
-		if(supposedToBeType === 'array'){
 
-			cleanedValue = cleanArray(value, schema.properties[key]); 
-		
 		}
 
 		cleanObj[key] = cleanedValue;
 
 	});
 
+	if(Object.keys(errors).length > 0){
+
+		throw {
+			message: 'Object not clean',
+			errors
+		};
+
+	}
+
 	return cleanObj;
 
 }