@awesomeness-js/utils 1.0.18 → 1.0.20

package/src/clean/string.js

@@ -0,0 +1,58 @@
+export default function cleanString(x, {
+    required = false,
+    minLength = false,
+    maxLength = false,
+    allowHtml = false,
+    allowScripts = false
+} = {}){
+    
+    try {
+
+        if(typeof x !== 'string') {
+            throw {
+                name: 'TypeError',
+                message: 'Input must be a string',
+                value: x
+            };
+        }
+
+        if(minLength !== false && x.length < minLength) {
+            throw {
+                message: `String length must be between ${minLength} `,
+                length: x.length,
+                value: x
+            };
+        }
+
+        if(maxLength !== false && x.length > maxLength) {
+            throw {
+                message: `String length must be less than or equal to ${maxLength}`,
+                length: x.length,
+                value: x
+            };
+        }
+
+        if(!allowHtml && /<[^>]*>/g.test(x)) {
+            throw {
+                message: 'HTML tags are not allowed',
+                value: x
+            };
+        }
+
+        if(!allowScripts && /<script[^>]*>.*<\/script>/g.test(x)) {
+            throw {
+                message: 'Script tags are not allowed',
+                value: x
+            };
+        }
+
+        return x;
+
+    } catch (e) {
+
+        if(required) { throw e; } else { return null; }
+        
+    }
+
+}
+

package/src/clean/thing.js

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

package/src/clean/timestamp.js

@@ -0,0 +1,56 @@
+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
+            };
+        }
+    
+        if(maxDaysInFuture === false && maxDaysInFPast === false) {
+            return 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 isoDateTimeString;
+
+    } 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

@@ -0,0 +1,19 @@
+import { createDecipheriv } from 'crypto';
+
+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;
+  
+    const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(iv, 'hex'));
+    decipher.setAuthTag(Buffer.from(authTag, 'hex'));
+  
+    let decrypted = decipher.update(cipherText, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+  
+    return decrypted;
+
+}

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

@@ -0,0 +1,29 @@
+import { randomBytes, createCipheriv } from 'crypto';
+
+
+// Encrypt plaintext using AES-256-GCM
+export default function encrypt(plainText, key = process.env.AWESOMENESS_ENCRYPTION_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);
+
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    let encrypted = cipher.update(plainText, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+
+    // GCM provides an auth tag, which is required for decryption
+    const authTag = cipher.getAuthTag().toString('hex');
+
+    // Return all parts needed for safe decryption
+    return {
+        iv: iv.toString('hex'),
+        authTag,
+        cipherText: encrypted
+    };
+
+}
+

package/src/password/check.js

@@ -0,0 +1,9 @@
+import { pbkdf2Sync } from 'crypto';
+
+// Compare a plain-text password to a stored salt+hash
+export default function validatePassword(password, storedHash) {
+  const [salt, originalHash] = storedHash.split('::');
+  const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
+  return derivedKey.toString('hex') === originalHash;
+}
+

package/src/password/hash.js

@@ -0,0 +1,11 @@
+import { randomBytes, pbkdf2Sync } from 'crypto';
+
+// Hash a password using Node.js built-in crypto (no external deps).
+export default function hashPassword(password) {
+  // Generate a random 16-byte salt
+  const salt = randomBytes(16).toString('hex');
+  // Derive a 64-byte key using PBKDF2 with 100k iterations (adjust as needed)
+  const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
+  // Return salt and hash combined as a single string
+  return `${salt}::${derivedKey.toString('hex')}`;
+}

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,33 @@
+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; }
+
+    
+}
+

package/src/validateSchema.js

