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

package/build/flagsmith-engine/environments/models.d.ts

@@ -9,7 +9,7 @@ export declare class EnvironmentAPIKeyModel {
     clientApiKey: string;
     expiresAt?: number;
     active: boolean;
-    constructor(id: number, key: string, created_at: number, name: string, client_api_key: string, expires_at?: number);
+    constructor(id: number, key: string, createdAt: number, name: string, clientApiKey: string, expiresAt?: number);
     isValid(): boolean;
 }
 export declare class EnvironmentModel {
@@ -21,5 +21,5 @@ export declare class EnvironmentModel {
     segment_config?: IntegrationModel;
     mixpanel_config?: IntegrationModel;
     heap_config?: IntegrationModel;
-    constructor(id: number, api_key: string, project: ProjectModel);
+    constructor(id: number, apiKey: string, project: ProjectModel);
 }

package/build/flagsmith-engine/environments/models.js

@@ -9,13 +9,13 @@ class EnvironmentAPIKeyModel {
     clientApiKey;
     expiresAt;
     active = true;
-    constructor(id, key, created_at, name, client_api_key, expires_at) {
+    constructor(id, key, createdAt, name, clientApiKey, expiresAt) {
         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() {
         return !!this.active && (!this.expiresAt || this.expiresAt > Date.now());
@@ -31,9 +31,9 @@ class EnvironmentModel {
     segment_config;
     mixpanel_config;
     heap_config;
-    constructor(id, api_key, project) {
+    constructor(id, apiKey, project) {
         this.id = id;
-        this.apiKey = api_key;
+        this.apiKey = apiKey;
         this.project = project;
     }
 }

package/build/flagsmith-engine/features/models.d.ts

@@ -22,9 +22,9 @@ export declare class FeatureStateModel {
     enabled: boolean;
     djangoID: number;
     featurestateUUID: string;
-    _value: any;
+    private value;
     multivariateFeatureStateValues: MultivariateFeatureStateValueModel[];
-    constructor(feature: FeatureModel, enabled: boolean, djangoID: number, value?: any, featurestate_uuid?: string);
+    constructor(feature: FeatureModel, enabled: boolean, djangoID: number, value?: any, featurestateUuid?: string);
     setValue(value: any): void;
     getValue(identityId?: number | string): any;
     get_feature_state_value(): any;

package/build/flagsmith-engine/features/models.js

@@ -44,23 +44,23 @@ class FeatureStateModel {
     enabled;
     djangoID;
     featurestateUUID = (0, uuid_1.v4)();
-    _value;
+    value;
     multivariateFeatureStateValues = [];
-    constructor(feature, enabled, djangoID, value, featurestate_uuid = (0, uuid_1.v4)()) {
+    constructor(feature, enabled, djangoID, value, featurestateUuid = (0, uuid_1.v4)()) {
         this.feature = feature;
         this.enabled = enabled;
         this.djangoID = djangoID;
-        this._value = value;
-        this.featurestateUUID = featurestate_uuid;
+        this.value = value;
+        this.featurestateUUID = featurestateUuid;
     }
     setValue(value) {
-        this._value = value;
+        this.value = value;
     }
     getValue(identityId) {
         if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
             return this.getMultivariateValue(identityId);
         }
-        return this._value;
+        return this.value;
     }
     get_feature_state_value() {
         return this.getValue();
@@ -79,7 +79,7 @@ class FeatureStateModel {
             }
             startPercentage = limit;
         }
-        return this._value;
+        return this.value;
     }
 }
 exports.FeatureStateModel = FeatureStateModel;

package/build/flagsmith-engine/identities/models.d.ts

@@ -8,7 +8,7 @@ export declare class IdentityModel {
     identityTraits: TraitModel[];
     identityUuid: string;
     djangoID: number | undefined;
-    constructor(created_date: string, identity_traits: TraitModel[], identity_features: IdentityFeaturesList, environment_api_key: string, identifier: string, identity_uuid?: string);
+    constructor(created_date: string, identityTraits: TraitModel[], identityFeatures: IdentityFeaturesList, environmentApiKey: string, identifier: string, identityUuid?: string);
     get compositeKey(): string;
     static generateCompositeKey(env_key: string, identifier: string): string;
     update_traits(traits: TraitModel[]): void;

package/build/flagsmith-engine/identities/models.js

@@ -11,12 +11,12 @@ class IdentityModel {
     identityTraits;
     identityUuid;
     djangoID;
-    constructor(created_date, identity_traits, identity_features, environment_api_key, identifier, identity_uuid) {
-        this.identityUuid = identity_uuid || uuidv4();
+    constructor(created_date, identityTraits, identityFeatures, environmentApiKey, identifier, identityUuid) {
+        this.identityUuid = identityUuid || uuidv4();
         this.createdDate = Date.parse(created_date) || Date.now();
-        this.identityTraits = identity_traits;
-        this.identityFeatures = new collections_1.IdentityFeaturesList(...identity_features);
-        this.environmentApiKey = environment_api_key;
+        this.identityTraits = identityTraits;
+        this.identityFeatures = new collections_1.IdentityFeaturesList(...identityFeatures);
+        this.environmentApiKey = environmentApiKey;
         this.identifier = identifier;
     }
     get compositeKey() {

package/build/flagsmith-engine/identities/util.js

@@ -16,7 +16,7 @@ function buildIdentityModel(identityJSON) {
     const model = new models_1.IdentityModel(identityJSON.created_date, identityJSON.identity_traits
         ? identityJSON.identity_traits.map((trait) => buildTraitModel(trait))
         : [], featureList, identityJSON.environment_api_key, identityJSON.identifier, identityJSON.identity_uuid);
-    model.djangoID = identityJSON['django_id'];
+    model.djangoID = identityJSON.django_id;
     return model;
 }
 exports.buildIdentityModel = buildIdentityModel;

package/build/flagsmith-engine/index.d.ts

@@ -2,7 +2,7 @@ import { EnvironmentModel } from './environments/models';
 import { FeatureStateModel } from './features/models';
 import { IdentityModel } from './identities/models';
 import { TraitModel } from './identities/traits/models';
-export declare function getIdentityFeatureState(environment: EnvironmentModel, identity: IdentityModel, feature_name: string, override_traits?: TraitModel[]): FeatureStateModel;
+export declare function getIdentityFeatureState(environment: EnvironmentModel, identity: IdentityModel, featureName: string, overrideTraits?: TraitModel[]): FeatureStateModel;
 export declare function getIdentityFeatureStates(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): FeatureStateModel[];
 export declare function getEnvironmentFeatureState(environment: EnvironmentModel, featureName: string): FeatureStateModel;
 export declare function getEnvironmentFeatureStates(environment: EnvironmentModel): FeatureStateModel[];

package/build/flagsmith-engine/index.js

@@ -2,45 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnvironmentFeatureStates = exports.getEnvironmentFeatureState = exports.getIdentityFeatureStates = exports.getIdentityFeatureState = void 0;
 const evaluators_1 = require("./segments/evaluators");
-function getIdentityFeatureStatesDict(environment, identity, override_traits) {
+const errors_1 = require("./utils/errors");
+function getIdentityFeatureStatesDict(environment, identity, overrideTraits) {
     // Get feature states from the environment
-    const feature_states = {};
+    const featureStates = {};
     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 = (0, evaluators_1.getIdentitySegments)(environment, identity, override_traits);
-    for (const matching_segment of identity_segments) {
-        for (const feature_state of matching_segment.featureStates) {
+    const identitySegments = (0, evaluators_1.getIdentitySegments)(environment, identity, overrideTraits);
+    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;
 }
-function getIdentityFeatureState(environment, identity, feature_name, override_traits) {
-    const featureStates = getIdentityFeatureStatesDict(environment, identity, override_traits);
-    const matchingFeature = Object.values(featureStates).filter(f => f.feature.name === feature_name);
+function getIdentityFeatureState(environment, identity, featureName, overrideTraits) {
+    const featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
+    const matchingFeature = Object.values(featureStates).filter(f => f.feature.name === featureName);
     if (matchingFeature.length === 0) {
-        throw new Error('Feature State Not Found');
+        throw new errors_1.FeatureStateNotFound('Feature State Not Found');
     }
     return matchingFeature[0];
 }
 exports.getIdentityFeatureState = getIdentityFeatureState;
 function getIdentityFeatureStates(environment, identity, overrideTraits) {
-    const feature_states = Object.values(getIdentityFeatureStatesDict(environment, identity, overrideTraits));
+    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;
 }
 exports.getIdentityFeatureStates = getIdentityFeatureStates;
 function getEnvironmentFeatureState(environment, featureName) {

package/build/flagsmith-engine/organisations/models.d.ts

@@ -4,6 +4,6 @@ export declare class OrganisationModel {
     featureAnalytics: boolean;
     stopServingFlags: boolean;
     persistTraitData: boolean;
-    constructor(id: number, name: string, feature_analytics: boolean, stop_serving_flags: boolean, persist_trait_data: boolean);
+    constructor(id: number, name: string, featureAnalytics: boolean, stopServingFlags: boolean, persistTraitData: boolean);
     get unique_slug(): string;
 }

package/build/flagsmith-engine/organisations/models.js

@@ -7,12 +7,12 @@ class OrganisationModel {
     featureAnalytics;
     stopServingFlags;
     persistTraitData;
-    constructor(id, name, feature_analytics, stop_serving_flags, persist_trait_data) {
+    constructor(id, name, featureAnalytics, stopServingFlags, persistTraitData) {
         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() {
         return this.id.toString() + '-' + this.name;

package/build/flagsmith-engine/projects/models.d.ts

@@ -6,5 +6,5 @@ export declare class ProjectModel {
     organisation: OrganisationModel;
     hideDisabledFlags: boolean;
     segments: SegmentModel[];
-    constructor(id: number, name: string, hide_disabled_flags: boolean, organization: OrganisationModel);
+    constructor(id: number, name: string, hideDisabledFlags: boolean, organization: OrganisationModel);
 }

package/build/flagsmith-engine/projects/models.js

@@ -6,12 +6,11 @@ class ProjectModel {
     name;
     organisation;
     hideDisabledFlags;
-    // FIXME
     segments = [];
-    constructor(id, name, hide_disabled_flags, organization) {
+    constructor(id, name, hideDisabledFlags, organization) {
         this.id = id;
         this.name = name;
-        this.hideDisabledFlags = hide_disabled_flags;
+        this.hideDisabledFlags = hideDisabledFlags;
         this.organisation = organization;
     }
 }

package/build/flagsmith-engine/segments/evaluators.js

@@ -19,11 +19,11 @@ function traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId) {
     return (matchesConditions &&
         rule.rules.filter(rule => traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId)).length === rule.rules.length);
 }
-function traitsMatchSegmentCondition(identity_traits, condition, segmentId, identityId) {
+function traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId) {
     if (condition.operator == constants_1.PERCENTAGE_SPLIT) {
         return (0, hashing_1.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/build/flagsmith-engine/utils/errors.d.ts

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

package/build/flagsmith-engine/utils/errors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureStateNotFound = void 0;
+class FeatureStateNotFound extends Error {
+}
+exports.FeatureStateNotFound = FeatureStateNotFound;

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

@@ -1 +1,9 @@
+/**
+ * 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 declare function getHashedPercentateForObjIds(objectIds: Array<any>, iterations?: number): number;

package/build/flagsmith-engine/utils/hashing/index.js

@@ -6,18 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHashedPercentateForObjIds = void 0;
 const md5_1 = __importDefault(require("md5"));
 const big_integer_1 = __importDefault(require("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, repeats) => 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) {
     function add(x, y) {
         var c = 0, r = [];
@@ -43,6 +33,14 @@ function h2d(s) {
     });
     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)
+ */
 function getHashedPercentateForObjIds(objectIds, iterations = 1) {
     let to_hash = makeRepeated(objectIds, iterations).join(',');
     const hashedValue = (0, md5_1.default)(to_hash);

package/build/index.d.ts

@@ -1,2 +1 @@
-import Flagsmith from './sdk';
-export default Flagsmith;
+export { Flagsmith } from './sdk';

package/build/index.js

@@ -3,5 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flagsmith = void 0;
 const sdk_1 = __importDefault(require("./sdk"));
-exports.default = sdk_1.default;
+var sdk_2 = require("./sdk");
+Object.defineProperty(exports, "Flagsmith", { enumerable: true, get: function () { return sdk_2.Flagsmith; } });
+// export default Flagsmith;
+module.exports = sdk_1.default;

package/build/sdk/analytics.js

@@ -9,27 +9,6 @@ const ANALYTICS_ENDPOINT = 'analytics/flags/';
 // Used to control how often we send data(in seconds)
 const ANALYTICS_TIMER = 10;
 const delay = (ms) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
-const retryFetch = (url, fetchOptions = {}, retries = 3, retryDelay = 1000, timeout) => {
-    return new Promise((resolve, reject) => {
-        // check for timeout
-        if (timeout)
-            setTimeout(() => reject('error: timeout'), timeout);
-        const wrapper = (n) => {
-            (0, node_fetch_1.default)(url, fetchOptions)
-                .then(res => resolve(res))
-                .catch(async (err) => {
-                if (n > 0) {
-                    await delay(retryDelay);
-                    wrapper(--n);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        };
-        wrapper(retries);
-    });
-};
 class AnalyticsProcessor {
     analyticsEndpoint;
     environmentKey;

package/build/sdk/index.d.ts

@@ -17,7 +17,7 @@ export declare class Flagsmith {
     identitiesUrl: string;
     environmentUrl: string;
     environmentDataPollingManager?: EnvironmentDataPollingManager;
-    environment?: EnvironmentModel;
+    environment: EnvironmentModel;
     private analyticsProcessor?;
     /**
      * A Flagsmith client.
@@ -94,6 +94,5 @@ export declare class Flagsmith {
     private getEnvironmentFlagsFromApi;
     private getIdentityFlagsFromApi;
     private buildIdentityModel;
-    stop(): void;
 }
 export default Flagsmith;

package/build/sdk/index.js

@@ -120,7 +120,7 @@ class Flagsmith {
         this.environment = await this.getEnvironmentFromApi();
     }
     async getJSONResponse(url, method, body) {
-        const headers = {};
+        const headers = { 'Content-Type': 'application/json' };
         if (this.environmentKey) {
             headers['X-Environment-Key'] = this.environmentKey;
         }
@@ -145,9 +145,6 @@ class Flagsmith {
         return (0, util_1.buildEnvironmentModel)(environment_data);
     }
     getEnvironmentFlagsFromDocument() {
-        if (!this.environment) {
-            throw new errors_1.FlagsmithClientError('Unable to build identity model when no local environment present.');
-        }
         return models_3.Flags.fromFeatureStateModels({
             featureStates: (0, flagsmith_engine_1.getEnvironmentFeatureStates)(this.environment),
             analyticsProcessor: this.analyticsProcessor,
@@ -155,10 +152,7 @@ class Flagsmith {
         });
     }
     getIdentityFlagsFromDocument(identifier, traits) {
-        if (!this.environment) {
-            throw new errors_1.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]
         })));
@@ -215,7 +209,7 @@ class Flagsmith {
         const traitModels = traits.map(trait => new models_2.TraitModel(trait.key, trait.value));
         return new models_1.IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
     }
-    stop() { }
 }
 exports.Flagsmith = Flagsmith;
 exports.default = Flagsmith;
+// export = Flagsmith;

package/build/sdk/polling_manager.d.ts

@@ -1,4 +1,4 @@
-import { Flagsmith } from '.';
+import Flagsmith from '.';
 export declare class EnvironmentDataPollingManager {
     private interval?;
     private main;

package/build/sdk/utils.d.ts

@@ -4,7 +4,7 @@ export declare function generateIdentitiesData(identifier: string, traits?: {
 }): {
     identifier: string;
     traits: {
-        trait_key: any;
+        trait_key: string;
         trait_value: any;
     }[];
 };

package/build/sdk/utils.js

@@ -9,7 +9,7 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
 if (typeof node_fetch_1.default.default !== 'undefined')
     node_fetch_1.default = node_fetch_1.default.default;
 function generateIdentitiesData(identifier, traits) {
-    const traitsGenerated = Object.values(traits || {}).map(trait => ({
+    const traitsGenerated = Object.entries(traits || {}).map(trait => ({
         trait_key: trait[0],
         trait_value: trait[1]
     }));