@becollective/utils 1.1.0 → 1.3.0

package/bundle.js

@@ -39,26 +39,96 @@ var password = {
 };
 
 var moment = require('moment');
+/**
+ * Get current age based on the given birth date
+ * @param {string} dateOfBirth
+ * @param {string} unit the measurement of the the difference
+ *  The supported measurements are:
+ *  years, months, weeks, days, hours, minutes, and seconds. 
+ * @returns {number} age
+ */
+
+
+var getAge = function getAge(dateOfBirth) {
+  var unit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'years';
+  var age = moment().diff(dateOfBirth, unit);
+
+  if (isNaN(age)) {
+    throw new Error('Invalid date');
+  }
+
+  return age;
+};
 /**
  * Check if a user requires parent(guardian) consent
  * i.e. Is under the age of 16 years, based on GDPR
  * https://gdpr-info.eu/art-8-gdpr/
- * @param {*} dateOfBirth moment.js compatible date time
+ * @param {string} dateOfBirth moment.js compatible date time
+ * @returns {boolean}
+ * NOTE:
+ * We used to not allow child (under 16) to register,
+ * and birthdate is not a required field for ghost user
+ * So an existing user could have no birthdate, we assume these users are adults
+ * TODO:
+ * Remove above logic after we migrated all legacy
+ * data to have a consistent birthdate property.
+ * Then we should throw error if birthdate is not valid
  */
 
-
 var isUnderSixteen = function isUnderSixteen(dateOfBirth) {
-  var age = moment().diff(dateOfBirth, 'years');
+  if (!dateOfBirth || !moment(dateOfBirth).isValid()) {
+    return false;
+  }
 
-  if (isNaN(age)) {
-    throw new Error('Invalid date');
+  var age = getAge(dateOfBirth);
+  return isNaN(age) ? false : age < 16;
+};
+
+var _require = require('@becollective/constants'),
+    currencies = _require.currencies; // We should probably throw and error on bad input instead of falling back to a default.
+// We're making an assumption that whoever is calling this function can safely work
+// with AUD. But this assumption removes a lot of error handling elsewhere.
+
+
+var getCurrencyFromCurrencyCode = function getCurrencyFromCurrencyCode(currencyCode) {
+  if (typeof currencyCode !== 'string' || !currencies[currencyCode]) {
+    console.error(new Error("Invalid currencyCode: ".concat(currencyCode, ". Falling back to 'AUD'.")));
+    return currencies.AUD;
+  }
+
+  return currencies[currencyCode];
+};
+var makeMoneyString = function makeMoneyString(_ref) {
+  var inputAmount = _ref.amount,
+      currencyCode = _ref.currencyCode,
+      _ref$rounded = _ref.rounded,
+      rounded = _ref$rounded === void 0 ? false : _ref$rounded,
+      _ref$showCurrencyCode = _ref.showCurrencyCode,
+      showCurrencyCode = _ref$showCurrencyCode === void 0 ? false : _ref$showCurrencyCode;
+  var amount = Number(inputAmount);
+
+  if (isNaN(amount)) {
+    console.error(new Error("Invalid amount: ".concat(inputAmount, ". Falling back to 0.")));
+    amount = 0;
   }
 
-  return age < 16;
+  var currency = getCurrencyFromCurrencyCode(currencyCode);
+  var minorUnit = currency.minorUnit,
+      symbol = currency.symbol;
+  var decimalPlaces = rounded ? 0 : minorUnit;
+  var localeAmount = amount.toLocaleString(undefined, {
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces
+  });
+  var currencyCodeString = showCurrencyCode ? " ".concat(currency.code) : '';
+  return "".concat(symbol).concat(localeAmount).concat(currencyCodeString);
 };
 
 var util = {
   password: password,
-  isUnderSixteen: isUnderSixteen
+  isUnderSixteen: isUnderSixteen,
+  getAge: getAge,
+  getCurrencyFromCurrencyCode: getCurrencyFromCurrencyCode,
+  makeMoneyString: makeMoneyString
 };
 module.exports = util;

package/index.js

@@ -1,9 +1,13 @@
-import { password } from './password';
-import { isUnderSixteen } from './date-time';
+import { password } from './src/password';
+import { isUnderSixteen, getAge } from './src/date-time';
+import { getCurrencyFromCurrencyCode, makeMoneyString } from './src/money';
 
 const util = {
   password,
   isUnderSixteen,
+  getAge,
+  getCurrencyFromCurrencyCode,
+  makeMoneyString,
 };
 
 module.exports = util;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@becollective/utils",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Common utilities",
   "main": "bundle.js",
   "scripts": {
-    "test": "NODE_ENV=localtest npm run build && ./node_modules/.bin/jest tests/*",
+    "test": "NODE_ENV=localtest npm run build && ./node_modules/.bin/jest",
     "build": "./node_modules/.bin/rollup -c",
-    "prepublish": "npm run build; npm test"
+    "prepare": "npm run build; npm test"
   },
   "author": "",
   "license": "ISC",
@@ -19,6 +19,15 @@
     "rollup-plugin-node-resolve": "^3.4.0"
   },
   "dependencies": {
+    "@becollective/constants": "^3.3.2",
     "moment": "^2.24.0"
+  },
+  "jest": {
+    "testMatch": [
+      "**/*.test.js"
+    ],
+    "setupFiles": [
+      "./testUtils/setup.js"
+    ]
   }
 }