@@ -0,0 +1,78 @@
+import each from './each.js';
+
+function validateSchema(schema){
+
+    // ref todo
+    if(schema.ref){ return true; }
+
+    let schemaType = typeof schema;
+
+    if(schemaType !== 'object' || schema === null) {
+        throw {
+            message: 'Input must be an object',
+            schema
+        };
+    }
+
+    // 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/combineFiles.test.js

@@ -0,0 +1,24 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+
+let combineTest = utils.combineFiles('./src', 'js');
+
+let combineTestBrowser = utils.combineFiles('./src', 'js', { 
+    moduleToBrowser: true 
+});
+
+test('combineFiles - combine all files in src/js', () => {
+    expect(combineTest).toBeDefined();
+    expect(combineTestBrowser).toBeDefined();
+    expect(combineTest.length).toBeGreaterThan(combineTestBrowser.length);
+})
+
+
+test('has import', () => {
+    expect(combineTest.includes('import')).toBe(true);
+})
+
+test('should not have import', () => {
+    expect(combineTestBrowser.includes('import')).toBe(false);
+})

package/tests/convertBytes.test.js

@@ -0,0 +1,9 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+
+let convertBytesTest = utils.convertBytes(1024);
+test('convertBytes 1024 => 1.00 KB', () => {
+    expect(convertBytesTest).toBeDefined();
+    expect(convertBytesTest).toEqual('1.00 KB');
+});

package/tests/env.test.js

@@ -0,0 +1,17 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+
+await utils.setLocalEnvs('./secrets/local.env');
+
+const env1 = process.env.JUST_A_TEST;
+
+test('localEnv - should be testValue', () => {
+    expect(env1).toBe('Local just a test');
+});
+
+await utils.setLocalEnvs('./secrets/dev.env');
+
+test('localEnv - should be testValue', () => {
+    expect(process.env.JUST_A_TEST).toBe('Dev just a test');
+});

package/tests/example.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/tests/fileList.test.js

@@ -0,0 +1,21 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+
+
+let fileList2 = utils.getAllFiles('./test', {
+   // fileTypes: ['.css'],
+   // fileTypes: ['.js'],
+   ignore: [
+        "/ignoreFolder", 
+        "/ignoreFolder2/", 
+        "*.env",
+        "*.test.js",
+        "/css/*.js",
+        "/js/*.css"
+    ]
+});
+
+test('file list of 3', () => {
+    expect(fileList2.length).toBe(3); // Adjust this number based on your test folder contents
+});

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

@@ -0,0 +1,26 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+
+// set AWESOMENESS_ENCRYPTION_KEY
+//await utils.setLocalEnvs('./secrets/dev.env');
+
+const storedHash = utils.password.hash('mySecret123');
+
+test('correct password check', () => {
+    expect(utils.password.check('mySecret123', storedHash)).toBe(true)
+});
+
+test('incorrect password check', () => {
+    expect(utils.password.check('wrongPassword', storedHash)).toBe(false)
+});
+
+// Example 256-bit key for AES-256
+// In real usage, store this securely (e.g., an environment variable or key vault).
+
+const secretMessage = 'This is top secret!';
+const encrypted = utils.encrypt(secretMessage);
+const decrypted = utils.decrypt(encrypted);
+test('encryption and decryption', () => {
+    expect(decrypted).toBe(secretMessage)
+});

package/tests/md5.test.js

@@ -0,0 +1,7 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+let md5Test = utils.md5('test');
+test('md5 test', () => {
+    expect(md5Test).toBe('098f6bcd4621d373cade4e832627b4f6');
+});

package/tests/uuid.test.js

@@ -0,0 +1,15 @@
+// example.test.js
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+
+let uuid = utils.uuid();
+let isValid = utils.isUUID(uuid);
+
+test('uuid create', () => {
+    expect(uuid).toBeDefined();
+    expect(uuid.length).toBe(36);
+});
+
+test('uuid isValid', () => {
+    expect(isValid).toBe(true);
+});

package/tests/validateSchema.test.js

@@ -0,0 +1,30 @@
+import { expect, test } from 'vitest'
+import utils from '../index.js';
+import schemas from '../schemas.js';
+
+let schema1 = utils.validateSchema(schemas.schema1);
+let schema2 = utils.validateSchema(schemas.schema2);
+
+
+test('schema1 is valid', () => {
+    expect(schema1).toBe(true);
+});
+
+test('schema2 is valid', () => {
+    expect(schema2).toBe(true);
+});
+
+let expectedError;
+
+try {
+    utils.validateSchema({
+        notReal: true
+    });
+    expectedError = false; // should not reach here
+} catch(e){
+    expectedError = true;
+}
+
+test('invalid schema throws error', () => {
+    expect(expectedError).toBe(true);
+});

package/types/clean/array.d.ts

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

package/types/clean/boolean.d.ts

@@ -0,0 +1,3 @@
+export default function cleanBoolean(x: any, { required }?: {
+    required?: boolean;
+}): any;

package/types/clean/integer.d.ts

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

package/types/clean/number.d.ts

@@ -0,0 +1,7 @@
+export default function cleanNumber(x: any, { required, min, max, maxDecimal, minDecimal, }?: {
+    required?: boolean;
+    min?: boolean;
+    max?: boolean;
+    maxDecimal?: boolean;
+    minDecimal?: boolean;
+}): any;

package/types/clean/object.d.ts

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

package/types/clean/string.d.ts

@@ -0,0 +1,7 @@
+export default function cleanString(x: any, { required, minLength, maxLength, allowHtml, allowScripts }?: {
+    required?: boolean;
+    minLength?: boolean;
+    maxLength?: boolean;
+    allowHtml?: boolean;
+    allowScripts?: boolean;
+}): string;

package/types/clean/thing.d.ts

@@ -0,0 +1,2 @@
+declare function _default(thing: any, schema: any): any;
+export default _default;

package/types/clean/timestamp.d.ts

@@ -0,0 +1,5 @@
+export default function cleanTimestamp(isoDateTimeString: any, { required, maxDaysInFuture, maxDaysInFPast, }?: {
+    required?: boolean;
+    maxDaysInFuture?: boolean;
+    maxDaysInFPast?: boolean;
+}): string;