flagsmith-nodejs 2.4.1 → 2.5.1

package/sdk/index.ts

@@ -14,6 +14,7 @@ import { generateIdentitiesData, retryFetch } from './utils';
 import { SegmentModel } from '../flagsmith-engine/segments/models';
 import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators';
 import { FlagsmithCache, FlagsmithConfig } from './types';
+import pino, { Logger } from "pino";
 
 export { AnalyticsProcessor } from './analytics';
 export { FlagsmithAPIError, FlagsmithClientError } from './errors';
@@ -49,6 +50,7 @@ export class Flagsmith {
     private cache?: FlagsmithCache;
     private onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
     private analyticsProcessor?: AnalyticsProcessor;
+    private logger: Logger;
     /**
      * A Flagsmith client.
      *
@@ -78,6 +80,7 @@ export class Flagsmith {
         @param data.defaultFlagHandler: callable which will be used in the case where
             flags cannot be retrieved from the API or a non existent feature is
             requested
+        @param data.logger: an instance of the pino Logger class to use for logging
      */
     constructor(data: FlagsmithConfig) {
         this.agent = data.agent;
@@ -97,6 +100,7 @@ export class Flagsmith {
         this.identitiesUrl = `${this.apiUrl}identities/`;
         this.environmentUrl = `${this.apiUrl}environment-document/`;
         this.onEnvironmentChange = data.onEnvironmentChange;
+        this.logger = data.logger || pino();
 
         if (!!data.cache) {
             const missingMethods: string[] = ['has', 'get', 'set'].filter(method => data.cache && !data.cache[method]);
@@ -129,7 +133,8 @@ export class Flagsmith {
             ? new AnalyticsProcessor({
                 environmentKey: this.environmentKey,
                 baseApiUrl: this.apiUrl,
-                requestTimeoutMs: this.requestTimeoutMs
+                requestTimeoutMs: this.requestTimeoutMs,
+                logger: this.logger
             })
             : undefined;
     }
@@ -168,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;
@@ -198,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) => {
@@ -324,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/types.ts

@@ -1,6 +1,7 @@
 import { DefaultFlag, Flags } from "./models";
 import { EnvironmentModel } from "../flagsmith-engine";
 import { RequestInit } from "node-fetch";
+import { Logger } from "pino";
 
 export interface FlagsmithCache {
   get(key: string): Promise<Flags|undefined> | undefined;
@@ -22,4 +23,5 @@ export interface FlagsmithConfig {
   defaultFlagHandler?: (featureName: string) => DefaultFlag;
   cache?: FlagsmithCache,
   onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void,
+  logger?: Logger
 }

package/tests/engine/unit/segments/segments_model.test.ts

@@ -89,16 +89,23 @@ const conditionMatchCases: [string, string | number | boolean, string, boolean][
     [CONDITION_OPERATORS.MODULO, 35.0, "4|3", true],
     [CONDITION_OPERATORS.MODULO, "foo", "4|3", false],
     [CONDITION_OPERATORS.MODULO, 35.0, "foo|bar", false],
+    [CONDITION_OPERATORS.IN, "foo", "", false],
+    [CONDITION_OPERATORS.IN, "foo", "foo, bar", true],
+    [CONDITION_OPERATORS.IN, "foo", "foo", true],
+    [CONDITION_OPERATORS.IN, 1, "1,2,3,4", true],
+    [CONDITION_OPERATORS.IN, 1, "", false],
+    [CONDITION_OPERATORS.IN, 1, "1", true],
     ['BAD_OP', 'a', 'a', false]
 ];
 
 test('test_segment_condition_matches_trait_value', () => {
     for (const testCase of conditionMatchCases) {
+        const [operator, traitValue, conditionValue, expectedResult] = testCase
         expect(
-            new SegmentConditionModel(testCase[0], testCase[2], 'foo').matchesTraitValue(
-                testCase[1]
+            new SegmentConditionModel(operator, conditionValue, 'foo').matchesTraitValue(
+                traitValue
             )
-        ).toBe(testCase[3]);
+        ).toBe(expectedResult);
     }
 });
 

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/analytics.test.ts

@@ -1,7 +1,8 @@
-jest.mock('node-fetch');
 import fetch from 'node-fetch';
 import { analyticsProcessor } from './utils';
 
+jest.mock('node-fetch', () => jest.fn());
+
 afterEach(() => {
     jest.clearAllMocks();
 });
@@ -52,3 +53,22 @@ test('test_analytics_processor_flush_early_exit_if_analytics_data_is_empty', asy
     await aP.flush();
     expect(fetch).not.toHaveBeenCalled();
 });
+
+
+test('errors in fetch sending analytics data are swallowed', async () => {
+    // Given
+    // we mock the fetch function to throw and error to mimick a network failure
+    (fetch as jest.MockedFunction<typeof fetch>).mockRejectedValue(new Error('some error'));
+
+    // and create the processor and track a feature so there is some analytics data
+    const processor = analyticsProcessor();
+    processor.trackFeature('myFeature');
+
+    // When
+    // we flush the data to trigger the call to fetch
+    await processor.flush();
+
+    // Then
+    // we expect that fetch was called but the exception was handled
+    expect(fetch).toHaveBeenCalled();
+})

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) {