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

package/.github/workflows/pull_request.yaml

@@ -1,33 +1,41 @@
 name: Unit/Integration Tests
 
 on:
-    pull_request:
-        types:
-            - opened
-            - synchronize
-            - reopened
-            - ready_for_review
-    push:
-        branches:
-            - main
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
+  push:
+    branches:
+      - main
 jobs:
-    build-and-test:
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v2
-            - uses: actions/setup-node@v1
-              with:
-                  node-version: '15.x'
-            - name: cache node modules
-              uses: actions/cache@v1
-              with:
-                  path: ~/.npm # npm cache files are stored in `~/.npm` on Linux/macOS
-                  key: npm-${{ hashFiles('package-lock.json') }}
-                  restore-keys: |
-                      npm-${{ hashFiles('package-lock.json') }}
-                      npm-
-            - run: npm i -g npm@7.0.2
-            - run: npm install
-            - run: npm test
-              env:
-                  CI: true
+  build-and-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Checkout submodules # checkout rest
+        shell: bash
+        run: |
+          # If your submodules are configured to use SSH instead of HTTPS please uncomment the following line
+          git config --global url."https://github.com/".insteadOf "git@github.com:"
+          auth_header="$(git config --local --get http.https://github.com/.extraheader)"
+          git submodule sync --recursive
+          git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: "15.x"
+      - name: cache node modules
+        uses: actions/cache@v1
+        with:
+          path: ~/.npm # npm cache files are stored in `~/.npm` on Linux/macOS
+          key: npm-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            npm-${{ hashFiles('package-lock.json') }}
+            npm-
+      - run: npm i -g npm@7.0.2
+      - run: npm install
+      - run: npm test
+        env:
+          CI: true

package/README.md

