flagsmith-nodejs 5.1.1 → 6.0.1

package/build/cjs/sdk/analytics.d.ts

@@ -44,7 +44,7 @@ export declare class AnalyticsProcessor {
     /**
      * Track a single evaluation event for a feature.
      *
-     * This method is called whenever {@link Flags.isFeatureEnabled}, {@link Flags.getFeatureValue} or {@link Flags.getFlag} are called.
+     * @see FlagsmithConfig.enableAnalytics
      */
     trackFeature(featureName: string): void;
 }

package/build/cjs/sdk/analytics.js

@@ -67,7 +67,7 @@ class AnalyticsProcessor {
     /**
      * Track a single evaluation event for a feature.
      *
-     * This method is called whenever {@link Flags.isFeatureEnabled}, {@link Flags.getFeatureValue} or {@link Flags.getFlag} are called.
+     * @see FlagsmithConfig.enableAnalytics
      */
     trackFeature(featureName) {
         this.analyticsData[featureName] = (this.analyticsData[featureName] || 0) + 1;

package/build/cjs/sdk/index.d.ts

@@ -11,6 +11,30 @@ export { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
 export { DefaultFlag, Flags } from './models.js';
 export { EnvironmentDataPollingManager } from './polling_manager.js';
 export { FlagsmithCache, FlagsmithConfig } from './types.js';
+/**
+ * A client for evaluating Flagsmith feature flags.
+ *
+ * Flags are evaluated remotely by the Flagsmith API over HTTP by default.
+ * To evaluate flags locally, create the client using {@link FlagsmithConfig.enableLocalEvaluation} and a server-side SDK key.
+ *
+ * @example
+ * import { Flagsmith, Flags, DefaultFlag } from 'flagsmith-nodejs'
+ *
+ * const flagsmith = new Flagsmith({
+ *   environmentKey: 'your_sdk_key',
+ *   defaultFlagHandler: (flagKey: string) => { new DefaultFlag(...) },
+ * });
+ *
+ * // Fetch the current environment flags
+ * const environmentFlags: Flags = flagsmith.getEnvironmentFlags()
+ * const isFooEnabled: boolean = environmentFlags.isFeatureEnabled('foo')
+ *
+ * // Evaluate flags for any identity
+ * const identityFlags: Flags = flagsmith.getIdentityFlags('my_user_123', {'vip': true})
+ * const bannerVariation: string = identityFlags.getFeatureValue('banner_flag')
+ *
+ * @see FlagsmithConfig
+*/
 export declare class Flagsmith {
     environmentKey?: string;
     apiUrl?: string;
@@ -29,53 +53,24 @@ export declare class Flagsmith {
     identitiesUrl?: string;
     environmentUrl?: string;
     environmentDataPollingManager?: EnvironmentDataPollingManager;
-    environment: EnvironmentModel;
+    private environment?;
     offlineMode: boolean;
     offlineHandler?: BaseOfflineHandler;
     identitiesWithOverridesByIdentifier?: Map<string, IdentityModel>;
     private cache?;
-    private onEnvironmentChange?;
+    private onEnvironmentChange;
     private analyticsProcessor?;
     private logger;
     private customFetch;
+    private readonly requestRetryDelayMilliseconds;
     /**
-     * A Flagsmith client.
+     * Creates a new {@link Flagsmith} client.
      *
-     * Provides an interface for interacting with the Flagsmith http API.
-     * Basic Usage::
-     *
-     * import flagsmith from Flagsmith
-     * const flagsmith = new Flagsmith({environmentKey: '<your API key>'});
-     * const environmentFlags = flagsmith.getEnvironmentFlags();
-     * const featureEnabled = environmentFlags.isFeatureEnabled('foo');
-     * const identityFlags = flagsmith.getIdentityFlags('identifier', {'foo': 'bar'});
-     * 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
-        @param {number} data.requestTimeoutSeconds: Number of seconds to wait for a request to
-            complete before terminating the request
-        @param {boolean} data.enableLocalEvaluation: Enables local evaluation of flags
-        @param {number} data.environmentRefreshIntervalSeconds: If using local evaluation,
-            specify the interval period between refreshes of local environment data
-        @param {number} data.retries: a urllib3.Retry object to use on all http requests to the
-            Flagsmith API
-        @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
-            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.
-    */
-    constructor(data?: FlagsmithConfig);
+     * If using local evaluation, the environment will be fetched lazily when needed by any method. Polling the
+     * environment for updates will start after {@link environmentRefreshIntervalSeconds} once the client is created.
+     * @param data The {@link FlagsmithConfig} options for this client.
+     */
+    constructor(data: FlagsmithConfig);
     /**
      * Get all the default for flags for the current environment.
      *
@@ -110,10 +105,11 @@ export declare class Flagsmith {
     getIdentitySegments(identifier: string, traits?: {
         [key: string]: any;
     }): Promise<SegmentModel[]>;
+    private fetchEnvironment;
     /**
-     * Updates the environment state for local flag evaluation.
-     * Sets a local promise to prevent race conditions in getIdentityFlags / getIdentitySegments.
-     * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
+     * Fetch the latest environment state from the Flagsmith API to use for local flag evaluation.
+     *
+     * If the environment is currently being fetched, calling this method will not cause additional fetches.
      */
     updateEnvironment(): Promise<void>;
     close(): Promise<void>;
@@ -121,7 +117,13 @@ export declare class Flagsmith {
     /**
      * This promise ensures that the environment is retrieved before attempting to locally evaluate.
      */
-    private environmentPromise;
+    private environmentPromise?;
+    /**
+     * Returns the current environment, fetching it from the API if needed.
+     *
+     * Calling this method concurrently while the environment is being fetched will not cause additional requests.
+     */
+    getEnvironment(): Promise<EnvironmentModel>;
     private getEnvironmentFromApi;
     private getEnvironmentFlagsFromDocument;
     private getIdentityFlagsFromDocument;

package/build/cjs/sdk/index.js

@@ -24,6 +24,30 @@ var polling_manager_js_2 = require("./polling_manager.js");
 Object.defineProperty(exports, "EnvironmentDataPollingManager", { enumerable: true, get: function () { return polling_manager_js_2.EnvironmentDataPollingManager; } });
 const DEFAULT_API_URL = 'https://edge.api.flagsmith.com/api/v1/';
 const DEFAULT_REQUEST_TIMEOUT_SECONDS = 10;
+/**
+ * A client for evaluating Flagsmith feature flags.
+ *
+ * Flags are evaluated remotely by the Flagsmith API over HTTP by default.
+ * To evaluate flags locally, create the client using {@link FlagsmithConfig.enableLocalEvaluation} and a server-side SDK key.
+ *
+ * @example
+ * import { Flagsmith, Flags, DefaultFlag } from 'flagsmith-nodejs'
+ *
+ * const flagsmith = new Flagsmith({
+ *   environmentKey: 'your_sdk_key',
+ *   defaultFlagHandler: (flagKey: string) => { new DefaultFlag(...) },
+ * });
+ *
+ * // Fetch the current environment flags
+ * const environmentFlags: Flags = flagsmith.getEnvironmentFlags()
+ * const isFooEnabled: boolean = environmentFlags.isFeatureEnabled('foo')
+ *
+ * // Evaluate flags for any identity
+ * const identityFlags: Flags = flagsmith.getIdentityFlags('my_user_123', {'vip': true})
+ * const bannerVariation: string = identityFlags.getFeatureValue('banner_flag')
+ *
+ * @see FlagsmithConfig
+*/
 class Flagsmith {
     environmentKey = undefined;
     apiUrl = undefined;
@@ -49,61 +73,30 @@ class Flagsmith {
     analyticsProcessor;
     logger;
     customFetch;
+    requestRetryDelayMilliseconds;
     /**
-     * A Flagsmith client.
+     * Creates a new {@link Flagsmith} client.
      *
-     * Provides an interface for interacting with the Flagsmith http API.
-     * Basic Usage::
-     *
-     * import flagsmith from Flagsmith
-     * const flagsmith = new Flagsmith({environmentKey: '<your API key>'});
-     * const environmentFlags = flagsmith.getEnvironmentFlags();
-     * const featureEnabled = environmentFlags.isFeatureEnabled('foo');
-     * const identityFlags = flagsmith.getIdentityFlags('identifier', {'foo': 'bar'});
-     * 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
-        @param {number} data.requestTimeoutSeconds: Number of seconds to wait for a request to
-            complete before terminating the request
-        @param {boolean} data.enableLocalEvaluation: Enables local evaluation of flags
-        @param {number} data.environmentRefreshIntervalSeconds: If using local evaluation,
-            specify the interval period between refreshes of local environment data
-        @param {number} data.retries: a urllib3.Retry object to use on all http requests to the
-            Flagsmith API
-        @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
-            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.
-    */
-    constructor(data = {}) {
-        // if (!data.offlineMode && !data.environmentKey) {
-        //     throw new Error('ValueError: environmentKey is required.');
-        // }
+     * If using local evaluation, the environment will be fetched lazily when needed by any method. Polling the
+     * environment for updates will start after {@link environmentRefreshIntervalSeconds} once the client is created.
+     * @param data The {@link FlagsmithConfig} options for this client.
+     */
+    constructor(data) {
         this.agent = data.agent;
         this.customFetch = data.fetch ?? fetch;
         this.environmentKey = data.environmentKey;
-        this.apiUrl = data.apiUrl || this.apiUrl;
+        this.apiUrl = data.apiUrl || DEFAULT_API_URL;
         this.customHeaders = data.customHeaders;
         this.requestTimeoutMs =
             1000 * (data.requestTimeoutSeconds ?? DEFAULT_REQUEST_TIMEOUT_SECONDS);
+        this.requestRetryDelayMilliseconds = data.requestRetryDelayMilliseconds ?? 1000;
         this.enableLocalEvaluation = data.enableLocalEvaluation;
         this.environmentRefreshIntervalSeconds =
             data.environmentRefreshIntervalSeconds || this.environmentRefreshIntervalSeconds;
         this.retries = data.retries;
         this.enableAnalytics = data.enableAnalytics || false;
         this.defaultFlagHandler = data.defaultFlagHandler;
-        this.onEnvironmentChange = data.onEnvironmentChange;
+        this.onEnvironmentChange = (error, result) => data.onEnvironmentChange?.(error, result);
         this.logger = data.logger || (0, pino_1.pino)();
         this.offlineMode = data.offlineMode || false;
         this.offlineHandler = data.offlineHandler;
@@ -114,9 +107,6 @@ class Flagsmith {
         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) {
             this.cache = data.cache;
         }
@@ -132,11 +122,12 @@ class Flagsmith {
             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.');
+                    throw new Error('Using local evaluation requires a server-side environment key');
+                }
+                if (this.environmentRefreshIntervalSeconds > 0) {
+                    this.environmentDataPollingManager = new polling_manager_js_1.EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds, this.logger);
+                    this.environmentDataPollingManager.start();
                 }
-                this.environmentDataPollingManager = new polling_manager_js_1.EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds);
-                this.environmentDataPollingManager.start();
-                this.updateEnvironment();
             }
             if (data.enableAnalytics) {
                 this.analyticsProcessor = new analytics_js_1.AnalyticsProcessor({
@@ -158,15 +149,22 @@ class Flagsmith {
         if (!!cachedItem) {
             return cachedItem;
         }
-        if (this.enableLocalEvaluation && !this.offlineMode) {
-            return new Promise((resolve, reject) => this.environmentPromise.then(() => {
-                resolve(this.getEnvironmentFlagsFromDocument());
-            }).catch(e => reject(e)));
+        try {
+            if (this.enableLocalEvaluation || this.offlineMode) {
+                return await this.getEnvironmentFlagsFromDocument();
+            }
+            return await this.getEnvironmentFlagsFromApi();
         }
-        if (this.environment) {
-            return this.getEnvironmentFlagsFromDocument();
+        catch (error) {
+            if (!this.defaultFlagHandler) {
+                throw new Error('getEnvironmentFlags failed and no default flag handler was provided', { cause: error });
+            }
+            this.logger.error(error, 'getEnvironmentFlags failed');
+            return new models_js_1.Flags({
+                flags: {},
+                defaultFlagHandler: this.defaultFlagHandler
+            });
         }
-        return this.getEnvironmentFlagsFromApi();
     }
     /**
      * Get all the flags for the current environment for a given identity. Will also
@@ -188,15 +186,22 @@ class Flagsmith {
             return cachedItem;
         }
         traits = traits || {};
-        if (this.enableLocalEvaluation) {
-            return new Promise((resolve, reject) => this.environmentPromise.then(() => {
-                resolve(this.getIdentityFlagsFromDocument(identifier, traits || {}));
-            }).catch(e => reject(e)));
+        try {
+            if (this.enableLocalEvaluation || this.offlineMode) {
+                return await this.getIdentityFlagsFromDocument(identifier, traits || {});
+            }
+            return await this.getIdentityFlagsFromApi(identifier, traits, transient);
         }
-        if (this.offlineMode) {
-            return this.getIdentityFlagsFromDocument(identifier, traits || {});
+        catch (error) {
+            if (!this.defaultFlagHandler) {
+                throw new Error('getIdentityFlags failed and no default flag handler was provided', { cause: error });
+            }
+            this.logger.error(error, 'getIdentityFlags failed');
+            return new models_js_1.Flags({
+                flags: {},
+                defaultFlagHandler: this.defaultFlagHandler
+            });
         }
-        return this.getIdentityFlagsFromApi(identifier, traits, transient);
     }
     /**
      * Get the segments for the current environment for a given identity. Will also
@@ -209,57 +214,59 @@ class Flagsmith {
             Flagsmith, e.g. {"num_orders": 10}
      * @returns Segments that the given identity belongs to.
      */
-    getIdentitySegments(identifier, traits) {
+    async getIdentitySegments(identifier, traits) {
         if (!identifier) {
             throw new Error('`identifier` argument is missing or invalid.');
         }
+        if (!this.enableLocalEvaluation) {
+            this.logger.error('This function is only permitted with local evaluation.');
+            return Promise.resolve([]);
+        }
         traits = traits || {};
-        if (this.enableLocalEvaluation) {
-            return new Promise((resolve, reject) => {
-                return this.environmentPromise.then(() => {
-                    const identityModel = this.getIdentityModel(identifier, Object.keys(traits || {}).map(key => ({
-                        key,
-                        value: traits?.[key]
-                    })));
-                    const segments = (0, evaluators_js_1.getIdentitySegments)(this.environment, identityModel);
-                    return resolve(segments);
-                }).catch(e => reject(e));
-            });
+        const environment = await this.getEnvironment();
+        const identityModel = this.getIdentityModel(environment, identifier, Object.keys(traits || {}).map(key => ({
+            key,
+            value: traits?.[key]
+        })));
+        return (0, evaluators_js_1.getIdentitySegments)(environment, identityModel);
+    }
+    async fetchEnvironment() {
+        const deferred = new utils_js_1.Deferred();
+        this.environmentPromise = deferred.promise;
+        try {
+            const environment = await this.getEnvironmentFromApi();
+            this.environment = environment;
+            if (environment.identityOverrides?.length) {
+                this.identitiesWithOverridesByIdentifier = new Map(environment.identityOverrides.map(identity => [identity.identifier, identity]));
+            }
+            deferred.resolve(environment);
+            return deferred.promise;
+        }
+        catch (error) {
+            deferred.reject(error);
+            return deferred.promise;
+        }
+        finally {
+            this.environmentPromise = undefined;
         }
-        console.error('This function is only permitted with local evaluation.');
-        return Promise.resolve([]);
     }
     /**
-     * Updates the environment state for local flag evaluation.
-     * Sets a local promise to prevent race conditions in getIdentityFlags / getIdentitySegments.
-     * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
+     * Fetch the latest environment state from the Flagsmith API to use for local flag evaluation.
+     *
+     * If the environment is currently being fetched, calling this method will not cause additional fetches.
      */
     async updateEnvironment() {
         try {
-            const request = this.getEnvironmentFromApi();
-            if (!this.environmentPromise) {
-                this.environmentPromise = request.then(res => {
-                    this.environment = res;
-                });
+            if (this.environmentPromise) {
                 await this.environmentPromise;
+                return;
             }
-            else {
-                this.environment = await request;
-            }
-            if (this.environment.identityOverrides?.length) {
-                this.identitiesWithOverridesByIdentifier = new Map(this.environment.identityOverrides.map(identity => [
-                    identity.identifier,
-                    identity
-                ]));
-            }
-            if (this.onEnvironmentChange) {
-                this.onEnvironmentChange(null, this.environment);
-            }
+            const environment = await this.fetchEnvironment();
+            this.onEnvironmentChange(null, environment);
         }
         catch (e) {
-            if (this.onEnvironmentChange) {
-                this.onEnvironmentChange(e, this.environment);
-            }
+            this.logger.error(e, 'updateEnvironment failed');
+            this.onEnvironmentChange(e);
         }
     }
     async close() {
@@ -280,7 +287,7 @@ class Flagsmith {
             method: method,
             body: JSON.stringify(body),
             headers: headers
-        }, this.retries, this.requestTimeoutMs, this.customFetch);
+        }, this.retries, this.requestTimeoutMs, this.requestRetryDelayMilliseconds, this.customFetch);
         if (data.status !== 200) {
             throw new errors_js_1.FlagsmithAPIError(`Invalid request made to Flagsmith API. Response status code: ${data.status}`);
         }
@@ -290,6 +297,23 @@ class Flagsmith {
      * This promise ensures that the environment is retrieved before attempting to locally evaluate.
      */
     environmentPromise;
+    /**
+     * Returns the current environment, fetching it from the API if needed.
+     *
+     * Calling this method concurrently while the environment is being fetched will not cause additional requests.
+     */
+    async getEnvironment() {
+        if (this.offlineHandler) {
+            return this.offlineHandler.getEnvironment();
+        }
+        if (this.environment) {
+            return this.environment;
+        }
+        if (!this.environmentPromise) {
+            this.environmentPromise = this.fetchEnvironment();
+        }
+        return this.environmentPromise;
+    }
     async getEnvironmentFromApi() {
         if (!this.environmentUrl) {
             throw new Error('`apiUrl` argument is missing or invalid.');
@@ -298,8 +322,9 @@ class Flagsmith {
         return (0, util_js_1.buildEnvironmentModel)(environment_data);
     }
     async getEnvironmentFlagsFromDocument() {
+        const environment = await this.getEnvironment();
         const flags = models_js_1.Flags.fromFeatureStateModels({
-            featureStates: (0, index_js_1.getEnvironmentFeatureStates)(this.environment),
+            featureStates: (0, index_js_1.getEnvironmentFeatureStates)(environment),
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler
         });
@@ -309,11 +334,12 @@ class Flagsmith {
         return flags;
     }
     async getIdentityFlagsFromDocument(identifier, traits) {
-        const identityModel = this.getIdentityModel(identifier, Object.keys(traits).map(key => ({
+        const environment = await this.getEnvironment();
+        const identityModel = this.getIdentityModel(environment, identifier, Object.keys(traits).map(key => ({
             key,
             value: traits[key]
         })));
-        const featureStates = (0, index_js_1.getIdentityFeatureStates)(this.environment, identityModel);
+        const featureStates = (0, index_js_1.getIdentityFeatureStates)(environment, identityModel);
         const flags = models_js_1.Flags.fromFeatureStateModels({
             featureStates: featureStates,
             analyticsProcessor: this.analyticsProcessor,
@@ -329,69 +355,41 @@ class Flagsmith {
         if (!this.environmentFlagsUrl) {
             throw new Error('`apiUrl` argument is missing or invalid.');
         }
-        try {
-            const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
-            const flags = models_js_1.Flags.fromAPIFlags({
-                apiFlags: apiFlags,
-                analyticsProcessor: this.analyticsProcessor,
-                defaultFlagHandler: this.defaultFlagHandler
-            });
-            if (!!this.cache) {
-                await this.cache.set('flags', flags);
-            }
-            return flags;
-        }
-        catch (e) {
-            if (this.offlineHandler) {
-                return this.getEnvironmentFlagsFromDocument();
-            }
-            if (this.defaultFlagHandler) {
-                return new models_js_1.Flags({
-                    flags: {},
-                    defaultFlagHandler: this.defaultFlagHandler
-                });
-            }
-            throw e;
+        const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
+        const flags = models_js_1.Flags.fromAPIFlags({
+            apiFlags: apiFlags,
+            analyticsProcessor: this.analyticsProcessor,
+            defaultFlagHandler: this.defaultFlagHandler
+        });
+        if (!!this.cache) {
+            await this.cache.set('flags', flags);
         }
+        return flags;
     }
     async getIdentityFlagsFromApi(identifier, traits, transient = false) {
         if (!this.identitiesUrl) {
             throw new Error('`apiUrl` argument is missing or invalid.');
         }
-        try {
-            const data = (0, utils_js_1.generateIdentitiesData)(identifier, traits, transient);
-            const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
-            const flags = models_js_1.Flags.fromAPIFlags({
-                apiFlags: jsonResponse['flags'],
-                analyticsProcessor: this.analyticsProcessor,
-                defaultFlagHandler: this.defaultFlagHandler
-            });
-            if (!!this.cache) {
-                await this.cache.set(`flags-${identifier}`, flags);
-            }
-            return flags;
-        }
-        catch (e) {
-            if (this.offlineHandler) {
-                return this.getIdentityFlagsFromDocument(identifier, traits);
-            }
-            if (this.defaultFlagHandler) {
-                return new models_js_1.Flags({
-                    flags: {},
-                    defaultFlagHandler: this.defaultFlagHandler
-                });
-            }
-            throw e;
+        const data = (0, utils_js_1.generateIdentitiesData)(identifier, traits, transient);
+        const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
+        const flags = models_js_1.Flags.fromAPIFlags({
+            apiFlags: jsonResponse['flags'],
+            analyticsProcessor: this.analyticsProcessor,
+            defaultFlagHandler: this.defaultFlagHandler
+        });
+        if (!!this.cache) {
+            await this.cache.set(`flags-${identifier}`, flags);
         }
+        return flags;
     }
-    getIdentityModel(identifier, traits) {
+    getIdentityModel(environment, identifier, traits) {
         const traitModels = traits.map(trait => new index_js_3.TraitModel(trait.key, trait.value));
         let identityWithOverrides = this.identitiesWithOverridesByIdentifier?.get(identifier);
         if (identityWithOverrides) {
             identityWithOverrides.updateTraits(traitModels);
             return identityWithOverrides;
         }
-        return new index_js_2.IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
+        return new index_js_2.IdentityModel('0', traitModels, [], environment.apiKey, identifier);
     }
 }
 exports.Flagsmith = Flagsmith;

package/build/cjs/sdk/models.d.ts

@@ -1,19 +1,20 @@
 import { FeatureStateModel } from '../flagsmith-engine/features/models.js';
 import { AnalyticsProcessor } from './analytics.js';
+type FlagValue = string | number | boolean | undefined;
 export declare class BaseFlag {
     enabled: boolean;
-    value: string | number | boolean | undefined;
+    value: FlagValue;
     isDefault: boolean;
-    constructor(value: string | number | boolean | undefined, enabled: boolean, isDefault: boolean);
+    constructor(value: FlagValue, enabled: boolean, isDefault: boolean);
 }
 export declare class DefaultFlag extends BaseFlag {
-    constructor(value: string | number | boolean | undefined, enabled: boolean);
+    constructor(value: FlagValue, enabled: boolean);
 }
 export declare class Flag extends BaseFlag {
     featureId: number;
     featureName: string;
     constructor(params: {
-        value: string | number | boolean | undefined;
+        value: FlagValue;
         enabled: boolean;
         isDefault?: boolean;
         featureId: number;
@@ -50,6 +51,7 @@ export declare class Flags {
     }): Flags;
     allFlags(): Flag[];
     getFlag(featureName: string): BaseFlag;
-    getFeatureValue(featureName: string): any;
+    getFeatureValue(featureName: string): FlagValue;
     isFeatureEnabled(featureName: string): boolean;
 }
+export {};

package/build/cjs/sdk/polling_manager.d.ts

@@ -1,9 +1,11 @@
 import Flagsmith from './index.js';
+import { Logger } from 'pino';
 export declare class EnvironmentDataPollingManager {
     private interval?;
     private main;
     private refreshIntervalSeconds;
-    constructor(main: Flagsmith, refreshIntervalSeconds: number);
+    private logger;
+    constructor(main: Flagsmith, refreshIntervalSeconds: number, logger: Logger);
     start(): void;
     stop(): void;
 }

package/build/cjs/sdk/polling_manager.js

@@ -5,16 +5,23 @@ class EnvironmentDataPollingManager {
     interval;
     main;
     refreshIntervalSeconds;
-    constructor(main, refreshIntervalSeconds) {
+    logger;
+    constructor(main, refreshIntervalSeconds, logger) {
         this.main = main;
         this.refreshIntervalSeconds = refreshIntervalSeconds;
+        this.logger = logger;
     }
     start() {
         const updateEnvironment = () => {
             if (this.interval)
                 clearInterval(this.interval);
             this.interval = setInterval(async () => {
-                await this.main.updateEnvironment();
+                try {
+                    await this.main.updateEnvironment();
+                }
+                catch (error) {
+                    this.logger.error(error, 'failed to poll environment');
+                }
             }, this.refreshIntervalSeconds * 1000);
         };
         updateEnvironment();