flagsmith-nodejs 2.0.0-beta.4 → 2.0.0-beta.7

package/flagsmith-engine/features/models.ts

@@ -79,10 +79,6 @@ export class FeatureStateModel {
         return this.value;
     }
 
-    get_feature_state_value() {
-        return this.getValue();
-    }
-
     getMultivariateValue(identityID: number | string) {
         const percentageValue = getHashedPercentateForObjIds([
             this.djangoID || this.featurestateUUID,

package/flagsmith-engine/identities/models.ts

@@ -37,7 +37,7 @@ export class IdentityModel {
         return `${env_key}_${identifier}`;
     }
 
-    update_traits(traits: TraitModel[]) {
+    updateTraits(traits: TraitModel[]) {
         const existingTraits: Map<string, TraitModel> = new Map();
         for (const trait of this.identityTraits) {
             existingTraits.set(trait.traitKey, trait);

package/flagsmith-engine/index.ts

@@ -79,7 +79,7 @@ export function getEnvironmentFeatureState(environment: EnvironmentModel, featur
     const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
 
     if (featuresStates.length === 0) {
-        throw new Error('Feature State Not Found');
+        throw new FeatureStateNotFound('Feature State Not Found');
     }
 
     return featuresStates[0];

package/flagsmith-engine/organisations/models.ts

@@ -19,7 +19,7 @@ export class OrganisationModel {
         this.persistTraitData = persistTraitData;
     }
 
-    get unique_slug() {
+    get uniqueSlug() {
         return this.id.toString() + '-' + this.name;
     }
 }

package/flagsmith-engine/segments/models.ts

@@ -23,8 +23,6 @@ export const matchingFunctions = {
     [CONDITION_OPERATORS.NOT_EQUAL]: (thisValue: any, otherValue: any) => thisValue != otherValue,
     [CONDITION_OPERATORS.CONTAINS]: (thisValue: any, otherValue: any) =>
         otherValue.includes(thisValue),
-    [CONDITION_OPERATORS.NOT_CONTAINS]: (thisValue: any, otherValue: any) =>
-        !otherValue.includes(thisValue)
 };
 
 export class SegmentConditionModel {

package/flagsmith-engine/utils/collections.ts

@@ -1,14 +1,3 @@
 import { FeatureStateModel } from '../features/models';
 
-export class IdentityFeaturesList extends Array<FeatureStateModel> {
-    public push(...e: FeatureStateModel[]): number {
-        for (const [_, item] of e.entries()) {
-            for (const [k, v] of this.entries()) {
-                if (v.djangoID === item.djangoID) {
-                    throw new Error('feature state for this feature already exists');
-                }
-            }
-        }
-        return super.push(...e);
-    }
-}
+export class IdentityFeaturesList extends Array<FeatureStateModel> {}

package/flagsmith-engine/utils/hashing/index.ts

@@ -39,12 +39,15 @@ function h2d(s: any): string {
  * @returns number number between 0 (inclusive) and 100 (exclusive)
  */
 export function getHashedPercentateForObjIds(objectIds: Array<any>, iterations = 1): number {
-    let to_hash = makeRepeated(objectIds, iterations).join(',');
-    const hashedValue = md5(to_hash);
+    let toHash = makeRepeated(objectIds, iterations).join(',');
+    const hashedValue = md5(toHash);
     const hashedInt = bigInt(h2d(hashedValue));
     const value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
 
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
     if (value === 100) {
+        /* istanbul ignore next */
         return getHashedPercentateForObjIds(objectIds, iterations + 1);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.7",
   "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": {
@@ -46,6 +46,7 @@
     "test:watch": "jest --coverage --watch --coverageReporters='text'",
     "test:debug": "node --inspect-brk node_modules/.bin/jest --coverage --watch --coverageReporters='text'",
     "build": "tsc",
+    "prepublish": "npm run build",
     "prepare": "husky install"
   },
   "dependencies": {
@@ -66,4 +67,4 @@
     "ts-jest": "^27.1.3",
     "typescript": "^4.6.2"
   }
-}
+}

package/sdk/analytics.ts

@@ -5,8 +5,6 @@ const ANALYTICS_ENDPOINT = 'analytics/flags/';
 // Used to control how often we send data(in seconds)
 const ANALYTICS_TIMER = 10;
 
-const delay = (ms: number) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
-
 export class AnalyticsProcessor {
     private analyticsEndpoint: string;
     private environmentKey: string;

package/sdk/index.ts

@@ -12,6 +12,7 @@ import { EnvironmentDataPollingManager } from './polling_manager';
 import { generateIdentitiesData, retryFetch } from './utils';
 import { SegmentModel } from '../flagsmith-engine/segments/models';
 import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators';
+import { FlagsmithCache } from './types';
 
 const DEFAULT_API_URL = 'https://api.flagsmith.com/api/v1/';
 
@@ -26,12 +27,16 @@ export class Flagsmith {
     enableAnalytics: boolean = false;
     defaultFlagHandler?: (featureName: string) => DefaultFlag;
 
+
     environmentFlagsUrl: string;
     identitiesUrl: string;
     environmentUrl: string;
 
     environmentDataPollingManager?: EnvironmentDataPollingManager;
     environment!: EnvironmentModel;
+
+    private cache?: FlagsmithCache;
+    private onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
     private analyticsProcessor?: AnalyticsProcessor;
     /**
      * A Flagsmith client.
@@ -73,6 +78,8 @@ export class Flagsmith {
         retries?: number;
         enableAnalytics?: boolean;
         defaultFlagHandler?: (featureName: string) => DefaultFlag;
+        cache?: FlagsmithCache,
+        onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void,
     }) {
         this.environmentKey = data.environmentKey;
         this.apiUrl = data.apiUrl || this.apiUrl;
@@ -88,6 +95,20 @@ export class Flagsmith {
         this.environmentFlagsUrl = `${this.apiUrl}flags/`;
         this.identitiesUrl = `${this.apiUrl}identities/`;
         this.environmentUrl = `${this.apiUrl}environment-document/`;
+        this.onEnvironmentChange = data.onEnvironmentChange;
+
+        if (!!data.cache) {
+            const missingMethods: string[] = ['has', 'get', 'set'].filter(method => data.cache && !data.cache[method]);
+
+            if (missingMethods.length > 0) {
+                throw new Error(
+                    `Please implement the following methods in your cache: ${missingMethods.join(
+                        ', '
+                    )}`
+                );
+            }
+            this.cache = data.cache;
+        }
 
         if (this.enableLocalEvaluation) {
             if (!this.environmentKey.startsWith('ser.')) {
@@ -105,10 +126,10 @@ export class Flagsmith {
 
         this.analyticsProcessor = data.enableAnalytics
             ? new AnalyticsProcessor({
-                  environmentKey: this.environmentKey,
-                  baseApiUrl: this.apiUrl,
-                  timeout: this.requestTimeoutSeconds
-              })
+                environmentKey: this.environmentKey,
+                baseApiUrl: this.apiUrl,
+                timeout: this.requestTimeoutSeconds
+            })
             : undefined;
     }
     /**
@@ -117,8 +138,19 @@ export class Flagsmith {
      * @returns Flags object holding all the flags for the current environment.
      */
     async getEnvironmentFlags(): Promise<Flags> {
+        const cachedItem = !!this.cache && await this.cache.get(`flags`);
+        if (!!cachedItem) {
+            return cachedItem;
+        }
+        if (this.enableLocalEvaluation) {
+            return new Promise(resolve =>
+                this.environmentPromise!.then(() => {
+                    resolve(this.getEnvironmentFlagsFromDocument());
+                })
+            );
+        }
         if (this.environment) {
-            return new Promise(resolve => resolve(this.getEnvironmentFlagsFromDocument()));
+            return this.getEnvironmentFlagsFromDocument();
         }
 
         return this.getEnvironmentFlagsFromApi();
@@ -134,7 +166,11 @@ export class Flagsmith {
             Flagsmith, e.g. {"num_orders": 10}
      * @returns Flags object holding all the flags for the given identity.
      */
-    getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+    async getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+        const cachedItem = !!this.cache && await this.cache.get(`flags-${identifier}`);
+        if (!!cachedItem) {
+            return cachedItem;
+        }
         traits = traits || {};
         if (this.enableLocalEvaluation) {
             return new Promise(resolve =>
@@ -188,14 +224,23 @@ export class Flagsmith {
      * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
      */
     async updateEnvironment() {
-        const request = this.getEnvironmentFromApi();
-        if (!this.environmentPromise) {
-            this.environmentPromise = request.then(res => {
-                this.environment = res;
-            });
-            await this.environmentPromise;
-        } else {
-            this.environment = await request;
+        try {
+            const request = this.getEnvironmentFromApi();
+            if (!this.environmentPromise) {
+                this.environmentPromise = request.then(res => {
+                    this.environment = res;
+                });
+                await this.environmentPromise;
+            } else {
+                this.environment = await request;
+            }
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(null, this.environment);
+            }
+        } catch (e) {
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(e as Error, this.environment);
+            }
         }
     }
 
@@ -247,15 +292,19 @@ export class Flagsmith {
         return buildEnvironmentModel(environment_data);
     }
 
-    private getEnvironmentFlagsFromDocument() {
-        return Flags.fromFeatureStateModels({
+    private async getEnvironmentFlagsFromDocument(): Promise<Flags> {
+        const flags = Flags.fromFeatureStateModels({
             featureStates: getEnvironmentFeatureStates(this.environment),
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler
         });
+        if (!!this.cache) {
+            await this.cache.set('flags', flags);
+        }
+        return flags;
     }
 
-    private getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }) {
+    private async getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }): Promise<Flags> {
         const identityModel = this.buildIdentityModel(
             identifier,
             Object.keys(traits).map(key => ({
@@ -266,21 +315,31 @@ export class Flagsmith {
 
         const featureStates = getIdentityFeatureStates(this.environment, identityModel);
 
-        return Flags.fromFeatureStateModels({
+        const flags = Flags.fromFeatureStateModels({
             featureStates: featureStates,
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler
         });
+
+        if (!!this.cache) {
+            await this.cache.set(`flags-${identifier}`, flags);
+        }
+
+        return flags;
     }
 
     private async getEnvironmentFlagsFromApi() {
         try {
             const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
-            return Flags.fromAPIFlags({
+            const flags = Flags.fromAPIFlags({
                 apiFlags: apiFlags,
                 analyticsProcessor: this.analyticsProcessor,
                 defaultFlagHandler: this.defaultFlagHandler
             });
+            if (!!this.cache) {
+                await this.cache.set('flags', flags);
+            }
+            return flags;
         } catch (e) {
             if (this.defaultFlagHandler) {
                 return new Flags({
@@ -297,11 +356,15 @@ export class Flagsmith {
         try {
             const data = generateIdentitiesData(identifier, traits);
             const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
-            return Flags.fromAPIFlags({
+            const flags = Flags.fromAPIFlags({
                 apiFlags: jsonResponse['flags'],
                 analyticsProcessor: this.analyticsProcessor,
                 defaultFlagHandler: this.defaultFlagHandler
             });
+            if (!!this.cache) {
+                await this.cache.set(`flags-${identifier}`, flags);
+            }
+            return flags;
         } catch (e) {
             if (this.defaultFlagHandler) {
                 return new Flags({
@@ -315,12 +378,6 @@ export class Flagsmith {
     }
 
     private buildIdentityModel(identifier: string, traits: { key: string; value: any }[]) {
-        if (!this.environment) {
-            throw new FlagsmithClientError(
-                'Unable to build identity model when no local environment present.'
-            );
-        }
-
         const traitModels = traits.map(trait => new TraitModel(trait.key, trait.value));
         return new IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
     }

package/sdk/polling_manager.ts

@@ -17,7 +17,6 @@ export class EnvironmentDataPollingManager {
                 await this.main.updateEnvironment();
             }, this.refreshIntervalSeconds * 1000);
         };
-        // todo: this call should be awaited for getIdentityFlags/getEnvironmentFlags when enableLocalEvaluation is true
         this.main.updateEnvironment();
         updateEnvironment();
     }

package/sdk/types.ts

@@ -0,0 +1,8 @@
+import { Flags } from "./models";
+
+export interface FlagsmithCache {
+  get(key: string): Promise<Flags>;
+  set(key: string, value: Flags): Promise<void>;
+  has(key: string): Promise<boolean>;
+  [key: string]: any;
+}

package/tests/engine/unit/{egine.test.ts → engine.test.ts}

@@ -25,6 +25,12 @@ test('test_identity_get_feature_state_without_any_override', () => {
     expect(feature_state.feature).toStrictEqual(feature1());
 });
 
+test('test_identity_get_feature_state_without_any_override_no_fs', () => {
+    expect(() => {
+        getIdentityFeatureState(environment(), identity(), 'nonExistentName');
+    }).toThrowError('Feature State Not Found');
+});
+
 test('test_identity_get_all_feature_states_no_segments', () => {
     const env = environment();
     const ident = identity();
@@ -61,6 +67,20 @@ test('test_identity_get_all_feature_states_with_traits', () => {
     expect(featureStates[0].getValue()).toBe('segment_override');
 });
 
+test('test_identity_get_all_feature_states_with_traits_hideDisabledFlags', () => {
+    const trait_models = new TraitModel(segmentConditionProperty, segmentConditionStringValue);
+
+    const env = environmentWithSegmentOverride();
+    env.project.hideDisabledFlags = true;
+
+    const featureStates = getIdentityFeatureStates(
+        env,
+        identityInSegment(),
+        [trait_models]
+    );
+    expect(featureStates.length).toBe(0);
+});
+
 test('test_environment_get_all_feature_states', () => {
     const env = environment();
     const featureStates = getEnvironmentFeatureStates(env);

package/tests/engine/unit/features/models.test.ts

@@ -7,6 +7,12 @@ import {
 } from '../../../../flagsmith-engine/features/models';
 import { feature1 } from '../utils';
 
+test('test_compare_feature_model', () => {
+    const fm1 = new FeatureModel(1, 'a', 'test');
+    const fm2 = new FeatureModel(1, 'a', 'test');
+    expect(fm1.eq(fm2)).toBe(true);
+});
+
 test('test_initializing_feature_state_creates_default_feature_state_uuid', () => {
     const featureState = new FeatureStateModel(feature1(), true, 1);
     expect(featureState.featurestateUUID).toBeDefined();
@@ -65,8 +71,6 @@ test('test_feature_state_get_value_mv_values', () => {
 
         mvFeatureState.setValue(mvFeatureControlValue);
 
-        // TODO
-        // expect(mvFeatureState.getValue(3)).toBe(testCase[1]);
-        expect(1).toBe(1);
+        expect(mvFeatureState.getValue("test")).toBe(mvFeatureValue2);
     }
 });

package/tests/engine/unit/identities/identities_builders.test.ts

@@ -42,6 +42,19 @@ test('test_build_identity_model_from_dictionary_uses_identity_feature_list_for_i
     expect(identityModel.identityFeatures?.length).toBe(1);
 });
 
+test('test_build_identity_model_from_dictionary_uses_identity_feature_list_for_identity_features', () => {
+    const identity_dict = {
+        id: 1,
+        identifier: 'test-identity',
+        environment_api_key: 'api-key',
+        created_date: '2021-08-22T06:25:23.406995Z',
+    };
+
+    const identityModel = buildIdentityModel(identity_dict);
+
+    expect(identityModel.identityFeatures?.length).toBe(0);
+});
+
 test('test_build_build_identity_model_from_dict_creates_identity_uuid', () => {
     const identity_model = buildIdentityModel({
         identifier: 'test_user',

package/tests/engine/unit/identities/identities_models.test.ts

@@ -54,7 +54,7 @@ test('test_update_traits_remove_traits_with_none_value', () => {
     const trait_key = ident.identityTraits[0].traitKey;
     const trait_to_remove = new TraitModel(trait_key, undefined);
 
-    ident.update_traits([trait_to_remove]);
+    ident.updateTraits([trait_to_remove]);
 
     expect(ident.identityTraits.length).toBe(0);
 });
@@ -66,7 +66,7 @@ test('test_update_identity_traits_updates_trait_value', () => {
     const traitValue = 'updated_trait_value';
     const traitToUpdate = new TraitModel(traitKey, traitValue);
 
-    identity.update_traits([traitToUpdate]);
+    identity.updateTraits([traitToUpdate]);
 
     expect(identity.identityTraits.length).toBe(1);
     expect(identity.identityTraits[0]).toBe(traitToUpdate);
@@ -77,7 +77,7 @@ test('test_update_traits_adds_new_traits', () => {
 
     const newTrait = new TraitModel('new_key', 'foobar');
 
-    identity.update_traits([newTrait]);
+    identity.updateTraits([newTrait]);
 
     expect(identity.identityTraits.length).toBe(2);
     expect(identity.identityTraits).toContain(newTrait);
@@ -92,14 +92,3 @@ test('test_append_feature_state', () => {
 
     expect(ident.identityFeatures).toContain(fs1);
 });
-
-test('test_appending_feature_states_raises_duplicate_feature_state_if_fs_for_the_feature_already_exists', () => {
-    const ident = identityInSegment();
-
-    const fs1 = new FeatureStateModel(feature1(), false, 1);
-    const fs2 = new FeatureStateModel(feature1(), true, 1);
-    ident.identityFeatures.push(fs1);
-    expect(() => {
-        ident.identityFeatures.push(fs2);
-    }).toThrowError();
-});

package/tests/engine/unit/organization/models.test.ts

@@ -8,5 +8,5 @@ test('Test builder', () => {
         stop_serving_flags: false,
         id: 13
     });
-    expect(model.unique_slug).toBe('13-Flagsmith');
+    expect(model.uniqueSlug).toBe('13-Flagsmith');
 });

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

@@ -61,7 +61,8 @@ const conditionMatchCases: [string, string | number | boolean, string, boolean][
     [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'bar', false],
     [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'baz', true],
     [CONDITION_OPERATORS.REGEX, 'foo', '[a-z]+', true],
-    [CONDITION_OPERATORS.REGEX, 'FOO', '[a-z]+', false]
+    [CONDITION_OPERATORS.REGEX, 'FOO', '[a-z]+', false],
+    ['BAD_OP', 'a', 'a', false]
 ];
 
 test('test_segment_condition_matches_trait_value', () => {

package/tests/engine/unit/utils.ts

@@ -87,7 +87,7 @@ export function getEnvironmentFeatureStateForFeatureByName(
     feature_name: string
 ): FeatureStateModel | undefined {
     const features = environment.featureStates.filter(fs => fs.feature.name === feature_name);
-    return features.length > 0 ? features[0] : undefined;
+    return features[0];
 }
 
 export function getEnvironmentFeatureStateForFeature(

package/tests/sdk/analytics.test.ts

@@ -36,6 +36,17 @@ test('test_analytics_processor_flush_post_request_data_match_ananlytics_data', a
     });
 });
 
+jest.useFakeTimers()
+test('test_analytics_processor_flush_post_request_data_match_ananlytics_data_test', async () => {
+    const aP = analyticsProcessor();
+    aP.trackFeature(1);
+    setTimeout(() => {
+        aP.trackFeature(2);
+        expect(fetch).toHaveBeenCalledTimes(1);
+    }, 15000);
+    jest.runOnlyPendingTimers();
+});
+
 test('test_analytics_processor_flush_early_exit_if_analytics_data_is_empty', async () => {
     const aP = analyticsProcessor();
     await aP.flush();