package/src/date-time.js

@@ -0,0 +1,39 @@
+const moment = require('moment');
+
+/**
+ * Get current age based on the given birth date
+ * @param {string} dateOfBirth
+ * @param {string} unit the measurement of the the difference
+ *  The supported measurements are:
+ *  years, months, weeks, days, hours, minutes, and seconds. 
+ * @returns {number} age
+ */
+export const getAge = (dateOfBirth, unit='years') => {
+  const age = moment().diff(dateOfBirth, unit);
+  if (isNaN(age)) {
+    throw new Error('Invalid date');
+  }
+  return age;
+};
+/**
+ * Check if a user requires parent(guardian) consent
+ * i.e. Is under the age of 16 years, based on GDPR
+ * https://gdpr-info.eu/art-8-gdpr/
+ * @param {string} dateOfBirth moment.js compatible date time
+ * @returns {boolean}
+ * NOTE:
+ * We used to not allow child (under 16) to register,
+ * and birthdate is not a required field for ghost user
+ * So an existing user could have no birthdate, we assume these users are adults
+ * TODO:
+ * Remove above logic after we migrated all legacy
+ * data to have a consistent birthdate property.
+ * Then we should throw error if birthdate is not valid
+ */
+export const isUnderSixteen = dateOfBirth => {
+  if (!dateOfBirth || !moment(dateOfBirth).isValid()) {
+    return false;
+  }
+  const age = getAge(dateOfBirth);
+  return isNaN(age) ? false : age < 16;
+};

package/src/date-time.test.js

@@ -0,0 +1,56 @@
+const { isUnderSixteen, getAge } = require('../bundle.js');
+const moment = require('moment');
+
+describe('getAge', () => {
+  const refPoint = moment().subtract(16, 'years');
+
+  test('Returns the correct age', () => {
+    const dob = moment(refPoint);
+
+    expect(getAge(dob)).toBe(16);
+    expect(getAge(dob.subtract(1, 'year').utc().format())).toBe(17);
+    expect(getAge(dob.add(13, 'months').utc().format())).toBe(15);
+  });
+
+  test('Returns the age in specified measurement', () => {
+    const dob = moment().subtract(15, 'months');
+
+    expect(getAge(dob)).toBe(1);
+    expect(getAge(dob, 'years')).toBe(1);
+    expect(getAge(dob, 'months')).toBe(15);
+  });
+
+  test('Throws Error if dob is not a valid date-string', () => {
+    expect(() => getAge(notDefined)).toThrow(/not defined/);
+    expect(() => getAge(null)).toThrow(/Invalid date/);
+    expect(() => getAge('not-valid')).toThrow(/Invalid date/);
+  });
+});
+
+describe('isUnderSixteen', () => {
+  const refPoint = moment().subtract(16, 'years');
+  const obj = {};
+  test('Is not U16 if dob is 16 years ago', () => {
+    const dob = moment(refPoint);
+
+    expect(isUnderSixteen(dob.subtract(1, 'minute').utc().format())).toBe(false);
+    expect(isUnderSixteen(dob.subtract(100, 'year').utc().format())).toBe(false);
+  });
+
+  test('Is U16 if dob is less than 16 years ago', () => {
+    const dob = moment(refPoint);
+
+    expect(isUnderSixteen(dob.add(1, 'minute').utc().format())).toBe(true);
+    expect(isUnderSixteen(dob.add(100, 'year').utc().format())).toBe(true);
+  });
+
+  test('Undefined dob', () => {
+    expect(isUnderSixteen(obj.notDefined)).toBe(false);
+  });
+  test('Null dob', () => {
+    expect(isUnderSixteen(null)).toBe(false);
+  });
+  test('Invalid date string', () => {
+    expect(isUnderSixteen('not-valid')).toBe(false);
+  });
+});

