@awesomeness-js/utils 1.0.18 → 1.0.20

package/build/build.js

@@ -1,4 +1,5 @@
 import build from '../src/build.js';
+
 build({
     src: './src',
     dest: './index.js',
@@ -8,4 +9,10 @@ build({
         'ignoreFolder/*',
         //'namespaceExample/*',
     ],
+});
+
+build({
+    src: './schemas',
+    dest: './schemas.js',
+    dts: false
 });

package/index.js

@@ -4,16 +4,30 @@
  * Do not edit manually.
  */
 import _build from './src/build.js';
+import _clean_array from './src/clean/array.js';
+import _clean_boolean from './src/clean/boolean.js';
+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';
 import _convertBytes from './src/convertBytes.js';
+import _decrypt from './src/decrypt.js';
 import _each from './src/each.js';
 import _eachAsync from './src/eachAsync.js';
+import _encrypt from './src/encrypt.js';
 import _getAllFiles from './src/getAllFiles.js';
 import _ignoreFolder_ignoreMe from './src/ignoreFolder/ignoreMe.js';
 import _ignoreMe from './src/ignoreMe.js';
 import _isUUID from './src/isUUID.js';
 import _md5 from './src/md5.js';
+import _password_check from './src/password/check.js';
+import _password_hash from './src/password/hash.js';
 import _setLocalEnvs from './src/setLocalEnvs.js';
+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';
@@ -26,19 +40,24 @@ import _utils_generateNamespaceCode from './src/utils/generateNamespaceCode.js';
 import _utils_generateNamespaceExportLines from './src/utils/generateNamespaceExportLines.js';
 import _utils_shouldIgnore from './src/utils/shouldIgnore.js';
 import _uuid from './src/uuid.js';
+import _validateSchema from './src/validateSchema.js';
 
 export { _build as build };
 export { _combineFiles as combineFiles };
 export { _convertBytes as convertBytes };
+export { _decrypt as decrypt };
 export { _each as each };
 export { _eachAsync as eachAsync };
+export { _encrypt as encrypt };
 export { _getAllFiles as getAllFiles };
 export { _ignoreMe as ignoreMe };
 export { _isUUID as isUUID };
 export { _md5 as md5 };
 export { _setLocalEnvs as setLocalEnvs };
+export { _thingType as thingType };
 export { _toPennies as toPennies };
 export { _uuid as uuid };
+export { _validateSchema as validateSchema };
 
 export default {
     /**
@@ -63,18 +82,46 @@ export default {
      * @returns {string} The converted bytes in a string format with appropriate units.
      */
     convertBytes: _convertBytes,
+    decrypt: _decrypt,
+    /**
+     * 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}
+     */
     each: _each,
     eachAsync: _eachAsync,
+    encrypt: _encrypt,
     getAllFiles: _getAllFiles,
     ignoreMe: _ignoreMe,
     isUUID: _isUUID,
     md5: _md5,
     setLocalEnvs: _setLocalEnvs,
+    thingType: _thingType,
     toPennies: _toPennies,
     uuid: _uuid,
+    validateSchema: _validateSchema,
+    clean: {
+        array: _clean_array,
+        boolean: _clean_boolean,
+        integer: _clean_integer,
+        number: _clean_number,
+        object: _clean_object,
+        string: _clean_string,
+        thing: _clean_thing,
+        timestamp: _clean_timestamp,
+        uuid: _clean_uuid,
+    },
     ignoreFolder: {
         ignoreMe: _ignoreFolder_ignoreMe,
     },
+    password: {
+        check: _password_check,
+        hash: _password_hash,
+    },
     utils: {
         buildExportsTree: _utils_buildExportsTree,
         buildFileDataList: _utils_buildFileDataList,

package/package.json

@@ -1,23 +1,26 @@
 {
     "name": "@awesomeness-js/utils",
-    "version": "1.0.18",
+    "version": "1.0.20",
     "description": "Awesomeness - Utils",
     "repository": {
-      "type": "git",
-      "url": "git+https://github.com/awesomeness-js/utils.git"
+        "type": "git",
+        "url": "git+https://github.com/awesomeness-js/utils.git"
     },
     "scripts": {
-      "prebuild": "node ./build/build.js",
-      "build": "tsc && npm run postBuild",
-      "postBuild": "node ./build/postBuild.js"
-    },    
+        "prebuild": "node ./build/build.js",
+        "build": "tsc && npm run postBuild",
+        "postBuild": "node ./build/postBuild.js",
+        "test": "vitest"
+    },
     "type": "module",
     "types": "./types/index.d.ts",
     "main": "index.js",
     "author": "Scott Forte",
     "license": "MIT",
     "publishConfig": {
-      "access": "public"
+        "access": "public"
+    },
+    "devDependencies": {
+        "vitest": "^3.0.9"
     }
-  }
-  
+}

package/schemas/schema1.js

@@ -0,0 +1,121 @@
+import { uuid } from '../index.js';
+
+const properties = {
+
+	exampleId: {
+		type: 'uuid',
+		description: 'the id of the vertex',
+		default: () => { return uuid(); },
+		example: '00000000-0000-0000-0000-000000000000',
+		immutable: true,
+		required: true
+	},
+
+	exampleString: {
+		type: 'string',
+		minLength: 1,
+		maxLength: 100,
+		example: 'This is my post',
+		description: 'main title of the post',
+		default: null,
+		required: true,
+	},
+
+	exampleArray: {
+		type: 'array',
+		items: {
+			type: 'string',
+			description: 'any tag, can have spaces',
+			minLength: 1,
+			maxLength: 100,
+		}
+	},
+
+	exampleArrayOfObjects: {
+		type: 'array',
+		items: {
+			type: 'object',
+			properties: {
+				name: {
+					type: 'string'
+				}
+			}
+		}
+	},
+
+	exampleObject: {
+		type: 'object',
+		properties: {
+			someString:{
+				type: 'string',
+			},
+			someArrayOfObjects:{
+				type: 'array',
+				items: {
+					type: 'object',
+					properties: {
+						name: {
+							type: 'string'
+						}
+					}
+				}
+			}
+		}
+	},
+
+	exampleRef: {
+		type: 'array',
+		items: {
+			ref: 'someThing'
+		}
+	}
+
+};
+
+const edges = Object.freeze({
+
+});
+
+const edgesIn = Object.freeze({
+	author: 'author',
+	viewed: 'viewed',
+});
+
+const relatedKVs = {
+	'blogPost::${id}::body': {
+		type: 'array',
+		description: 'body of the post - stored off vertex for query performance',
+		items: {
+			type: 'object',
+			description: 'any part of a blog post on order',
+			properties: {
+				fn: {
+					type: 'string',
+					description: 'the name of the fn such a "body" (app.print.blogPost.body)',
+					enum: [
+						"body",
+						"h1",
+						"h2",
+						"image",
+						"div",
+						"p",
+						"callToAction"
+					]
+				},
+				data: {
+					type: 'object',
+					description: 'data passed to the fn',
+				}
+			}
+		}
+	}
+};
+
+export default {
+	name: 'Blog Post',
+	description: `a blog post`,
+	properties,
+	edges,
+	edgesIn,
+	relatedKVs
+};

package/schemas/schema2.js

@@ -0,0 +1,121 @@
+import { uuid } from '../index.js';
+
+const properties = {
+
+	exampleId: {
+		type: 'uuid',
+		description: 'the id of the vertex',
+		default: () => { return uuid(); },
+		example: '00000000-0000-0000-0000-000000000000',
+		immutable: true,
+		required: true
+	},
+
+	exampleString: {
+		type: 'string',
+		minLength: 1,
+		maxLength: 100,
+		example: 'This is my post',
+		description: 'main title of the post',
+		default: null,
+		required: true,
+	},
+
+	exampleArray: {
+		type: 'array',
+		items: {
+			type: 'string',
+			description: 'any tag, can have spaces',
+			minLength: 1,
+			maxLength: 100,
+		}
+	},
+
+	exampleArrayOfObjects: {
+		type: 'array',
+		items: {
+			type: 'object',
+			properties: {
+				name: {
+					type: 'string'
+				}
+			}
+		}
+	},
+
+	exampleObject: {
+		type: 'object',
+		properties: {
+			someString:{
+				type: 'string',
+			},
+			someArrayOfObjects:{
+				type: 'array',
+				items: {
+					type: 'object',
+					properties: {
+						name: {
+							type: 'string'
+						}
+					}
+				}
+			}
+		}
+	},
+
+	exampleRef: {
+		type: 'array',
+		items: {
+			ref: 'someThing'
+		}
+	}
+
+};
+
+const edges = Object.freeze({
+
+});
+
+const edgesIn = Object.freeze({
+	author: 'author',
+	viewed: 'viewed',
+});
+
+const relatedKVs = {
+	'blogPost::${id}::body': {
+		type: 'array',
+		description: 'body of the post - stored off vertex for query performance',
+		items: {
+			type: 'object',
+			description: 'any part of a blog post on order',
+			properties: {
+				fn: {
+					type: 'string',
+					description: 'the name of the fn such a "body" (app.print.blogPost.body)',
+					enum: [
+						"body",
+						"h1",
+						"h2",
+						"image",
+						"div",
+						"p",
+						"callToAction"
+					]
+				},
+				data: {
+					type: 'object',
+					description: 'data passed to the fn',
+				}
+			}
+		}
+	}
+};
+
+export default {
+	name: 'Blog Post',
+	description: `a blog post`,
+	properties,
+	edges,
+	edgesIn,
+	relatedKVs
+};

package/schemas.js

@@ -0,0 +1,15 @@
+/**
+ * This file is auto-generated by the build script.
+ * It consolidates API functions for use in the application.
+ * Do not edit manually.
+ */
+import _schema1 from './schemas/schema1.js';
+import _schema2 from './schemas/schema2.js';
+
+export { _schema1 as schema1 };
+export { _schema2 as schema2 };
+
+export default {
+    schema1: _schema1,
+    schema2: _schema2,
+};

package/secrets/dev.env

@@ -1 +1,2 @@
-JUST_A_TEST='Dev just a test'
+JUST_A_TEST='Dev just a test'
+AWESOMENESS_ENCRYPTION_KEY='12345678901234567890123456789012'

package/secrets/local.env

@@ -1 +1,2 @@
-JUST_A_TEST='Local just a test'
+JUST_A_TEST='Local just a test'
+AWESOMENESS_ENCRYPTION_KEY='12345678901234567890123456789012'

package/src/clean/array.js

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

package/src/clean/boolean.js

@@ -0,0 +1,22 @@
+export default function cleanBoolean(x, {
+    required = false
+} = {}){
+
+    try {
+    
+        if(x !== true && x !== false){
+            throw {
+                message: `Invalid boolean value "${x}"`,
+            }
+        }
+        
+        return x;
+
+    } catch (e) {
+
+        if(required) { throw e; } else { return null; }
+        
+    }
+    
+}
+

package/src/clean/integer.js

@@ -0,0 +1,55 @@
+export default function cleanInt(x, {
+    required = false,
+    min = false,
+    max = false,
+} = {}){
+
+    try {
+
+        if (typeof x !== 'number' || !Number.isInteger(x)) {
+
+            // convert string to number if possible
+            if (typeof x === 'string' && !isNaN(parseInt(x))) {
+                x = parseInt(x);
+            } else {
+                throw {
+                    message: 'Input must be an integer',
+                    value: x
+                }
+            }
+    
+        }
+    
+        if (min !== false && x < min) { 
+        
+            throw {
+                message: `Integer must be greater than or equal to ${min}`,
+                value: x,
+                min,
+                max
+            }
+    
+        }
+    
+        if (max !== false && x > max) { 
+    
+            throw {
+                message: `Integer must be less than or equal to ${max}`,
+                value: x,
+                min,
+                max
+            }        
+    
+        }
+    
+        return x;
+
+    } catch (e) {
+
+        if(required) { throw e; } else { return null; }
+        
+    }
+    
+    
+}
+

package/src/clean/number.js

@@ -0,0 +1,75 @@
+export default function cleanNumber(x, {
+    required = false,
+    min = false,
+    max = false,
+    maxDecimal = false,
+    minDecimal = false,
+} = {}){
+
+    try {
+
+        if (typeof x !== 'number') {
+
+            // convert string to number if possible
+            if (typeof x === 'string' && !isNaN(parseFloat(x))) {
+                x = parseFloat(x);
+            } else {
+                throw {
+                    message: 'Input must be a number',
+                    value: x
+                }
+            }
+
+        }
+
+        if (min !== false && x < min) { 
+        
+            throw {
+                message: `Integer must be greater than or equal to ${min}`,
+                value: x,
+                min,
+                max
+            }
+
+        }
+
+        if (max !== false && x > max) { 
+
+            throw {
+                message: `Integer must be less than or equal to ${max}`,
+                value: x,
+                min,
+                max
+            }        
+
+        }
+
+        if (maxDecimal !== false && x.toString().split('.')[1]?.length > maxDecimal) { 
+
+            throw {
+                message: `Number must have at most ${maxDecimal} decimal places`,
+                value: x,
+                maxDecimal
+            }        
+
+        }
+
+        if (minDecimal !== false && x.toString().split('.')[1]?.length < minDecimal) {
+
+            throw {
+                message: `Number must have at least ${minDecimal} decimal places`,
+                value: x,
+                minDecimal
+            }        
+
+        }
+        
+        return x;
+  
+    } catch (e) {
+
+        if(required) { throw e; } else { return null; }
+        
+    }
+}
+

package/src/clean/object.js

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