flagsmith-nodejs 2.0.0-beta.5 → 2.0.0-beta.6

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

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntegrationModel = void 0;
-class IntegrationModel {
-    api_key = undefined;
-    base_url = undefined;
-}
+var IntegrationModel = /** @class */ (function () {
+    function IntegrationModel() {
+        this.api_key = undefined;
+        this.base_url = undefined;
+    }
+    return IntegrationModel;
+}());
 exports.IntegrationModel = IntegrationModel;

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

@@ -1,15 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnvironmentModel = exports.EnvironmentAPIKeyModel = void 0;
-class EnvironmentAPIKeyModel {
-    id;
-    key;
-    createdAt;
-    name;
-    clientApiKey;
-    expiresAt;
-    active = true;
-    constructor(id, key, createdAt, name, clientApiKey, expiresAt) {
+var EnvironmentAPIKeyModel = /** @class */ (function () {
+    function EnvironmentAPIKeyModel(id, key, createdAt, name, clientApiKey, expiresAt) {
+        this.active = true;
         this.id = id;
         this.key = key;
         this.createdAt = createdAt;
@@ -17,24 +11,19 @@ class EnvironmentAPIKeyModel {
         this.clientApiKey = clientApiKey;
         this.expiresAt = expiresAt;
     }
-    isValid() {
+    EnvironmentAPIKeyModel.prototype.isValid = function () {
         return !!this.active && (!this.expiresAt || this.expiresAt > Date.now());
-    }
-}
+    };
+    return EnvironmentAPIKeyModel;
+}());
 exports.EnvironmentAPIKeyModel = EnvironmentAPIKeyModel;
-class EnvironmentModel {
-    id;
-    apiKey;
-    project;
-    featureStates = [];
-    amplitude_config;
-    segment_config;
-    mixpanel_config;
-    heap_config;
-    constructor(id, apiKey, project) {
+var EnvironmentModel = /** @class */ (function () {
+    function EnvironmentModel(id, apiKey, project) {
+        this.featureStates = [];
         this.id = id;
         this.apiKey = apiKey;
         this.project = project;
     }
-}
+    return EnvironmentModel;
+}());
 exports.EnvironmentModel = EnvironmentModel;

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

@@ -1,19 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildEnvironmentAPIKeyModel = exports.buildEnvironmentModel = void 0;
-const util_1 = require("../features/util");
-const util_2 = require("../projects/util");
-const models_1 = require("./models");
+var util_1 = require("../features/util");
+var util_2 = require("../projects/util");
+var models_1 = require("./models");
 function buildEnvironmentModel(environmentJSON) {
-    const project = (0, util_2.buildProjectModel)(environmentJSON.project);
-    const featureStates = environmentJSON.feature_states.map((fs) => (0, util_1.buildFeatureStateModel)(fs));
-    const environmentModel = new models_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
+    var project = (0, util_2.buildProjectModel)(environmentJSON.project);
+    var featureStates = environmentJSON.feature_states.map(function (fs) {
+        return (0, util_1.buildFeatureStateModel)(fs);
+    });
+    var environmentModel = new models_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
     environmentModel.featureStates = featureStates;
     return environmentModel;
 }
 exports.buildEnvironmentModel = buildEnvironmentModel;
 function buildEnvironmentAPIKeyModel(apiKeyJSON) {
-    const model = new models_1.EnvironmentAPIKeyModel(apiKeyJSON.id, apiKeyJSON.key, Date.parse(apiKeyJSON.created_at), apiKeyJSON.name, apiKeyJSON.client_api_key);
+    var model = new models_1.EnvironmentAPIKeyModel(apiKeyJSON.id, apiKeyJSON.key, Date.parse(apiKeyJSON.created_at), apiKeyJSON.name, apiKeyJSON.client_api_key);
     return model;
 }
 exports.buildEnvironmentAPIKeyModel = buildEnvironmentAPIKeyModel;

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

@@ -1,85 +1,102 @@
 "use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeatureStateModel = exports.MultivariateFeatureStateValueModel = exports.MultivariateFeatureOptionModel = exports.FeatureModel = void 0;
-const uuid_1 = require("uuid");
-const hashing_1 = require("../utils/hashing");
-class FeatureModel {
-    id;
-    name;
-    type;
-    constructor(id, name, type) {
+var uuid_1 = require("uuid");
+var hashing_1 = require("../utils/hashing");
+var FeatureModel = /** @class */ (function () {
+    function FeatureModel(id, name, type) {
         this.id = id;
         this.name = name;
         this.type = type;
     }
-    eq(other) {
+    FeatureModel.prototype.eq = function (other) {
         return !!other && this.id === other.id;
-    }
-}
+    };
+    return FeatureModel;
+}());
 exports.FeatureModel = FeatureModel;
-class MultivariateFeatureOptionModel {
-    value;
-    id;
-    constructor(value, id) {
+var MultivariateFeatureOptionModel = /** @class */ (function () {
+    function MultivariateFeatureOptionModel(value, id) {
         this.value = value;
         this.id = id;
     }
-}
+    return MultivariateFeatureOptionModel;
+}());
 exports.MultivariateFeatureOptionModel = MultivariateFeatureOptionModel;
-class MultivariateFeatureStateValueModel {
-    multivariateFeatureOption;
-    percentageAllocation;
-    id;
-    mvFsValueUuid = (0, uuid_1.v4)();
-    constructor(multivariate_feature_option, percentage_allocation, id, mvFsValueUuid) {
+var MultivariateFeatureStateValueModel = /** @class */ (function () {
+    function MultivariateFeatureStateValueModel(multivariate_feature_option, percentage_allocation, id, mvFsValueUuid) {
+        this.mvFsValueUuid = (0, uuid_1.v4)();
         this.id = id;
         this.percentageAllocation = percentage_allocation;
         this.multivariateFeatureOption = multivariate_feature_option;
         this.mvFsValueUuid = mvFsValueUuid || this.mvFsValueUuid;
     }
-}
+    return MultivariateFeatureStateValueModel;
+}());
 exports.MultivariateFeatureStateValueModel = MultivariateFeatureStateValueModel;
-class FeatureStateModel {
-    feature;
-    enabled;
-    djangoID;
-    featurestateUUID = (0, uuid_1.v4)();
-    value;
-    multivariateFeatureStateValues = [];
-    constructor(feature, enabled, djangoID, value, featurestateUuid = (0, uuid_1.v4)()) {
+var FeatureStateModel = /** @class */ (function () {
+    function FeatureStateModel(feature, enabled, djangoID, value, featurestateUuid) {
+        if (featurestateUuid === void 0) { featurestateUuid = (0, uuid_1.v4)(); }
+        this.featurestateUUID = (0, uuid_1.v4)();
+        this.multivariateFeatureStateValues = [];
         this.feature = feature;
         this.enabled = enabled;
         this.djangoID = djangoID;
         this.value = value;
         this.featurestateUUID = featurestateUuid;
     }
-    setValue(value) {
+    FeatureStateModel.prototype.setValue = function (value) {
         this.value = value;
-    }
-    getValue(identityId) {
+    };
+    FeatureStateModel.prototype.getValue = function (identityId) {
         if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
             return this.getMultivariateValue(identityId);
         }
         return this.value;
-    }
-    get_feature_state_value() {
+    };
+    FeatureStateModel.prototype.get_feature_state_value = function () {
         return this.getValue();
-    }
-    getMultivariateValue(identityID) {
-        const percentageValue = (0, hashing_1.getHashedPercentateForObjIds)([
+    };
+    FeatureStateModel.prototype.getMultivariateValue = function (identityID) {
+        var e_1, _a;
+        var percentageValue = (0, hashing_1.getHashedPercentateForObjIds)([
             this.djangoID || this.featurestateUUID,
             identityID
         ]);
-        let startPercentage = 0;
-        const sortedF = this.multivariateFeatureStateValues.sort((a, b) => !!(a.id && b.id) ? a.id - b.id : a.mvFsValueUuid > b.mvFsValueUuid ? -1 : 1);
-        for (const myValue of sortedF) {
-            const limit = myValue.percentageAllocation + startPercentage;
-            if (startPercentage <= percentageValue && percentageValue < limit) {
-                return myValue.multivariateFeatureOption.value;
+        var startPercentage = 0;
+        var sortedF = this.multivariateFeatureStateValues.sort(function (a, b) {
+            return !!(a.id && b.id) ? a.id - b.id : a.mvFsValueUuid > b.mvFsValueUuid ? -1 : 1;
+        });
+        try {
+            for (var sortedF_1 = __values(sortedF), sortedF_1_1 = sortedF_1.next(); !sortedF_1_1.done; sortedF_1_1 = sortedF_1.next()) {
+                var myValue = sortedF_1_1.value;
+                var limit = myValue.percentageAllocation + startPercentage;
+                if (startPercentage <= percentageValue && percentageValue < limit) {
+                    return myValue.multivariateFeatureOption.value;
+                }
+                startPercentage = limit;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (sortedF_1_1 && !sortedF_1_1.done && (_a = sortedF_1.return)) _a.call(sortedF_1);
             }
-            startPercentage = limit;
+            finally { if (e_1) throw e_1.error; }
         }
         return this.value;
-    }
-}
+    };
+    return FeatureStateModel;
+}());
 exports.FeatureStateModel = FeatureStateModel;

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFeatureStateModel = exports.buildFeatureModel = void 0;
-const models_1 = require("./models");
+var models_1 = require("./models");
 function buildFeatureModel(featuresModelJSON) {
     return new models_1.FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
 }
 exports.buildFeatureModel = buildFeatureModel;
 function buildFeatureStateModel(featuresStateModelJSON) {
-    const featureStateModel = new models_1.FeatureStateModel(buildFeatureModel(featuresStateModelJSON.feature), featuresStateModelJSON.enabled, featuresStateModelJSON.django_id, featuresStateModelJSON.feature_state_value, featuresStateModelJSON.uuid);
-    const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
-        ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv) => {
-            const featureOption = new models_1.MultivariateFeatureOptionModel(fsv.multivariate_feature_option.value, fsv.multivariate_feature_option.id);
+    var featureStateModel = new models_1.FeatureStateModel(buildFeatureModel(featuresStateModelJSON.feature), featuresStateModelJSON.enabled, featuresStateModelJSON.django_id, featuresStateModelJSON.feature_state_value, featuresStateModelJSON.uuid);
+    var multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
+        ? featuresStateModelJSON.multivariate_feature_state_values.map(function (fsv) {
+            var featureOption = new models_1.MultivariateFeatureOptionModel(fsv.multivariate_feature_option.value, fsv.multivariate_feature_option.id);
             return new models_1.MultivariateFeatureStateValueModel(featureOption, fsv.percentage_allocation, fsv.id);
         })
         : [];

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

@@ -1,47 +1,112 @@
 "use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdentityModel = void 0;
-const collections_1 = require("../utils/collections");
-const { v4: uuidv4 } = require('uuid');
-class IdentityModel {
-    identifier;
-    environmentApiKey;
-    createdDate;
-    identityFeatures;
-    identityTraits;
-    identityUuid;
-    djangoID;
-    constructor(created_date, identityTraits, identityFeatures, environmentApiKey, identifier, identityUuid) {
+var collections_1 = require("../utils/collections");
+var uuidv4 = require('uuid').v4;
+var IdentityModel = /** @class */ (function () {
+    function IdentityModel(created_date, identityTraits, identityFeatures, environmentApiKey, identifier, identityUuid) {
         this.identityUuid = identityUuid || uuidv4();
         this.createdDate = Date.parse(created_date) || Date.now();
         this.identityTraits = identityTraits;
-        this.identityFeatures = new collections_1.IdentityFeaturesList(...identityFeatures);
+        this.identityFeatures = new (collections_1.IdentityFeaturesList.bind.apply(collections_1.IdentityFeaturesList, __spreadArray([void 0], __read(identityFeatures), false)))();
         this.environmentApiKey = environmentApiKey;
         this.identifier = identifier;
     }
-    get compositeKey() {
-        return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
-    }
-    static generateCompositeKey(env_key, identifier) {
-        return `${env_key}_${identifier}`;
-    }
-    update_traits(traits) {
-        const existingTraits = new Map();
-        for (const trait of this.identityTraits) {
-            existingTraits.set(trait.traitKey, trait);
-        }
-        for (const trait of traits) {
-            if (!!trait.traitValue) {
+    Object.defineProperty(IdentityModel.prototype, "compositeKey", {
+        get: function () {
+            return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IdentityModel.generateCompositeKey = function (env_key, identifier) {
+        return "".concat(env_key, "_").concat(identifier);
+    };
+    IdentityModel.prototype.update_traits = function (traits) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var existingTraits = new Map();
+        try {
+            for (var _d = __values(this.identityTraits), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var trait = _e.value;
                 existingTraits.set(trait.traitKey, trait);
             }
-            else {
-                existingTraits.delete(trait.traitKey);
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var traits_1 = __values(traits), traits_1_1 = traits_1.next(); !traits_1_1.done; traits_1_1 = traits_1.next()) {
+                var trait = traits_1_1.value;
+                if (!!trait.traitValue) {
+                    existingTraits.set(trait.traitKey, trait);
+                }
+                else {
+                    existingTraits.delete(trait.traitKey);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (traits_1_1 && !traits_1_1.done && (_b = traits_1.return)) _b.call(traits_1);
             }
+            finally { if (e_2) throw e_2.error; }
         }
         this.identityTraits = [];
-        for (const [k, v] of existingTraits.entries()) {
-            this.identityTraits.push(v);
+        try {
+            for (var _f = __values(existingTraits.entries()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
+                this.identityTraits.push(v);
+            }
         }
-    }
-}
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    return IdentityModel;
+}());
 exports.IdentityModel = IdentityModel;

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

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraitModel = void 0;
-class TraitModel {
-    traitKey;
-    traitValue;
-    constructor(key, value) {
+var TraitModel = /** @class */ (function () {
+    function TraitModel(key, value) {
         this.traitKey = key;
         this.traitValue = value;
     }
-}
+    return TraitModel;
+}());
 exports.TraitModel = TraitModel;

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

@@ -1,20 +1,44 @@
 "use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildIdentityModel = exports.buildTraitModel = void 0;
-const util_1 = require("../features/util");
-const collections_1 = require("../utils/collections");
-const models_1 = require("./models");
-const models_2 = require("./traits/models");
+var util_1 = require("../features/util");
+var collections_1 = require("../utils/collections");
+var models_1 = require("./models");
+var models_2 = require("./traits/models");
 function buildTraitModel(traitJSON) {
     return new models_2.TraitModel(traitJSON.trait_key, traitJSON.trait_value);
 }
 exports.buildTraitModel = buildTraitModel;
 function buildIdentityModel(identityJSON) {
-    const featureList = identityJSON.identity_features
-        ? new collections_1.IdentityFeaturesList(...identityJSON.identity_features.map((f) => (0, util_1.buildFeatureStateModel)(f)))
-        : [];
-    const model = new models_1.IdentityModel(identityJSON.created_date, identityJSON.identity_traits
-        ? identityJSON.identity_traits.map((trait) => buildTraitModel(trait))
+    var featureList = identityJSON.identity_features
+        ? new (collections_1.IdentityFeaturesList.bind.apply(collections_1.IdentityFeaturesList, __spreadArray([void 0], __read(identityJSON.identity_features.map(function (f) { return (0, util_1.buildFeatureStateModel)(f); })), false)))() : [];
+    var model = new models_1.IdentityModel(identityJSON.created_date, identityJSON.identity_traits
+        ? identityJSON.identity_traits.map(function (trait) { return buildTraitModel(trait); })
         : [], featureList, identityJSON.environment_api_key, identityJSON.identifier, identityJSON.identity_uuid);
     model.djangoID = identityJSON.django_id;
     return model;

package/build/flagsmith-engine/index.js

@@ -1,35 +1,87 @@
 "use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnvironmentFeatureStates = exports.getEnvironmentFeatureState = exports.getIdentityFeatureStates = exports.getIdentityFeatureState = void 0;
-const evaluators_1 = require("./segments/evaluators");
-const errors_1 = require("./utils/errors");
+var evaluators_1 = require("./segments/evaluators");
+var errors_1 = require("./utils/errors");
 function getIdentityFeatureStatesDict(environment, identity, overrideTraits) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
     // Get feature states from the environment
-    const featureStates = {};
-    for (const fs of environment.featureStates) {
-        featureStates[fs.feature.id] = fs;
+    var featureStates = {};
+    try {
+        for (var _e = __values(environment.featureStates), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var fs = _f.value;
+            featureStates[fs.feature.id] = fs;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     // Override with any feature states defined by matching segments
-    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?
-            featureStates[featureState.feature.id] = featureState;
+    var identitySegments = (0, evaluators_1.getIdentitySegments)(environment, identity, overrideTraits);
+    try {
+        for (var identitySegments_1 = __values(identitySegments), identitySegments_1_1 = identitySegments_1.next(); !identitySegments_1_1.done; identitySegments_1_1 = identitySegments_1.next()) {
+            var matchingSegment = identitySegments_1_1.value;
+            try {
+                for (var _g = (e_3 = void 0, __values(matchingSegment.featureStates)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var featureState = _h.value;
+                    // 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?
+                    featureStates[featureState.feature.id] = featureState;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
         }
     }
-    // Override with any feature states defined directly the identity
-    for (const fs of identity.identityFeatures || []) {
-        if (featureStates[fs.feature.id]) {
-            featureStates[fs.feature.id] = fs;
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (identitySegments_1_1 && !identitySegments_1_1.done && (_b = identitySegments_1.return)) _b.call(identitySegments_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        // Override with any feature states defined directly the identity
+        for (var _j = __values(identity.identityFeatures || []), _k = _j.next(); !_k.done; _k = _j.next()) {
+            var fs = _k.value;
+            if (featureStates[fs.feature.id]) {
+                featureStates[fs.feature.id] = fs;
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_k && !_k.done && (_d = _j.return)) _d.call(_j);
         }
+        finally { if (e_4) throw e_4.error; }
     }
     return featureStates;
 }
 function getIdentityFeatureState(environment, identity, featureName, overrideTraits) {
-    const featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
-    const matchingFeature = Object.values(featureStates).filter(f => f.feature.name === featureName);
+    var featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
+    var matchingFeature = Object.values(featureStates).filter(function (f) { return f.feature.name === featureName; });
     if (matchingFeature.length === 0) {
         throw new errors_1.FeatureStateNotFound('Feature State Not Found');
     }
@@ -37,15 +89,15 @@ function getIdentityFeatureState(environment, identity, featureName, overrideTra
 }
 exports.getIdentityFeatureState = getIdentityFeatureState;
 function getIdentityFeatureStates(environment, identity, overrideTraits) {
-    const featureStates = Object.values(getIdentityFeatureStatesDict(environment, identity, overrideTraits));
+    var featureStates = Object.values(getIdentityFeatureStatesDict(environment, identity, overrideTraits));
     if (environment.project.hideDisabledFlags) {
-        return featureStates.filter(fs => !!fs.enabled);
+        return featureStates.filter(function (fs) { return !!fs.enabled; });
     }
     return featureStates;
 }
 exports.getIdentityFeatureStates = getIdentityFeatureStates;
 function getEnvironmentFeatureState(environment, featureName) {
-    const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
+    var featuresStates = environment.featureStates.filter(function (f) { return f.feature.name === featureName; });
     if (featuresStates.length === 0) {
         throw new Error('Feature State Not Found');
     }
@@ -54,7 +106,7 @@ function getEnvironmentFeatureState(environment, featureName) {
 exports.getEnvironmentFeatureState = getEnvironmentFeatureState;
 function getEnvironmentFeatureStates(environment) {
     if (environment.project.hideDisabledFlags) {
-        return environment.featureStates.filter(fs => !!fs.enabled);
+        return environment.featureStates.filter(function (fs) { return !!fs.enabled; });
     }
     return environment.featureStates;
 }

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

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrganisationModel = void 0;
-class OrganisationModel {
-    id;
-    name;
-    featureAnalytics;
-    stopServingFlags;
-    persistTraitData;
-    constructor(id, name, featureAnalytics, stopServingFlags, persistTraitData) {
+var OrganisationModel = /** @class */ (function () {
+    function OrganisationModel(id, name, featureAnalytics, stopServingFlags, persistTraitData) {
         this.id = id;
         this.name = name;
         this.featureAnalytics = featureAnalytics;
         this.stopServingFlags = stopServingFlags;
         this.persistTraitData = persistTraitData;
     }
-    get unique_slug() {
-        return this.id.toString() + '-' + this.name;
-    }
-}
+    Object.defineProperty(OrganisationModel.prototype, "unique_slug", {
+        get: function () {
+            return this.id.toString() + '-' + this.name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OrganisationModel;
+}());
 exports.OrganisationModel = OrganisationModel;