package/src/money.js

@@ -0,0 +1,37 @@
+const { currencies } = require('@becollective/constants');
+
+// We should probably throw and error on bad input instead of falling back to a default.
+// We're making an assumption that whoever is calling this function can safely work
+// with AUD. But this assumption removes a lot of error handling elsewhere.
+export const getCurrencyFromCurrencyCode = currencyCode => {
+  if (typeof currencyCode !== 'string' || !currencies[currencyCode]) {
+    console.error(new Error(`Invalid currencyCode: ${currencyCode}. Falling back to 'AUD'.`));
+    return currencies.AUD;
+  }
+
+  return currencies[currencyCode];
+};
+
+export const makeMoneyString = ({
+  amount: inputAmount,
+  currencyCode,
+  rounded = false,
+  showCurrencyCode = false,
+}) => {
+  let amount = Number(inputAmount);
+  if (isNaN(amount)) {
+    console.error(new Error(`Invalid amount: ${inputAmount}. Falling back to 0.`));
+    amount = 0;
+  }
+
+  const currency = getCurrencyFromCurrencyCode(currencyCode);
+  const { minorUnit, symbol } = currency;
+
+  const decimalPlaces = rounded ? 0 : minorUnit;
+  const localeAmount = amount.toLocaleString(undefined, {
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces,
+  });
+  const currencyCodeString = showCurrencyCode ? ` ${currency.code}` : '';
+  return `${symbol}${localeAmount}${currencyCodeString}`;
+};

package/src/money.test.js

@@ -0,0 +1,99 @@
+const { currencies } = require('@becollective/constants');
+
+const { getCurrencyFromCurrencyCode, makeMoneyString } = require('../bundle.js');
+
+describe('getCurrencyFromCurrencyCode', () => {
+  test('Returns the correct currency', () => {
+    expect(getCurrencyFromCurrencyCode('AUD')).toMatchObject(currencies.AUD);
+    expect(getCurrencyFromCurrencyCode('NZD')).toMatchObject(currencies.NZD);
+    expect(getCurrencyFromCurrencyCode('GBP')).toMatchObject(currencies.GBP);
+  });
+
+  test('Returns AUD currency if currencyCode not found or invalid', () => {
+    const bogusCurrencyCodes = [
+      undefined,
+      1234,
+      'some junk that is not a currency code',
+      { foo: 'bar' },
+    ];
+    bogusCurrencyCodes.forEach(bogusCurrencyCode => {
+      expect(getCurrencyFromCurrencyCode(bogusCurrencyCode)).toMatchObject(currencies.AUD);
+    });
+  });
+});
+
+describe('makeMoneyString', () => {
+  test('Outputs a rounded money string', () => {
+    expect(
+      makeMoneyString({
+        amount: 123.05,
+        rounded: true,
+        currencyCode: 'AUD',
+      })
+    ).toEqual('$123');
+
+    expect(
+      makeMoneyString({
+        amount: 123.5,
+        rounded: true,
+        currencyCode: 'AUD',
+      })
+    ).toEqual('$124');
+
+    expect(
+      makeMoneyString({
+        amount: 123.95,
+        rounded: true,
+        currencyCode: 'AUD',
+      })
+    ).toEqual('$124');
+  });
+
+  test('Outputs a money string with currency code', () => {
+    expect(
+      makeMoneyString({
+        amount: 123.05,
+        currencyCode: 'NZD',
+        showCurrencyCode: true,
+      })
+    ).toEqual('$123.05 NZD');
+  });
+
+  test('Outputs a money string for AUD if bad input is provided', () => {
+    const bogusCurrencyCodes = [
+      undefined,
+      1234,
+      'some junk that is not a currency code',
+      { foo: 'bar' },
+    ];
+    bogusCurrencyCodes.forEach(bogusCurrencyCode => {
+      expect(
+        makeMoneyString({
+          amount: 123.05,
+          currencyCode: bogusCurrencyCode,
+          showCurrencyCode: true,
+        })
+      ).toEqual('$123.05 AUD');
+    });
+  });
+
+  test('Gracefully handles non-Number `amount` input', () => {
+    expect(
+      makeMoneyString({
+        amount: '100.25',
+        rounded: true,
+        currencyCode: 'GBP',
+      })
+    ).toEqual('£100');
+
+    const bogusAmountValues = [undefined, null, 'some junk that is not a number', { foo: 'bar' }];
+    bogusAmountValues.forEach(bogusAmountValue => {
+      expect(
+        makeMoneyString({
+          amount: bogusAmountValue,
+          currencyCode: 'GBP',
+        })
+      ).toEqual('£0.00');
+    });
+  });
+});

