@awesomeness-js/utils 1.0.19 → 1.0.21

package/src/clean/timestamp.js

@@ -0,0 +1,52 @@
+export default function cleanTimestamp( isoDateTimeString , {
+    required = false,
+    maxDaysInFuture = false,
+    maxDaysInFPast = false,
+} = {}){
+    
+    try {
+
+        if(typeof isoDateTimeString !== 'string') {
+            throw {
+                message: 'Input must be a string',
+                isoDateTimeString
+            };
+        }
+    
+        const date = new Date(isoDateTimeString);
+    
+        if(isNaN(date.getTime())) {
+            throw {
+                message: 'Invalid date string',
+                isoDateTimeString
+            };
+        }
+    
+        const now = new Date();
+        
+        if(maxDaysInFuture !== false && (date - now) > maxDaysInFuture * 24 * 60 * 60 * 1000) {
+            throw {
+                message: `Date is more than ${maxDaysInFuture} days in the future`,
+                isoDateTimeString
+            };
+        }
+    
+        if(maxDaysInFPast !== false && (now - date) > maxDaysInFPast * 24 * 60 * 60 * 1000) {
+            throw {
+                message: `Date is more than ${maxDaysInFPast} days in the past`,
+                value: isoDateTimeString
+            };
+        }
+    
+        return date.toISOString();
+
+    } catch (e) {
+
+        if(required) { throw e; } else { return null; }
+        
+    }
+
+  
+
+}
+

package/src/clean/uuid.js

@@ -0,0 +1,33 @@
+import isUUID from "../isUUID.js";
+export default function cleanUUID(uuid,{
+    required = false,
+} = {}){
+    
+    try {
+            
+        if(typeof uuid !== 'string'){
+            throw {
+                message: 'Input must be a string',
+                uuid
+            };
+        }
+
+        if(!isUUID(uuid)){
+            throw {
+                message: 'Invalid UUID format',
+                uuid
+            };
+        }
+
+        return uuid;
+
+    } catch (e) {
+
+        if(required) { throw e; } else { return null; }
+
+    }
+
+
+
+}
+

package/src/combineFiles.js

