flagsmith-nodejs 3.1.1 → 3.3.0

package/build/sdk/offline_handlers.js

@@ -0,0 +1,66 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFileHandler = exports.BaseOfflineHandler = void 0;
+var fs = __importStar(require("fs"));
+var util_1 = require("../flagsmith-engine/environments/util");
+var BaseOfflineHandler = /** @class */ (function () {
+    function BaseOfflineHandler() {
+    }
+    BaseOfflineHandler.prototype.getEnvironment = function () {
+        throw new Error('Not implemented');
+    };
+    return BaseOfflineHandler;
+}());
+exports.BaseOfflineHandler = BaseOfflineHandler;
+var LocalFileHandler = /** @class */ (function (_super) {
+    __extends(LocalFileHandler, _super);
+    function LocalFileHandler(environment_document_path) {
+        var _this = _super.call(this) || this;
+        var environment_document = fs.readFileSync(environment_document_path, 'utf8');
+        _this.environment = (0, util_1.buildEnvironmentModel)(JSON.parse(environment_document));
+        return _this;
+    }
+    LocalFileHandler.prototype.getEnvironment = function () {
+        return this.environment;
+    };
+    return LocalFileHandler;
+}(BaseOfflineHandler));
+exports.LocalFileHandler = LocalFileHandler;

package/build/sdk/types.d.ts

@@ -2,6 +2,7 @@ import { DefaultFlag, Flags } from "./models";
 import { EnvironmentModel } from "../flagsmith-engine";
 import { RequestInit } from "node-fetch";
 import { Logger } from "pino";
+import { BaseOfflineHandler } from "./offline_handlers";
 export interface FlagsmithCache {
     get(key: string): Promise<Flags | undefined> | undefined;
     set(key: string, value: Flags, ttl: string | number): boolean | Promise<boolean>;
@@ -9,7 +10,7 @@ export interface FlagsmithCache {
     [key: string]: any;
 }
 export interface FlagsmithConfig {
-    environmentKey: string;
+    environmentKey?: string;
     apiUrl?: string;
     agent?: RequestInit['agent'];
     customHeaders?: {
@@ -24,4 +25,6 @@ export interface FlagsmithConfig {
     cache?: FlagsmithCache;
     onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
     logger?: Logger;
+    offlineMode?: boolean;
+    offlineHandler?: BaseOfflineHandler;
 }

package/flagsmith-engine/environments/models.ts

@@ -1,6 +1,6 @@
 import { FeatureStateModel } from '../features/models';
+import { IdentityModel } from '../identities/models';
 import { ProjectModel } from '../projects/models';
-import { IntegrationModel } from './integrations/models';
 
 export class EnvironmentAPIKeyModel {
     id: number;
@@ -37,10 +37,7 @@ export class EnvironmentModel {
     apiKey: string;
     project: ProjectModel;
     featureStates: FeatureStateModel[] = [];
-    amplitude_config?: IntegrationModel;
-    segment_config?: IntegrationModel;
-    mixpanel_config?: IntegrationModel;
-    heap_config?: IntegrationModel;
+    identityOverrides: IdentityModel[] = [];
 
     constructor(id: number, apiKey: string, project: ProjectModel) {
         this.id = id;

package/flagsmith-engine/environments/util.ts

@@ -1,4 +1,5 @@
 import { buildFeatureStateModel } from '../features/util';
+import { buildIdentityModel } from '../identities/util';
 import { buildProjectModel } from '../projects/util';
 import { EnvironmentAPIKeyModel, EnvironmentModel } from './models';
 
@@ -13,6 +14,11 @@ export function buildEnvironmentModel(environmentJSON: any) {
         project
     );
     environmentModel.featureStates = featureStates;
+    if (!!environmentJSON.identity_overrides) {
+        environmentModel.identityOverrides = environmentJSON.identity_overrides.map((identityData: any) =>
+            buildIdentityModel(identityData)
+        );
+    }
     return environmentModel;
 }
 

package/flagsmith-engine/features/util.ts

@@ -16,25 +16,26 @@ export function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStat
         featuresStateModelJSON.enabled,
         featuresStateModelJSON.django_id,
         featuresStateModelJSON.feature_state_value,
-        featuresStateModelJSON.uuid
+        featuresStateModelJSON.featurestate_uuid
     );
 
-    featureStateModel.featureSegment = featuresStateModelJSON.feature_segment ? 
-        buildFeatureSegment(featuresStateModelJSON.feature_segment) : 
+    featureStateModel.featureSegment = featuresStateModelJSON.feature_segment ?
+        buildFeatureSegment(featuresStateModelJSON.feature_segment) :
         undefined;
 
     const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
         ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv: any) => {
-              const featureOption = new MultivariateFeatureOptionModel(
-                  fsv.multivariate_feature_option.value,
-                  fsv.multivariate_feature_option.id
-              );
-              return new MultivariateFeatureStateValueModel(
-                  featureOption,
-                  fsv.percentage_allocation,
-                  fsv.id
-              );
-          })
+            const featureOption = new MultivariateFeatureOptionModel(
+                fsv.multivariate_feature_option.value,
+                fsv.multivariate_feature_option.id
+            );
+            return new MultivariateFeatureStateValueModel(
+                featureOption,
+                fsv.percentage_allocation,
+                fsv.id,
+                fsv.mv_fs_value_uuid
+            );
+        })
         : [];
 
     featureStateModel.multivariateFeatureStateValues = multivariateFeatureStateValues;

