@becollective/utils 1.5.5 → 1.7.1

package/index.js

@@ -1,10 +1,15 @@
 import { password } from './src/password';
-import { isUnderSixteen, getAge, datesByThemselves, getShiftText } from './src/date-time';
+import {
+  isUnderSixteen,
+  getAge,
+  datesByThemselves,
+  getShiftText,
+} from './src/date-time';
 import { getCurrencyFromCurrencyCode, makeMoneyString } from './src/money';
 import { readableOpportunityType } from './src/opportunity';
 import { getTimeInfo } from './src/opportunityUser';
 import { getHomeLocalityFromLocationList } from './src/locality';
-
+import FeatureFlag from './src/FeatureFlag';
 const util = {
   getAge,
   getCurrencyFromCurrencyCode,
@@ -18,6 +23,7 @@ const util = {
   getTimeInfo,
   getHomeLocalityFromLocationList,
   getShiftText,
+  FeatureFlag,
 };
 
 module.exports = util;

package/jestconfig.json

@@ -0,0 +1,11 @@
+{
+  "transform": {
+    "^.+\\.(t|j)sx?$": "ts-jest"
+  },
+  "testRegex": "(/tests/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+  "moduleFileExtensions": ["ts", "tsx", "js", "jsx", "json", "node"],
+  "collectCoverage": true,
+  "setupFiles": [
+    "./setup.ts"
+  ]
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@becollective/utils",
-  "version": "1.5.5",
+  "version": "1.7.1",
   "description": "Common utilities",
   "main": "bundle.js",
   "scripts": {
-    "test": "NODE_ENV=localtest npm run build && ./node_modules/.bin/jest",
+    "test": "NODE_ENV=localtest jest --config jestconfig.json --detectOpenHandles --verbose --forceExit",
     "build": "rollup -c",
     "prepare": "npm run build"
   },
@@ -13,23 +13,28 @@
   "devDependencies": {
     "@babel/core": "^7.1.6",
     "@babel/preset-env": "^7.1.6",
-    "jest": "^23.6.0",
-    "rollup": "^0.67.1",
+    "@rollup/plugin-commonjs": "^18.1.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-typescript": "^8.2.1",
+    "@types/jest": "^24.0.19",
+    "@types/mongodb": "^3.5.16",
+    "@types/node": "^15.0.1",
+    "@types/pino": "^5.8.12",
+    "jest": "^24.9.0",
+    "prettier": "^1.18.2",
+    "rollup": "^2.47.0",
     "rollup-plugin-babel": "^4.0.3",
-    "rollup-plugin-node-resolve": "^3.4.0"
+    "rollup-plugin-node-resolve": "^3.4.0",
+    "ts-jest": "^24.3.0",
+    "tslint": "^5.20.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^3.6.4"
   },
   "dependencies": {
     "@becollective/constants": "^3.11.0",
+    "axios": "^0.21.1",
     "lodash": "^4.17.15",
     "moment": "^2.24.0",
     "moment-timezone": "^0.5.26"
-  },
-  "jest": {
-    "testMatch": [
-      "**/*.test.js"
-    ],
-    "setupFiles": [
-      "./testUtils/setup.js"
-    ]
   }
 }

package/rollup.config.js

@@ -1,5 +1,8 @@
 import resolve from 'rollup-plugin-node-resolve';
 import babel from 'rollup-plugin-babel';
+import typescript from '@rollup/plugin-typescript';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
 
 export default {
   input: 'index.js',
@@ -8,6 +11,9 @@ export default {
     format: 'cjs'
   },
   plugins: [
+    json(),
+    commonjs(),
+    typescript(),
     resolve(),
     babel({
       exclude: 'node_modules/**', // only transpile our source code

package/setup.ts

@@ -0,0 +1,7 @@
+// Jest will set NODE_ENV to "test" if not specified
+if (
+  process.env.NODE_ENV !== 'compose' &&
+  process.env.NODE_ENV !== 'localtest'
+) {
+  process.env.NODE_ENV = 'localtest';
+}

package/src/FeatureFlag.ts

@@ -0,0 +1,50 @@
+import axios from 'axios';
+import { memoize, get as lodashGet } from 'lodash';
+
+const fetchFeatureActive = async (
+  feature: string,
+  options: { env: string; region?: string },
+): Promise<boolean> => {
+  const getFlagByFeatureUrl = `https://lb-central.becollective.com/api/v2/feature-flags/${feature}`;
+  let isFeatureActive = false;
+  const featureFlags = await axios.get(getFlagByFeatureUrl);
+  const environments = lodashGet(featureFlags, 'data.Environments');
+  if (environments) {
+    isFeatureActive = environments.includes(options.env);
+  }
+  return isFeatureActive;
+};
+
+const memoizedFeatureActive = memoize(fetchFeatureActive, (feature, options) =>
+  JSON.stringify({ feature, options }),
+);
+
+class FeatureFlag {
+  ttl: number;
+  expiry: number;
+  constructor(ttl?) {
+    this.ttl = ttl || 1000 * 60 * 5; // default to 5 minutes
+    this.expiry = Date.now() + ttl;
+  }
+  async isFeatureActive(
+    feature: string,
+    options: { env: string; region?: string },
+  ): Promise<boolean> {
+    // Lazy expiration upon function call
+    const now = Date.now();
+    if (now >= this.expiry) {
+      memoizedFeatureActive.cache.clear();
+      this.expiry = now + this.ttl;
+    }
+    return await memoizedFeatureActive(feature, options);
+  }
+  clearCache() {
+    memoizedFeatureActive.cache.clear();
+  }
+  setCacheTtl(ttl: number) {
+    this.ttl = ttl;
+    this.expiry = Date.now() + ttl;
+  }
+}
+
+export default FeatureFlag;

package/tests/featureFlag.test.ts

@@ -0,0 +1,102 @@
+import axios from 'axios';
+import FeatureFlag from '../src/FeatureFlag';
+
+const featureFlag = new FeatureFlag();
+jest.mock('axios');
+const mockAxios = axios as jest.Mocked<typeof axios>;
+const feature = 'test-feature';
+
+describe('Make feature decision based on feature flags', () => {
+  test('should return true if feature is flagged active on localtest', async () => {
+    mockAxios.get.mockReturnValue(
+      Promise.resolve({
+        data: { Environments: ['localtest', 'compose'] },
+      }),
+    );
+    const isActive = await featureFlag.isFeatureActive(feature, {
+      env: 'localtest',
+    });
+    expect(isActive).toBe(true);
+  });
+  test('should return false if feature is NOT flagged active on localtest', async () => {
+    featureFlag.clearCache();
+    mockAxios.get.mockReturnValue(
+      Promise.resolve({
+        data: { Environments: ['dev-au'] },
+      }),
+    );
+    const isActive = await featureFlag.isFeatureActive(feature, {
+      env: 'localtest',
+    });
+    expect(isActive).toBe(false);
+  });
+  test('should return false if no result returned from feature flag', async () => {
+    featureFlag.clearCache();
+    mockAxios.get.mockReturnValue(Promise.resolve({}));
+    const isActive = await featureFlag.isFeatureActive(feature, {
+      env: 'localtest',
+    });
+    expect(isActive).toBe(false);
+  });
+  describe('Test caching', () => {
+    test('should return same result for same parameter without fetch api', async () => {
+      featureFlag.clearCache();
+      mockAxios.get.mockReturnValue(
+        Promise.resolve({
+          data: { Environments: ['localtest', 'compose'] },
+        }),
+      );
+      const isActive = await featureFlag.isFeatureActive(feature, {
+        env: 'localtest',
+      });
+      expect(mockAxios.get).toBeCalled();
+      expect(isActive).toBe(true);
+      mockAxios.get.mockClear();
+      const secondCallResult = await featureFlag.isFeatureActive(feature, {
+        env: 'localtest',
+      });
+      expect(mockAxios.get).not.toBeCalled();
+      expect(secondCallResult).toBe(true);
+    });
+    test('should fetch api after expiry', async () => {
+      featureFlag.clearCache();
+      featureFlag.setCacheTtl(0);
+      mockAxios.get.mockReturnValue(
+        Promise.resolve({
+          data: { Environments: ['localtest', 'compose'] },
+        }),
+      );
+      const isActive = await featureFlag.isFeatureActive(feature, {
+        env: 'localtest',
+      });
+      expect(mockAxios.get).toBeCalled();
+      expect(isActive).toBe(true);
+      mockAxios.get.mockClear();
+      const secondCallResult = await featureFlag.isFeatureActive(feature, {
+        env: 'localtest',
+      });
+      expect(mockAxios.get).toBeCalled();
+      expect(secondCallResult).toBe(true);
+    });
+    test('should fetch api for different parameter', async () => {
+      featureFlag.clearCache();
+      featureFlag.setCacheTtl(1000 * 60 * 5);
+      mockAxios.get.mockReturnValue(
+        Promise.resolve({
+          data: { Environments: ['localtest', 'compose'] },
+        }),
+      );
+      const isActive = await featureFlag.isFeatureActive(feature, {
+        env: 'localtest',
+      });
+      expect(mockAxios.get).toBeCalled();
+      expect(isActive).toBe(true);
+      mockAxios.get.mockClear();
+      const secondCallResult = await featureFlag.isFeatureActive(feature, {
+        env: 'compose',
+      });
+      expect(mockAxios.get).toBeCalled();
+      expect(secondCallResult).toBe(true);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "lib": ["es2017"],
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "sourceMap": true,
+    "target": "es2017",
+    "outDir": "lib"
+  },
+  "exclude": ["node_modules", "setup.ts"]
+}

package/tslint.json

@@ -0,0 +1,100 @@
+{
+  "extends": ["tslint:recommended", "tslint-config-prettier"],
+  "rules": {
+    "align": [
+      true,
+      "parameters",
+      "arguments",
+      "statements"
+    ],
+    "ban": false,
+    "class-name": true,
+    "comment-format": [
+      true,
+      "check-space"
+    ],
+    "curly": true,
+    "eofline": false,
+    "forin": true,
+    "indent": [ true, "spaces" ],
+    "interface-name": [true, "never-prefix"],
+    "jsdoc-format": true,
+    "jsx-no-lambda": false,
+    "jsx-no-multiline-js": false,
+    "label-position": true,
+    "max-line-length": [ true, 120 ],
+    "member-ordering": [
+      true,
+      {
+        "order": [
+          "public-before-private",
+          "static-before-instance",
+          "variables-before-functions"
+        ]
+      }
+    ],
+    "no-any": true,
+    "no-arg": true,
+    "no-bitwise": true,
+    "no-console": [
+      true,
+      "log",
+      "error",
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
+    "no-consecutive-blank-lines": true,
+    "no-construct": true,
+    "no-debugger": true,
+    "no-duplicate-variable": true,
+    "no-empty": true,
+    "no-eval": true,
+    "no-shadowed-variable": true,
+    "no-string-literal": true,
+    "no-switch-case-fall-through": true,
+    "no-trailing-whitespace": false,
+    "no-unused-expression": true,
+    "one-line": [
+      true,
+      "check-open-brace",
+      "check-whitespace"
+    ],
+    "quotemark": [true, "single", "jsx-double"],
+    "radix": true,
+    "semicolon": [true, "always"],
+    "switch-default": true,
+
+    "trailing-comma": [true, {"multiline": "always", "singleline": "never"}],
+
+    "triple-equals": [ true, "allow-null-check" ],
+    "typedef": [
+      true,
+      "parameter",
+      "property-declaration"
+    ],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }
+    ],
+    "variable-name": [true, "ban-keywords", "check-format", "allow-leading-underscore", "allow-pascal-case"],
+    "whitespace": [
+      true,
+      "check-branch",
+      "check-decl",
+      "check-module",
+      "check-operator",
+      "check-separator",
+      "check-type",
+      "check-typecast"
+    ]
+  }
+}

package/testUtils/setup.js

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