@awesomeness-js/utils 1.0.20 → 1.0.21

package/index.js

@@ -10,7 +10,6 @@ import _clean_integer from './src/clean/integer.js';
 import _clean_number from './src/clean/number.js';
 import _clean_object from './src/clean/object.js';
 import _clean_string from './src/clean/string.js';
-import _clean_thing from './src/clean/thing.js';
 import _clean_timestamp from './src/clean/timestamp.js';
 import _clean_uuid from './src/clean/uuid.js';
 import _combineFiles from './src/combineFiles.js';
@@ -31,6 +30,7 @@ import _thingType from './src/thingType.js';
 import _toPennies from './src/toPennies.js';
 import _utils_buildExportsTree from './src/utils/buildExportsTree.js';
 import _utils_buildFileDataList from './src/utils/buildFileDataList.js';
+import _utils_clean from './src/utils/clean.js';
 import _utils_extractJSDocComment from './src/utils/extractJSDocComment.js';
 import _utils_generateFile from './src/utils/generateFile.js';
 import _utils_generateFlatExportLines from './src/utils/generateFlatExportLines.js';
@@ -111,7 +111,6 @@ export default {
         number: _clean_number,
         object: _clean_object,
         string: _clean_string,
-        thing: _clean_thing,
         timestamp: _clean_timestamp,
         uuid: _clean_uuid,
     },