package/flagsmith-engine/index.ts

@@ -7,7 +7,6 @@ import { SegmentModel } from './segments/models';
 import { FeatureStateNotFound } from './utils/errors';
 
 export { EnvironmentModel } from './environments/models';
-export { IntegrationModel } from './environments/integrations/models';
 export { FeatureStateModel } from './features/models';
 export { IdentityModel } from './identities/models';
 export { TraitModel } from './identities/traits/models';

package/index.ts

@@ -11,9 +11,12 @@ export {
   default
 } from './sdk';
 
+export {
+  FlagsmithConfig
+} from './sdk/types'
+
 export {
   EnvironmentModel,
-  IntegrationModel,
   FeatureStateModel,
   IdentityModel,
   TraitModel,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "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": {

package/sdk/index.ts

@@ -1,4 +1,4 @@
-import { RequestInit } from "node-fetch";
+import { RequestInit } from 'node-fetch';
 import { getEnvironmentFeatureStates, getIdentityFeatureStates } from '../flagsmith-engine';
 import { EnvironmentModel } from '../flagsmith-engine/environments/models';
 import { buildEnvironmentModel } from '../flagsmith-engine/environments/util';
@@ -6,6 +6,7 @@ import { IdentityModel } from '../flagsmith-engine/identities/models';
 import { TraitModel } from '../flagsmith-engine/identities/traits/models';
 
 import { AnalyticsProcessor } from './analytics';
+import { BaseOfflineHandler } from './offline_handlers';
 import { FlagsmithAPIError, FlagsmithClientError } from './errors';
 
 import { DefaultFlag, Flags } from './models';
@@ -14,7 +15,7 @@ import { generateIdentitiesData, retryFetch } from './utils';
 import { SegmentModel } from '../flagsmith-engine/segments/models';
 import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators';
 import { FlagsmithCache, FlagsmithConfig } from './types';
-import pino, { Logger } from "pino";
+import pino, { Logger } from 'pino';
 
 export { AnalyticsProcessor } from './analytics';
 export { FlagsmithAPIError, FlagsmithClientError } from './errors';
@@ -26,10 +27,9 @@ export { FlagsmithCache, FlagsmithConfig } from './types';
 const DEFAULT_API_URL = 'https://edge.api.flagsmith.com/api/v1/';
 const DEFAULT_REQUEST_TIMEOUT_SECONDS = 10;
 
-
 export class Flagsmith {
-    environmentKey?: string;
-    apiUrl: string = DEFAULT_API_URL;
+    environmentKey?: string = undefined;
+    apiUrl?: string = undefined;
     customHeaders?: { [key: string]: any };
     agent: RequestInit['agent'];
     requestTimeoutMs?: number;
@@ -40,12 +40,16 @@ export class Flagsmith {
     defaultFlagHandler?: (featureName: string) => DefaultFlag;
 
 
-    environmentFlagsUrl: string;
-    identitiesUrl: string;
-    environmentUrl: string;
+    environmentFlagsUrl?: string;
+    identitiesUrl?: string;
+    environmentUrl?: string;
 
     environmentDataPollingManager?: EnvironmentDataPollingManager;
     environment!: EnvironmentModel;
+    offlineMode: boolean = false;
+    offlineHandler?: BaseOfflineHandler = undefined;
+
+    identitiesWithOverridesByIdentifier?: Map<string, IdentityModel>;
 
     private cache?: FlagsmithCache;
     private onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
@@ -65,6 +69,7 @@ export class Flagsmith {
      * const featureEnabledForIdentity = identityFlags.isFeatureEnabled("foo")
      *
      *  @param {string} data.environmentKey: The environment key obtained from Flagsmith interface
+     *      Required unless offlineMode is True.
         @param {string} data.apiUrl: Override the URL of the Flagsmith API to communicate with
         @param  data.customHeaders: Additional headers to add to requests made to the
             Flagsmith API
@@ -78,16 +83,26 @@ export class Flagsmith {
         @param {boolean} data.enableAnalytics: if enabled, sends additional requests to the Flagsmith
             API to power flag analytics charts
         @param data.defaultFlagHandler: callable which will be used in the case where
-            flags cannot be retrieved from the API or a non existent feature is
+            flags cannot be retrieved from the API or a non-existent feature is
             requested
         @param data.logger: an instance of the pino Logger class to use for logging
-     */
-    constructor(data: FlagsmithConfig) {
+        @param {boolean} data.offlineMode: sets the client into offline mode. Relies on offlineHandler for
+            evaluating flags.
+        @param {BaseOfflineHandler} data.offlineHandler: provide a handler for offline logic. Used to get environment
+            document from another source when in offlineMode. Works in place of
+            defaultFlagHandler if offlineMode is not set and using remote evaluation.
+    */
+    constructor(data: FlagsmithConfig = {}) {
+        // if (!data.offlineMode && !data.environmentKey) {
+        //     throw new Error('ValueError: environmentKey is required.');
+        // }
+
         this.agent = data.agent;
         this.environmentKey = data.environmentKey;
         this.apiUrl = data.apiUrl || this.apiUrl;
         this.customHeaders = data.customHeaders;
-        this.requestTimeoutMs = 1000 * (data.requestTimeoutSeconds ?? DEFAULT_REQUEST_TIMEOUT_SECONDS);
+        this.requestTimeoutMs =
+            1000 * (data.requestTimeoutSeconds ?? DEFAULT_REQUEST_TIMEOUT_SECONDS);
         this.enableLocalEvaluation = data.enableLocalEvaluation;
         this.environmentRefreshIntervalSeconds =
             data.environmentRefreshIntervalSeconds || this.environmentRefreshIntervalSeconds;
@@ -95,14 +110,26 @@ export class Flagsmith {
         this.enableAnalytics = data.enableAnalytics || false;
         this.defaultFlagHandler = data.defaultFlagHandler;
 
-        this.environmentFlagsUrl = `${this.apiUrl}flags/`;
-        this.identitiesUrl = `${this.apiUrl}identities/`;
-        this.environmentUrl = `${this.apiUrl}environment-document/`;
         this.onEnvironmentChange = data.onEnvironmentChange;
         this.logger = data.logger || pino();
+        this.offlineMode = data.offlineMode || false;
+        this.offlineHandler = data.offlineHandler;
+
+        // argument validation
+        if (this.offlineMode && !this.offlineHandler) {
+            throw new Error('ValueError: offlineHandler must be provided to use offline mode.');
+        } else if (this.defaultFlagHandler && this.offlineHandler) {
+            throw new Error('ValueError: Cannot use both defaultFlagHandler and offlineHandler.');
+        }
+
+        if (this.offlineHandler) {
+            this.environment = this.offlineHandler.getEnvironment();
+        }
 
         if (!!data.cache) {
-            const missingMethods: string[] = ['has', 'get', 'set'].filter(method => data.cache && !data.cache[method]);
+            const missingMethods: string[] = ['has', 'get', 'set'].filter(
+                method => data.cache && !data.cache[method]
+            );
 
             if (missingMethods.length > 0) {
                 throw new Error(
@@ -114,28 +141,40 @@ export class Flagsmith {
             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.'
+        if (!this.offlineMode) {
+            if (!this.environmentKey) {
+                throw new Error('ValueError: environmentKey is required.');
+            }
+
+            const apiUrl = data.apiUrl || DEFAULT_API_URL;
+            this.apiUrl = apiUrl.endsWith('/') ? apiUrl : `${apiUrl}/`;
+            this.environmentFlagsUrl = `${this.apiUrl}flags/`;
+            this.identitiesUrl = `${this.apiUrl}identities/`;
+            this.environmentUrl = `${this.apiUrl}environment-document/`;
+
+            if (this.enableLocalEvaluation) {
+                if (!this.environmentKey.startsWith('ser.')) {
+                    console.error(
+                        'In order to use local evaluation, please generate a server key in the environment settings page.'
+                    );
+                }
+                this.environmentDataPollingManager = new EnvironmentDataPollingManager(
+                    this,
+                    this.environmentRefreshIntervalSeconds
                 );
+                this.environmentDataPollingManager.start();
+                this.updateEnvironment();
             }
-            this.environmentDataPollingManager = new EnvironmentDataPollingManager(
-                this,
-                this.environmentRefreshIntervalSeconds
-            );
-            this.environmentDataPollingManager.start();
-            this.updateEnvironment();
-        }
 
-        this.analyticsProcessor = data.enableAnalytics
-            ? new AnalyticsProcessor({
-                environmentKey: this.environmentKey,
-                baseApiUrl: this.apiUrl,
-                requestTimeoutMs: this.requestTimeoutMs,
-                logger: this.logger
-            })
-            : undefined;
+            this.analyticsProcessor = data.enableAnalytics
+                ? new AnalyticsProcessor({
+                    environmentKey: this.environmentKey,
+                    baseApiUrl: this.apiUrl,
+                    requestTimeoutMs: this.requestTimeoutMs,
+                    logger: this.logger
+                })
+                : undefined;
+        }
     }
     /**
      * Get all the default for flags for the current environment.
@@ -143,15 +182,15 @@ export class Flagsmith {
      * @returns Flags object holding all the flags for the current environment.
      */
     async getEnvironmentFlags(): Promise<Flags> {
-        const cachedItem = !!this.cache && await this.cache.get(`flags`);
+        const cachedItem = !!this.cache && (await this.cache.get(`flags`));
         if (!!cachedItem) {
             return cachedItem;
         }
-        if (this.enableLocalEvaluation) {
+        if (this.enableLocalEvaluation && !this.offlineMode) {
             return new Promise((resolve, reject) =>
                 this.environmentPromise!.then(() => {
                     resolve(this.getEnvironmentFlagsFromDocument());
-                }).catch((e) => reject(e))
+                }).catch(e => reject(e))
             );
         }
         if (this.environment) {
@@ -160,6 +199,7 @@ export class Flagsmith {
 
         return this.getEnvironmentFlagsFromApi();
     }
+
     /**
      * Get all the flags for the current environment for a given identity. Will also
         upsert all traits to the Flagsmith API for future evaluations. Providing a
@@ -173,10 +213,10 @@ export class Flagsmith {
      */
     async getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
         if (!identifier) {
-            throw new Error("`identifier` argument is missing or invalid.")
+            throw new Error('`identifier` argument is missing or invalid.');
         }
 
-        const cachedItem = !!this.cache && await this.cache.get(`flags-${identifier}`);
+        const cachedItem = !!this.cache && (await this.cache.get(`flags-${identifier}`));
         if (!!cachedItem) {
             return cachedItem;
         }
@@ -188,6 +228,10 @@ export class Flagsmith {
                 }).catch(e => reject(e))
             );
         }
+        if (this.offlineMode) {
+            return this.getIdentityFlagsFromDocument(identifier, traits || {});
+        }
+
         return this.getIdentityFlagsFromApi(identifier, traits);
     }
 
@@ -207,14 +251,14 @@ export class Flagsmith {
         traits?: { [key: string]: any }
     ): Promise<SegmentModel[]> {
         if (!identifier) {
-            throw new Error("`identifier` argument is missing or invalid.")
+            throw new Error('`identifier` argument is missing or invalid.');
         }
 
         traits = traits || {};
         if (this.enableLocalEvaluation) {
             return new Promise((resolve, reject) => {
                 return this.environmentPromise!.then(() => {
-                    const identityModel = this.buildIdentityModel(
+                    const identityModel = this.getIdentityModel(
                         identifier,
                         Object.keys(traits || {}).map(key => ({
                             key,
@@ -224,7 +268,7 @@ export class Flagsmith {
 
                     const segments = getIdentitySegments(this.environment, identityModel);
                     return resolve(segments);
-                }).catch((e) => reject(e));
+                }).catch(e => reject(e));
             });
         }
         console.error('This function is only permitted with local evaluation.');
@@ -247,6 +291,11 @@ export class Flagsmith {
             } else {
                 this.environment = await request;
             }
+            if (this.environment.identityOverrides?.length) {
+                this.identitiesWithOverridesByIdentifier = new Map<string, IdentityModel>(
+                    this.environment.identityOverrides.map(identity => [identity.identifier, identity]
+                    ));
+            }
             if (this.onEnvironmentChange) {
                 this.onEnvironmentChange(null, this.environment);
             }
@@ -286,7 +335,7 @@ export class Flagsmith {
                 headers: headers
             },
             this.retries,
-            this.requestTimeoutMs || undefined,
+            this.requestTimeoutMs || undefined
         );
 
         if (data.status !== 200) {
@@ -304,6 +353,9 @@ export class Flagsmith {
     private environmentPromise: Promise<any> | undefined;
 
     private async getEnvironmentFromApi() {
+        if (!this.environmentUrl) {
+            throw new Error('`apiUrl` argument is missing or invalid.');
+        }
         const environment_data = await this.getJSONResponse(this.environmentUrl, 'GET');
         return buildEnvironmentModel(environment_data);
     }
@@ -321,8 +373,11 @@ export class Flagsmith {
         return flags;
     }
 
-    private async getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }): Promise<Flags> {
-        const identityModel = this.buildIdentityModel(
+    private async getIdentityFlagsFromDocument(
+        identifier: string,
+        traits: { [key: string]: any }
+    ): Promise<Flags> {
+        const identityModel = this.getIdentityModel(
             identifier,
             Object.keys(traits).map(key => ({
                 key,
@@ -348,6 +403,9 @@ export class Flagsmith {
     }
 
     private async getEnvironmentFlagsFromApi() {
+        if (!this.environmentFlagsUrl) {
+            throw new Error('`apiUrl` argument is missing or invalid.');
+        }
         try {
             const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
             const flags = Flags.fromAPIFlags({
@@ -361,6 +419,9 @@ export class Flagsmith {
             }
             return flags;
         } catch (e) {
+            if (this.offlineHandler) {
+                return this.getEnvironmentFlagsFromDocument();
+            }
             if (this.defaultFlagHandler) {
                 return new Flags({
                     flags: {},
@@ -373,6 +434,9 @@ export class Flagsmith {
     }
 
     private async getIdentityFlagsFromApi(identifier: string, traits: { [key: string]: any }) {
+        if (!this.identitiesUrl) {
+            throw new Error('`apiUrl` argument is missing or invalid.');
+        }
         try {
             const data = generateIdentitiesData(identifier, traits);
             const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
@@ -387,6 +451,9 @@ export class Flagsmith {
             }
             return flags;
         } catch (e) {
+            if (this.offlineHandler) {
+                return this.getIdentityFlagsFromDocument(identifier, traits);
+            }
             if (this.defaultFlagHandler) {
                 return new Flags({
                     flags: {},
@@ -398,11 +465,15 @@ export class Flagsmith {
         }
     }
 
-    private buildIdentityModel(identifier: string, traits: { key: string; value: any }[]) {
+    private getIdentityModel(identifier: string, traits: { key: string; value: any }[]) {
         const traitModels = traits.map(trait => new TraitModel(trait.key, trait.value));
+        let identityWithOverrides = this.identitiesWithOverridesByIdentifier?.get(identifier);
+        if (identityWithOverrides) {
+            identityWithOverrides.updateTraits(traitModels);
+            return identityWithOverrides;
+        }
         return new IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
     }
 }
 
 export default Flagsmith;
-

package/sdk/offline_handlers.ts

@@ -0,0 +1,22 @@
+import * as fs from 'fs';
+import { buildEnvironmentModel } from '../flagsmith-engine/environments/util';
+import { EnvironmentModel } from '../flagsmith-engine/environments/models';
+
+export class BaseOfflineHandler {
+    getEnvironment() : EnvironmentModel {
+        throw new Error('Not implemented');
+    }
+}
+
+export class LocalFileHandler extends BaseOfflineHandler {
+    environment: EnvironmentModel;
+    constructor(environment_document_path: string) {
+        super();
+        const environment_document = fs.readFileSync(environment_document_path, 'utf8');
+        this.environment = buildEnvironmentModel(JSON.parse(environment_document));
+    }
+
+    getEnvironment(): EnvironmentModel {
+        return this.environment;
+    }
+}

package/sdk/types.ts

@@ -2,6 +2,7 @@ import { DefaultFlag, Flags } from "./models";
 import { EnvironmentModel } from "../flagsmith-engine";
 import { RequestInit } from "node-fetch";
 import { Logger } from "pino";
+import { BaseOfflineHandler } from "./offline_handlers";
 
 export interface FlagsmithCache {
   get(key: string): Promise<Flags|undefined> | undefined;
@@ -11,7 +12,7 @@ export interface FlagsmithCache {
 }
 
 export interface FlagsmithConfig {
-  environmentKey: string;
+  environmentKey?: string;
   apiUrl?: string;
   agent?:RequestInit['agent'];
   customHeaders?: { [key: string]: any };
@@ -24,4 +25,6 @@ export interface FlagsmithConfig {
   cache?: FlagsmithCache,
   onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void,
   logger?: Logger
+  offlineMode?: boolean;
+  offlineHandler?: BaseOfflineHandler;
 }

package/tests/sdk/data/environment.json

@@ -17,6 +17,7 @@
         "feature_states": [
           {
             "feature_state_value": "segment_override",
+            "featurestate_uuid": "dd77a1ab-08cf-4743-8a3b-19e730444a14",
             "multivariate_feature_state_values": [],
             "django_id": 81027,
             "feature": {
@@ -88,5 +89,30 @@
       "featurestate_uuid": "96fc3503-09d7-48f1-a83b-2dc903d5c08a",
       "enabled": false
     }
+  ],
+  "identity_overrides": [
+    {
+      "identifier": "overridden-id",
+      "identity_uuid": "0f21cde8-63c5-4e50-baca-87897fa6cd01",
+      "created_date": "2019-08-27T14:53:45.698555Z",
+      "updated_at": "2023-07-14 16:12:00.000000",
+      "environment_api_key": "B62qaMZNwfiqT76p38ggrQ",
+      "identity_features": [
+        {
+          "id": 1,
+          "feature": {
+            "id": 1,
+            "name": "some_feature",
+            "type": "STANDARD"
+          },
+          "featurestate_uuid": "1bddb9a5-7e59-42c6-9be9-625fa369749f",
+          "feature_state_value": "some-overridden-value",
+          "enabled": false,
+          "environment": 1,
+          "identity": null,
+          "feature_segment": null
+        }
+      ]
+    }
   ]
-}
+}