flagsmith-nodejs 6.0.1 → 6.2.0

package/index.ts

@@ -1,29 +1,26 @@
 export {
-  AnalyticsProcessor,
-  AnalyticsProcessorOptions,
-  FlagsmithAPIError,
-  FlagsmithClientError,
-  EnvironmentDataPollingManager,
-  FlagsmithCache,
-  DefaultFlag,
-  Flags,
-  Flagsmith,
+    AnalyticsProcessor,
+    AnalyticsProcessorOptions,
+    FlagsmithAPIError,
+    FlagsmithClientError,
+    EnvironmentDataPollingManager,
+    FlagsmithCache,
+    BaseFlag,
+    DefaultFlag,
+    Flags,
+    Flagsmith
 } from './sdk/index.js';
 
-export {
-  BaseOfflineHandler,
-  LocalFileHandler,
-} from './sdk/offline_handlers.js';
+export { BaseOfflineHandler, LocalFileHandler } from './sdk/offline_handlers.js';
 
-export {
-  FlagsmithConfig
-} from './sdk/types.js'
+export { FlagsmithConfig, FlagsmithValue, TraitConfig } from './sdk/types.js';
 
 export {
-  EnvironmentModel,
-  FeatureStateModel,
-  IdentityModel,
-  TraitModel,
-  SegmentModel,
-  OrganisationModel
+    EnvironmentModel,
+    FeatureModel,
+    FeatureStateModel,
+    IdentityModel,
+    TraitModel,
+    SegmentModel,
+    OrganisationModel
 } from './flagsmith-engine/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "6.0.1",
+  "version": "6.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/cjs/index.js",
   "type": "module",

package/release-please-config.json

@@ -0,0 +1,62 @@
+{
+    "bootstrap-sha": "644c5c883ecbb3786507b50cea01903dc2e533bf",
+    "packages": {
+        ".": {
+            "release-type": "node",
+            "changelog-path": "CHANGELOG.md",
+            "bump-minor-pre-major": false,
+            "bump-patch-for-minor-pre-major": false,
+            "draft": false,
+            "prerelease": false,
+            "include-component-in-tag": false
+        }
+    },
+    "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+    "changelog-sections": [
+        {
+            "type": "feat",
+            "hidden": false,
+            "section": "Features"
+        },
+        {
+            "type": "fix",
+            "hidden": false,
+            "section": "Bug Fixes"
+        },
+        {
+            "type": "ci",
+            "hidden": false,
+            "section": "CI"
+        },
+        {
+            "type": "docs",
+            "hidden": false,
+            "section": "Docs"
+        },
+        {
+            "type": "deps",
+            "hidden": false,
+            "section": "Dependency Updates"
+        },
+        {
+            "type": "perf",
+            "hidden": false,
+            "section": "Performance Improvements"
+        },
+        {
+            "type": "refactor",
+            "hidden": false,
+            "section": "Refactoring"
+        },
+        {
+            "type": "test",
+            "hidden": false,
+            "section": "Tests"
+        },
+        {
+            "type": "chore",
+            "hidden": false,
+            "section": "Other"
+        }
+    ]
+}

package/sdk/analytics.ts

@@ -1,13 +1,14 @@
 import { pino, Logger } from 'pino';
-import { Fetch } from "./types.js";
-import { FlagsmithConfig } from "./types.js";
+import { Fetch } from './types.js';
+import { FlagsmithConfig } from './types.js';
+import { getUserAgent } from './utils.js';
 
 export const ANALYTICS_ENDPOINT = './analytics/flags/';
 
 /** Duration in seconds to wait before trying to flush collected data after {@link trackFeature} is called. **/
 const ANALYTICS_TIMER = 10;
 
