@awesomeness-js/utils 1.1.7 → 1.1.9

package/index.js

@@ -6,6 +6,8 @@
 import _build from './src/build.js';
 import _clean_array from './src/clean/array.js';
 import _clean_boolean from './src/clean/boolean.js';
+import _clean_custom from './src/clean/custom.js';
+import _clean_file from './src/clean/file.js';
 import _clean_integer from './src/clean/integer.js';
 import _clean_number from './src/clean/number.js';
 import _clean_object from './src/clean/object.js';
@@ -64,6 +66,8 @@ export { _wait as wait };
 export const clean = {
 	array: _clean_array,
 	boolean: _clean_boolean,
+	custom: _clean_custom,
+	file: _clean_file,
 	integer: _clean_integer,
 	number: _clean_number,
 	object: _clean_object,
@@ -141,6 +145,8 @@ export default {
 	clean: {
 		array: _clean_array,
 		boolean: _clean_boolean,
+		custom: _clean_custom,
+		file: _clean_file,
 		integer: _clean_integer,
 		number: _clean_number,
 		object: _clean_object,

package/package.json

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

package/src/clean/custom.js

@@ -0,0 +1,39 @@
+export default function cleanCustom(value, {
+	required = false,
+	validate = null, // callback that returns true or cleaned value, throws or returns false if invalid
+} = {}) {
+	
+	try {
+		if (value === undefined || value === null) {
+			throw {
+				message: 'Value is missing',
+				value
+			};
+		}
+
+		if (typeof validate === 'function') {
+			const result = validate(value);
+
+			// if validator returns false, treat as invalid
+			if (result === false) {
+				throw {
+					message: 'Validation failed',
+					value
+				};
+			}
+
+			// if validator returns something else, assume cleaned value
+			return result === true ? value : result;
+		}
+
+		// no validation callback, just return the value
+		return value;
+
+	} catch (e) {
+		if (required) {
+			throw e;
+		} else {
+			return null;
+		}
+	}
+}

package/src/clean/file.js

@@ -0,0 +1,62 @@
+export default function cleanFile(file, {
+	required = false,
+	validTypes = [],
+	minSize = false, // bytes
+	maxSize = false, // bytes
+} = {}) {
+
+	try {
+		if (!file || typeof file !== 'object') {
+			throw {
+				message: 'File must be an object (like req.file or File API object)',
+				value: file
+			};
+		}
+
+		if (typeof file.size !== 'number' || typeof file.type !== 'string') {
+			throw {
+				message: 'File object missing required fields (size, type)',
+				value: file
+			};
+		}
+
+		// type validation
+		if (Array.isArray(validTypes) && validTypes.length > 0) {
+			const isValidType = validTypes.some(t => file.type === t || file.name?.endsWith(t));
+			if (!isValidType) {
+				throw {
+					message: `Invalid file type: ${file.type}`,
+					allowed: validTypes,
+					value: file.name || null
+				};
+			}
+		}
+
+		// size validation
+		if (minSize !== false && file.size < minSize) {
+			throw {
+				message: `File is smaller than minimum size (${minSize} bytes)`,
+				value: file.size
+			};
+		}
+
+		if (maxSize !== false && file.size > maxSize) {
+			throw {
+				message: `File is larger than maximum size (${maxSize} bytes)`,
+				value: file.size
+			};
+		}
+
+		// return a normalized safe file info object
+		return {
+			name: file.name || null,
+			type: file.type,
+			size: file.size,
+			lastModified: file.lastModified ? new Date(file.lastModified).toISOString() : null,
+		};
+
+	} catch (e) {
+		if (required) throw e;
+		else return null;
+	}
+}

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;
 
 }

package/types/clean/array.d.ts

@@ -1,2 +1,6 @@
-declare const _default: (arr: any, schema?: {}) => any[];
+declare const _default: (arr: any, schema?: {}, { testMode, allOrNothing, path }?: {
+    testMode?: boolean;
+    allOrNothing?: boolean;
+    path?: string;
+}) => any[];
 export default _default;

package/types/clean/custom.d.ts

@@ -0,0 +1,4 @@
+export default function cleanCustom(value: any, { required, validate, }?: {
+    required?: boolean;
+    validate?: any;
+}): any;

package/types/clean/file.d.ts

@@ -0,0 +1,11 @@
+export default function cleanFile(file: any, { required, validTypes, minSize, maxSize, }?: {
+    required?: boolean;
+    validTypes?: any[];
+    minSize?: boolean;
+    maxSize?: boolean;
+}): {
+    name: any;
+    type: any;
+    size: any;
+    lastModified: string;
+};

package/types/clean/object.d.ts

@@ -1,2 +1,6 @@
-declare const _default: (obj: any, schema: any) => {};
+declare const _default: (obj: any, schema: any, { testMode, allOrNothing, path }?: {
+    testMode?: boolean;
+    allOrNothing?: boolean;
+    path?: string;
+}) => {};
 export default _default;

package/types/index.d.ts

@@ -6,6 +6,8 @@
 import type _build from './build';
 import type _clean_array from './clean/array';
 import type _clean_boolean from './clean/boolean';
+import type _clean_custom from './clean/custom';
+import type _clean_file from './clean/file';
 import type _clean_integer from './clean/integer';
 import type _clean_number from './clean/number';
 import type _clean_object from './clean/object';
@@ -64,6 +66,8 @@ export declare const wait: typeof _wait;
 export declare const clean: {
 	array: typeof _clean_array;
 	boolean: typeof _clean_boolean;
+	custom: typeof _clean_custom;
+	file: typeof _clean_file;
 	integer: typeof _clean_integer;
 	number: typeof _clean_number;
 	object: typeof _clean_object;
@@ -141,6 +145,8 @@ declare const _default: {
 	clean: {
 		array: typeof _clean_array,
 		boolean: typeof _clean_boolean,
+		custom: typeof _clean_custom,
+		file: typeof _clean_file,
 		integer: typeof _clean_integer,
 		number: typeof _clean_number,
 		object: typeof _clean_object,

package/types/utils/clean.d.ts

@@ -9,8 +9,16 @@ declare namespace _default {
     export { cleanUUID as uuid };
 }
 export default _default;
-declare function cleanArray(arr: any, schema?: {}): any[];
-declare function cleanObject(obj: any, schema: any): {};
+declare function cleanArray(arr: any, schema?: {}, { testMode, allOrNothing, path }?: {
+    testMode?: boolean;
+    allOrNothing?: boolean;
+    path?: string;
+}): any[];
+declare function cleanObject(obj: any, schema: any, { testMode, allOrNothing, path }?: {
+    testMode?: boolean;
+    allOrNothing?: boolean;
+    path?: string;
+}): {};
 import cleanBoolean from '../clean/boolean.js';
 import cleanInteger from '../clean/integer.js';
 import cleanNumber from '../clean/number.js';