flagsmith-nodejs 3.1.1 → 3.2.0

package/build/sdk/index.d.ts

@@ -1,5 +1,6 @@
-import { RequestInit } from "node-fetch";
+import { RequestInit } from 'node-fetch';
 import { EnvironmentModel } from '../flagsmith-engine/environments/models';
+import { BaseOfflineHandler } from './offline_handlers';
 import { DefaultFlag, Flags } from './models';
 import { EnvironmentDataPollingManager } from './polling_manager';
 import { SegmentModel } from '../flagsmith-engine/segments/models';
@@ -11,7 +12,7 @@ export { EnvironmentDataPollingManager } from './polling_manager';
 export { FlagsmithCache, FlagsmithConfig } from './types';
 export declare class Flagsmith {
     environmentKey?: string;
-    apiUrl: string;
+    apiUrl?: string;
     customHeaders?: {
         [key: string]: any;
     };
@@ -22,11 +23,13 @@ export declare class Flagsmith {
     retries?: number;
     enableAnalytics: boolean;
     defaultFlagHandler?: (featureName: string) => DefaultFlag;
-    environmentFlagsUrl: string;
-    identitiesUrl: string;
-    environmentUrl: string;
+    environmentFlagsUrl?: string;
+    identitiesUrl?: string;
+    environmentUrl?: string;
     environmentDataPollingManager?: EnvironmentDataPollingManager;
     environment: EnvironmentModel;
+    offlineMode: boolean;
+    offlineHandler?: BaseOfflineHandler;
     private cache?;
     private onEnvironmentChange?;
     private analyticsProcessor?;
@@ -45,6 +48,7 @@ export declare 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
@@ -58,11 +62,16 @@ export declare 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);
     /**
      * Get all the default for flags for the current environment.
      *

package/build/sdk/index.js

@@ -105,6 +105,7 @@ var Flagsmith = /** @class */ (function () {
      * 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
@@ -118,32 +119,54 @@ var Flagsmith = /** @class */ (function () {
         @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
-     */
+        @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.
+    */
     function Flagsmith(data) {
+        // if (!data.offlineMode && !data.environmentKey) {
+        //     throw new Error('ValueError: environmentKey is required.');
+        // }
+        if (data === void 0) { data = {}; }
         var _a;
-        this.apiUrl = DEFAULT_API_URL;
+        this.environmentKey = undefined;
+        this.apiUrl = undefined;
         this.enableLocalEvaluation = false;
         this.environmentRefreshIntervalSeconds = 60;
         this.enableAnalytics = false;
+        this.offlineMode = false;
+        this.offlineHandler = undefined;
         this.agent = data.agent;
         this.environmentKey = data.environmentKey;
         this.apiUrl = data.apiUrl || this.apiUrl;
         this.customHeaders = data.customHeaders;
-        this.requestTimeoutMs = 1000 * ((_a = data.requestTimeoutSeconds) !== null && _a !== void 0 ? _a : DEFAULT_REQUEST_TIMEOUT_SECONDS);
+        this.requestTimeoutMs =
+            1000 * ((_a = data.requestTimeoutSeconds) !== null && _a !== void 0 ? _a : DEFAULT_REQUEST_TIMEOUT_SECONDS);
         this.enableLocalEvaluation = data.enableLocalEvaluation;
         this.environmentRefreshIntervalSeconds =
             data.environmentRefreshIntervalSeconds || this.environmentRefreshIntervalSeconds;
         this.retries = data.retries;
         this.enableAnalytics = data.enableAnalytics || false;
         this.defaultFlagHandler = data.defaultFlagHandler;
-        this.environmentFlagsUrl = "".concat(this.apiUrl, "flags/");
-        this.identitiesUrl = "".concat(this.apiUrl, "identities/");
-        this.environmentUrl = "".concat(this.apiUrl, "environment-document/");
         this.onEnvironmentChange = data.onEnvironmentChange;
         this.logger = data.logger || (0, pino_1.default)();
+        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) {
             var missingMethods = ['has', 'get', 'set'].filter(function (method) { return data.cache && !data.cache[method]; });
             if (missingMethods.length > 0) {
@@ -151,22 +174,32 @@ var Flagsmith = /** @class */ (function () {
             }
             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.');
+            }
+            var apiUrl = data.apiUrl || DEFAULT_API_URL;
+            this.apiUrl = apiUrl.endsWith('/') ? apiUrl : "".concat(apiUrl, "/");
+            this.environmentFlagsUrl = "".concat(this.apiUrl, "flags/");
+            this.identitiesUrl = "".concat(this.apiUrl, "identities/");
+            this.environmentUrl = "".concat(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 polling_manager_1.EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds);
+                this.environmentDataPollingManager.start();
+                this.updateEnvironment();
             }
-            this.environmentDataPollingManager = new polling_manager_1.EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds);
-            this.environmentDataPollingManager.start();
-            this.updateEnvironment();
+            this.analyticsProcessor = data.enableAnalytics
+                ? new analytics_1.AnalyticsProcessor({
+                    environmentKey: this.environmentKey,
+                    baseApiUrl: this.apiUrl,
+                    requestTimeoutMs: this.requestTimeoutMs,
+                    logger: this.logger
+                })
+                : undefined;
         }
-        this.analyticsProcessor = data.enableAnalytics
-            ? new analytics_1.AnalyticsProcessor({
-                environmentKey: this.environmentKey,
-                baseApiUrl: this.apiUrl,
-                requestTimeoutMs: this.requestTimeoutMs,
-                logger: this.logger
-            })
-            : undefined;
     }
     /**
      * Get all the default for flags for the current environment.
@@ -191,7 +224,7 @@ var Flagsmith = /** @class */ (function () {
                         if (!!cachedItem) {
                             return [2 /*return*/, cachedItem];
                         }
-                        if (this.enableLocalEvaluation) {
+                        if (this.enableLocalEvaluation && !this.offlineMode) {
                             return [2 /*return*/, new Promise(function (resolve, reject) {
                                     return _this.environmentPromise.then(function () {
                                         resolve(_this.getEnvironmentFlagsFromDocument());
@@ -225,7 +258,7 @@ var Flagsmith = /** @class */ (function () {
                 switch (_b.label) {
                     case 0:
                         if (!identifier) {
-                            throw new Error("`identifier` argument is missing or invalid.");
+                            throw new Error('`identifier` argument is missing or invalid.');
                         }
                         _a = !!this.cache;
                         if (!_a) return [3 /*break*/, 2];
@@ -246,6 +279,9 @@ var Flagsmith = /** @class */ (function () {
                                     }).catch(function (e) { return reject(e); });
                                 })];
                         }
+                        if (this.offlineMode) {
+                            return [2 /*return*/, this.getIdentityFlagsFromDocument(identifier, traits || {})];
+                        }
                         return [2 /*return*/, this.getIdentityFlagsFromApi(identifier, traits)];
                 }
             });
@@ -265,7 +301,7 @@ var Flagsmith = /** @class */ (function () {
     Flagsmith.prototype.getIdentitySegments = function (identifier, traits) {
         var _this = this;
         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) {
@@ -383,7 +419,11 @@ var Flagsmith = /** @class */ (function () {
             var environment_data;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getJSONResponse(this.environmentUrl, 'GET')];
+                    case 0:
+                        if (!this.environmentUrl) {
+                            throw new Error('`apiUrl` argument is missing or invalid.');
+                        }
+                        return [4 /*yield*/, this.getJSONResponse(this.environmentUrl, 'GET')];
                     case 1:
                         environment_data = _a.sent();
                         return [2 /*return*/, (0, util_1.buildEnvironmentModel)(environment_data)];
@@ -449,25 +489,33 @@ var Flagsmith = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 4, , 5]);
-                        return [4 /*yield*/, this.getJSONResponse(this.environmentFlagsUrl, 'GET')];
+                        if (!this.environmentFlagsUrl) {
+                            throw new Error('`apiUrl` argument is missing or invalid.');
+                        }
+                        _a.label = 1;
                     case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        return [4 /*yield*/, this.getJSONResponse(this.environmentFlagsUrl, 'GET')];
+                    case 2:
                         apiFlags = _a.sent();
                         flags = models_3.Flags.fromAPIFlags({
                             apiFlags: apiFlags,
                             analyticsProcessor: this.analyticsProcessor,
                             defaultFlagHandler: this.defaultFlagHandler
                         });
-                        if (!!!this.cache) return [3 /*break*/, 3];
+                        if (!!!this.cache) return [3 /*break*/, 4];
                         // @ts-ignore node-cache types are incorrect, ttl should be optional
                         return [4 /*yield*/, this.cache.set('flags', flags)];
-                    case 2:
+                    case 3:
                         // @ts-ignore node-cache types are incorrect, ttl should be optional
                         _a.sent();
-                        _a.label = 3;
-                    case 3: return [2 /*return*/, flags];
-                    case 4:
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, flags];
+                    case 5:
                         e_3 = _a.sent();
+                        if (this.offlineHandler) {
+                            return [2 /*return*/, this.getEnvironmentFlagsFromDocument()];
+                        }
                         if (this.defaultFlagHandler) {
                             return [2 /*return*/, new models_3.Flags({
                                     flags: {},
@@ -475,7 +523,7 @@ var Flagsmith = /** @class */ (function () {
                                 })];
                         }
                         throw e_3;
-                    case 5: return [2 /*return*/];
+                    case 6: return [2 /*return*/];
                 }
             });
         });
@@ -486,26 +534,34 @@ var Flagsmith = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 4, , 5]);
+                        if (!this.identitiesUrl) {
+                            throw new Error('`apiUrl` argument is missing or invalid.');
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
                         data = (0, utils_1.generateIdentitiesData)(identifier, traits);
                         return [4 /*yield*/, this.getJSONResponse(this.identitiesUrl, 'POST', data)];
-                    case 1:
+                    case 2:
                         jsonResponse = _a.sent();
                         flags = models_3.Flags.fromAPIFlags({
                             apiFlags: jsonResponse['flags'],
                             analyticsProcessor: this.analyticsProcessor,
                             defaultFlagHandler: this.defaultFlagHandler
                         });
-                        if (!!!this.cache) return [3 /*break*/, 3];
+                        if (!!!this.cache) return [3 /*break*/, 4];
                         // @ts-ignore node-cache types are incorrect, ttl should be optional
                         return [4 /*yield*/, this.cache.set("flags-".concat(identifier), flags)];
-                    case 2:
+                    case 3:
                         // @ts-ignore node-cache types are incorrect, ttl should be optional
                         _a.sent();
-                        _a.label = 3;
-                    case 3: return [2 /*return*/, flags];
-                    case 4:
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, flags];
+                    case 5:
                         e_4 = _a.sent();
+                        if (this.offlineHandler) {
+                            return [2 /*return*/, this.getIdentityFlagsFromDocument(identifier, traits)];
+                        }
                         if (this.defaultFlagHandler) {
                             return [2 /*return*/, new models_3.Flags({
                                     flags: {},
@@ -513,7 +569,7 @@ var Flagsmith = /** @class */ (function () {
                                 })];
                         }
                         throw e_4;
-                    case 5: return [2 /*return*/];
+                    case 6: return [2 /*return*/];
                 }
             });
         });

package/build/sdk/offline_handlers.d.ts

@@ -0,0 +1,9 @@
+import { EnvironmentModel } from '../flagsmith-engine/environments/models';
+export declare class BaseOfflineHandler {
+    getEnvironment(): EnvironmentModel;
+}
+export declare class LocalFileHandler extends BaseOfflineHandler {
+    environment: EnvironmentModel;
+    constructor(environment_document_path: string);
+    getEnvironment(): EnvironmentModel;
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "3.1.1",
+  "version": "3.2.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,14 @@ 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;
 
     private cache?: FlagsmithCache;
     private onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
@@ -65,6 +67,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 +81,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 +108,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 +139,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 +180,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 +197,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 +211,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 +226,10 @@ export class Flagsmith {
                 }).catch(e => reject(e))
             );
         }