-const DEFAULT_REQUEST_TIMEOUT_MS = 3000
+const DEFAULT_REQUEST_TIMEOUT_MS = 3000;
 
 export interface AnalyticsProcessorOptions {
     /** URL of the Flagsmith analytics events API endpoint
@@ -20,7 +21,7 @@ export interface AnalyticsProcessorOptions {
     requestTimeoutMs?: number;
     logger?: Logger;
     /** Custom {@link fetch} implementation to use for API requests. **/
-    fetch?: Fetch
+    fetch?: Fetch;
 
     /** @deprecated Use {@link analyticsUrl} instead. **/
     baseApiUrl?: string;
@@ -69,14 +70,17 @@ export class AnalyticsProcessor {
                 signal: AbortSignal.timeout(this.requestTimeoutMs),
                 headers: {
                     'Content-Type': 'application/json',
-                    'X-Environment-Key': this.environmentKey
+                    'X-Environment-Key': this.environmentKey,
+                    'User-Agent': getUserAgent()
                 }
             });
             await this.currentFlush;
         } catch (error) {
             // We don't want failing to write analytics to cause any exceptions in the main
             // thread so we just swallow them here.
-            this.logger.warn('Failed to post analytics to Flagsmith API. Not clearing data, will retry.')
+            this.logger.warn(
+                'Failed to post analytics to Flagsmith API. Not clearing data, will retry.'
+            );
             return;
         } finally {
             this.currentFlush = undefined;

package/sdk/index.ts

@@ -1,26 +1,35 @@
 import { Dispatcher } from 'undici-types';
-import { getEnvironmentFeatureStates, getIdentityFeatureStates } from '../flagsmith-engine/index.js';
+import {
+    getEnvironmentFeatureStates,
+    getIdentityFeatureStates
+} from '../flagsmith-engine/index.js';
 import { EnvironmentModel } from '../flagsmith-engine/index.js';
 import { buildEnvironmentModel } from '../flagsmith-engine/environments/util.js';
 import { IdentityModel } from '../flagsmith-engine/index.js';
 import { TraitModel } from '../flagsmith-engine/index.js';
 
-import {ANALYTICS_ENDPOINT, AnalyticsProcessor} from './analytics.js';
+import { ANALYTICS_ENDPOINT, AnalyticsProcessor } from './analytics.js';
 import { BaseOfflineHandler } from './offline_handlers.js';
 import { FlagsmithAPIError } from './errors.js';
 
 import { DefaultFlag, Flags } from './models.js';
 import { EnvironmentDataPollingManager } from './polling_manager.js';
-import { Deferred, generateIdentitiesData, retryFetch } from './utils.js';
+import { Deferred, generateIdentitiesData, getUserAgent, retryFetch } from './utils.js';
 import { SegmentModel } from '../flagsmith-engine/index.js';
 import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators.js';
-import { Fetch, FlagsmithCache, FlagsmithConfig, FlagsmithTraitValue, ITraitConfig } from './types.js';
+import {
+    Fetch,
+    FlagsmithCache,
+    FlagsmithConfig,
+    FlagsmithTraitValue,
+    TraitConfig
+} from './types.js';
 import { pino, Logger } from 'pino';
 
 export { AnalyticsProcessor, AnalyticsProcessorOptions } from './analytics.js';
 export { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
 
-export { DefaultFlag, Flags } from './models.js';
+export { BaseFlag, DefaultFlag, Flags } from './models.js';
 export { EnvironmentDataPollingManager } from './polling_manager.js';
 export { FlagsmithCache, FlagsmithConfig } from './types.js';
 
@@ -50,7 +59,7 @@ const DEFAULT_REQUEST_TIMEOUT_SECONDS = 10;
  * const bannerVariation: string = identityFlags.getFeatureValue('banner_flag')
  *
  * @see FlagsmithConfig
-*/
+ */
 export class Flagsmith {
     environmentKey?: string = undefined;
     apiUrl?: string = undefined;
@@ -128,20 +137,23 @@ export class Flagsmith {
 
             const apiUrl = data.apiUrl || DEFAULT_API_URL;
             this.apiUrl = apiUrl.endsWith('/') ? apiUrl : `${apiUrl}/`;
-            this.analyticsUrl = this.analyticsUrl || new URL(ANALYTICS_ENDPOINT, new Request(this.apiUrl).url).href
+            this.analyticsUrl =
+                this.analyticsUrl || new URL(ANALYTICS_ENDPOINT, new Request(this.apiUrl).url).href;
             this.environmentFlagsUrl = `${this.apiUrl}flags/`;
             this.identitiesUrl = `${this.apiUrl}identities/`;
             this.environmentUrl = `${this.apiUrl}environment-document/`;
 
             if (this.enableLocalEvaluation) {
                 if (!this.environmentKey.startsWith('ser.')) {
-                    throw new Error('Using local evaluation requires a server-side environment key');
+                    throw new Error(
+                        'Using local evaluation requires a server-side environment key'
+                    );
                 }
-                if (this.environmentRefreshIntervalSeconds > 0){
+                if (this.environmentRefreshIntervalSeconds > 0) {
                     this.environmentDataPollingManager = new EnvironmentDataPollingManager(
                         this,
                         this.environmentRefreshIntervalSeconds,
-                        this.logger,
+                        this.logger
                     );
                     this.environmentDataPollingManager.start();
                 }
@@ -152,8 +164,8 @@ export class Flagsmith {
                     environmentKey: this.environmentKey,
                     analyticsUrl: this.analyticsUrl,
                     requestTimeoutMs: this.requestTimeoutMs,
-                    logger: this.logger,
-                })
+                    logger: this.logger
+                });
             }
         }
     }
