flagsmith-nodejs 2.5.0 → 2.5.1

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) {
@@ -423,7 +429,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "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) => {
@@ -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/tests/engine/unit/utils/utils.test.ts

@@ -0,0 +1,62 @@
+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
+        console.log(objectIdPairs);
+        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

@@ -227,6 +227,23 @@ 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) {