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

package/example/package.json

@@ -15,6 +15,7 @@
     "npm": "3.10.x"
   },
   "dependencies": {
+    "flagsmith-nodejs": "^2.0.0-beta.1",
     "node-cache": "^5.1.2",
     "ssg-node-express": "4.16.4",
     "ssg-util": "0.0.3"

package/example/server/api/index.js

@@ -1,14 +1,16 @@
 const Router = require('express').Router;
-const { Flagsmith } = require('../../../build/sdk');
-const environmentKey = ""
-if(!environmentKey) {
-    throw new Error("Please generate a Server Side SDK Key in environment settings to run the example")
+const Flagsmith = require('../../../build');
+const environmentKey = '';
+if (!environmentKey) {
+    throw new Error(
+        'Please generate a Server Side SDK Key in environment settings to run the example'
+    );
 }
 const flagsmith = new Flagsmith({
     environmentKey,
     enableLocalEvaluation: true,
-    defaultFlagHandler: (str)=> {
-        return {enabled:false, isDefault:true, value:null}
+    defaultFlagHandler: str => {
+        return { enabled: false, isDefault: true, value: null };
     }
 });
 
@@ -21,11 +23,16 @@ module.exports = () => {
     });
 
     api.get('/:user', async (req, res) => {
-        const flags = await flagsmith.getIdentityFlags(req.params.user, {checkout_v2: 1});
+        const flags = await flagsmith.getIdentityFlags(req.params.user, { checkout_v2: 1 });
         const fontSize = flags.getFeatureValue('font_size');
         const checkoutV2 = flags.isFeatureEnabled('checkout_v2');
         res.json({ fontSize, checkoutV2 });
     });
 
+    api.get('/:user/segments', async (req, res) => {
+        const segments = await flagsmith.getIdentitySegments(req.params.user, { checkout_v2: 1 });
+        res.json(segments.map(v => v.name));
+    });
+
     return api;
 };

package/example/server/index.js

@@ -22,5 +22,8 @@ console.log('To get an example response for getFlags');
 console.log();
 console.log('Go to http://localhost:' + PORT + '/api/flagsmith_sample_user');
 console.log('To get an example feature state for a user');
+console.log();
+console.log('Go to http://localhost:' + PORT + '/api/flagsmith_sample_user/segments');
+console.log('To get the segments which the user belongs to');
 
 module.exports = app;

package/flagsmith-engine/environments/models.ts

@@ -14,17 +14,17 @@ export class EnvironmentAPIKeyModel {
     constructor(
         id: number,
         key: string,
-        created_at: number,
+        createdAt: number,
         name: string,
-        client_api_key: string,
-        expires_at?: number
+        clientApiKey: string,
+        expiresAt?: number
     ) {
         this.id = id;
         this.key = key;
-        this.createdAt = created_at;
+        this.createdAt = createdAt;
         this.name = name;
-        this.clientApiKey = client_api_key;
-        this.expiresAt = expires_at;
+        this.clientApiKey = clientApiKey;
+        this.expiresAt = expiresAt;
     }
 
     isValid() {
@@ -42,9 +42,9 @@ export class EnvironmentModel {
     mixpanel_config?: IntegrationModel;
     heap_config?: IntegrationModel;
 
-    constructor(id: number, api_key: string, project: ProjectModel) {
+    constructor(id: number, apiKey: string, project: ProjectModel) {
         this.id = id;
-        this.apiKey = api_key;
+        this.apiKey = apiKey;
         this.project = project;
     }
 }

package/flagsmith-engine/features/models.ts

@@ -51,7 +51,7 @@ export class FeatureStateModel {
     enabled: boolean;
     djangoID: number;
     featurestateUUID: string = uuidv4();
-    _value: any;
+    private value: any;
     multivariateFeatureStateValues: MultivariateFeatureStateValueModel[] = [];
 
     constructor(
@@ -59,24 +59,24 @@ export class FeatureStateModel {
         enabled: boolean,
         djangoID: number,
         value?: any,
-        featurestate_uuid: string = uuidv4()
+        featurestateUuid: string = uuidv4()
     ) {
         this.feature = feature;
         this.enabled = enabled;
         this.djangoID = djangoID;
-        this._value = value;
-        this.featurestateUUID = featurestate_uuid;
+        this.value = value;
+        this.featurestateUUID = featurestateUuid;
     }
 
     setValue(value: any) {
-        this._value = value;
+        this.value = value;
     }
 
     getValue(identityId?: number | string) {
         if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
             return this.getMultivariateValue(identityId);
         }
-        return this._value;
+        return this.value;
     }
 
     get_feature_state_value() {
@@ -100,6 +100,6 @@ export class FeatureStateModel {
             }
             startPercentage = limit;
         }
-        return this._value;
+        return this.value;
     }
 }

package/flagsmith-engine/identities/models.ts

@@ -15,17 +15,17 @@ export class IdentityModel {
 
     constructor(
         created_date: string,
-        identity_traits: TraitModel[],
-        identity_features: IdentityFeaturesList,
-        environment_api_key: string,
+        identityTraits: TraitModel[],
+        identityFeatures: IdentityFeaturesList,
+        environmentApiKey: string,
         identifier: string,
-        identity_uuid?: string
+        identityUuid?: string
     ) {
-        this.identityUuid = identity_uuid || uuidv4();
+        this.identityUuid = identityUuid || uuidv4();
         this.createdDate = Date.parse(created_date) || Date.now();
-        this.identityTraits = identity_traits;
-        this.identityFeatures = new IdentityFeaturesList(...identity_features);
-        this.environmentApiKey = environment_api_key;
+        this.identityTraits = identityTraits;
+        this.identityFeatures = new IdentityFeaturesList(...identityFeatures);
+        this.environmentApiKey = environmentApiKey;
         this.identifier = identifier;
     }
 

package/flagsmith-engine/identities/util.ts

@@ -25,6 +25,6 @@ export function buildIdentityModel(identityJSON: any): IdentityModel {
         identityJSON.identity_uuid
     );
 
-    model.djangoID = identityJSON['django_id'];
+    model.djangoID = identityJSON.django_id;
     return model;
 }

package/flagsmith-engine/index.ts

@@ -4,56 +4,57 @@ import { IdentityModel } from './identities/models';
 import { TraitModel } from './identities/traits/models';
 import { getIdentitySegments } from './segments/evaluators';
 import { SegmentModel } from './segments/models';
+import { FeatureStateNotFound } from './utils/errors';
 
 function getIdentityFeatureStatesDict(
     environment: EnvironmentModel,
     identity: IdentityModel,
-    override_traits?: TraitModel[]
+    overrideTraits?: TraitModel[]
 ) {
     // Get feature states from the environment
-    const feature_states: { [key: number]: FeatureStateModel } = {};
+    const featureStates: { [key: number]: FeatureStateModel } = {};
     for (const fs of environment.featureStates) {
-        feature_states[fs.feature.id] = fs;
+        featureStates[fs.feature.id] = fs;
     }
 
     // Override with any feature states defined by matching segments
-    const identity_segments: SegmentModel[] = getIdentitySegments(
+    const identitySegments: SegmentModel[] = getIdentitySegments(
         environment,
         identity,
-        override_traits
+        overrideTraits
     );
-    for (const matching_segment of identity_segments) {
-        for (const feature_state of matching_segment.featureStates) {
+    for (const matchingSegment of identitySegments) {
+        for (const featureState of matchingSegment.featureStates) {
             // note that feature states are stored on the segment in descending priority
             // order so we only care that the last one is added
             // TODO: can we optimise this?
-            feature_states[feature_state.feature.id] = feature_state;
+            featureStates[featureState.feature.id] = featureState;
         }
     }
 
     // Override with any feature states defined directly the identity
     for (const fs of identity.identityFeatures || []) {
-        if (feature_states[fs.feature.id]) {
-            feature_states[fs.feature.id] = fs;
+        if (featureStates[fs.feature.id]) {
+            featureStates[fs.feature.id] = fs;
         }
     }
-    return feature_states;
+    return featureStates;
 }
 
 export function getIdentityFeatureState(
     environment: EnvironmentModel,
     identity: IdentityModel,
-    feature_name: string,
-    override_traits?: TraitModel[]
+    featureName: string,
+    overrideTraits?: TraitModel[]
 ): FeatureStateModel {
-    const featureStates = getIdentityFeatureStatesDict(environment, identity, override_traits);
+    const featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
 
     const matchingFeature = Object.values(featureStates).filter(
-        f => f.feature.name === feature_name
+        f => f.feature.name === featureName
     );
 
     if (matchingFeature.length === 0) {
-        throw new Error('Feature State Not Found');
+        throw new FeatureStateNotFound('Feature State Not Found');
     }
 
     return matchingFeature[0];
@@ -64,14 +65,14 @@ export function getIdentityFeatureStates(
     identity: IdentityModel,
     overrideTraits?: TraitModel[]
 ): FeatureStateModel[] {
-    const feature_states = Object.values(
+    const featureStates = Object.values(
         getIdentityFeatureStatesDict(environment, identity, overrideTraits)
     );
 
     if (environment.project.hideDisabledFlags) {
-        return feature_states.filter(fs => !!fs.enabled);
+        return featureStates.filter(fs => !!fs.enabled);
     }
-    return feature_states;
+    return featureStates;
 }
 
 export function getEnvironmentFeatureState(environment: EnvironmentModel, featureName: string) {

package/flagsmith-engine/organisations/models.ts

@@ -8,15 +8,15 @@ export class OrganisationModel {
     constructor(
         id: number,
         name: string,
-        feature_analytics: boolean,
-        stop_serving_flags: boolean,
-        persist_trait_data: boolean
+        featureAnalytics: boolean,
+        stopServingFlags: boolean,
+        persistTraitData: boolean
     ) {
         this.id = id;
         this.name = name;
-        this.featureAnalytics = feature_analytics;
-        this.stopServingFlags = stop_serving_flags;
-        this.persistTraitData = persist_trait_data;
+        this.featureAnalytics = featureAnalytics;
+        this.stopServingFlags = stopServingFlags;
+        this.persistTraitData = persistTraitData;
     }
 
     get unique_slug() {

package/flagsmith-engine/projects/models.ts

@@ -6,18 +6,17 @@ export class ProjectModel {
     name: string;
     organisation: OrganisationModel;
     hideDisabledFlags: boolean;
-    // FIXME
     segments: SegmentModel[] = [];
 
     constructor(
         id: number,
         name: string,
-        hide_disabled_flags: boolean,
+        hideDisabledFlags: boolean,
         organization: OrganisationModel
     ) {
         this.id = id;
         this.name = name;
-        this.hideDisabledFlags = hide_disabled_flags;
+        this.hideDisabledFlags = hideDisabledFlags;
         this.organisation = organization;
     }
 }

package/flagsmith-engine/segments/evaluators.ts

@@ -56,7 +56,7 @@ function traitsMatchSegmentRule(
 }
 
 function traitsMatchSegmentCondition(
-    identity_traits: TraitModel[],
+    identityTraits: TraitModel[],
     condition: SegmentConditionModel,
     segmentId: number | string,
     identityId: number | string
@@ -65,7 +65,7 @@ function traitsMatchSegmentCondition(
         return getHashedPercentateForObjIds([segmentId, identityId]) <= parseFloat(condition.value);
     }
 
-    const traits = identity_traits.filter(t => t.traitKey === condition.property_);
+    const traits = identityTraits.filter(t => t.traitKey === condition.property_);
     const trait = traits.length > 0 ? traits[0] : undefined;
 
     return trait ? condition.matchesTraitValue(trait.traitValue) : false;

package/flagsmith-engine/utils/errors.ts

@@ -0,0 +1 @@
+export class FeatureStateNotFound extends Error {}

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

@@ -1,22 +1,10 @@
 import md5 from 'md5';
 import bigInt from 'big-integer';
 
-// def get_hashed_percentage_for_object_ids(
-//   object_ids: typing.Iterable[typing.Any], iterations: int = 1
-// ) -> float:
-//   """
-//   Given a list of object ids, get a floating point number between 0 and 1 based on
-//   the hash of those ids. This should give the same value every time for any
-//   list of ids.
-
-//   :param object_ids: list of object ids to calculate the has for
-//   :param iterations: num times to include each id in the generated string to hash
-//   :return: (float) number between 0 (inclusive) and 100 (exclusive)
-//   """
-
 const makeRepeated = (arr: Array<any>, repeats: number) =>
     Array.from({ length: repeats }, () => arr).flat();
 
+// https://stackoverflow.com/questions/12532871/how-to-convert-a-very-large-hex-number-to-decimal-in-javascript
 function h2d(s: any): string {
     function add(x: any, y: any) {
         var c = 0,
@@ -42,7 +30,14 @@ function h2d(s: any): string {
     });
     return dec;
 }
-
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @param  {} iterations=1 num times to include each id in the generated string to hash
+ * @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);

package/index.ts

@@ -1,3 +1,6 @@
 import Flagsmith from './sdk';
 
-export default Flagsmith;
+export { Flagsmith } from './sdk';
+// export default Flagsmith;
+
+module.exports = Flagsmith;

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.4",
   "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": {
     "type": "git",
-    "url": "https://github.com/SolidStateGroup/bullet-train-nodejs-client"
+    "url": "https://github.com/Flagsmith/flagsmith-nodejs-client"
   },
   "keywords": [
     "nodejs",
-    "bullet train",
     "flagsmith",
-    "feature flagger",
+    "feature flags",
+    "feature toggles",
+    "remote configuration",
     "continuous deployment"
   ],
   "bugs": {
-    "url": "https://github.com/SolidStateGroup/bullet-train-nodejs-client/issues"
+    "url": "https://github.com/Flagsmith/flagsmith-nodejs-client/issues"
   },
-  "homepage": "http://bullet-train.io",
-  "author": "SSG",
+  "homepage": "http://flagsmith.com/",
+  "author": "Flagsmith",
   "contributors": [
     {
       "name": "Tom Stuart",
@@ -26,7 +27,7 @@
     },
     {
       "name": "Kyle Johnson",
-      "email": "kyle@solidstategroup.com",
+      "email": "kyle.johnson@flagsmith.com",
       "url": "https://www.npmjs.com/~kyle-ssg"
     },
     {
@@ -42,6 +43,8 @@
   "scripts": {
     "lint": "prettier --write .",
     "test": "jest --coverage --coverageReporters='text'",
+    "test:watch": "jest --coverage --watch --coverageReporters='text'",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --coverage --watch --coverageReporters='text'",
     "build": "tsc",
     "prepare": "husky install"
   },

package/sdk/analytics.ts

@@ -7,34 +7,6 @@ const ANALYTICS_TIMER = 10;
 
 const delay = (ms: number) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
 
-const retryFetch = (
-    url: string,
-    fetchOptions = {},
-    retries = 3,
-    retryDelay = 1000,
-    timeout: number
-) => {
-    return new Promise((resolve, reject) => {
-        // check for timeout
-        if (timeout) setTimeout(() => reject('error: timeout'), timeout);
-
-        const wrapper = (n: number) => {
-            fetch(url, fetchOptions)
-                .then(res => resolve(res))
-                .catch(async err => {
-                    if (n > 0) {
-                        await delay(retryDelay);
-                        wrapper(--n);
-                    } else {
-                        reject(err);
-                    }
-                });
-        };
-
-        wrapper(retries);
-    });
-};
-
 export class AnalyticsProcessor {
     private analyticsEndpoint: string;
     private environmentKey: string;

package/sdk/index.ts

@@ -10,6 +10,8 @@ import { FlagsmithAPIError, FlagsmithClientError } from './errors';
 import { DefaultFlag, Flags } from './models';
 import { EnvironmentDataPollingManager } from './polling_manager';
 import { generateIdentitiesData, retryFetch } from './utils';
+import { SegmentModel } from '../flagsmith-engine/segments/models';
+import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators';
 
 const DEFAULT_API_URL = 'https://api.flagsmith.com/api/v1/';
 
@@ -20,7 +22,7 @@ export class Flagsmith {
     requestTimeoutSeconds?: number;
     enableLocalEvaluation?: boolean = false;
     environmentRefreshIntervalSeconds: number = 60;
-    retries?: any;
+    retries?: number;
     enableAnalytics: boolean = false;
     defaultFlagHandler?: (featureName: string) => DefaultFlag;
 
@@ -29,7 +31,7 @@ export class Flagsmith {
     environmentUrl: string;
 
     environmentDataPollingManager?: EnvironmentDataPollingManager;
-    environment?: EnvironmentModel;
+    environment!: EnvironmentModel;
     private analyticsProcessor?: AnalyticsProcessor;
     /**
      * A Flagsmith client.
@@ -68,7 +70,7 @@ export class Flagsmith {
         requestTimeoutSeconds?: number;
         enableLocalEvaluation?: boolean;
         environmentRefreshIntervalSeconds?: number;
-        retries?: any;
+        retries?: number;
         enableAnalytics?: boolean;
         defaultFlagHandler?: (featureName: string) => DefaultFlag;
     }) {
@@ -88,11 +90,17 @@ export class Flagsmith {
         this.environmentUrl = `${this.apiUrl}environment-document/`;
 
         if (this.enableLocalEvaluation) {
+            if (!this.environmentKey.startsWith('ser.')) {
+                console.error(
+                    'In order to use local evaluation, please generate a server key in the environment settings page.'
+                );
+            }
             this.environmentDataPollingManager = new EnvironmentDataPollingManager(
                 this,
                 this.environmentRefreshIntervalSeconds
             );
             this.environmentDataPollingManager.start();
+            this.updateEnvironment();
         }
 
         this.analyticsProcessor = data.enableAnalytics
@@ -128,20 +136,67 @@ export class Flagsmith {
      */
     getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
         traits = traits || {};
-        if (this.environment) {
+        if (this.enableLocalEvaluation) {
             return new Promise(resolve =>
-                resolve(this.getIdentityFlagsFromDocument(identifier, traits || {}))
+                this.environmentPromise!.then(() => {
+                    resolve(this.getIdentityFlagsFromDocument(identifier, traits || {}));
+                })
             );
         }
         return this.getIdentityFlagsFromApi(identifier, traits);
     }
 
+    /**
+     * Get the segments for the current environment for a given identity. Will also
+        upsert all traits to the Flagsmith API for future evaluations. Providing a
+        trait with a value of None will remove the trait from the identity if it exists.
+     *
+     * @param  {string} identifier a unique identifier for the identity in the current
+            environment, e.g. email address, username, uuid
+     * @param  {{[key:string]:any}} traits? a dictionary of traits to add / update on the identity in
+            Flagsmith, e.g. {"num_orders": 10}
+     * @returns Segments that the given identity belongs to.
+     */
+    getIdentitySegments(
+        identifier: string,
+        traits?: { [key: string]: any }
+    ): Promise<SegmentModel[]> {
+        traits = traits || {};
+        if (this.enableLocalEvaluation) {
+            return this.environmentPromise!.then(() => {
+                return new Promise(resolve => {
+                    const identityModel = this.buildIdentityModel(
+                        identifier,
+                        Object.keys(traits || {}).map(key => ({
+                            key,
+                            value: traits?.[key]
+                        }))
+                    );
+
+                    const segments = getIdentitySegments(this.environment, identityModel);
+                    return resolve(segments);
+                });
+            });
+        }
+        console.error('This function is only permitted with local evaluation.');
+        return Promise.resolve([]);
+    }
+
     /**
      * Updates the environment state for local flag evaluation.
+     * Sets a local promise to prevent race conditions in getIdentityFlags / getIdentitySegments.
      * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
      */
     async updateEnvironment() {
-        this.environment = await this.getEnvironmentFromApi();
+        const request = this.getEnvironmentFromApi();
+        if (!this.environmentPromise) {
+            this.environmentPromise = request.then(res => {
+                this.environment = res;
+            });
+            await this.environmentPromise;
+        } else {
+            this.environment = await request;
+        }
     }
 
     private async getJSONResponse(
@@ -149,7 +204,7 @@ export class Flagsmith {
         method: string,
         body?: { [key: string]: any }
     ): Promise<any> {
-        const headers: { [key: string]: any } = {};
+        const headers: { [key: string]: any } = { 'Content-Type': 'application/json' };
         if (this.environmentKey) {
             headers['X-Environment-Key'] = this.environmentKey as string;
         }
@@ -182,18 +237,17 @@ export class Flagsmith {
         return data.json();
     }
 
+    /**
+     * This promise ensures that the environment is retrieved before attempting to locally evaluate.
+     */
+    private environmentPromise: Promise<any> | undefined;
+
     private async getEnvironmentFromApi() {
         const environment_data = await this.getJSONResponse(this.environmentUrl, 'GET');
         return buildEnvironmentModel(environment_data);
     }
 
     private getEnvironmentFlagsFromDocument() {
-        if (!this.environment) {
-            throw new FlagsmithClientError(
-                'Unable to build identity model when no local environment present.'
-            );
-        }
-
         return Flags.fromFeatureStateModels({
             featureStates: getEnvironmentFeatureStates(this.environment),
             analyticsProcessor: this.analyticsProcessor,
@@ -202,18 +256,13 @@ export class Flagsmith {
     }
 
     private getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }) {
-        if (!this.environment) {
-            throw new FlagsmithClientError(
-                'Unable to build identity model when no local environment present.'
-            );
-        }
-
-        const identityModel = this.buildIdentityModel(identifier, Object.keys(traits).map((key)=>(
-            {
+        const identityModel = this.buildIdentityModel(
+            identifier,
+            Object.keys(traits).map(key => ({
                 key,
                 value: traits[key]
-            }
-        )));
+            }))
+        );
 
         const featureStates = getIdentityFeatureStates(this.environment, identityModel);
 
@@ -265,7 +314,7 @@ export class Flagsmith {
         }
     }
 
-    private buildIdentityModel(identifier: string, traits: { key:string, value:any }[]) {
+    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.'
@@ -275,8 +324,6 @@ export class Flagsmith {
         const traitModels = traits.map(trait => new TraitModel(trait.key, trait.value));
         return new IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
     }
-
-    stop() {}
 }
 
 export default Flagsmith;