package/testUtils/setup.js

@@ -0,0 +1,21 @@
+process.env.NODE_ENV = 'localtest';
+
+let hasListened = false;
+if(!hasListened) {
+  hasListened = true;
+  process.on('unhandledRejection', (err) => {
+    console.debug(err.stack);
+  });
+}
+
+global.console = {
+  // These could be called in parts of the code for good reason but pollute the test output.
+  // So suppress the while testing.
+  // Ref: https://stackoverflow.com/questions/44467657/jest-better-way-to-disable-console-inside-unit-tests
+  log: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  // Use console.debug if you need to debug while testing
+  debug: console.debug,
+};

package/date-time.js

@@ -1,15 +0,0 @@
-const moment = require('moment');
-
-/**
- * Check if a user requires parent(guardian) consent
- * i.e. Is under the age of 16 years, based on GDPR
- * https://gdpr-info.eu/art-8-gdpr/
- * @param {*} dateOfBirth moment.js compatible date time
- */
-export const isUnderSixteen = dateOfBirth => {
-  const age = moment().diff(dateOfBirth, 'years');
-  if (isNaN(age)) {
-    throw new Error('Invalid date');
-  }
-  return age < 16;
-};

package/tests/isUnderSixteen.test.js

@@ -1,26 +0,0 @@
-const { isUnderSixteen } = require('../bundle.js');
-const moment = require('moment');
-
-describe('isUnderSixteen', () => {
-  const refPoint = moment().subtract(16, 'years');
-
-  test('Is not U16 if dob is 16 years ago', () => {
-    const dob = moment(refPoint);
-
-    expect(isUnderSixteen(dob.subtract(1, 'second').utc().format())).toBe(false);
-    expect(isUnderSixteen(dob.subtract(100, 'year').utc().format())).toBe(false);
-  });
-
-  test('Is U16 if dob is less than 16 years ago', () => {
-    const dob = moment(refPoint);
-
-    expect(isUnderSixteen(dob.add(1, 'second').utc().format())).toBe(true);
-    expect(isUnderSixteen(dob.add(100, 'year').utc().format())).toBe(true);
-  });
-
-  test('Throws Error if dob is not a valid date-string', () => {
-    expect(() => isUnderSixteen(notDefined)).toThrow(/not defined/);
-    expect(() => isUnderSixteen(null)).toThrow(/Invalid date/);
-    expect(() => isUnderSixteen('not-valid')).toThrow(/Invalid date/);
-  });
-});

package/tests/setup.js

@@ -1,9 +0,0 @@
-process.env.NODE_ENV = 'localtest';
-
-let hasListened = false;
-if(!hasListened) {
-  hasListened = true;
-  process.on('unhandledRejection', (err) => {
-    console.error(err.stack);
-  });
-}