@awesomeness-js/utils 1.0.19 → 1.0.21

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/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/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

@@ -0,0 +1 @@
+export {};

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,6 @@
+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

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

package/types/clean/object.d.ts

@@ -0,0 +1 @@
+export {};

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;

package/types/clean/uuid.d.ts

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

package/types/each.d.ts

@@ -1 +1,10 @@
-export default function each(objectOrArray: any, callback: any): void;
+/**
+ * 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: any | any[], callback: Function): void;

package/types/hashPassword.d.ts

@@ -1 +1 @@
-export default function hashPassword(password: any): string;
+export default function hashPassword(password: any): string;