@@ -19,6 +19,13 @@ Please read [CONTRIBUTING.md](https://gist.github.com/kyle-ssg/c36a03aebe492e45c
 
 If you encounter a bug or feature request we would like to hear about it. Before you submit an issue please search existing issues in order to prevent duplicates.
 
+## Testing
+
+To run the local tests you need to run following command beforehand:
+```
+git submodule add git@github.com:Flagsmith/engine-test-data.git tests/engine/engine-tests/engine-test-data/
+```
+
 ## Get in touch
 
 If you have any questions about our projects you can email <a href="mailto:support@flagsmith.com">support@flagsmith.com</a>.

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

@@ -27,6 +27,5 @@ export declare class FeatureStateModel {
     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;
     getMultivariateValue(identityID: number | string): any;
 }

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

@@ -65,9 +65,6 @@ var FeatureStateModel = /** @class */ (function () {
         }
         return this.value;
     };
-    FeatureStateModel.prototype.get_feature_state_value = function () {
-        return this.getValue();
-    };
     FeatureStateModel.prototype.getMultivariateValue = function (identityID) {
         var e_1, _a;
         var percentageValue = (0, hashing_1.getHashedPercentateForObjIds)([

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

@@ -11,5 +11,5 @@ export declare class IdentityModel {
     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;
+    updateTraits(traits: TraitModel[]): void;
 }

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

@@ -58,7 +58,7 @@ var IdentityModel = /** @class */ (function () {
     IdentityModel.generateCompositeKey = function (env_key, identifier) {
         return "".concat(env_key, "_").concat(identifier);
     };
-    IdentityModel.prototype.update_traits = function (traits) {
+    IdentityModel.prototype.updateTraits = function (traits) {
         var e_1, _a, e_2, _b, e_3, _c;
         var existingTraits = new Map();
         try {

package/build/flagsmith-engine/index.js

@@ -99,7 +99,7 @@ exports.getIdentityFeatureStates = getIdentityFeatureStates;
 function getEnvironmentFeatureState(environment, featureName) {
     var featuresStates = environment.featureStates.filter(function (f) { return f.feature.name === featureName; });
     if (featuresStates.length === 0) {
-        throw new Error('Feature State Not Found');
+        throw new errors_1.FeatureStateNotFound('Feature State Not Found');
     }
     return featuresStates[0];
 }

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

@@ -5,5 +5,5 @@ export declare class OrganisationModel {
     stopServingFlags: boolean;
     persistTraitData: boolean;
     constructor(id: number, name: string, featureAnalytics: boolean, stopServingFlags: boolean, persistTraitData: boolean);
-    get unique_slug(): string;
+    get uniqueSlug(): string;
 }

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

@@ -9,7 +9,7 @@ var OrganisationModel = /** @class */ (function () {
         this.stopServingFlags = stopServingFlags;
         this.persistTraitData = persistTraitData;
     }
-    Object.defineProperty(OrganisationModel.prototype, "unique_slug", {
+    Object.defineProperty(OrganisationModel.prototype, "uniqueSlug", {
         get: function () {
             return this.id.toString() + '-' + this.name;
         },

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

@@ -22,9 +22,6 @@ exports.matchingFunctions = (_a = {},
     _a[constants_1.CONDITION_OPERATORS.CONTAINS] = function (thisValue, otherValue) {
         return otherValue.includes(thisValue);
     },
-    _a[constants_1.CONDITION_OPERATORS.NOT_CONTAINS] = function (thisValue, otherValue) {
-        return !otherValue.includes(thisValue);
-    },
     _a);
 var SegmentConditionModel = /** @class */ (function () {
     function SegmentConditionModel(operator, value, property) {

package/build/flagsmith-engine/utils/collections.d.ts

@@ -1,4 +1,3 @@
 import { FeatureStateModel } from '../features/models';
 export declare class IdentityFeaturesList extends Array<FeatureStateModel> {
-    push(...e: FeatureStateModel[]): number;
 }

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

@@ -14,42 +14,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-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.");
-};
-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.IdentityFeaturesList = void 0;
 var IdentityFeaturesList = /** @class */ (function (_super) {
@@ -57,41 +21,6 @@ var IdentityFeaturesList = /** @class */ (function (_super) {
     function IdentityFeaturesList() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    IdentityFeaturesList.prototype.push = function () {
-        var e_1, _a, e_2, _b;
-        var e = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            e[_i] = arguments[_i];
-        }
-        try {
-            for (var _c = __values(e.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var _e = __read(_d.value, 2), _ = _e[0], item = _e[1];
-                try {
-                    for (var _f = (e_2 = void 0, __values(this.entries())), _g = _f.next(); !_g.done; _g = _f.next()) {
-                        var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
-                        if (v.djangoID === item.djangoID) {
-                            throw new Error('feature state for this feature already exists');
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return _super.prototype.push.apply(this, __spreadArray([], __read(e), false));
-    };
     return IdentityFeaturesList;
 }(Array));
 exports.IdentityFeaturesList = IdentityFeaturesList;

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

@@ -45,11 +45,14 @@ function h2d(s) {
  */
 function getHashedPercentateForObjIds(objectIds, iterations) {
     if (iterations === void 0) { iterations = 1; }
-    var to_hash = makeRepeated(objectIds, iterations).join(',');
-    var hashedValue = (0, md5_1.default)(to_hash);
+    var toHash = makeRepeated(objectIds, iterations).join(',');
+    var hashedValue = (0, md5_1.default)(toHash);
     var hashedInt = (0, big_integer_1.default)(h2d(hashedValue));
     var value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
     if (value === 100) {
+        /* istanbul ignore next */
         return getHashedPercentateForObjIds(objectIds, iterations + 1);
     }
     return value;

package/build/sdk/analytics.js

@@ -44,7 +44,6 @@ var node_fetch_1 = __importDefault(require("node-fetch"));
 var ANALYTICS_ENDPOINT = 'analytics/flags/';
 // Used to control how often we send data(in seconds)
 var ANALYTICS_TIMER = 10;
-var delay = function (ms) { return new Promise(function (resolve) { return setTimeout(function () { return resolve(undefined); }, ms); }); };
 var AnalyticsProcessor = /** @class */ (function () {
     /**
      * AnalyticsProcessor is used to track how often individual Flags are evaluated within

package/build/sdk/index.d.ts

@@ -2,6 +2,7 @@ import { EnvironmentModel } from '../flagsmith-engine/environments/models';
 import { DefaultFlag, Flags } from './models';
 import { EnvironmentDataPollingManager } from './polling_manager';
 import { SegmentModel } from '../flagsmith-engine/segments/models';
+import { FlagsmithCache } from './types';
 export declare class Flagsmith {
     environmentKey?: string;
     apiUrl: string;
@@ -19,6 +20,8 @@ export declare class Flagsmith {
     environmentUrl: string;
     environmentDataPollingManager?: EnvironmentDataPollingManager;
     environment: EnvironmentModel;
+    private cache?;
+    private onEnvironmentChange?;
     private analyticsProcessor?;
     /**
      * A Flagsmith client.
@@ -62,6 +65,8 @@ export declare class Flagsmith {
         retries?: number;
         enableAnalytics?: boolean;
         defaultFlagHandler?: (featureName: string) => DefaultFlag;
+        cache?: FlagsmithCache;
+        onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
     });
     /**
      * Get all the default for flags for the current environment.

package/build/sdk/index.js

@@ -124,6 +124,14 @@ var Flagsmith = /** @class */ (function () {
         this.environmentFlagsUrl = "".concat(this.apiUrl, "flags/");
         this.identitiesUrl = "".concat(this.apiUrl, "identities/");
         this.environmentUrl = "".concat(this.apiUrl, "environment-document/");
+        this.onEnvironmentChange = data.onEnvironmentChange;
+        if (!!data.cache) {
+            var missingMethods = ['has', 'get', 'set'].filter(function (method) { return data.cache && !data.cache[method]; });
+            if (missingMethods.length > 0) {
+                throw new Error("Please implement the following methods in your cache: ".concat(missingMethods.join(', ')));
+            }
+            this.cache = data.cache;
+        }
         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.');
@@ -147,12 +155,34 @@ var Flagsmith = /** @class */ (function () {
      */
     Flagsmith.prototype.getEnvironmentFlags = function () {
         return __awaiter(this, void 0, void 0, function () {
+            var cachedItem, _a;
             var _this = this;
-            return __generator(this, function (_a) {
-                if (this.environment) {
-                    return [2 /*return*/, new Promise(function (resolve) { return resolve(_this.getEnvironmentFlagsFromDocument()); })];
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = !!this.cache;
+                        if (!_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.cache.get("flags")];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        cachedItem = _a;
+                        if (!!cachedItem) {
+                            return [2 /*return*/, cachedItem];
+                        }
+                        if (this.enableLocalEvaluation) {
+                            return [2 /*return*/, new Promise(function (resolve) {
+                                    return _this.environmentPromise.then(function () {
+                                        resolve(_this.getEnvironmentFlagsFromDocument());
+                                    });
+                                })];
+                        }
+                        if (this.environment) {
+                            return [2 /*return*/, this.getEnvironmentFlagsFromDocument()];
+                        }
+                        return [2 /*return*/, this.getEnvironmentFlagsFromApi()];
                 }
-                return [2 /*return*/, this.getEnvironmentFlagsFromApi()];
             });
         });
     };
@@ -168,16 +198,35 @@ var Flagsmith = /** @class */ (function () {
      * @returns Flags object holding all the flags for the given identity.
      */
     Flagsmith.prototype.getIdentityFlags = function (identifier, traits) {
-        var _this = this;
-        traits = traits || {};
-        if (this.enableLocalEvaluation) {
-            return new Promise(function (resolve) {
-                return _this.environmentPromise.then(function () {
-                    resolve(_this.getIdentityFlagsFromDocument(identifier, traits || {}));
-                });
+        return __awaiter(this, void 0, void 0, function () {
+            var cachedItem, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = !!this.cache;
+                        if (!_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.cache.get("flags-".concat(identifier))];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        cachedItem = _a;
+                        if (!!cachedItem) {
+                            return [2 /*return*/, cachedItem];
+                        }
+                        traits = traits || {};
+                        if (this.enableLocalEvaluation) {
+                            return [2 /*return*/, new Promise(function (resolve) {
+                                    return _this.environmentPromise.then(function () {
+                                        resolve(_this.getIdentityFlagsFromDocument(identifier, traits || {}));
+                                    });
+                                })];
+                        }
+                        return [2 /*return*/, this.getIdentityFlagsFromApi(identifier, traits)];
+                }
             });
-        }
-        return this.getIdentityFlagsFromApi(identifier, traits);
+        });
     };
     /**
      * Get the segments for the current environment for a given identity. Will also
@@ -215,11 +264,12 @@ var Flagsmith = /** @class */ (function () {
      */
     Flagsmith.prototype.updateEnvironment = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var request, _a;
+            var request, _a, e_1;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
+                        _b.trys.push([0, 5, , 6]);
                         request = this.getEnvironmentFromApi();
                         if (!!this.environmentPromise) return [3 /*break*/, 2];
                         this.environmentPromise = request.then(function (res) {
@@ -235,7 +285,18 @@ var Flagsmith = /** @class */ (function () {
                     case 3:
                         _a.environment = _b.sent();
                         _b.label = 4;
-                    case 4: return [2 /*return*/];
+                    case 4:
+                        if (this.onEnvironmentChange) {
+                            this.onEnvironmentChange(null, this.environment);
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        e_1 = _b.sent();
+                        if (this.onEnvironmentChange) {
+                            this.onEnvironmentChange(e_1, this.environment);
+                        }
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
                 }
             });
         });
@@ -243,7 +304,7 @@ var Flagsmith = /** @class */ (function () {
     Flagsmith.prototype.getJSONResponse = function (url, method, body) {
         return __awaiter(this, void 0, void 0, function () {
             var headers, _a, _b, _c, k, v, data;
-            var e_1, _d;
+            var e_2, _d;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
@@ -258,12 +319,12 @@ var Flagsmith = /** @class */ (function () {
                                     headers[k] = v;
                                 }
                             }
-                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
                             finally {
                                 try {
                                     if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
                                 }
-                                finally { if (e_1) throw e_1.error; }
+                                finally { if (e_2) throw e_2.error; }
                             }
                         }
                         return [4 /*yield*/, (0, utils_1.retryFetch)(url, {
@@ -296,87 +357,124 @@ var Flagsmith = /** @class */ (function () {
         });
     };
     Flagsmith.prototype.getEnvironmentFlagsFromDocument = function () {
-        return models_3.Flags.fromFeatureStateModels({
-            featureStates: (0, flagsmith_engine_1.getEnvironmentFeatureStates)(this.environment),
-            analyticsProcessor: this.analyticsProcessor,
-            defaultFlagHandler: this.defaultFlagHandler
+        return __awaiter(this, void 0, void 0, function () {
+            var flags;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        flags = models_3.Flags.fromFeatureStateModels({
+                            featureStates: (0, flagsmith_engine_1.getEnvironmentFeatureStates)(this.environment),
+                            analyticsProcessor: this.analyticsProcessor,
+                            defaultFlagHandler: this.defaultFlagHandler
+                        });
+                        if (!!!this.cache) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.cache.set('flags', flags)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, flags];
+                }
+            });
         });
     };
     Flagsmith.prototype.getIdentityFlagsFromDocument = function (identifier, traits) {
-        var identityModel = this.buildIdentityModel(identifier, Object.keys(traits).map(function (key) { return ({
-            key: key,
-            value: traits[key]
-        }); }));
-        var featureStates = (0, flagsmith_engine_1.getIdentityFeatureStates)(this.environment, identityModel);
-        return models_3.Flags.fromFeatureStateModels({
-            featureStates: featureStates,
-            analyticsProcessor: this.analyticsProcessor,
-            defaultFlagHandler: this.defaultFlagHandler
+        return __awaiter(this, void 0, void 0, function () {
+            var identityModel, featureStates, flags;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        identityModel = this.buildIdentityModel(identifier, Object.keys(traits).map(function (key) { return ({
+                            key: key,
+                            value: traits[key]
+                        }); }));
+                        featureStates = (0, flagsmith_engine_1.getIdentityFeatureStates)(this.environment, identityModel);
+                        flags = models_3.Flags.fromFeatureStateModels({
+                            featureStates: featureStates,
+                            analyticsProcessor: this.analyticsProcessor,
+                            defaultFlagHandler: this.defaultFlagHandler
+                        });
+                        if (!!!this.cache) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.cache.set("flags-".concat(identifier), flags)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, flags];
+                }
+            });
         });
     };
     Flagsmith.prototype.getEnvironmentFlagsFromApi = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var apiFlags, e_2;
+            var apiFlags, flags, e_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 2, , 3]);
+                        _a.trys.push([0, 4, , 5]);
                         return [4 /*yield*/, this.getJSONResponse(this.environmentFlagsUrl, 'GET')];
                     case 1:
                         apiFlags = _a.sent();
-                        return [2 /*return*/, models_3.Flags.fromAPIFlags({
-                                apiFlags: apiFlags,
-                                analyticsProcessor: this.analyticsProcessor,
-                                defaultFlagHandler: this.defaultFlagHandler
-                            })];
+                        flags = models_3.Flags.fromAPIFlags({
+                            apiFlags: apiFlags,
+                            analyticsProcessor: this.analyticsProcessor,
+                            defaultFlagHandler: this.defaultFlagHandler
+                        });
+                        if (!!!this.cache) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.cache.set('flags', flags)];
                     case 2:
-                        e_2 = _a.sent();
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, flags];
+                    case 4:
+                        e_3 = _a.sent();
                         if (this.defaultFlagHandler) {
                             return [2 /*return*/, new models_3.Flags({
                                     flags: {},
                                     defaultFlagHandler: this.defaultFlagHandler
                                 })];
                         }
-                        throw e_2;
-                    case 3: return [2 /*return*/];
+                        throw e_3;
+                    case 5: return [2 /*return*/];
                 }
             });
         });
     };
     Flagsmith.prototype.getIdentityFlagsFromApi = function (identifier, traits) {
         return __awaiter(this, void 0, void 0, function () {
-            var data, jsonResponse, e_3;
+            var data, jsonResponse, flags, e_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 2, , 3]);
+                        _a.trys.push([0, 4, , 5]);
                         data = (0, utils_1.generateIdentitiesData)(identifier, traits);
                         return [4 /*yield*/, this.getJSONResponse(this.identitiesUrl, 'POST', data)];
                     case 1:
                         jsonResponse = _a.sent();
-                        return [2 /*return*/, models_3.Flags.fromAPIFlags({
-                                apiFlags: jsonResponse['flags'],
-                                analyticsProcessor: this.analyticsProcessor,
-                                defaultFlagHandler: this.defaultFlagHandler
-                            })];
+                        flags = models_3.Flags.fromAPIFlags({
+                            apiFlags: jsonResponse['flags'],
+                            analyticsProcessor: this.analyticsProcessor,
+                            defaultFlagHandler: this.defaultFlagHandler
+                        });
+                        if (!!!this.cache) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.cache.set("flags-".concat(identifier), flags)];
                     case 2:
-                        e_3 = _a.sent();
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, flags];
+                    case 4:
+                        e_4 = _a.sent();
                         if (this.defaultFlagHandler) {
                             return [2 /*return*/, new models_3.Flags({
                                     flags: {},
                                     defaultFlagHandler: this.defaultFlagHandler
                                 })];
                         }
-                        throw e_3;
-                    case 3: return [2 /*return*/];
+                        throw e_4;
+                    case 5: return [2 /*return*/];
                 }
             });
         });
     };
     Flagsmith.prototype.buildIdentityModel = function (identifier, traits) {
-        if (!this.environment) {
-            throw new errors_1.FlagsmithClientError('Unable to build identity model when no local environment present.');
-        }
         var traitModels = traits.map(function (trait) { return new models_2.TraitModel(trait.key, trait.value); });
         return new models_1.IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
     };

package/build/sdk/polling_manager.js

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

package/build/sdk/types.d.ts

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

package/build/sdk/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });