@thirstie/thirstievalidators 0.0.6 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thirstie/thirstievalidators",
-  "version": "0.0.6",
+  "version": "0.2.0",
   "description": "A collection of data validators used by Thirstiejs modules",
   "author": "Thirstie, Inc. <technology@thirstie.com>",
   "license": "MIT",
@@ -22,6 +22,9 @@
     "test": "concurrently \"npm run lint\" \"npm run test:coverage\"",
     "test:watch": "node --experimental-vm-modules ../../node_modules/.bin/jest unit --watch"
   },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
   "jest": {
     "moduleFileExtensions": [
       "js",
@@ -30,5 +33,5 @@
     "testEnvironment": "jsdom",
     "transform": {}
   },
-  "gitHead": "b7400621954f917a80a9a530ea89cc2d41aa6373"
+  "gitHead": "c6fda8b11121b5262a6b4ce933221d72f49610a6"
 }

package/src/agegate.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+
+export const ageGate = (ageGateType, ageGateValue, legalAge = null) => {
+  const ageGateTypeValidation = z.enum([ 'yesno', 'dob' ]);
+  const ageDateValidation = z.coerce.date();
+  legalAge = legalAge || 21;
+
+  let _type = null;
+  try {
+    _type = ageGateTypeValidation.parse(ageGateType.toLowerCase());
+  } catch {
+    return {};
+  }
+
+  let _passed = false;
+  let { success, data: userDOB } = ageDateValidation.safeParse(ageGateValue);
+  switch (_type) {
+    case 'yesno':
+      _passed = !!ageGateValue;
+      userDOB = null;
+      break;
+    case 'dob':
+      if (success) {
+        const today = new Date();
+        const legalAsOf = new Date(userDOB.getFullYear() + legalAge, userDOB.getMonth(), userDOB.getDate());
+        _passed = !legalAsOf ? false : legalAsOf <= today;
+      }
+      break;
+  }
+  return { ageGateType: _type, ageGatePassed: _passed, ageGateDOB: userDOB || null };
+};

package/src/emailLists.js

@@ -0,0 +1,58 @@
+export const emailTypoList = [
+  'gnail.co',
+  'gmil.com',
+  'gmsil.com',
+  'gamil.com',
+  'gmai.com',
+  'gnail.com',
+  'gmail.co',
+  'gmail.cm',
+  'gmail.co',
+  'gmal.com',
+  'gmaill.com',
+  'gmail.ca',
+  'gmal.com',
+  'gmai.com',
+  'gmaiil.com',
+  'gmail.con',
+  'gmail.comm',
+  'gmaol.com',
+  'gmail.om',
+  'gmaol.co',
+  'gmall.com',
+  'gmal.co',
+  'ail.com'
+];
+
+export const trustedEmailDomains = [
+  'gmail.com',
+  'yahoo.com',
+  'hotmail.com',
+  'aol.com',
+  'comcast.net',
+  'icloud.com',
+  'me.com',
+  'msn.com',
+  'outlook.com',
+  'sbcglobal.net',
+  'live.com',
+  'att.net',
+  'verizon.net',
+  'mac.com',
+  'ymail.com',
+  'optonline.net',
+  'cox.net',
+  'bellsouth.net',
+  'charter.net',
+  'anheuser-busch.com',
+  'mail.com',
+  'rocketmail.com',
+  'earthlink.net',
+  'aim.com',
+  'cbrands.com',
+  'kdrp.com',
+  'protonmail.com',
+  'roadrunner.com',
+  'pacbell.net',
+  'yopmail.com'
+];

package/src/index.js

@@ -1,12 +1,28 @@
 import passwordcheck from './passwordcheck';
+import { getAdministrativeArea, COUNTRY_CODES } from './iso3166codes';
+import { emailTypoList, trustedEmailDomains } from './emailLists';
+import { ageGate } from './agegate';
 
 // see: https://github.com/ThirstieAdmin/archived-repos/tree/master/thirstie-templates/react-cookbook/src/utils
