@awesomeness-js/utils 1.1.9 → 1.1.21

package/package.json

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

package/src/clean/buffer.js

@@ -0,0 +1,74 @@
+export default function cleanBuffer(fileObj, {
+	required = false,
+	validTypes = [],  // ['image/png', '.jpg']
+	minSize = false,  // bytes
+	maxSize = false,  // bytes
+} = {}) {
+
+	try {
+		if (
+			!fileObj ||
+			typeof fileObj !== 'object' ||
+			!(fileObj.buffer instanceof Buffer)
+		) {
+			throw {
+				message: 'Invalid buffer object (expected Busboy fileObj)',
+				value: fileObj
+			};
+		}
+
+		const { buffer, filename, mimeType, totalSize } = fileObj;
+		const size = totalSize ?? buffer.length;
+
+		// basic fields check
+		if (typeof size !== 'number' || !mimeType) {
+			throw {
+				message: 'Missing required fields (mimeType, size)',
+				value: fileObj
+			};
+		}
+
+		// type validation
+		if (Array.isArray(validTypes) && validTypes.length > 0) {
+			const isValidType = validTypes.some(t =>
+				mimeType === t || (filename && filename.endsWith(t))
+			);
+
+			if (!isValidType) {
+				throw {
+					message: `Invalid buffer type: ${mimeType}`,
+					allowed: validTypes,
+					value: filename || null
+				};
+			}
+		}
+
+		// size validation
+		if (minSize !== false && size < minSize) {
+			throw {
+				message: `Buffer smaller than minimum size (${minSize} bytes)`,
+				value: size
+			};
+		}
+
+		if (maxSize !== false && size > maxSize) {
+			throw {
+				message: `Buffer larger than maximum size (${maxSize} bytes)`,
+				value: size
+			};
+		}
+
+		// normalized safe object
+		return {
+			name: filename || null,
+			type: mimeType,
+			size,
+			encoding: fileObj.encoding || null,
+			createdAt: new Date().toISOString(),
+		};
+
+	} catch (e) {
+		if (required) throw e;
+		return null;
+	}
+}

package/src/thingType.js

@@ -29,6 +29,19 @@ export default (thing) => {
 	if (type === 'object' && thing !== null) {
 
 		type = Array.isArray(thing) ? 'array' : 'object';
+
+		if(type ===  'object'){
+
+			// is this a file / buffer
+			const isBuffer = thing instanceof Buffer || thing instanceof ArrayBuffer || thing instanceof Blob;
+
+			if(isBuffer){
+
+				type = 'buffer';
+
+			}
+
+		}
 		
 		return type;
 	

package/src/utils/clean.js

@@ -10,14 +10,15 @@ import cleanTimestamp from '../clean/timestamp.js';
 import cleanUUID from '../clean/uuid.js';
 
 const knownTypesToClean = [
+	'array',
 	'boolean',
+	'buffer',
 	'integer',
 	'number',
+	'object',
 	'string',
 	'timestamp',
 	'uuid',
-	'object',
-	'array'
 ];
 
 function cleanArray(arr, schema = {}, {

package/src/validateSchema.js

@@ -40,12 +40,14 @@ function validateSchema(schema){
 	const validTypes = [
 		'array',
 		'boolean',
+		'buffer',
+		'custom',
 		'integer',
 		'number',
 		'object',
 		'string',
 		'timestamp',
-		'uuid'
+		'uuid',
 	];
 
 	if(!schema.type || !validTypes.includes(schema.type)) {

package/src/clean/file.js

@@ -1,62 +0,0 @@
-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;
-	}
-}