flagsmith-nodejs 2.4.0 → 2.5.0

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;
     }
@@ -323,7 +328,8 @@ export class Flagsmith {
         const flags = Flags.fromFeatureStateModels({
             featureStates: featureStates,
             analyticsProcessor: this.analyticsProcessor,
-            defaultFlagHandler: this.defaultFlagHandler
+            defaultFlagHandler: this.defaultFlagHandler,
+            identityID: identityModel.djangoID || identityModel.identityUuid
         });
 
         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/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/data/environment.json

@@ -63,8 +63,30 @@
         "type": "STANDARD",
         "id": 1
       },
-      "segment_id": null,
+      "feature_segment": null,
       "enabled": true
+    },
+    {
+      "multivariate_feature_state_values": [
+        {
+          "percentage_allocation": 100,
+          "multivariate_feature_option": {
+            "value": "bar",
+            "id": 1
+          },
+          "mv_fs_value_uuid": "42d5cdf9-8ec9-4b8d-a3ca-fd43c64d5f05",
+          "id": 1
+        }
+      ],
+      "feature_state_value": "foo",
+      "feature": {
+        "name": "mv_feature",
+        "type": "MULTIVARIATE",
+        "id": 2
+      },
+      "feature_segment": null,
+      "featurestate_uuid": "96fc3503-09d7-48f1-a83b-2dc903d5c08a",
+      "enabled": false
     }
   ]
 }

package/tests/sdk/flagsmith-identity-flags.test.ts

@@ -27,7 +27,7 @@ test('test_get_identity_flags_calls_api_when_no_local_environment_no_traits', as
   expect(identityFlags[0].featureName).toBe('some_feature');
 });
 
-test('test_get_identity_flags_calls_api_when_local_environment_no_traits', async () => {
+test('test_get_identity_flags_uses_environment_when_local_environment_no_traits', async () => {
   // @ts-ignore
   fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
   const identifier = 'identifier';
@@ -138,3 +138,20 @@ test('test_default_flag_is_used_when_no_identity_flags_returned_and_no_custom_de
   expect(flag.enabled).toBe(false);
 });
 
+
+test('test_get_identity_flags_multivariate_value_with_local_evaluation_enabled', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+  const identifier = 'identifier';
+
+  const flg = flagsmith({
+      environmentKey: 'ser.key',
+      enableLocalEvaluation: true,
+
+  });
+
+  const identityFlags = (await flg.getIdentityFlags(identifier))
+
+  expect(identityFlags.getFeatureValue('mv_feature')).toBe('bar');
+  expect(identityFlags.isFeatureEnabled('mv_feature')).toBe(false);
+});

package/tests/sdk/flagsmith.test.ts

@@ -45,16 +45,11 @@ test('test_update_environment_sets_environment', async () => {
     await flg.updateEnvironment();
     expect(flg.environment).toBeDefined();
 
-    // @ts-ignore
-    flg.environment.featureStates[0].featurestateUUID = undefined;
-    // @ts-ignore
-    flg.environment.project.segments[0].featureStates[0].featurestateUUID = undefined;
-    // @ts-ignore
     const model = environmentModel(JSON.parse(environmentJSON()));
-    // @ts-ignore
-    model.featureStates[0].featurestateUUID = undefined;
-    // @ts-ignore
-    model.project.segments[0].featureStates[0].featurestateUUID = undefined;
+
+    wipeFeatureStateUUIDs(flg.environment)
+    wipeFeatureStateUUIDs(model)
+
     expect(flg.environment).toStrictEqual(model);
 });
 
@@ -231,3 +226,24 @@ test('test onEnvironmentChange is called after error', async () => {
 
     expect(callbackSpy).toBeCalled();
 });
+
+
+
+async function wipeFeatureStateUUIDs (enviromentModel: EnvironmentModel) {
+    // TODO: this has been pulled out of tests above as a helper function.
+    //  I'm not entirely sure why it's necessary, however, we should look to remove.
+    enviromentModel.featureStates.forEach(fs => {
+        // @ts-ignore
+        fs.featurestateUUID = undefined;
+        fs.multivariateFeatureStateValues.forEach(mvfsv => {
+            // @ts-ignore
+            mvfsv.mvFsValueUuid = undefined;
+        })
+    });
+    enviromentModel.project.segments.forEach(s => {
+        s.featureStates.forEach(fs => {
+            // @ts-ignore
+            fs.featurestateUUID = undefined;
+        })
+    })
+}