@@ -174,7 +186,10 @@ export class Flagsmith {
             return await this.getEnvironmentFlagsFromApi();
         } catch (error) {
             if (!this.defaultFlagHandler) {
-                throw new Error('getEnvironmentFlags failed and no default flag handler was provided', { cause: error });
+                throw new Error(
+                    'getEnvironmentFlags failed and no default flag handler was provided',
+                    { cause: error }
+                );
             }
             this.logger.error(error, 'getEnvironmentFlags failed');
             return new Flags({
@@ -191,13 +206,13 @@ export class Flagsmith {
      *
      * @param  {string} identifier a unique identifier for the identity in the current
             environment, e.g. email address, username, uuid
-     * @param  {{[key:string]:any | ITraitConfig}} traits? a dictionary of traits to add / update on the identity in
+     * @param  {{[key:string]:any | TraitConfig}} traits? a dictionary of traits to add / update on the identity in
             Flagsmith, e.g. {"num_orders": 10} or {age: {value: 30, transient: true}}
      * @returns Flags object holding all the flags for the given identity.
      */
     async getIdentityFlags(
         identifier: string,
-        traits?: { [key: string]: FlagsmithTraitValue | ITraitConfig },
+        traits?: { [key: string]: FlagsmithTraitValue | TraitConfig },
         transient: boolean = false
     ): Promise<Flags> {
         if (!identifier) {
@@ -216,7 +231,10 @@ export class Flagsmith {
             return await this.getIdentityFlagsFromApi(identifier, traits, transient);
         } catch (error) {
             if (!this.defaultFlagHandler) {
-                throw new Error('getIdentityFlags failed and no default flag handler was provided', { cause: error })
+                throw new Error(
+                    'getIdentityFlags failed and no default flag handler was provided',
+                    { cause: error }
+                );
             }
             this.logger.error(error, 'getIdentityFlags failed');
             return new Flags({
@@ -292,8 +310,8 @@ export class Flagsmith {
     async updateEnvironment(): Promise<void> {
         try {
             if (this.environmentPromise) {
-                await this.environmentPromise
-                return
+                await this.environmentPromise;
+                return;
             }
             const environment = await this.fetchEnvironment();
             this.onEnvironmentChange(null, environment);
@@ -311,12 +329,14 @@ export class Flagsmith {
         url: string,
         method: string,
         body?: { [key: string]: any }
-    ): Promise<any> {
+    ): Promise<{ response: Response; data: any }> {
         const headers: { [key: string]: any } = { 'Content-Type': 'application/json' };
         if (this.environmentKey) {
             headers['X-Environment-Key'] = this.environmentKey as string;
         }
 
+        headers['User-Agent'] = getUserAgent();
+
         if (this.customHeaders) {
             for (const [k, v] of Object.entries(this.customHeaders)) {
                 headers[k] = v;
@@ -334,7 +354,7 @@ export class Flagsmith {
             this.retries,
             this.requestTimeoutMs,
             this.requestRetryDelayMilliseconds,
-            this.customFetch,
+            this.customFetch
         );
 
         if (data.status !== 200) {
@@ -343,7 +363,7 @@ export class Flagsmith {
             );
         }
 
-        return data.json();
+        return { response: data, data: await data.json() };
     }
 
     /**
@@ -373,8 +393,52 @@ export class Flagsmith {
         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);
+        const startTime = Date.now();
+        const documents: any[] = [];
+        let url = this.environmentUrl;
+        let loggedWarning = false;
+
+        while (true) {
+            try {
+                if (!loggedWarning) {
+                    const elapsedMs = Date.now() - startTime;
+                    if (elapsedMs > this.environmentRefreshIntervalSeconds * 1000) {
+                        this.logger.warn(
+                            `Environment document retrieval exceeded the polling interval of ${this.environmentRefreshIntervalSeconds} seconds.`
+                        );
+                        loggedWarning = true;
+                    }
+                }
+
+                const { response, data } = await this.getJSONResponse(url, 'GET');
+
+                documents.push(data);
+
+                const linkHeader = response.headers.get('link');
+                if (linkHeader) {
+                    const nextMatch = linkHeader.match(/<([^>]+)>;\s*rel="next"/);
+
+                    if (nextMatch) {
+                        const relativeUrl = decodeURIComponent(nextMatch[1]);
+                        url = new URL(relativeUrl, this.apiUrl).href;
+
+                        continue;
+                    }
+                }
+                break;
+            } catch (error) {
+                throw error;
+            }
+        }
+
+        // Compile the document
+        const compiledDocument = documents[0];
+        for (let i = 1; i < documents.length; i++) {
+            compiledDocument.identity_overrides = compiledDocument.identity_overrides || [];
+            compiledDocument.identity_overrides.push(...(documents[i].identity_overrides || []));
+        }
+
+        return buildEnvironmentModel(compiledDocument);
     }
 
     private async getEnvironmentFlagsFromDocument(): Promise<Flags> {
@@ -424,7 +488,7 @@ export class Flagsmith {
         if (!this.environmentFlagsUrl) {
             throw new Error('`apiUrl` argument is missing or invalid.');
         }
-        const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
+        const { data: apiFlags } = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
         const flags = Flags.fromAPIFlags({
             apiFlags: apiFlags,
             analyticsProcessor: this.analyticsProcessor,
@@ -438,14 +502,14 @@ export class Flagsmith {
 
     private async getIdentityFlagsFromApi(
         identifier: string,
-        traits: { [key: string]: FlagsmithTraitValue | ITraitConfig },
+        traits: { [key: string]: FlagsmithTraitValue | TraitConfig },
         transient: boolean = false
     ) {
         if (!this.identitiesUrl) {
             throw new Error('`apiUrl` argument is missing or invalid.');
         }
         const data = generateIdentitiesData(identifier, traits, transient);
-        const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
+        const { data: jsonResponse } = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
         const flags = Flags.fromAPIFlags({
             apiFlags: jsonResponse['flags'],
             analyticsProcessor: this.analyticsProcessor,
@@ -463,8 +527,7 @@ export class Flagsmith {
         traits: { key: string; value: any }[]
     ) {
         const traitModels = traits.map(trait => new TraitModel(trait.key, trait.value));
-        let identityWithOverrides =
-            this.identitiesWithOverridesByIdentifier?.get(identifier);
+        let identityWithOverrides = this.identitiesWithOverridesByIdentifier?.get(identifier);
         if (identityWithOverrides) {
             identityWithOverrides.updateTraits(traitModels);
             return identityWithOverrides;

package/sdk/models.ts

@@ -3,9 +3,21 @@ import { AnalyticsProcessor } from './analytics.js';
 
 type FlagValue = string | number | boolean | undefined;
 
+/**
+ * A Flagsmith feature. It has an enabled/disabled state, and an optional {@link FlagValue}.
+ */
 export class BaseFlag {
+    /**
+     * Indicates whether this feature is enabled.
+     */
     enabled: boolean;
+    /**
+     * An optional {@link FlagValue} for this feature.
+     */
     value: FlagValue;
+    /**
+     * If true, the state for this feature was determined by a default flag handler. See {@link DefaultFlag}.
+     */
     isDefault: boolean;
 
     constructor(value: FlagValue, enabled: boolean, isDefault: boolean) {
@@ -15,14 +27,27 @@ export class BaseFlag {
     }
 }
 
+/**
+ * A {@link BaseFlag} returned by a default flag handler when flag evaluation fails.
+ * @see FlagsmithConfig#defaultFlagHandler
+ */
 export class DefaultFlag extends BaseFlag {
     constructor(value: FlagValue, enabled: boolean) {
         super(value, enabled, true);
     }
 }
 
+/**
+ * A Flagsmith feature retrieved from a successful flag evaluation.
+ */
 export class Flag extends BaseFlag {
+    /**
+     * An identifier for this feature, unique in a single Flagsmith installation.
+     */
     featureId: number;
+    /**
+     * The programmatic name for this feature, unique per Flagsmith project.
+     */
     featureName: string;
 
     constructor(params: {

package/sdk/offline_handlers.ts

@@ -3,7 +3,7 @@ import { buildEnvironmentModel } from '../flagsmith-engine/environments/util.js'
 import { EnvironmentModel } from '../flagsmith-engine/environments/models.js';
 
 export class BaseOfflineHandler {
-    getEnvironment() : EnvironmentModel {
+    getEnvironment(): EnvironmentModel {
         throw new Error('Not implemented');
     }
 }

package/sdk/types.ts

@@ -3,10 +3,12 @@ import { EnvironmentModel } from '../flagsmith-engine/index.js';
 import { Dispatcher } from 'undici-types';
 import { Logger } from 'pino';
 import { BaseOfflineHandler } from './offline_handlers.js';
-import { Flagsmith } from './index.js'
-
-export type IFlagsmithValue<T = string | number | boolean | null> = T;
+import { Flagsmith } from './index.js';
 
+/**
+ * A concrete type for the possible values of a feature.
+ */
+export type FlagsmithValue<T = string | number | boolean | null> = T;
 
 /**
  * Stores and retrieves {@link Flags} from a cache.
@@ -26,7 +28,7 @@ export interface FlagsmithCache {
     set(key: string, value: Flags): Promise<void>;
 }
 
-export type Fetch = typeof fetch
+export type Fetch = typeof fetch;
 
 /**
  * The configuration options for a {@link Flagsmith} client.
@@ -53,7 +55,7 @@ export interface FlagsmithConfig {
     /**
      * Custom headers to use in all HTTP requests.
      */
-    customHeaders?: HeadersInit
+    customHeaders?: HeadersInit;
     /**
      * The network request timeout duration, in seconds.
      *
@@ -96,7 +98,7 @@ export interface FlagsmithConfig {
      * const defaultHandler = () => new DefaultFlag(undefined, false)
      *
      * // Enable only VIP flags by default
-     * const vipDefaultHandler = (key: string) => new Default(undefined, key.startsWith('vip_'))
+     * const vipDefaultHandler = (key: string) => new DefaultFlag(undefined, key.startsWith('vip_'))
      */
     defaultFlagHandler?: (flagKey: string) => DefaultFlag;
     cache?: FlagsmithCache;
@@ -117,9 +119,16 @@ export interface FlagsmithConfig {
     offlineHandler?: BaseOfflineHandler;
 }
 
-export interface ITraitConfig {
+/**
+ * Represents the configuration for a trait in Flagsmith.
+ *
+ * @property value The {@link FlagsmithTraitValue} for this trait.
+ * @property [transient] Indicates whether the trait should be persisted when used in a remote flag evaluation context.
+ * Defaults to false.
+ */
+export interface TraitConfig {
     value: FlagsmithTraitValue;
     transient?: boolean;
 }
 
-export declare type FlagsmithTraitValue = IFlagsmithValue;
+export declare type FlagsmithTraitValue = FlagsmithValue;

package/sdk/utils.ts

@@ -1,11 +1,14 @@
-import {Fetch, FlagsmithTraitValue, ITraitConfig} from './types.js';
-import {Dispatcher} from "undici-types";
+import { Fetch, FlagsmithTraitValue, TraitConfig } from './types.js';
+import { Dispatcher } from 'undici-types';
 
-type Traits = { [key: string]: ITraitConfig | FlagsmithTraitValue };
+type Traits = { [key: string]: TraitConfig | FlagsmithTraitValue };
+
+const FLAGSMITH_USER_AGENT = 'flagsmith-nodejs-sdk';
+const FLAGSMITH_UNKNOWN_VERSION = 'unknown';
 
 export function isTraitConfig(
-    traitValue: ITraitConfig | FlagsmithTraitValue
-): traitValue is ITraitConfig {
+    traitValue: TraitConfig | FlagsmithTraitValue
+): traitValue is TraitConfig {
     return !!traitValue && typeof traitValue == 'object' && traitValue.value !== undefined;
 }
 
@@ -15,12 +18,12 @@ export function generateIdentitiesData(identifier: string, traits: Traits, trans
             return {
                 trait_key: key,
                 trait_value: value?.value,
-                transient: value?.transient,
+                transient: value?.transient
             };
         } else {
             return {
                 trait_key: key,
-                trait_value: value,
+                trait_value: value
             };
         }
     });
@@ -47,7 +50,7 @@ export const retryFetch = (
     retries: number = 3,
     timeoutMs: number = 10, // set an overall timeout for this function
     retryDelayMs: number = 1000,
-    customFetch: Fetch,
+    customFetch: Fetch
 ): Promise<Response> => {
     const retryWrapper = async (n: number): Promise<Response> => {
         try {
@@ -102,3 +105,13 @@ export class Deferred<T> {
         this.rejectPromise(reason);
     }
 }
+
+export function getUserAgent(): string {
+    try {
+        const packageJson = require('../package.json');
+        const version = packageJson?.version;
+        return version ? `${FLAGSMITH_USER_AGENT}/${version}` : FLAGSMITH_UNKNOWN_VERSION;
+    } catch {
+        return FLAGSMITH_UNKNOWN_VERSION;
+    }
+}

package/tests/engine/e2e/engine.test.ts

@@ -3,11 +3,9 @@ import { EnvironmentModel } from '../../../flagsmith-engine/environments/models.
 import { buildEnvironmentModel } from '../../../flagsmith-engine/environments/util.js';
 import { IdentityModel } from '../../../flagsmith-engine/identities/models.js';
 import { buildIdentityModel } from '../../../flagsmith-engine/identities/util.js';
-import * as testData from '../engine-tests/engine-test-data/data/environment_n9fbf9h3v4fFgH3U3ngWhb.json'
+import * as testData from '../engine-tests/engine-test-data/data/environment_n9fbf9h3v4fFgH3U3ngWhb.json';
 
-function extractTestCases(
-    data: any
-): {
+function extractTestCases(data: any): {
     environment: EnvironmentModel;
     identity: IdentityModel;
     response: any;

package/tests/engine/unit/engine.test.ts

@@ -12,7 +12,6 @@ import {
     environmentWithSegmentOverride,
     feature1,
     getEnvironmentFeatureStateForFeature,
-    getEnvironmentFeatureStateForFeatureByName,
     identity,
     identityInSegment,
     segmentConditionProperty,
@@ -73,11 +72,7 @@ test('test_identity_get_all_feature_states_with_traits_hideDisabledFlags', () =>
     const env = environmentWithSegmentOverride();
     env.project.hideDisabledFlags = true;
 
-    const featureStates = getIdentityFeatureStates(
-        env,
-        identityInSegment(),
-        [trait_models]
-    );
+    const featureStates = getIdentityFeatureStates(env, identityInSegment(), [trait_models]);
     expect(featureStates.length).toBe(0);
 });
 

package/tests/engine/unit/features/models.test.ts

@@ -66,11 +66,11 @@ test('test_feature_state_get_value_mv_values', () => {
         const mvFeatureState = new FeatureStateModel(myFeature, true, 1);
         mvFeatureState.multivariateFeatureStateValues = [
             mvFeatureStateValue1,
-            mvFeatureStateValue2,
+            mvFeatureStateValue2
         ];
 
         mvFeatureState.setValue(mvFeatureControlValue);
 
-        expect(mvFeatureState.getValue("test")).toBe(mvFeatureValue2);
+        expect(mvFeatureState.getValue('test')).toBe(mvFeatureValue2);
     }
 });

package/tests/engine/unit/identities/identities_builders.test.ts

@@ -47,7 +47,7 @@ test('test_build_identity_model_from_dictionary_uses_identity_feature_list_for_i
         id: 1,
         identifier: 'test-identity',
         environment_api_key: 'api-key',
-        created_date: '2021-08-22T06:25:23.406995Z',
+        created_date: '2021-08-22T06:25:23.406995Z'
     };
 
     const identityModel = buildIdentityModel(identity_dict);