@@ -125,6 +124,7 @@ export default {
     utils: {
         buildExportsTree: _utils_buildExportsTree,
         buildFileDataList: _utils_buildFileDataList,
+        clean: _utils_clean,
         extractJSDocComment: _utils_extractJSDocComment,
         generateFile: _utils_generateFile,
         generateFlatExportLines: _utils_generateFlatExportLines,

package/package.json

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

package/src/clean/array.js

@@ -1,43 +1,2 @@
-import thingType from '../thingType.js'; 
-function cleanArray(arr, schema = {}){
-
-    if(!Array.isArray(arr)) {
-        throw {
-            name: 'TypeError',
-            message: 'Input must be an array',
-            arr
-        };
-    }
-
-    validateSchema(schema);
-
-    const cleanArrayItems = [];
-
-    const supposedToBeType = schema.type;
-
-    arr.forEach( item => {
-
-        const itemType = thingType(item);
-
-        if(itemType !== supposedToBeType){
-
-            throw {
-                message: 'type invalid',
-                itemType,
-                supposedToBeType
-            };
-
-        }
-
-        const cleanFnImported = import(`./${supposedToBeType}.js`);
-        const cleanItem = cleanFnImported(value, schema[key]);
-
-        cleanArrayItems.push(cleanItem);
-
-    });
-
-    return cleanArrayItems;
-    
-}
-
-export default cleanArray;
+import clean from '../utils/clean.js';
+export default clean.array;

package/src/clean/integer.js

@@ -1,5 +1,6 @@
 export default function cleanInt(x, {
     required = false,
+    convertString = true,
     min = false,
     max = false,
 } = {}){
@@ -9,8 +10,26 @@ export default function cleanInt(x, {
         if (typeof x !== 'number' || !Number.isInteger(x)) {
 
             // convert string to number if possible
-            if (typeof x === 'string' && !isNaN(parseInt(x))) {
-                x = parseInt(x);
+            // but not a decimal string
+            if (convertString && typeof x === 'string') {
+
+                if(x.includes('.')){
+                    throw {
+                        message: 'string contains decimal',
+                        value: x
+                    };
+                }
+
+                if(!isNaN(parseInt(x))){
+                    x = parseInt(x);
+                } else {
+                    throw {
+                        message: 'string cannot be parsed to integer',
+                        value: x
+                    }
+                }
+                
+
             } else {
                 throw {
                     message: 'Input must be an integer',

package/src/clean/number.js

@@ -1,5 +1,6 @@
 export default function cleanNumber(x, {
     required = false,
+    convertString = true,
     min = false,
     max = false,
     maxDecimal = false,
@@ -11,8 +12,25 @@ export default function cleanNumber(x, {
         if (typeof x !== 'number') {
 
             // convert string to number if possible
-            if (typeof x === 'string' && !isNaN(parseFloat(x))) {
-                x = parseFloat(x);
+            if (convertString && typeof x === 'string') {
+
+                try {
+                    x = parseFloat(x);
+                } catch(e){
+                    throw {
+                        message: 'Input cannot be parsed',
+                        value: x
+                    }
+                }
+                                
+
+                if(isNaN(x)){
+                    throw {
+                        message: 'Input cannot be parsed NaN',
+                        value: x
+                    }
+                }
+
             } else {
                 throw {
                     message: 'Input must be a number',

package/src/clean/object.js

@@ -1,67 +1,3 @@
-import each from '../each.js';
-import validateSchema from '../validateSchema.js';
-import thingType from '../thingType.js'; 
-
-function cleanObject(obj, schema = {}){
-
-    try {
-
-        validateSchema(schema);
-
-        if(typeof obj !== 'object' || obj === null){
-            throw {
-                message: 'Input must be an object',
-                obj
-            };
-        }
-    
-        let keysPassed = Object.keys(obj);
-        let keysSchema = Object.keys(schema.properties);
-
-        const origLength = keysPassed.length;
-        keysPassed = keysPassed.filter(key => keysSchema.includes(key));
-
-        if(origLength !== keysPassed.length){
-            throw {
-                name: 'KeyError',
-                message: 'Object contains keys not in schema',
-                keysPassed,
-                keysSchema
-            };
-        }
-    
-        const cleanObj = {};
-    
-        // Iterate over the schema keys
-        each(obj, (value, key) => {
-
-            const valType = thingType(value);
-            const supposedToBeType = schema[key].type;
-
-            if(valType !== supposedToBeType){
-
-                throw {
-                    message: 'type invalid',
-                    valType,
-                    supposedToBeType
-                };
-
-            }
-
-            const cleanFnImported = import(`./${supposedToBeType}.js`);
-            cleanObj[key] = cleanFnImported(value, schema[key]);
-    
-        });
-
-        return cleanObj;
-
-    } catch(e){
-
-        if(required) { throw e; } else { return null; }
-
-    }
-
-}
-
-export default cleanObject;
+import clean from '../utils/clean.js';
+export default clean.object;
 

package/src/clean/string.js

@@ -5,6 +5,8 @@ export default function cleanString(x, {
     allowHtml = false,
     allowScripts = false
 } = {}){
+
+    if(allowScripts && !allowHtml){ allowHtml = true; }
     
     try {
 

package/src/clean/timestamp.js

@@ -22,10 +22,6 @@ export default function cleanTimestamp( isoDateTimeString , {
             };
         }
     
-        if(maxDaysInFuture === false && maxDaysInFPast === false) {
-            return isoDateTimeString;
-        }
-    
         const now = new Date();
         
         if(maxDaysInFuture !== false && (date - now) > maxDaysInFuture * 24 * 60 * 60 * 1000) {
@@ -42,7 +38,7 @@ export default function cleanTimestamp( isoDateTimeString , {
             };
         }
     
-        return isoDateTimeString;
+        return date.toISOString();
 
     } catch (e) {
 

package/src/thingType.js

@@ -28,6 +28,8 @@ export default (thing) => {
     let is_iso_dateTime = thing && typeof thing === 'string' && thing.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$/);
     if(is_iso_dateTime) { type = 'timestamp'; return type; }
 
+    return type;
+
     
 }
 

package/src/utils/clean.js

@@ -0,0 +1,183 @@
+import thingType from '../thingType.js'; 
+import validateSchema from '../validateSchema.js';
+import each from '../each.js';
+
+import cleanBoolean from '../clean/boolean.js';
+import cleanInteger from '../clean/integer.js';
+import cleanNumber from '../clean/number.js';
+import cleanString from '../clean/string.js';
+import cleanTimestamp from '../clean/timestamp.js';
+import cleanUUID from '../clean/uuid.js';
+
+function cleanArray(arr, schema = {}){
+
+    try {
+
+        if(!Array.isArray(arr)) {
+            throw {
+                message: 'Input must be an array',
+                arr
+            };
+        }
+    
+        validateSchema(schema);
+    
+        const cleanArrayItems = [];
+    
+        const supposedToBeType = schema.items.type;
+    
+        arr.forEach( (item, key) => {
+    
+            const itemType = thingType(item);
+    
+    
+            if(itemType !== supposedToBeType){
+    
+                throw {
+                    message: 'type invalid',
+                    itemType,
+                    supposedToBeType
+                };
+    
+            }
+    
+            let cleanedItem = item;
+    
+            if(supposedToBeType === 'boolean'){ cleanedItem = cleanBoolean(item); }
+            if(supposedToBeType === 'integer'){ cleanedItem = cleanInteger(item); }
+            if(supposedToBeType === 'number'){ cleanedItem = cleanNumber(item); }
+            if(supposedToBeType === 'string'){ cleanedItem = cleanString(item); }
+            if(supposedToBeType === 'timestamp'){ cleanedItem = cleanTimestamp(item); }
+            if(supposedToBeType === 'uuid'){ cleanedItem = cleanUUID(item); }
+            
+            if(supposedToBeType === 'array'){ 
+                cleanedItem = cleanArray(item, schema.items); 
+            }
+
+            if(supposedToBeType === 'object'){ 
+                cleanedItem = cleanObject(item, schema.items); 
+            }
+
+            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
+                }
+            }
+
+    
+            cleanArrayItems.push(cleanedItem);
+    
+        });
+    
+        if(cleanArrayItems.length === 0){
+            throw {
+                message: 'array is empty',
+                arr
+            };
+        }
+
+        return cleanArrayItems;
+
+    } catch (e) {
+
+        if(schema.required === true){
+            throw e
+        } else {
+            return null;
+        }
+
+    }
+
+
+    
+}
+
+
+function cleanObject(obj, schema){
+
+    validateSchema(schema);
+
+    if(typeof obj !== 'object' || obj === null){
+        throw {
+            message: 'Clean Object - Input must be an object',
+            obj,
+            schema
+        };
+    }
+
+    let keysPassed = Object.keys(obj);
+    let keysSchema = Object.keys(schema.properties);
+
+    const origLength = keysPassed.length;
+    keysPassed = keysPassed.filter(key => keysSchema.includes(key));
+
+    if(origLength !== keysPassed.length){
+        throw {
+            name: 'KeyError',
+            message: 'Object contains keys not in schema',
+            keysPassed,
+            keysSchema,
+            obj
+        };
+    }
+
+    const cleanObj = {};
+
+    // Iterate over the schema keys
+    each(obj, (value, key) => {
+
+        const valType = thingType(value);
+        const supposedToBeType = schema.properties[key].type;
+
+        if(valType !== supposedToBeType){
+
+            throw {
+                message: 'type invalid',
+                valType,
+                supposedToBeType,
+                key
+            };
+
+        }
+
+        let cleanedValue;
+
+        if(supposedToBeType === 'boolean'){ cleanedValue = cleanBoolean(value); }
+        if(supposedToBeType === 'integer'){ cleanedValue = cleanInteger(value); }
+        if(supposedToBeType === 'number'){ cleanedValue = cleanNumber(value); }
+        if(supposedToBeType === 'string'){ cleanedValue = cleanString(value); }
+        if(supposedToBeType === 'timestamp'){ cleanedValue = cleanTimestamp(value); }
+        if(supposedToBeType === 'uuid'){ cleanedValue = cleanUUID(value); }
+
+        if(supposedToBeType === 'object'){ 
+            cleanedValue = cleanObject(value, schema.properties[key]); 
+        }
+
+        if(supposedToBeType === 'array'){ 
+            cleanedValue = cleanArray(value, schema.properties[key]); 
+        }
+
+        cleanObj[key] = cleanedValue;
+
+    });
+
+    return cleanObj;
+
+}
+
+export default {
+    array: cleanArray,
+    object: cleanObject,
+    boolean: cleanBoolean,
+    integer: cleanInteger,
+    number: cleanNumber,
+    string: cleanString,
+    timestamp: cleanTimestamp,
+    uuid: cleanUUID
+};

package/src/validateSchema.js

@@ -2,6 +2,13 @@ import each from './each.js';
 
 function validateSchema(schema){
 
+    if(!schema){
+        throw {
+            message: 'Schema is required.',
+            schema
+        };
+    }
+
     // ref todo
     if(schema.ref){ return true; }
 
@@ -9,8 +16,9 @@ function validateSchema(schema){
 
     if(schemaType !== 'object' || schema === null) {
         throw {
-            message: 'Input must be an object',
-            schema
+            message: 'Schema Invalid - Input must be an object',
+            schema,
+            schemaType
         };
     }
 

package/tests/clean/array.test.js

@@ -0,0 +1,154 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+const testStringArray = [ 'a', 'b', 'c' ];
+const testIntegerArray = [ 1, 2, 3, 4, 5 ];
+const testBooleanArray = [true, false, true, false];
+
+const testArrayOfArraysOfIntegers = [
+    testIntegerArray,
+    testIntegerArray,
+    testIntegerArray
+];
+
+const testArrayOfArraysOfStrings = [
+    testStringArray,
+    testStringArray,
+    testStringArray
+];
+
+const schemaForStrings = {
+    type: 'array',
+    items: {
+        type: 'string'
+    }
+};
+
+const schemaForIntegers = {
+    type: 'array',
+    items: {
+        type: 'integer'
+    }
+};
+
+
+const schemaForBooleans = {
+    type: 'array',
+    items: {
+        type: 'boolean'
+    }
+};
+
+const schemaForArrayOfArrays_integers = {
+    type: 'array',
+    items: {
+        type: 'array',
+        items: { type: 'integer' }
+    }
+};
+
+const schemaForArrayOfArrays_strings = {
+    type: 'array',
+    items: {
+        type: 'array',
+        items: { type: 'string' }
+    }
+};
+
+const testObject = {
+    stringProp: 'a string',
+    integerProp: 42,
+    numberProp: 3.14,
+    booleanProp: true,
+    timestampProp: new Date().toISOString(),
+    uuidProp: utils.uuid(), // generate a valid UUID
+};
+
+const arrayOfObjects = [
+    { ...testObject },
+    { ...testObject },
+    { ...testObject }
+];
+
+const objSchema = {
+    type: 'object',
+    properties: {
+        stringProp: { type: 'string', required: true },
+        integerProp: { type: 'integer', required: true },
+        numberProp: { type: 'number', required: true },
+        booleanProp: { type: 'boolean', required: true },
+        timestampProp: { type: 'timestamp', required: true },
+        uuidProp: { type: 'uuid', required: true },
+        optionalStringProp: { type: 'string', required: false },
+        optionalIntegerProp: { type: 'integer', required: false },
+        optionalNumberProp: { type: 'number', required: false },
+        optionalBooleanProp: { type: 'boolean', required: false },
+        optionalTimestampProp: { type: 'timestamp', required: false },
+        optionalUuidProp: { type: 'uuid', required: false }
+    },
+};
+
+
+const schemaForArrayOfObjects = {
+    type: 'array',
+    required: true,
+    items: {
+        ... objSchema,
+    }
+};
+
+test('testStringArray', () => {
+
+    const x = utils.clean.array(testStringArray, schemaForStrings);
+    expect(x).toStrictEqual(testStringArray);
+
+});
+
+test('testIntegerArray', () => {
+
+    const x = utils.clean.array(testIntegerArray, schemaForIntegers);
+    expect(x).toStrictEqual(testIntegerArray);
+
+});
+
+test('testBooleanArray', () => {
+
+    const x = utils.clean.array(testBooleanArray, schemaForBooleans);
+    expect(x).toStrictEqual(testBooleanArray);
+
+});
+
+test('testBooleanArray but pass different schema', () => {
+
+    expect(()=> utils.clean.array(testBooleanArray, { ... schemaForIntegers, required: true }) ).toThrow();
+
+});
+
+test('schemaForArrayOfArrays_integers', () => {
+
+    const x = utils.clean.array(testArrayOfArraysOfIntegers, schemaForArrayOfArrays_integers);
+    expect(x).toStrictEqual(testArrayOfArraysOfIntegers);
+
+});
+
+test('schemaForArrayOfArrays_strings', () => {
+
+    const x = utils.clean.array(testArrayOfArraysOfStrings, schemaForArrayOfArrays_strings);
+    expect(x).toStrictEqual(testArrayOfArraysOfStrings);
+
+});
+
+test('schemaForArrayOfArrays_strings wrong type', () => {
+
+    const x = utils.clean.array(testArrayOfArraysOfStrings, schemaForArrayOfArrays_integers);
+    expect(x).toBe(null);
+
+});
+
+test('schemaForArrayOfObjects', () => {
+
+    const x = utils.clean.array(arrayOfObjects, schemaForArrayOfObjects);
+    expect(x).toStrictEqual(arrayOfObjects);   
+
+});

package/tests/clean/boolean.test.js

@@ -0,0 +1,27 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+let x = true;
+let y = false;
+let z = 1;
+
+test('boolean - true', () => {
+    expect(utils.clean.boolean(x)).toBe(true);
+});
+
+test('boolean - false', () => {
+    expect(utils.clean.boolean(y)).toBe(false);
+});
+
+test('boolean - number', () => {
+    expect(utils.clean.boolean(z)).toBe(null);
+});
+
+test('boolean - NOT to throw', () => {
+    expect(() => utils.clean.boolean(y, { required: true })).not.toThrow();
+});
+
+test('boolean - to throw', () => {
+    expect(() => utils.clean.boolean(z, { required: true })).toThrow();
+});

package/tests/clean/integer.test.js

@@ -0,0 +1,39 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+let x = 1;
+let y = 1.2;
+let z = '102';
+let z2 = '102.45';
+let z3 = 102.45;
+
+test('integer - 1', () => {
+    expect(utils.clean.integer(x)).toBe(1);
+});
+
+test('integer - null', () => {
+    expect(utils.clean.integer(y)).toBe(null);
+});
+
+
+test('integer as string - 102', () => {
+    expect(utils.clean.integer(z)).toBe(102);
+});
+
+test('integer - NOT to throw - 102', () => {
+    expect(() => utils.clean.integer(z, { required: true })).not.toThrow();
+});
+
+test('integer - to throw', () => {
+    expect(() => utils.clean.integer(y, { required: true })).toThrow();
+});
+
+test('integer - to throw - "102.45"', () => {
+    expect(() => utils.clean.integer(z2, { required: true })).toThrow();
+});
+
+test('integer - to throw - 102.45', () => {
+    console.log(utils.clean.integer(z3));
+    expect(() => utils.clean.integer(z3, { required: true })).toThrow();
+});

package/tests/clean/number.test.js

@@ -0,0 +1,49 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+let x = 1;
+let y = 1.2;
+let z = '102';
+let z2 = '102.45';
+let bad = 'bad';
+
+test('number - 1', () => {
+    expect(utils.clean.number(x)).toBe(1);
+});
+
+test('number - 1.2', () => {
+    expect(utils.clean.number(y)).toBe(1.2);
+});
+
+test('number as string - 102', () => {
+    expect(utils.clean.number(z)).toBe(102);
+});
+
+test('number - string to 102', () => {
+    expect(utils.clean.number(z, { required: true })).toBe(102);
+});
+
+test('number - string to 102.45', () => {
+    console.log(utils.clean.number(z2));
+    expect(utils.clean.number(z2, { required: true })).toBe(102.45);
+});
+
+test('number as string - bad to null', () => {
+    expect(utils.clean.number(bad)).toBe(null);
+});
+
+test('number as string - bad to throw', () => {
+    expect(()=> utils.clean.number(bad, { required: true }) ).toThrow();
+});
+
+test('number is too high', () => {
+    expect(()=> utils.clean.number(100, { min: 1, max: 10, required: true }) ).toThrow();
+    expect(()=> utils.clean.number(100.11, { min: 1, max: 100.1, required: true }) ).toThrow();
+});
+
+test('number is too low', () => {
+    expect(()=> utils.clean.number(0, { min: 1, max: 10, required: true }) ).toThrow();
+    expect(()=> utils.clean.number(1.2, { min: 1.3, max: 10, required: true }) ).toThrow();
+});
+

package/tests/clean/object.test.js

@@ -0,0 +1,172 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+const testObject = {
+    stringProp: 'a string',
+    integerProp: 42,
+    numberProp: 3.14,
+    booleanProp: true,
+    timestampProp: new Date().toISOString(),
+    uuidProp: utils.uuid(), // generate a valid UUID
+};
+
+const invalidTestObject = {
+    stringProp: 123, // should be a string
+    integerProp: 'not an integer', // should be an integer
+    numberProp: 'not a number', // should be a number
+    booleanProp: 'not a boolean', // should be a boolean
+    timestampProp: 'not a timestamp', // should be a timestamp
+    uuidProp: 'not a uuid', // should be a uuid
+    optionalStringProp: 456, // should be a string
+    optionalIntegerProp: 'not an integer', // should be an integer
+    optionalNumberProp: 'not a number', // should be a number
+    optionalBooleanProp: 'not a boolean', // should be a boolean
+    optionalTimestampProp: 'not a timestamp', // should be a timestamp
+    optionalUuidProp: 'not a uuid' // should be a uuid
+};
+
+const testObject2 = {
+    obj1: { ...testObject },
+    obj2: { ...testObject }
+};
+
+const invalidTestObject2 = {
+    obj1: { ...invalidTestObject },
+    obj2: { ...invalidTestObject }
+};
+
+const schema = {
+    type: 'object',
+    properties: {
+        stringProp: { type: 'string', required: true },
+        integerProp: { type: 'integer', required: true },
+        numberProp: { type: 'number', required: true },
+        booleanProp: { type: 'boolean', required: true },
+        timestampProp: { type: 'timestamp', required: true },
+        uuidProp: { type: 'uuid', required: true },
+        optionalStringProp: { type: 'string', required: false },
+        optionalIntegerProp: { type: 'integer', required: false },
+        optionalNumberProp: { type: 'number', required: false },
+        optionalBooleanProp: { type: 'boolean', required: false },
+        optionalTimestampProp: { type: 'timestamp', required: false },
+        optionalUuidProp: { type: 'uuid', required: false }
+    },
+};
+
+const schema2 = {
+    type: 'object',
+    properties: {
+        obj1: {
+            type: 'object',
+            required: true,
+            properties: { ... schema.properties }
+        },
+        obj2: {
+            type: 'object',
+            required: true,
+            properties: { ... schema.properties }
+        }
+    },
+};
+
+
+const testArraysOfIntegers = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9]
+];
+
+const testStringArrayOfArrays = [
+    ['a', 'b', 'c'],
+    ['d', 'e', 'f'],
+    ['g', 'h', 'i'],
+];
+
+const testArrayOfBooleans = [
+    [true, false, true],
+    [false, true, false],
+    [true, true, false]
+];
+
+const objectOfArrays = {
+    testArraysOfIntegers: [...testArraysOfIntegers],
+    testStringArrayOfArrays: [...testStringArrayOfArrays],
+    testArrayOfBooleans: [...testArrayOfBooleans],
+};
+
+const objectOfArrays_schema = {
+    type: 'object',
+    properties: {
+        testArraysOfIntegers: {
+            type: 'array',
+            items: {
+                type: 'array',
+                items: { type: 'integer' }
+            }
+        },
+        testStringArrayOfArrays: {
+            type: 'array',
+            items: {
+                type: 'array',
+                items: { type: 'string' }
+            }
+        },
+        testArrayOfBooleans: {
+            type: 'array',
+            items: {
+                type: 'array',
+                items: { type: 'boolean' }
+            }
+        }
+    }
+};
+
+test('testObject', () => {
+    try {
+        const cleanedObject = utils.clean.object(testObject, schema);
+        expect(cleanedObject).toStrictEqual(testObject);
+    } catch (error) {
+        console.error('Error cleaning object:', error);
+        throw error; // rethrow to fail the test
+    }
+});
+
+test('invalidTestObject', () => {
+    try {
+        const cleanedObject = utils.clean.object(invalidTestObject, schema);
+        //console.log({ cleanedObject })
+        expect(cleanedObject).toStrictEqual(invalidTestObject);
+    } catch (error) {
+        //console.error('Error cleaning object:', error);
+        expect(error.message).toBe('type invalid');
+    }
+});
+
+test('testObject2', () => {
+    try {
+        const cleanedObject = utils.clean.object(testObject2, schema2);
+        //console.log('cleanedObject', cleanedObject);
+        expect(cleanedObject).toStrictEqual(testObject2);
+    } catch (error) {
+        console.error('Error cleaning object:', error);
+        throw error; // rethrow to fail the test
+    }
+});
+
+
+test('incorrect should throw', () => {
+    expect(()=> utils.clean.object(testObject, schema2)).toThrow();
+});
+
+
+test('object of arrays test', () => {
+    try {
+        const cleanedObject = utils.clean.object(objectOfArrays, objectOfArrays_schema);
+        //console.log('cleanedObject', cleanedObject);
+        expect(cleanedObject).toStrictEqual(objectOfArrays);
+    } catch (error) {
+        console.error('Error cleaning object:', error);
+        throw error; // rethrow to fail the test
+    }
+});

package/tests/clean/string.test.js

@@ -0,0 +1,44 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+test('good string', () => {
+    expect(utils.clean.string('good string')).toBe('good string');
+});
+
+test('number', () => {
+    expect(utils.clean.string(123)).toBe(null);
+    expect(()=> utils.clean.string(123, { required: true })).toThrow();
+});
+
+test('string too short', () => {
+    expect(utils.clean.string('123456789', { minLength: 10 })).toBe(null);
+    expect(()=> utils.clean.string('123456789', { minLength: 10, required: true })).toThrow();
+});
+
+test('string too long', () => {
+    expect(utils.clean.string('123456789', { maxLength: 5 })).toBe(null);
+    expect(()=> utils.clean.string('123456789', { maxLength: 5, required: true })).toThrow();
+});
+
+test('no html', () => {
+    expect(utils.clean.string('<div>no go</div>')).toBe(null);
+    expect(()=> utils.clean.string('<div>no go</div>', { required: true })).toThrow();
+});
+
+test('no script', () => {
+    expect(utils.clean.string('<script>no go</script>')).toBe(null);
+    expect(()=> utils.clean.string('<script>no go</script>', { required: true })).toThrow();
+});
+
+test('allow html', () => {
+    let x = utils.clean.string('<div>all good/div>', { allowHtml: true });
+    expect(utils.clean.string('<div>all good</div>', { allowHtml: true })).toBe('<div>all good</div>');
+    expect(utils.clean.string('<div>all good</div>', { allowHtml: true, required: true })).toBe('<div>all good</div>');
+});
+
+test('allow script', () => {
+    expect(utils.clean.string('<script>all good</script>', { allowScripts: true })).toBe('<script>all good</script>');
+    expect(utils.clean.string('<script>all good</script>', { allowScripts: true, required: true })).toBe('<script>all good</script>');
+});
+

package/tests/clean/timestamp.test.js

@@ -0,0 +1,13 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+test('good timestamp', () => {
+    const x = utils.clean.timestamp('2024-12-30');
+    expect(x).toBe('2024-12-30T00:00:00.000Z');
+});
+
+test('bad timestamp', () => {
+    expect(utils.clean.timestamp('2024-12-32')).toBe(null);
+    expect(()=>utils.clean.timestamp('2024-12-32', { required: true })).toThrow();
+});

package/tests/clean/uuid.test.js

@@ -0,0 +1,14 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../../index.js';
+
+test('good uuid', () => {
+    const id = utils.uuid();
+    const x = utils.clean.uuid(id);
+    expect(x).toBe(id);
+});
+
+test('bad uuid', () => {
+    expect(utils.clean.uuid('2024-12-32')).toBe(null);
+    expect(()=>utils.clean.uuid('2024-12-32', { required: true })).toThrow();
+});

package/tests/hash-and-encrypt.test.js

@@ -3,7 +3,7 @@ import { expect, test } from 'vitest'
 import utils from '../index.js';
 
 // set AWESOMENESS_ENCRYPTION_KEY
-//await utils.setLocalEnvs('./secrets/dev.env');
+await utils.setLocalEnvs('./secrets/dev.env');
 
 const storedHash = utils.password.hash('mySecret123');
 

package/tsconfig.json

@@ -6,7 +6,8 @@
     "outDir": "types",          // Output directory for type files
     "moduleResolution": "node",
     "skipLibCheck": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "types": ["vitest/globals"]
   },
   "include": ["src/**/*"],
   "exclude": [

package/types/clean/array.d.ts

@@ -1,2 +1 @@
-export default cleanArray;
-declare function cleanArray(arr: any, schema?: {}): any[];
+export {};

package/types/clean/integer.d.ts

@@ -1,5 +1,6 @@
-export default function cleanInt(x: any, { required, min, max, }?: {
+export default function cleanInt(x: any, { required, convertString, min, max, }?: {
     required?: boolean;
+    convertString?: boolean;
     min?: boolean;
     max?: boolean;
 }): any;

package/types/clean/number.d.ts

@@ -1,5 +1,6 @@
-export default function cleanNumber(x: any, { required, min, max, maxDecimal, minDecimal, }?: {
+export default function cleanNumber(x: any, { required, convertString, min, max, maxDecimal, minDecimal, }?: {
     required?: boolean;
+    convertString?: boolean;
     min?: boolean;
     max?: boolean;
     maxDecimal?: boolean;

package/types/clean/object.d.ts

@@ -1,2 +1 @@
-export default cleanObject;
-declare function cleanObject(obj: any, schema?: {}): {};
+export {};

package/types/index.d.ts

@@ -10,7 +10,6 @@ import type _clean_integer from './clean/integer';
 import type _clean_number from './clean/number';
 import type _clean_object from './clean/object';
 import type _clean_string from './clean/string';
-import type _clean_thing from './clean/thing';
 import type _clean_timestamp from './clean/timestamp';
 import type _clean_uuid from './clean/uuid';
 import type _combineFiles from './combineFiles';
@@ -31,6 +30,7 @@ import type _thingType from './thingType';
 import type _toPennies from './toPennies';
 import type _utils_buildExportsTree from './utils/buildExportsTree';
 import type _utils_buildFileDataList from './utils/buildFileDataList';
+import type _utils_clean from './utils/clean';
 import type _utils_extractJSDocComment from './utils/extractJSDocComment';
 import type _utils_generateFile from './utils/generateFile';
 import type _utils_generateFlatExportLines from './utils/generateFlatExportLines';
@@ -111,7 +111,6 @@ declare const _default: {
         number: typeof _clean_number,
         object: typeof _clean_object,
         string: typeof _clean_string,
-        thing: typeof _clean_thing,
         timestamp: typeof _clean_timestamp,
         uuid: typeof _clean_uuid,
     },
@@ -125,6 +124,7 @@ declare const _default: {
     utils: {
         buildExportsTree: typeof _utils_buildExportsTree,
         buildFileDataList: typeof _utils_buildFileDataList,
+        clean: typeof _utils_clean,
         extractJSDocComment: typeof _utils_extractJSDocComment,
         generateFile: typeof _utils_generateFile,
         generateFlatExportLines: typeof _utils_generateFlatExportLines,

package/types/utils/clean.d.ts

@@ -0,0 +1,2 @@
+export default cleanArray;
+declare function cleanArray(arr: any, schema?: {}): any[];

package/vitest.config.js

@@ -1,6 +1,16 @@
 export default {
   test: {
     globals: true,
-    environment: 'node', // Use 'jsdom' for browser-like testing
+    environment: 'node',
+    watchExclude: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/coverage/**',
+      '**/.git/**',
+      '**/!(**/*.test.js)'  // Ignore everything except test files
+    ],
+    testMatch: [
+      '**/*.test.js'
+    ]
   },
-}
+}

package/src/clean/thing.js

@@ -1,31 +0,0 @@
-import thingType from '../thingType.js';
-
-export default (thing, schema) => {
-
-    const type = thingType(thing);
-    
-    let validTypes = [
-        'array',
-        'boolean',
-        'integer',
-        'number',
-        'object',
-        'string',
-        'timestamp',
-        'uuid'
-    ];
-
-    if(!validTypes.includes(type)){
-        throw {
-            message: `Invalid type "${type}" for thing`,
-            thing
-        }
-    }
-
-    const cleanFnImported = import(`./${type}.js`);
-    const cleanedThing = cleanFnImported(thing, schema);
-
-    return cleanedThing;
-
-}
-