@becollective/utils 1.6.1 → 1.7.2

package/index.js

@@ -9,7 +9,7 @@ import { getCurrencyFromCurrencyCode, makeMoneyString } from './src/money';
 import { readableOpportunityType } from './src/opportunity';
 import { getTimeInfo } from './src/opportunityUser';
 import { getHomeLocalityFromLocationList } from './src/locality';
-import { isFeatureActive } from './src/featureDecision';
+import FeatureFlag from './src/FeatureFlag';
 const util = {
   getAge,
   getCurrencyFromCurrencyCode,
@@ -23,7 +23,7 @@ const util = {
   getTimeInfo,
   getHomeLocalityFromLocationList,
   getShiftText,
-  isFeatureActive,
+  FeatureFlag,
 };
 
 module.exports = util;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@becollective/utils",
-  "version": "1.6.1",
+  "version": "1.7.2",
   "description": "Common utilities",
   "main": "bundle.js",
   "scripts": {

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/src/password.js

@@ -11,7 +11,7 @@ export const password = {
   validate: (input) => {
     if(typeof input !== 'string') {
       throw new Error('not-string');
-    } else if(input.length < 8) {
+    } else if(input.length < 12) {
       throw new Error('invalid-length');
     }
 

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/tests/password.test.js

@@ -2,7 +2,7 @@ const util = require('../bundle.js');
 
 describe('password.valiate', () => {
   test('validate a valid password', async () => {
-    const password = 'Password123';
+    const password = 'Password123456';
     let result;
     try {
       result = util.password.validate(password);
@@ -18,13 +18,13 @@ describe('password.valiate', () => {
     }).toThrow('invalid-length');
   }, 1000);
   test('validate a one rule password', async () => {
-    const password = 'foobarab';
+    const password = 'foobarabpcip';
     expect(() => {
       util.password.validate(password);
     }).toThrow('invalid-minimum-rules');
   }, 1000);
   test('validate a two rule password', async () => {
-    const password = 'foobar123';
+    const password = 'foobarpcip123';
     expect(() => {
       util.password.validate(password);
     }).toThrow('invalid-minimum-rules');

package/src/featureDecision.ts

@@ -1,14 +0,0 @@
-import axios from 'axios';
-
-export const isFeatureActive = 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);
-  if (featureFlags && featureFlags.data && featureFlags.data.Environments) {
-    isFeatureActive = featureFlags.data.Environments.includes(options.env);
-  }
-  return isFeatureActive;
-};

package/tests/featureDecision.test.ts

@@ -1,38 +0,0 @@
-import { isFeatureActive } from '../src/featureDecision';
-import axios from 'axios';
-
-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 isFeatureActive(feature, {
-      env: 'localtest',
-    });
-    expect(isActive).toBe(true);
-  });
-  test('should return false if feature is NOT flagged active on localtest', async () => {
-    mockAxios.get.mockReturnValue(
-      Promise.resolve({
-        data: { Environments: ['dev-au'] },
-      }),
-    );
-    const isActive = await isFeatureActive(feature, {
-      env: 'localtest',
-    });
-    expect(isActive).toBe(false);
-  });
-  test('should return false if no result returned from feature flag', async () => {
-    mockAxios.get.mockReturnValue(Promise.resolve({}));
-    const isActive = await isFeatureActive(feature, {
-      env: 'localtest',
-    });
-    expect(isActive).toBe(false);
-  });
-});