+        if (this.offlineMode) {
+            return this.getIdentityFlagsFromDocument(identifier, traits || {});
+        }
+
         return this.getIdentityFlagsFromApi(identifier, traits);
     }
 
@@ -207,7 +249,7 @@ 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 || {};
@@ -224,7 +266,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.');
@@ -286,7 +328,7 @@ export class Flagsmith {
                 headers: headers
             },
             this.retries,
-            this.requestTimeoutMs || undefined,
+            this.requestTimeoutMs || undefined
         );
 
         if (data.status !== 200) {
@@ -304,6 +346,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,7 +366,10 @@ export class Flagsmith {
         return flags;
     }
 
-    private async getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }): Promise<Flags> {
+    private async getIdentityFlagsFromDocument(
+        identifier: string,
+        traits: { [key: string]: any }
+    ): Promise<Flags> {
         const identityModel = this.buildIdentityModel(
             identifier,
             Object.keys(traits).map(key => ({
@@ -348,6 +396,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 +412,9 @@ export class Flagsmith {
             }
             return flags;
         } catch (e) {
+            if (this.offlineHandler) {
+                return this.getEnvironmentFlagsFromDocument();
+            }
             if (this.defaultFlagHandler) {
                 return new Flags({
                     flags: {},
@@ -373,6 +427,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 +444,9 @@ export class Flagsmith {
             }
             return flags;
         } catch (e) {
+            if (this.offlineHandler) {
+                return this.getIdentityFlagsFromDocument(identifier, traits);
+            }
             if (this.defaultFlagHandler) {
                 return new Flags({
                     flags: {},
@@ -405,4 +465,3 @@ export class Flagsmith {
 }
 
 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/offline-environment.json

@@ -0,0 +1,93 @@
+{
+    "api_key": "B62qaMZNwfiqT76p38ggrQ",
+    "project": {
+      "name": "Test project",
+      "organisation": {
+        "feature_analytics": false,
+        "name": "Test Org",
+        "id": 1,
+        "persist_trait_data": true,
+        "stop_serving_flags": false
+      },
+      "id": 1,
+      "hide_disabled_flags": false,
+      "segments": [
+        {
+          "name": "regular_segment",
+          "feature_states": [
+            {
+              "feature_state_value": "segment_override",
+              "multivariate_feature_state_values": [],
+              "django_id": 81027,
+              "feature": {
+                "name": "some_feature",
+                "type": "STANDARD",
+                "id": 1
+              },
+              "enabled": false
+            }
+          ],
+          "id": 1,
+          "rules": [
+            {
+              "type": "ALL",
+              "conditions": [],
+              "rules": [
+                {
+                  "type": "ANY",
+                  "conditions": [
+                    {
+                      "value": "40",
+                      "property_": "age",
+                      "operator": "LESS_THAN"
+                    }
+                  ],
+                  "rules": []
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    "segment_overrides": [],
+    "id": 1,
+    "feature_states": [
+      {
+        "multivariate_feature_state_values": [],
+        "feature_state_value": "offline-value",
+        "id": 1,
+        "featurestate_uuid": "40eb539d-3713-4720-bbd4-829dbef10d51",
+        "feature": {
+          "name": "some_feature",
+          "type": "STANDARD",
+          "id": 1
+        },
+        "feature_segment": null,
+        "enabled": true
+      },
+      {
+        "multivariate_feature_state_values": [
+          {
+            "percentage_allocation": 100,
+            "multivariate_feature_option": {
+              "value": "bar",
+              "id": 1
+            },
+            "mv_fs_value_uuid": "42d5cdf9-8ec9-4b8d-a3ca-fd43c64d5f05",
+            "id": 1
+          }
+        ],
+        "feature_state_value": "foo",
+        "feature": {
+          "name": "mv_feature",
+          "type": "MULTIVARIATE",
+          "id": 2
+        },
+        "feature_segment": null,
+        "featurestate_uuid": "96fc3503-09d7-48f1-a83b-2dc903d5c08a",
+        "enabled": false
+      }
+    ]
+  }
+  

package/tests/sdk/flagsmith.test.ts

@@ -2,11 +2,12 @@ import Flagsmith from '../../sdk';
 import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
 import fetch, {RequestInit} from 'node-fetch';
 import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON } from './utils';
-import { DefaultFlag } from '../../sdk/models';
+import { DefaultFlag, Flags } from '../../sdk/models';
 import {delay, retryFetch} from '../../sdk/utils';
 import * as utils from '../../sdk/utils';
 import { EnvironmentModel } from '../../flagsmith-engine/environments/models';
 import https from 'https'
+import { BaseOfflineHandler } from '../../sdk/offline_handlers';
 
 jest.mock('node-fetch');
 jest.mock('../../sdk/polling_manager');
@@ -202,7 +203,7 @@ test('request timeout uses default if not provided', async () => {
     expect(flg.requestTimeoutMs).toBe(10000);
 })
 
-test('test_throws_when_no_identity_flags_returned_due_to_error', async () => {
+test('test_throws_when_no_identityFlags_returned_due_to_error', async () => {
     // @ts-ignore
     fetch.mockReturnValue(Promise.resolve(new Response('bad data')));
 
@@ -275,10 +276,108 @@ test('getIdentitySegments throws error if identifier is empty string', () => {
 })
 
 
-async function wipeFeatureStateUUIDs (enviromentModel: EnvironmentModel) {
+test('offline_mode', async() => {
+    // Given
+    const environment: EnvironmentModel = environmentModel(JSON.parse(environmentJSON('offline-environment.json')));
+
+    class DummyOfflineHandler extends BaseOfflineHandler {
+        getEnvironment(): EnvironmentModel {
+            return environment;
+        }
+    }
+
+    // When
+    const flagsmith = new Flagsmith({ offlineMode: true, offlineHandler: new DummyOfflineHandler() });
+
+    // Then
+    // we can request the flags from the client successfully
+    const environmentFlags: Flags = await flagsmith.getEnvironmentFlags();
+    let flag = environmentFlags.getFlag('some_feature');
+    expect(flag.isDefault).toBe(false);
+    expect(flag.enabled).toBe(true);
+    expect(flag.value).toBe('offline-value');
+
+
+    const identityFlags: Flags = await flagsmith.getIdentityFlags("identity");
+    flag = identityFlags.getFlag('some_feature');
+    expect(flag.isDefault).toBe(false);
+    expect(flag.enabled).toBe(true);
+    expect(flag.value).toBe('offline-value');
+});
+
+
+test('test_flagsmith_uses_offline_handler_if_set_and_no_api_response', async () => {
+    // Given
+    const environment: EnvironmentModel = environmentModel(JSON.parse(environmentJSON('offline-environment.json')));
+    const api_url = 'http://some.flagsmith.com/api/v1/';
+    const mock_offline_handler = new BaseOfflineHandler() as jest.Mocked<BaseOfflineHandler>;
+  
+    jest.spyOn(mock_offline_handler, 'getEnvironment').mockReturnValue(environment);
+
+    const flagsmith = new Flagsmith({
+      environmentKey: 'some-key',
+      apiUrl: api_url,
+      offlineHandler: mock_offline_handler,
+    });
+
+    jest.spyOn(flagsmith, 'getEnvironmentFlags');
+    jest.spyOn(flagsmith, 'getIdentityFlags');
+
+  
+    flagsmith.environmentFlagsUrl = 'http://some.flagsmith.com/api/v1/environment-flags';
+    flagsmith.identitiesUrl = 'http://some.flagsmith.com/api/v1/identities';
+
+    // Mock a 500 Internal Server Error response
+    const errorResponse = new Response(null, {
+        status: 500,
+        statusText: 'Internal Server Error',
+    });
+
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(errorResponse));
+
+    // When
+    const environmentFlags:Flags = await flagsmith.getEnvironmentFlags();
+    const identityFlags:Flags = await flagsmith.getIdentityFlags('identity', {});
+
+    // Then
+    expect(mock_offline_handler.getEnvironment).toHaveBeenCalledTimes(1);
+    expect(flagsmith.getEnvironmentFlags).toHaveBeenCalled();
+    expect(flagsmith.getIdentityFlags).toHaveBeenCalled();
+    
+    expect(environmentFlags.isFeatureEnabled('some_feature')).toBe(true);
+    expect(environmentFlags.getFeatureValue('some_feature')).toBe('offline-value');
+  
+    expect(identityFlags.isFeatureEnabled('some_feature')).toBe(true);
+    expect(identityFlags.getFeatureValue('some_feature')).toBe('offline-value');
+});
+
+test('cannot use offline mode without offline handler', () => {
+    // When and Then
+    expect(() => new Flagsmith({ offlineMode: true, offlineHandler: undefined })).toThrowError(
+      'ValueError: offlineHandler must be provided to use offline mode.'
+    );
+});
+  
+test('cannot use both default handler and offline handler', () => {
+    // When and Then
+    expect(() => new Flagsmith({
+      offlineHandler: new BaseOfflineHandler(),
+      defaultFlagHandler: (flagName) => new DefaultFlag('foo', true)
+    })).toThrowError('ValueError: Cannot use both defaultFlagHandler and offlineHandler.');
+});
+  
+test('cannot create Flagsmith client in remote evaluation without API key', () => {
+    // When and Then
+    // @ts-ignore
+    expect(() => new Flagsmith()).toThrowError('ValueError: environmentKey is required.');
+});
+
+
+async function wipeFeatureStateUUIDs (environmentModel: EnvironmentModel) {
     // TODO: this has been pulled out of tests above as a helper function.
     //  I'm not entirely sure why it's necessary, however, we should look to remove.
-    enviromentModel.featureStates.forEach(fs => {
+    environmentModel.featureStates.forEach(fs => {
         // @ts-ignore
         fs.featurestateUUID = undefined;
         fs.multivariateFeatureStateValues.forEach(mvfsv => {
@@ -286,7 +385,7 @@ async function wipeFeatureStateUUIDs (enviromentModel: EnvironmentModel) {
             mvfsv.mvFsValueUuid = undefined;
         })
     });
-    enviromentModel.project.segments.forEach(s => {
+    environmentModel.project.segments.forEach(s => {
         s.featureStates.forEach(fs => {
             // @ts-ignore
             fs.featurestateUUID = undefined;

package/tests/sdk/offline-handlers.test.ts

@@ -0,0 +1,33 @@
+import * as fs from 'fs';
+import { LocalFileHandler } from '../../sdk/offline_handlers';
+import { EnvironmentModel } from '../../flagsmith-engine';
+
+const offlineEnvironment = require('./data/offline-environment.json');
+
+jest.mock('fs')
+
+const offlineEnvironmentString = JSON.stringify(offlineEnvironment)
+
+test('local file handler', () => {
+  const environmentDocumentFilePath = '/some/path/environment.json';
+
+  // Mock the fs.readFileSync function to return environmentJson
+
+  // @ts-ignore
+  const readFileSyncMock = jest.spyOn(fs, 'readFileSync');
+  readFileSyncMock.mockImplementation(() => offlineEnvironmentString);
+
+  // Given
+  const localFileHandler = new LocalFileHandler(environmentDocumentFilePath);
+
+  // When
+  const environmentModel = localFileHandler.getEnvironment();
+
+  // Then
+  expect(environmentModel).toBeInstanceOf(EnvironmentModel);
+  expect(environmentModel.apiKey).toBe('B62qaMZNwfiqT76p38ggrQ');
+  expect(readFileSyncMock).toHaveBeenCalledWith(environmentDocumentFilePath, 'utf8');
+
+  // Restore the original implementation of fs.readFileSync
+  readFileSyncMock.mockRestore();
+});

package/tests/sdk/utils.ts

@@ -42,8 +42,8 @@ export function flagsmith(params = {}) {
     });
 }
 
-export function environmentJSON() {
-    return readFileSync(DATA_DIR + 'environment.json', 'utf-8');
+export function environmentJSON(environmentFilename: string = 'environment.json') {
+    return readFileSync(DATA_DIR + environmentFilename, 'utf-8');
 }
 
 export function environmentModel(environmentJSON: any) {