some-common-functions-js 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# JavaScript Object Utilities & Field Validation Functions
+
+Common functions used for working with JavaScript objects and validating field values.
+
+---
+
+## 1. JavaScript Object Utilities
+
+### `getPaths(anObject)`
+Returns a string array of path/field names inside a JavaScript object.
+** Example **
+let client = {
+    name: "Jack",
+    surname: "Stober",
+    address: {
+        streetNum: "57",
+        streetName: "Tiger Drive",
+        suburb: "Lakeside Ext.1",
+        town: "Lakeside",
+        country {
+            name: "South Africa",
+            code: "za"
+        }
+    }
+};
+
+let paths = getPaths(client);
+// ["name", "surname", "address.streetNum", "address.streetName", "address.suburb",
+//  "address.town", "address.country.name", "address.country.code"]
+
+### `hasOnly(anObject, ...fields)`
+Returns `true` if the object contains **only** some or all of the specified fields and no others.
+** Examples **
+let car = {
+    make: "Ford",
+    model: "Ranger",
+    year: "2015",
+};
+
+let result = hasOnly(car, ["make", "model", "year"]);
+// true, because car has *only all of the specified fields and no other fields.
+
+result = hasOnly(car, ["make", "model", "year", "maxSpeed", "gvm"]);
+// true, because car has *only some of the specified fields and no other fields.
+
+result = hasOnly(car, ["maxSpeed", "gvm", "power"]);
+// false, because car has fields other than the specified fields.
+
+result = hasOnly(car, ["make", "model"]);
+// false, because car has fields other than the specified fields.
+
+### `hasAll(anObject, ...fields)`
+Returns `true` if the object contains **all** the specified fields.  
+The object may contain additional fields.
+** Example **
+let car = {
+    make: "Ford",
+    model: "Ranger",
+    year: "2015",
+    power: "1000kW",
+    type: "pickup truck"
+};
+
+let result = hasAll(car, ["make", "model", "year"]);
+// true, because car has all the specified fields.
+
+---
+
+## 2. Field Validation Functions
+
+### `isValidUserName(userName)`
+Returns `true` if a username is valid.
+
+### `isValidName(name)`
+Returns `true` if a personal name is valid.
+
+### `isValidEmail(email)`
+Returns `true` if an email address is valid.
+
+### `isValidPhoneNum(num)`
+Returns `true` if a phone number is valid.
+
+### `isValidOrganisationName(name)`
+Returns `true` if an organisation name is valid.
+
+### `isValidPassword(password)`
+Returns `true` if the password meets the required strength rules.
+
+---
+
+## License
+MIT

package/index.js

@@ -0,0 +1,160 @@
+/** File: ./backend/utilityFunctions/commonFunctions.js
+ * Description: Common functions to be put here.
+ * Date        Dev   Version  Description
+ * 2024/09/01  ITA   1.00     Genesis.
+ * 2024/11/11  ITA   1.02     Added file header. Function getPaths to return a sorted array of paths.
+ * 2024/11/29  ITA   1.03     Function to be added to export soon after definition.
+*/
+
+
+function isValidUserName(userName) {
+    if (!userName) // The username must be provided.
+        return false;
+
+    const regEx = /^[a-zA-Z][a-zA-Z0-9_-]{2,50}$/;
+    return regEx.test(userName);
+}
+module.exports.isValidUserName = isValidUserName;
+
+function isValidName(name) {
+    if (!name) // The name must be provided.
+        return false;
+
+    const regEx = /^[A-Za-z' -]{2,50}$/;
+    return regEx.test(name);
+}
+module.exports.isValidName = isValidName;
+
+function isValidEmail(email) {
+    if (!email)
+        return false;
+
+    const regEx = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+    return regEx.test(email);
+}
+module.exports.isValidEmail = isValidEmail;
+
+function isValidPhoneNum(num) {
+    if (!num) // The number must be provided.
+        return false;
+
+    const regEx = /^[0-9]{10,15}$/g;
+    return regEx.test(num);
+}
+module.exports.isValidPhoneNum = isValidPhoneNum;
+
+function isValidOrganisationName(name) {  
+    if (!name) // The name must be provided.
+        return false;
+
+    const regEx = /^[a-zA-Z0-9.\-\(\) ]{2,}$/;
+    return regEx.test(name);
+}
+module.exports.isValidOrganisationName = isValidOrganisationName;
+
+function isValidPassword(password) {
+    if (!password)
+        return false;
+
+    // Password must be at least 6 characters long
+    if (password.length < 6)
+        return false;
+
+    // Must contain at least 1 uppercase letter
+    if (/[A-Z]/.test(password) === false)
+        return false;
+    
+      // Must contain at least 1 lowercase letter
+    if (/[a-z]/.test(password) === false)
+        return false;
+    
+    // Must contain at least 1 number
+    if (/[0-9]/.test(password) === false)
+        return false;
+
+    // Must not contain white space characters
+    if (/[\s]/.test(password))
+        return false;
+    
+    // Must contain atleast 1 symbol
+    if (/[\][!"#$%&'()*+,./:;<=>?@^\\_`{|}~-]/.test(password) === false)
+        return false;
+  
+    return true;
+}
+module.exports.isValidPassword = isValidPassword;
+
+/**
+ * Get the paths (fields) of the plain Javascript object.
+ * @param {object} anObject 
+ * @returns a string array of paths.
+ */
+function getPaths(anObject) {
+    const paths = [];
+    if (!(Object.prototype.toString.call(anObject) === '[object Object]'))
+        return paths;
+    
+    for (const path in anObject) {
+        const nestedPaths = getPaths(anObject[path]);
+        if (nestedPaths.length > 0) {
+            nestedPaths.forEach(nestedPath=> {
+                paths.push(path + '.' + nestedPath); 
+            });
+        }
+        else
+            paths.push(path);
+    }
+    paths.sort();
+    return paths;
+} // function getPaths()
+module.exports.getPaths = getPaths;
+
+/**
+ * Determine whether an object contains only some or all of the specified fields, and not any other fields.
+ * @param {*} anObject a Javascript object.
+ * @param  {...string} fields one or more field names.
+ * @returns boolean.
+ */
+function hasOnly(anObject, ...fields) {
+    if (!fields || !fields.length)
+        throw new Error('fields must be specified');
+
+    const paths = getPaths(anObject);
+    let count = 0;
+    for (const index in paths) {
+        const path = paths[index];
+
+        if (!fields.includes(path))
+            return false;
+        else
+            count++;
+    } // for (const index in paths)
+
+    return (count > 0);
+}
+module.exports.hasOnly = hasOnly;
+
+/**
+ * Determine whether an object contains all of the specified fields. It may have additional fields.
+ * @param {*} anObject a Javascript object.
+ * @param  {...string} fields one or field names.
+ * @returns boolean.
+ */
+function hasAll(anObject, ...fields) {
+    if (!fields || !fields.length)
+        throw new Error('fields must be specified');
+    
+    const paths = getPaths(anObject);
+    let count = 0;
+    for (const index in fields) {
+        const field = fields[index];
+
+        if (!paths.includes(field))
+            return false;
+        else
+            count++;
+    } // for (const index in paths)
+
+    return (count === fields.length);
+}
+module.exports.hasAll = hasAll;

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "some-common-functions-js",
+  "version": "1.0.0",
+  "description": "Common functions used with Javascript objects, and field validation functions.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/IsaiahTshabalala/common-functions"
+  },
+  "license": "ISC",
+  "author": "ITA",
+  "type": "commonjs",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}