@@ -20,7 +20,10 @@ function combineFiles(dir, fileType, {
 			
 			if(isDir){
 
-				returnString += combineFiles(`${dir}/${stuff}`, fileType);  
+				returnString += combineFiles(`${dir}/${stuff}`, fileType, {
+					minify,
+					moduleToBrowser,
+				});  
 
 			} else {
 
@@ -30,6 +33,7 @@ function combineFiles(dir, fileType, {
 				let file = stuff.split('.');
 				let ext = file[file.length - 1];
 
+
 				if(ext === fileType){
 					
 					let thisData = readFileSync(`${dir}/${stuff}`, 'utf8');
@@ -39,6 +43,11 @@ function combineFiles(dir, fileType, {
 						// can this file be converted to browser?
 						let browserFriendly = thisData.startsWith('export default ');
 
+						if(browserFriendly){
+							browserFriendly = thisData.includes('import') === false; // no imports allowed
+						}
+
+
 						if(browserFriendly){
 
 							// strip properly formatted file

package/src/decrypt.js

@@ -1,8 +1,10 @@
 import { createDecipheriv } from 'crypto';
 
-export default function decrypt(encryptedData, key = process.env.AWESOMENESS_ENCRYPTION_KEY ?? 'YOU SHOULD HAVE REPLACED THIS... Slacker...') {
-    
-    console.log({ key });
+export default function decrypt(encryptedData, key = process.env.AWESOMENESS_ENCRYPTION_KEY) {
+
+    if(!key){
+        throw new Error('Encryption key is not set. Please set the AWESOMENESS_ENCRYPTION_KEY environment variable.');
+    }
 
     const { iv, authTag, cipherText } = encryptedData;
   

package/src/each.js

@@ -1,3 +1,13 @@
+
+/**
+ * Iterates over elements of an array or properties of an object, invoking a callback for each element/property.
+ * The iteration stops if the callback returns `false`.
+ *
+ * @example each({ a: 1, b: 2 }, (value, key) => { console.log(value, key); });
+ * @param {Object|Array} objectOrArray - The object or array to iterate over.
+ * @param {Function} callback - The function to invoke per iteration. It is invoked with two arguments: (value, key/index).
+ * @returns {void}
+ */
 export default function each(objectOrArray, callback) {
 
 	if(Array.isArray(objectOrArray)){

package/src/encrypt.js

@@ -1,9 +1,12 @@
 import { randomBytes, createCipheriv } from 'crypto';
 
+
 // Encrypt plaintext using AES-256-GCM
-export default function encrypt(plainText, key = process.env.AWESOMENESS_ENCRYPTION_KEY ?? 'YOU SHOULD HAVE REPLACED THIS... Slacker...') {
+export default function encrypt(plainText, key = process.env.AWESOMENESS_ENCRYPTION_KEY) {
 
-    console.log({ key });
+    if(!key){
+        throw new Error('Encryption key is not set. Please set the AWESOMENESS_ENCRYPTION_KEY environment variable.');
+    }
 
     // GCM typically uses a 12- or 16-byte IV/nonce
     const iv = randomBytes(12);

package/src/setLocalEnvs.js

@@ -12,7 +12,14 @@ export default async (localSecretsPath = './secrets/local.env') => {
 		if(line[0] === '#'){ continue; }
 
 		let parts = line.split('=');
+
 		if(parts.length === 2){
+
+			// remove \r
+			if(parts[1][parts[1].length - 1] === '\r'){
+				parts[1] = parts[1].substring(0, parts[1].length - 1);
+			}
+			
 			// remove outside single quotes
 			if(
 				parts[1][0] === "'"
@@ -21,13 +28,11 @@ export default async (localSecretsPath = './secrets/local.env') => {
 				parts[1] = parts[1].substring(1, parts[1].length - 1);
 			}
 
-			// remove \r
-			if(parts[1][parts[1].length - 1] === '\r'){
-				parts[1] = parts[1].substring(0, parts[1].length - 1);
-			}
+
 			
 			process.env[parts[0]] = parts[1];
 		}
 	}
 
+
 }

package/src/thingType.js

@@ -0,0 +1,35 @@
+import isUUID from './isUUID.js'
+export default (thing) => {
+
+    if (thing === undefined) { return 'undefined'; }
+    if (thing === null) { return 'null'; }
+
+    let type = typeof thing;
+
+    let same = ['undefined', 'null', 'boolean', 'function', 'symbol', 'bigint'].includes(type);
+    if (same) { return type; }
+
+    // array vs object
+    if (type === 'object' && thing !== null) {
+        type = Array.isArray(thing) ? 'array' : 'object';
+        return type;
+    }
+
+    // integer vs double
+    if (type === 'number') {
+        type = Number.isInteger(thing) ? 'integer' : 'number';
+        return type;
+    }
+
+    // string vs iso timestamp vs uuid
+    let is_uuid = isUUID(thing);
+    if(is_uuid){ type = 'uuid'; return type; }
+
+    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

@@ -0,0 +1,86 @@
+import each from './each.js';
+
+function validateSchema(schema){
+
+    if(!schema){
+        throw {
+            message: 'Schema is required.',
+            schema
+        };
+    }
+
+    // ref todo
+    if(schema.ref){ return true; }
+
+    let schemaType = typeof schema;
+
+    if(schemaType !== 'object' || schema === null) {
+        throw {
+            message: 'Schema Invalid - Input must be an object',
+            schema,
+            schemaType
+        };
+    }
+
+    // object properties dont have type
+    if(!schema.type && schema.properties){ schema.type = 'object'; }
+
+    const validTypes = [
+        'array',
+        'boolean',
+        'integer',
+        'number',
+        'object',
+        'string',
+        'timestamp',
+        'uuid'
+    ];
+
+    if(!schema.type || !validTypes.includes(schema.type)) {
+        throw {
+            message: `Schema must have a valid type.`,
+            validTypes,
+            schema
+        };
+    }
+
+
+    if(schema.type === 'object') {
+
+        if(schema.properties){
+            
+            // run through each property
+            each(schema.properties, (v,k) => {
+                validateSchema(v);
+            });
+            
+        } else {
+
+            throw {
+                message: 'Object invalid - needs "properties"',
+                schema
+            }
+
+        }
+
+    }
+
+    if(schema.type === 'array') {
+
+        if(!schema.items){
+            throw {
+                message: 'Array schema must have items defined.',
+                schema
+            };
+        }
+
+        validateSchema(schema.items);
+
+    }
+
+    return true;
+
+}
+
+export default validateSchema;
+

package/test/js/abc.test.js

@@ -0,0 +1,6 @@
+// example.test.js
+import { expect, test } from 'vitest'
+
+test('adds 2 + 3 to equal 5', () => {
+  expect(2 + 3).toBe(5)
+})

package/test/secret.test.js

@@ -1 +1,7 @@
-// just a test file to ignore
+// just a test file to ignore
+// example.test.js
+import { expect, test } from 'vitest'
+
+test('adds 2 + 3 to equal 5', () => {
+  expect(2 + 3).toBe(5)
+})

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();
+});