flagsmith-nodejs 2.5.0 → 2.5.2

package/build/sdk/index.js

@@ -223,6 +223,9 @@ var Flagsmith = /** @class */ (function () {
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
+                        if (!identifier) {
+                            throw new Error("`identifier` argument is missing or invalid.");
+                        }
                         _a = !!this.cache;
                         if (!_a) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.cache.get("flags-".concat(identifier))];
@@ -260,6 +263,9 @@ var Flagsmith = /** @class */ (function () {
      */
     Flagsmith.prototype.getIdentitySegments = function (identifier, traits) {
         var _this = this;
+        if (!identifier) {
+            throw new Error("`identifier` argument is missing or invalid.");
+        }
         traits = traits || {};
         if (this.enableLocalEvaluation) {
             return new Promise(function (resolve, reject) {
@@ -358,10 +364,9 @@ var Flagsmith = /** @class */ (function () {
                         return [4 /*yield*/, (0, utils_1.retryFetch)(url, {
                                 agent: this.agent,
                                 method: method,
-                                timeout: this.requestTimeoutMs || undefined,
                                 body: JSON.stringify(body),
                                 headers: headers
-                            }, this.retries)];
+                            }, this.retries, this.requestTimeoutMs || undefined)];
                     case 1:
                         data = _e.sent();
                         if (data.status !== 200) {
@@ -423,7 +428,7 @@ var Flagsmith = /** @class */ (function () {
                             featureStates: featureStates,
                             analyticsProcessor: this.analyticsProcessor,
                             defaultFlagHandler: this.defaultFlagHandler,
-                            identityID: identityModel.djangoID || identityModel.identityUuid
+                            identityID: identityModel.djangoID || identityModel.compositeKey
                         });
                         if (!!!this.cache) return [3 /*break*/, 2];
                         // @ts-ignore node-cache types are incorrect, ttl should be optional

package/build/sdk/utils.js

@@ -63,11 +63,8 @@ var retryFetch = function (url, fetchOptions, retries, timeout // set an overall
 ) {
     if (retries === void 0) { retries = 3; }
     return new Promise(function (resolve, reject) {
-        // check for timeout
-        if (timeout)
-            setTimeout(function () { return reject('error: timeout'); }, timeout);
-        var wrapper = function (n) {
-            (0, node_fetch_1.default)(url, fetchOptions)
+        var retryWrapper = function (n) {
+            requestWrapper()
                 .then(function (res) { return resolve(res); })
                 .catch(function (err) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -77,7 +74,7 @@ var retryFetch = function (url, fetchOptions, retries, timeout // set an overall
                             return [4 /*yield*/, (0, exports.delay)(1000)];
                         case 1:
                             _a.sent();
-                            wrapper(--n);
+                            retryWrapper(--n);
                             return [3 /*break*/, 3];
                         case 2:
                             reject(err);
@@ -87,7 +84,16 @@ var retryFetch = function (url, fetchOptions, retries, timeout // set an overall
                 });
             }); });
         };
-        wrapper(retries);
+        var requestWrapper = function () {
+            return new Promise(function (resolve, reject) {
+                if (timeout)
+                    setTimeout(function () { return reject('error: timeout'); }, timeout);
+                return (0, node_fetch_1.default)(url, fetchOptions)
+                    .then(function (res) { return resolve(res); })
+                    .catch(function (err) { return reject(err); });
+            });
+        };
+        retryWrapper(retries);
     });
 };
 exports.retryFetch = retryFetch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "description": "Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.",
   "main": "build/index.js",
   "repository": {

package/sdk/index.ts

@@ -173,6 +173,10 @@ export class Flagsmith {
      * @returns Flags object holding all the flags for the given identity.
      */
     async getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+        if (!identifier) {
+            throw new Error("`identifier` argument is missing or invalid.")
+        }
+
         const cachedItem = !!this.cache && await this.cache.get(`flags-${identifier}`);
         if (!!cachedItem) {
             return cachedItem;
@@ -203,6 +207,10 @@ export class Flagsmith {
         identifier: string,
         traits?: { [key: string]: any }
     ): Promise<SegmentModel[]> {
+        if (!identifier) {
+            throw new Error("`identifier` argument is missing or invalid.")
+        }
+
         traits = traits || {};
         if (this.enableLocalEvaluation) {
             return new Promise((resolve, reject) => {
@@ -275,11 +283,11 @@ export class Flagsmith {
             {
                 agent: this.agent,
                 method: method,
-                timeout: this.requestTimeoutMs || undefined,
                 body: JSON.stringify(body),
                 headers: headers
             },
-            this.retries
+            this.retries,
+            this.requestTimeoutMs || undefined,
         );
 
         if (data.status !== 200) {
@@ -329,7 +337,7 @@ export class Flagsmith {
             featureStates: featureStates,
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler,
-            identityID: identityModel.djangoID || identityModel.identityUuid
+            identityID: identityModel.djangoID || identityModel.compositeKey
         });
 
         if (!!this.cache) {

package/sdk/utils.ts

@@ -23,22 +23,28 @@ export const retryFetch = (
     timeout?: number // set an overall timeout for this function
 ): Promise<Response> => {
     return new Promise((resolve, reject) => {
-        // check for timeout
-        if (timeout) setTimeout(() => reject('error: timeout'), timeout);
-
-        const wrapper = (n: number) => {
-            fetch(url, fetchOptions)
+        const retryWrapper = (n: number) => {
+            requestWrapper()
                 .then(res => resolve(res))
                 .catch(async err => {
                     if (n > 0) {
                         await delay(1000);
-                        wrapper(--n);
+                        retryWrapper(--n);
                     } else {
                         reject(err);
                     }
                 });
         };
 
-        wrapper(retries);
+        const requestWrapper = (): Promise<Response> => {
+            return new Promise((resolve, reject) => {
+                if (timeout) setTimeout(() => reject('error: timeout'), timeout);
+                return fetch(url, fetchOptions)
+                    .then(res => resolve(res))
+                    .catch(err => reject(err))
+            })
+        }
+
+        retryWrapper(retries);
     });
 };

package/tests/engine/unit/utils/utils.test.ts

@@ -0,0 +1,61 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing';
+
+describe('getHashedPercentageForObjIds', () => {
+    it.each([
+        [[12, 93]],
+        [[uuidv4(), 99]],
+        [[99, uuidv4()]],
+        [[uuidv4(), uuidv4()]]
+    ])('returns x where 0 <= x < 100', (objIds: (string|number)[]) => {
+        let result = getHashedPercentateForObjIds(objIds);
+        expect(result).toBeLessThan(100);
+        expect(result).toBeGreaterThanOrEqual(0);
+    });
+
+    it.each([
+        [[12, 93]],
+        [[uuidv4(), 99]],
+        [[99, uuidv4()]],
+        [[uuidv4(), uuidv4()]]
+    ])('returns the same value each time', (objIds: (string|number)[]) => {
+        let resultOne = getHashedPercentateForObjIds(objIds);
+        let resultTwo = getHashedPercentateForObjIds(objIds);
+        expect(resultOne).toEqual(resultTwo);
+    })
+
+    it('is unique for different object ids', () => {
+        let resultOne = getHashedPercentateForObjIds([14, 106]);
+        let resultTwo = getHashedPercentateForObjIds([53, 200]);
+        expect(resultOne).not.toEqual(resultTwo);
+    })
+
+    it('is evenly distributed', () => {
+        // copied from python test here:
+        // https://github.com/Flagsmith/flagsmith-engine/blob/main/tests/unit/utils/test_utils_hashing.py#L56
+        const testSample = 500;
+        const numTestBuckets = 50;
+        const testBucketSize = Math.floor(testSample / numTestBuckets)
+        const errorFactor = 0.1
+
+        // Given
+        let objectIdPairs = Array.from(Array(testSample).keys()).flatMap(d => Array.from(Array(testSample).keys()).map(e => [d, e].flat()))
+
+        // When
+        let values = objectIdPairs.map((objIds) => getHashedPercentateForObjIds(objIds));
+
+        // Then
+        for (let i = 0; i++; i < numTestBuckets) {
+            let bucketStart = i * testBucketSize;
+            let bucketEnd = (i + 1) * testBucketSize;
+            let bucketValueLimit = Math.min(
+                (i + 1) / numTestBuckets + errorFactor + ((i + 1) / numTestBuckets),
+                1
+            )
+
+            for (let i = bucketStart; i++; i < bucketEnd) {
+                expect(values[i]).toBeLessThanOrEqual(bucketValueLimit);
+            }
+        }
+    })
+})

package/tests/sdk/flagsmith.test.ts

@@ -172,6 +172,27 @@ test('test_default_flag_used_after_multiple_API_errors', async () => {
     expect(flag.value).toBe(defaultFlag.value);
 });
 
+test('default flag handler used when timeout occurs', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(sleep(10000)));
+
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler,
+        requestTimeoutSeconds: 0.1,
+    });
+
+    const flags = await flg.getEnvironmentFlags();
+    const flag = flags.getFlag('some_feature');
+    expect(flag.isDefault).toBe(true);
+    expect(flag.enabled).toBe(defaultFlag.enabled);
+    expect(flag.value).toBe(defaultFlag.value);
+})
+
 test('test_throws_when_no_identity_flags_returned_due_to_error', async () => {
     // @ts-ignore
     fetch.mockReturnValue(Promise.resolve(new Response('bad data')));
@@ -227,6 +248,22 @@ test('test onEnvironmentChange is called after error', async () => {
     expect(callbackSpy).toBeCalled();
 });
 
+test('getIdentityFlags throws error if identifier is empty string', async () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key',
+    });
+
+    await expect(flagsmith.getIdentityFlags('')).rejects.toThrow('`identifier` argument is missing or invalid.');
+})
+
+
+test('getIdentitySegments throws error if identifier is empty string', () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key',
+    });
+
+    expect(() => { flagsmith.getIdentitySegments(''); }).toThrow('`identifier` argument is missing or invalid.');
+})
 
 
 async function wipeFeatureStateUUIDs (enviromentModel: EnvironmentModel) {
@@ -247,3 +284,9 @@ async function wipeFeatureStateUUIDs (enviromentModel: EnvironmentModel) {
         })
     })
 }
+
+function sleep(ms: number) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}