-// TODO: research using https://www.npmjs.com/package/validator
-const thirstieValidators = {
+// Validator must return true or false
+const Validators = {
   email: (value, options = null) => {
+    const checkTypeoList = (options && options.checkTypeos) ? options.checkTypeos : false;
     const emailRegex = /^(?![.!#$%&'*+/=?^_`{|}~-])(?!.*\.{2})[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]{1,64}@[a-zA-Z0-9]{1,255}\.[a-zA-Z]{2,}$/;
-    // TODO: add domain checks
-    return emailRegex.test(value);
+    let isValid = emailRegex.test(value);
+    if (isValid && checkTypeoList) {
+      const emailDomain = value.split('@')[1].toLowerCase();
+      isValid = !emailTypoList.includes(emailDomain);
+    }
+    return isValid;
+  },
+  emailHasTrustedDomain: (value, options = null) => {
+    const emailParts = value && value.toLowerCase().split('@');
+    if (emailParts && emailParts.length === 2) {
+      const emailDomain = emailParts[1];
+      return trustedEmailDomains.includes(emailDomain);
+    }
+    return false;
   },
   phoneNumber: (value, options = null) => {
     const phoneRegex = /^((\+1|1)?( |-)?)?(\([2-9][0-9]{2}\)|[2-9][0-9]{2})( |-)?([2-9][0-9]{2}( |-)?[0-9]{4})$/;
@@ -17,7 +33,7 @@ const thirstieValidators = {
     return false;
   },
   postalCode: (value, options = null) => {
-    const country = options.countryCode ? options.countryCode.toLowerCase() : 'en-us';
+    const country = (options && options.countryCode) ? options.countryCode.toLowerCase() : 'en-us';
     const regex = {
       'en-us': /^\d{5}$/,
       'en-ca': /^[a-zA-Z]\d[a-zA-Z]\s?\d[a-zA-Z]\d$/
@@ -27,9 +43,44 @@ const thirstieValidators = {
     }
     return false;
   },
-  stateProvinceCode: (value, options = null) => { throw new Error('Not implemented'); },
-  currencyValue: (value, options = null) => { throw new Error('Not implemented'); },
-  passwordStrength: (value, options = null) => { return passwordcheck(value); }
+  stateProvinceCode: (value, options = null) => {
+    const countryCode = (options && options.countryCode) ? options.countryCode.toLowerCase() : 'en-us';
+    const check = getAdministrativeArea(value.toUpperCase(), countryCode);
+    if (!check) {
+      return false;
+    } else {
+      return true;
+    }
+  },
+  currencyValue: (value, options = null) => {
+    const countryCode = (options && options.countryCode) ? options.countryCode.toLowerCase() : 'en-us';
+    const countryValues = COUNTRY_CODES[countryCode];
+    const currencySymbols = countryValues.currency;
+
+    const checkValue = currencySymbols.reduce((acc, val) => acc.replace(val, ''), value).replace(' ', '');
+
+    const regx0 = /[^.^\d]+/;
+    const regx = /\d+\.+\d+/;
+    if (!regx0.test(checkValue)) {
+      return regx.test(checkValue);
+    } else {
+      return false;
+    }
+  }
+};
+
+const Checkers = {
+  passwordStrength: (value, options = null) => { return passwordcheck(value); },
+  emailCheck: (value, options = null) => {
+    const isValid = Validators.email(value, { checkTypeos: true });
+    const isTrusted = Validators.emailHasTrustedDomain(value);
+    return { isValid, isTrusted };
+  },
+  ageGate: (value, options = null) => {
+    const ageGateType = options.ageGateType || 'dob';
+    const legalAge = options.legalAge;
+    return ageGate(ageGateType, value, legalAge);
+  }
 };
 
-export default thirstieValidators;
+export { Validators, Checkers };

package/src/iso3166codes.js

@@ -0,0 +1,82 @@
+export const US_STATES = {
+  AL: 'Alabama',
+  AK: 'Alaska',
+  AZ: 'Arizona',
+  AR: 'Arkansas',
+  CA: 'California',
+  CO: 'Colorado',
+  CT: 'Connecticut',
+  DE: 'Delaware',
+  DC: 'District of Columbia',
+  FL: 'Florida',
+  GA: 'Georgia',
+  HI: 'Hawaii',
+  ID: 'Idaho',
+  IL: 'Illinois',
+  IN: 'Indiana',
+  IA: 'Iowa',
+  KS: 'Kansas',
+  KY: 'Kentucky',
+  LA: 'Louisiana',
+  ME: 'Maine',
+  MD: 'Maryland',
+  MA: 'Massachusetts',
+  MI: 'Michigan',
+  MN: 'Minnesota',
+  MS: 'Mississippi',
+  MO: 'Missouri',
+  MT: 'Montana',
+  NE: 'Nebraska',
+  NV: 'Nevada',
+  NH: 'New Hampshire',
+  NJ: 'New Jersey',
+  NM: 'New Mexico',
+  NY: 'New York',
+  NC: 'North Carolina',
+  ND: 'North Dakota',
+  OH: 'Ohio',
+  OK: 'Oklahoma',
+  OR: 'Oregon',
+  PA: 'Pennsylvania',
+  RI: 'Rhode Island',
+  SC: 'South Carolina',
+  SD: 'South Dakota',
+  TN: 'Tennessee',
+  TX: 'Texas',
+  UT: 'Utah',
+  VT: 'Vermont',
+  VA: 'Virginia',
+  WA: 'Washington',
+  WV: 'West Virginia',
+  WI: 'Wisconsin',
+  WY: 'Wyoming'
+};
+
+export const CA_PROVINCES = {
+  AB: 'Alberta',
+  BC: 'British Columbia',
+  MB: 'Manitoba',
+  NB: 'New Brunswick',
+  NL: 'Newfoundland and Labrador',
+  NS: 'Nova Scotia',
+  ON: 'Ontario',
+  PE: 'Prince Edward Island',
+  QC: 'Quebec',
+  SK: 'Saskatchewan'
+};
+
+// ISO-3166 codes
+export const COUNTRY_CODES = {
+  'en-us': { name: 'United States', alpha3: 'USA', numeric: '840', administrativeAreas: US_STATES, alpha2: 'US', currency: [ '$', 'USD' ] },
+  'en-ca': { name: 'Canada', alpha3: 'CAN', numeric: '124', administrativeAreas: CA_PROVINCES, alpha1: 'CA', currency: [ '$', 'CAD' ] }
+};
+
+export const getAdministrativeArea = (value, countryCode = null) => {
+  const country = countryCode ? countryCode.toLowerCase() : 'en-us';
+  const countryValues = COUNTRY_CODES[country];
+  if (countryValues) {
+    return countryValues.administrativeAreas[value];
+  } else {
+    return false;
+  }
+};

package/src/passwordcheck.js

@@ -18,7 +18,6 @@ const blindEntropy = (pw) => {
 
   const permutations = numberPermutations + lowercasePermutations + uppercasePermutations + punctuationPermutations;
   const pwLength = pw.length;
-
   return Math.log2(permutations ** pwLength);
 };
 

package/tests/unit/checkers.agegate.unit.test.js

@@ -0,0 +1,40 @@
+import { Checkers } from '../../src/index.js';
+
+describe('Checker.ageGate', () => {
+  it('should validate a list of items', () => {
+    const fixtures = [
+      {
+        ageGateType: 'YesNo',
+        ageGateValue: true,
+        expectedvalidation: { ageGateType: 'yesno', ageGatePassed: true, ageGateDOB: null }
+      },
+      {
+        ageGateType: 'yesno',
+        ageGateValue: null,
+        expectedvalidation: { ageGateType: 'yesno', ageGatePassed: false, ageGateDOB: null }
+      },
+      {
+        ageGateType: 'yesno',
+        ageGateValue: false,
+        expectedvalidation: { ageGateType: 'yesno', ageGatePassed: false, ageGateDOB: null }
+      },
+      {
+        ageGateType: 'DOB',
+        ageGateValue: new Date(1964, 8, 28),
+        expectedvalidation: { ageGateType: 'dob', ageGatePassed: true, ageGateDOB: new Date(1964, 8, 28) }
+      },
+      {
+        ageGateType: 'DOB',
+        ageGateValue: new Date(2014, 8, 28),
+        expectedvalidation: { ageGateType: 'dob', ageGatePassed: false, ageGateDOB: new Date(2014, 8, 28) }
+      }
+    ];
+
+    fixtures.forEach((item) => {
+      const { ageGateType, ageGateValue, expectedvalidation } = item;
+      const result = Checkers.ageGate(ageGateValue, { ageGateType });
+      expect(result.ageGateType).toBe(expectedvalidation.ageGateType);
+      expect(result.ageGatePassed).toBe(expectedvalidation.ageGatePassed);
+    });
+  });
+});

package/tests/unit/{passwordcheck.unit.test.js → checkers.password.unit.test.js}

@@ -1,4 +1,4 @@
-import thirstieValidators from '../../src/index.js';
+import { Checkers } from '../../src/index.js';
 
 describe('passwordcheck', () => {
   it('should return password strength', () => {
@@ -15,7 +15,7 @@ describe('passwordcheck', () => {
       }
     ];
     fixtures.forEach((fixture) => {
-      const pwStrength = thirstieValidators.passwordStrength(fixture.testValue);
+      const pwStrength = Checkers.passwordStrength(fixture.testValue);
       expect(pwStrength.strength).toBe(fixture.strength);
       expect(pwStrength.label).toBe(fixture.label);
     });

package/tests/unit/validators.agegate.unit.test.js

@@ -0,0 +1,31 @@
+import { ageGate } from '../../src/agegate';
+
+describe('agegate validation', () => {
+  it('should validate a list of items', () => {
+    const fixtures = [
+      {
+        ageGateType: 'YesNo',
+        ageGateValue: true,
+        expectedvalidation: { ageGateType: 'yesno', ageGatePassed: true, ageGateDOB: null }
+      },
+      {
+        ageGateType: 'yesno',
+        ageGateValue: 'true',
+        expectedvalidation: { ageGateType: 'yesno', ageGatePassed: true, ageGateDOB: null }
+      },
+      {
+        ageGateType: 'DOB',
+        ageGateValue: new Date(1964, 8, 28),
+        expectedvalidation: { ageGateType: 'dob', ageGatePassed: true, ageGateDOB: new Date(1964, 8, 28) }
+      }
+    ];
+
+    fixtures.forEach((item) => {
+      const { ageGateType, ageGateValue, expectedvalidation } = item;
+      const result = ageGate(ageGateType, ageGateValue);
+      expect(result.ageGateType).toBe(expectedvalidation.ageGateType);
+      expect(result.ageGatePassed).toBe(expectedvalidation.ageGatePassed);
+      expect(result.ageGateDOB).toEqual(expectedvalidation.ageGateDOB);
+    });
+  });
+});

package/tests/unit/validators.email.unit.test.js

@@ -1,4 +1,4 @@
-import thirstieValidators from '../../src/index.js';
+import { Validators } from '../../src/index.js';
 
 describe('email validation', () => {
   /* see:
@@ -13,10 +13,11 @@ describe('email validation', () => {
       'first.last@example.com'
     ];
     fixtures.forEach((fixture) => {
-      const validationCheck = thirstieValidators.email(fixture);
+      const validationCheck = Validators.email(fixture);
       expect(validationCheck).toBe(true);
     });
   });
+
   it('should return false for invalid emails', () => {
     const fixtures = [
       'localpart@domainname',
@@ -24,8 +25,33 @@ describe('email validation', () => {
       'first.last@example.c'
     ];
     fixtures.forEach((fixture) => {
-      const validationCheck = thirstieValidators.email(fixture);
+      const validationCheck = Validators.email(fixture);
+      expect(validationCheck).toBe(false);
+    });
+  });
+
+  it('should return false for invalid domains if option is selected', () => {
+    const fixtures = [
+      'localpart@gnail.co',
+      'first.last@ail.com'
+    ];
+    fixtures.forEach((fixture) => {
+      const options = { checkTypeos: true };
+      const validationCheck = Validators.email(fixture, options);
       expect(validationCheck).toBe(false);
     });
   });
+
+  it('should recognize trusted domains', () => {
+    const fixtures = [
+      'localpart@gmail.com',
+      'first.last@yahoo.com',
+      'bob.lablaw@aol.com'
+    ];
+    fixtures.forEach((fixture) => {
+      const options = { checkTypeos: true };
+      const validationCheck = Validators.emailHasTrustedDomain(fixture, options);
+      expect(validationCheck).toBe(true);
+    });
+  });
 });

package/tests/unit/validators.other.unit.test.js

@@ -0,0 +1,40 @@
+import { Validators } from '../../src/index.js';
+
+describe('currency validation', () => {
+  it('should validate a currency input', () => {
+    const fixtures = [
+      [ '$45.00', true ],
+      [ '$45.00x', false ]
+    ];
+    fixtures.forEach((fixture) => {
+      const validationCheck = Validators.currencyValue(fixture[0]);
+      expect(validationCheck).toBe(fixture[1]);
+    });
+  });
+});
+
+describe('state code validation', () => {
+  it('should validate a US state code', () => {
+    const fixtures = [
+      [ 'ma', true ],
+      [ 'MA', true ],
+      [ 'XX', false ]
+    ];
+    fixtures.forEach((fixture) => {
+      const validationCheck = Validators.stateProvinceCode(fixture[0]);
+      expect(validationCheck).toBe(fixture[1]);
+    });
+  });
+
+  it('should validate a Canadian state code', () => {
+    const fixtures = [
+      [ 'on', true ],
+      [ 'ON', true ],
+      [ 'XX', false ]
+    ];
+    fixtures.forEach((fixture) => {
+      const validationCheck = Validators.stateProvinceCode(fixture[0], { countryCode: 'en-ca' });
+      expect(validationCheck).toBe(fixture[1]);
+    });
+  });
+});