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

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,7 +23,7 @@ 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 });

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.2",
   "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"
     },
     {

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

@@ -29,7 +29,7 @@ export class Flagsmith {
     environmentUrl: string;
 
     environmentDataPollingManager?: EnvironmentDataPollingManager;
-    environment?: EnvironmentModel;
+    environment!: EnvironmentModel;
     private analyticsProcessor?: AnalyticsProcessor;
     /**
      * A Flagsmith client.
@@ -149,7 +149,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;
         }
@@ -188,12 +188,6 @@ export class Flagsmith {
     }
 
     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 +196,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 +254,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 +264,7 @@ 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;
+// export = Flagsmith;

package/sdk/models.ts

@@ -123,7 +123,9 @@ export class Flags {
             if (this.defaultFlagHandler) {
                 return this.defaultFlagHandler(featureName);
             }
-            throw new FlagsmithClientError(`Feature does not exist: ${featureName}, implement defaultFlagHandler to handle this case.`);
+            throw new FlagsmithClientError(
+                `Feature does not exist: ${featureName}, implement defaultFlagHandler to handle this case.`
+            );
         }
 
         if (this.analyticsProcessor && flag.featureId) {

package/sdk/polling_manager.ts

@@ -1,4 +1,4 @@
-import { Flagsmith } from '.';
+import Flagsmith from '.';
 
 export class EnvironmentDataPollingManager {
     private interval?: NodeJS.Timer;
@@ -12,14 +12,14 @@ export class EnvironmentDataPollingManager {
 
     start() {
         const updateEnvironment = () => {
-            if(this.interval) clearInterval(this.interval)
+            if (this.interval) clearInterval(this.interval);
             this.interval = setInterval(async () => {
                 await this.main.updateEnvironment();
             }, this.refreshIntervalSeconds * 1000);
         };
         // todo: this call should be awaited for getIdentityFlags/getEnvironmentFlags when enableLocalEvaluation is true
-        this.main.updateEnvironment()
-        updateEnvironment()
+        this.main.updateEnvironment();
+        updateEnvironment();
     }
 
     stop() {

package/sdk/utils.ts

@@ -3,7 +3,7 @@ import fetch, { Response } from 'node-fetch';
 if (typeof fetch.default !== 'undefined') fetch = fetch.default;
 
 export function generateIdentitiesData(identifier: string, traits?: { [key: string]: any }) {
-    const traitsGenerated = Object.values(traits || {}).map(trait => ({
+    const traitsGenerated = Object.entries(traits || {}).map(trait => ({
         trait_key: trait[0],
         trait_value: trait[1]
     }));

package/tests/sdk/flagsmith.test.ts

@@ -1,4 +1,4 @@
-import { Flagsmith } from '../../sdk';
+import Flagsmith from '../../sdk';
 import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
 import fetch, { Headers } from 'node-fetch';
 import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON } from './utils';

package/tests/sdk/polling.test.ts

@@ -1,4 +1,4 @@
-import { Flagsmith } from '../../sdk';
+import Flagsmith from '../../sdk';
 import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
 import { delay } from '../../sdk/utils';
 jest.mock('../../sdk');

package/tests/sdk/utils.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'fs';
 import { buildEnvironmentModel } from '../../flagsmith-engine/environments/util';
 import { AnalyticsProcessor } from '../../sdk/analytics';
-import { Flagsmith } from '../../sdk';
+import Flagsmith from '../../sdk';
 
 const DATA_DIR = __dirname + '/data/';