flagsmith-nodejs 3.3.3 → 4.0.0

package/sdk/index.ts

@@ -1,28 +1,28 @@
-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';
-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';
-import { EnvironmentDataPollingManager } from './polling_manager';
-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';
-
-export { AnalyticsProcessor } from './analytics';
-export { FlagsmithAPIError, FlagsmithClientError } from './errors';
-
-export { DefaultFlag, Flags } from './models';
-export { EnvironmentDataPollingManager } from './polling_manager';
-export { FlagsmithCache, FlagsmithConfig } from './types';
+import { Dispatcher } from 'undici-types';
+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 { AnalyticsProcessor } from './analytics.js';
+import { BaseOfflineHandler } from './offline_handlers.js';
+import { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
+
+import { DefaultFlag, Flags } from './models.js';
+import { EnvironmentDataPollingManager } from './polling_manager.js';
+import { generateIdentitiesData, 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 { pino, Logger } from 'pino';
+
+export { AnalyticsProcessor } from './analytics.js';
+export { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
+
+export { DefaultFlag, Flags } from './models.js';
+export { EnvironmentDataPollingManager } from './polling_manager.js';
+export { FlagsmithCache, FlagsmithConfig } from './types.js';
 
 const DEFAULT_API_URL = 'https://edge.api.flagsmith.com/api/v1/';
 const DEFAULT_REQUEST_TIMEOUT_SECONDS = 10;
@@ -31,7 +31,7 @@ export class Flagsmith {
     environmentKey?: string = undefined;
     apiUrl?: string = undefined;
     customHeaders?: { [key: string]: any };
-    agent: RequestInit['agent'];
+    agent?: Dispatcher;
     requestTimeoutMs?: number;
     enableLocalEvaluation?: boolean = false;
     environmentRefreshIntervalSeconds: number = 60;
@@ -39,7 +39,6 @@ export class Flagsmith {
     enableAnalytics: boolean = false;
     defaultFlagHandler?: (featureName: string) => DefaultFlag;
 
-
     environmentFlagsUrl?: string;
     identitiesUrl?: string;
     environmentUrl?: string;
@@ -55,6 +54,7 @@ export class Flagsmith {
     private onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
     private analyticsProcessor?: AnalyticsProcessor;
     private logger: Logger;
+    private customFetch: Fetch;
     /**
      * A Flagsmith client.
      *
@@ -98,6 +98,7 @@ export class Flagsmith {
         // }
 
         this.agent = data.agent;
+        this.customFetch = data.fetch ?? fetch;
         this.environmentKey = data.environmentKey;
         this.apiUrl = data.apiUrl || this.apiUrl;
         this.customHeaders = data.customHeaders;
@@ -168,11 +169,11 @@ export class Flagsmith {
 
             this.analyticsProcessor = data.enableAnalytics
                 ? new AnalyticsProcessor({
-                    environmentKey: this.environmentKey,
-                    baseApiUrl: this.apiUrl,
-                    requestTimeoutMs: this.requestTimeoutMs,
-                    logger: this.logger
-                })
+                      environmentKey: this.environmentKey,
+                      baseApiUrl: this.apiUrl,
+                      requestTimeoutMs: this.requestTimeoutMs,
+                      logger: this.logger
+                  })
                 : undefined;
         }
     }
@@ -207,11 +208,15 @@ 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}} traits? a dictionary of traits to add / update on the identity in
-            Flagsmith, e.g. {"num_orders": 10}
+     * @param  {{[key:string]:any | ITraitConfig}} 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]: any }): Promise<Flags> {
+    async getIdentityFlags(
+        identifier: string,
+        traits?: { [key: string]: FlagsmithTraitValue | ITraitConfig },
+        transient: boolean = false
+    ): Promise<Flags> {
         if (!identifier) {
             throw new Error('`identifier` argument is missing or invalid.');
         }
@@ -232,7 +237,7 @@ export class Flagsmith {
             return this.getIdentityFlagsFromDocument(identifier, traits || {});
         }
 
-        return this.getIdentityFlagsFromApi(identifier, traits);
+        return this.getIdentityFlagsFromApi(identifier, traits, transient);
     }
 
     /**
@@ -293,8 +298,11 @@ export class Flagsmith {
             }
             if (this.environment.identityOverrides?.length) {
                 this.identitiesWithOverridesByIdentifier = new Map<string, IdentityModel>(
-                    this.environment.identityOverrides.map(identity => [identity.identifier, identity]
-                    ));
+                    this.environment.identityOverrides.map(identity => [
+                        identity.identifier,
+                        identity
+                    ])
+                );
             }
             if (this.onEnvironmentChange) {
                 this.onEnvironmentChange(null, this.environment);
@@ -329,13 +337,14 @@ export class Flagsmith {
         const data = await retryFetch(
             url,
             {
-                agent: this.agent,
+                dispatcher: this.agent,
                 method: method,
                 body: JSON.stringify(body),
                 headers: headers
             },
             this.retries,
-            this.requestTimeoutMs || undefined
+            this.requestTimeoutMs,
+            this.customFetch,
         );
 
         if (data.status !== 200) {
@@ -367,7 +376,6 @@ export class Flagsmith {
             defaultFlagHandler: this.defaultFlagHandler
         });
         if (!!this.cache) {
-            // @ts-ignore node-cache types are incorrect, ttl should be optional
             await this.cache.set('flags', flags);
         }
         return flags;
@@ -395,7 +403,6 @@ export class Flagsmith {
         });
 
         if (!!this.cache) {
-            // @ts-ignore node-cache types are incorrect, ttl should be optional
             await this.cache.set(`flags-${identifier}`, flags);
         }
 
@@ -414,7 +421,6 @@ export class Flagsmith {
                 defaultFlagHandler: this.defaultFlagHandler
             });
             if (!!this.cache) {
-                // @ts-ignore node-cache types are incorrect, ttl should be optional
                 await this.cache.set('flags', flags);
             }
             return flags;
@@ -433,12 +439,16 @@ export class Flagsmith {
         }
     }
 
-    private async getIdentityFlagsFromApi(identifier: string, traits: { [key: string]: any }) {
+    private async getIdentityFlagsFromApi(
+        identifier: string,
+        traits: { [key: string]: FlagsmithTraitValue | ITraitConfig },
+        transient: boolean = false
+    ) {
         if (!this.identitiesUrl) {
             throw new Error('`apiUrl` argument is missing or invalid.');
         }
         try {
-            const data = generateIdentitiesData(identifier, traits);
+            const data = generateIdentitiesData(identifier, traits, transient);
             const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
             const flags = Flags.fromAPIFlags({
                 apiFlags: jsonResponse['flags'],
@@ -446,7 +456,6 @@ export class Flagsmith {
                 defaultFlagHandler: this.defaultFlagHandler
             });
             if (!!this.cache) {
-                // @ts-ignore node-cache types are incorrect, ttl should be optional
                 await this.cache.set(`flags-${identifier}`, flags);
             }
             return flags;

package/sdk/models.ts

@@ -1,6 +1,5 @@
-import { FeatureStateModel } from '../flagsmith-engine/features/models';
-import { AnalyticsProcessor } from './analytics';
-import { FlagsmithClientError } from './errors';
+import { FeatureStateModel } from '../flagsmith-engine/features/models.js';
+import { AnalyticsProcessor } from './analytics.js';
 
 export class BaseFlag {
     enabled: boolean;

package/sdk/offline_handlers.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
-import { buildEnvironmentModel } from '../flagsmith-engine/environments/util';
-import { EnvironmentModel } from '../flagsmith-engine/environments/models';
+import { buildEnvironmentModel } from '../flagsmith-engine/environments/util.js';
+import { EnvironmentModel } from '../flagsmith-engine/environments/models.js';
 
 export class BaseOfflineHandler {
     getEnvironment() : EnvironmentModel {

package/sdk/polling_manager.ts

@@ -1,7 +1,7 @@
-import Flagsmith from '.';
+import Flagsmith from './index.js';
 
 export class EnvironmentDataPollingManager {
-    private interval?: NodeJS.Timer;
+    private interval?: NodeJS.Timeout;
     private main: Flagsmith;
     private refreshIntervalSeconds: number;
 
@@ -17,7 +17,6 @@ export class EnvironmentDataPollingManager {
                 await this.main.updateEnvironment();
             }, this.refreshIntervalSeconds * 1000);
         };
-        this.main.updateEnvironment();
         updateEnvironment();
     }
 

package/sdk/types.ts

@@ -1,30 +1,41 @@
-import { DefaultFlag, Flags } from "./models";
-import { EnvironmentModel } from "../flagsmith-engine";
-import { RequestInit } from "node-fetch";
-import { Logger } from "pino";
-import { BaseOfflineHandler } from "./offline_handlers";
+import { DefaultFlag, Flags } from './models.js';
+import { EnvironmentModel } from '../flagsmith-engine/index.js';
+import { Dispatcher } from 'undici-types';
+import { Logger } from 'pino';
+import { BaseOfflineHandler } from './offline_handlers.js';
 
+export type IFlagsmithValue<T = string | number | boolean | null> = T;
 export interface FlagsmithCache {
-  get(key: string): Promise<Flags|undefined> | undefined;
-  set(key: string, value: Flags, ttl: string | number): boolean | Promise<boolean>;
-  has(key: string): boolean | Promise<boolean>;
-  [key: string]: any;
+    get(key: string): Promise<Flags | undefined> | undefined;
+    set(key: string, value: Flags, ttl?: string | number): boolean | Promise<boolean>;
+    has(key: string): boolean | Promise<boolean>;
+    [key: string]: any;
 }
 
+export type Fetch = typeof fetch
+
 export interface FlagsmithConfig {
-  environmentKey?: string;
-  apiUrl?: string;
-  agent?:RequestInit['agent'];
-  customHeaders?: { [key: string]: any };
-  requestTimeoutSeconds?: number;
-  enableLocalEvaluation?: boolean;
-  environmentRefreshIntervalSeconds?: number;
-  retries?: number;
-  enableAnalytics?: boolean;
-  defaultFlagHandler?: (featureName: string) => DefaultFlag;
-  cache?: FlagsmithCache,
-  onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void,
-  logger?: Logger
-  offlineMode?: boolean;
-  offlineHandler?: BaseOfflineHandler;
+    environmentKey?: string;
+    apiUrl?: string;
+    agent?: Dispatcher;
+    fetch?: Fetch;
+    customHeaders?: { [key: string]: any };
+    requestTimeoutSeconds?: number;
+    enableLocalEvaluation?: boolean;
+    environmentRefreshIntervalSeconds?: number;
+    retries?: number;
+    enableAnalytics?: boolean;
+    defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    cache?: FlagsmithCache;
+    onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
+    logger?: Logger;
+    offlineMode?: boolean;
+    offlineHandler?: BaseOfflineHandler;
+}
+
+export interface ITraitConfig {
+    value: FlagsmithTraitValue;
+    transient?: boolean;
 }
+
+export declare type FlagsmithTraitValue = IFlagsmithValue;

package/sdk/utils.ts

@@ -1,12 +1,36 @@
-import fetch, { RequestInit, Response } from 'node-fetch';
-// @ts-ignore
-if (typeof fetch.default !== 'undefined') fetch = fetch.default;
+import {Fetch, FlagsmithTraitValue, ITraitConfig} from './types.js';
+import {Dispatcher} from "undici-types";
 
-export function generateIdentitiesData(identifier: string, traits: { [key: string]: any }) {
-    const traitsGenerated = Object.entries(traits).map(trait => ({
-        trait_key: trait[0],
-        trait_value: trait[1]
-    }));
+type Traits = { [key: string]: ITraitConfig | FlagsmithTraitValue };
+
+export function isTraitConfig(
+    traitValue: ITraitConfig | FlagsmithTraitValue
+): traitValue is ITraitConfig {
+    return !!traitValue && typeof traitValue == 'object' && traitValue.value !== undefined;
+}
+
+export function generateIdentitiesData(identifier: string, traits: Traits, transient: boolean) {
+    const traitsGenerated = Object.entries(traits).map(([key, value]) => {
+        if (isTraitConfig(value)) {
+            return {
+                trait_key: key,
+                trait_value: value?.value,
+                transient: value?.transient,
+            };
+        } else {
+            return {
+                trait_key: key,
+                trait_value: value,
+            };
+        }
+    });
+    if (transient) {
+        return {
+            identifier: identifier,
+            traits: traitsGenerated,
+            transient: true
+        };
+    }
     return {
         identifier: identifier,
         traits: traitsGenerated
@@ -18,40 +42,28 @@ export const delay = (ms: number) =>
 
 export const retryFetch = (
     url: string,
-    fetchOptions: RequestInit,
+    // built-in RequestInit type doesn't have dispatcher/agent
+    fetchOptions: RequestInit & { dispatcher?: Dispatcher },
     retries: number = 3,
-    timeout: number = 10// set an overall timeout for this function
+    timeoutMs: number = 10, // set an overall timeout for this function
+    customFetch: Fetch,
 ): Promise<Response> => {
     return new Promise((resolve, reject) => {
         const retryWrapper = (n: number) => {
-            requestWrapper()
-                .then(res => resolve(res))
-                .catch(async err => {
-                    if (n > 0) {
-                        await delay(1000);
-                        retryWrapper(--n);
-                    } else {
-                        reject(err);
-                    }
-                });
-        };
-
-        const requestWrapper = (): Promise<Response> => {
-            return new Promise((resolve, reject) => {
-                let timeoutId: NodeJS.Timeout;
-                if (timeout) {
-                    timeoutId = setTimeout(() => reject('error: timeout'), timeout);
-                }
-                return fetch(url, fetchOptions)
-                    .then(res => resolve(res))
-                    .catch(err => reject(err))
-                    .finally(() => {
-                        if (timeoutId) {
-                            clearTimeout(timeoutId);
-                        }
-                    })
+            customFetch(url, {
+                ...fetchOptions,
+                signal: AbortSignal.timeout(timeoutMs)
             })
-        }
+            .then(res => resolve(res))
+            .catch(async err => {
+                if (n > 0) {
+                    await delay(1000);
+                    retryWrapper(--n);
+                } else {
+                    reject(err);
+                }
+            });
+        };
 
         retryWrapper(retries);
     });

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

@@ -1,18 +1,17 @@
-import { readFileSync } from 'fs';
-import { getIdentityFeatureStates } from '../../../flagsmith-engine';
-import { EnvironmentModel } from '../../../flagsmith-engine/environments/models';
-import { buildEnvironmentModel } from '../../../flagsmith-engine/environments/util';
-import { IdentityModel } from '../../../flagsmith-engine/identities/models';
-import { buildIdentityModel } from '../../../flagsmith-engine/identities/util';
+import { getIdentityFeatureStates } from '../../../flagsmith-engine/index.js';
+import { EnvironmentModel } from '../../../flagsmith-engine/environments/models.js';
+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'
 
 function extractTestCases(
-    filePath: string
+    data: any
 ): {
     environment: EnvironmentModel;
     identity: IdentityModel;
     response: any;
 }[] {
-    const data = JSON.parse(readFileSync(filePath, 'utf-8'));
     const environmentModel = buildEnvironmentModel(data['environment']);
     const test_data = data['identities_and_responses'].map((test_case: any) => {
         const identity = buildIdentityModel(test_case['identity']);
@@ -27,9 +26,7 @@ function extractTestCases(
 }
 
 test('Test Engine', () => {
-    const testCases = extractTestCases(
-        __dirname + '/../engine-tests/engine-test-data/data/environment_n9fbf9h3v4fFgH3U3ngWhb.json'
-    );
+    const testCases = extractTestCases(testData);
     for (const testCase of testCases) {
         const engine_response = getIdentityFeatureStates(testCase.environment, testCase.identity);
         const sortedEngineFlags = engine_response.sort((a, b) =>

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

@@ -3,10 +3,10 @@ import {
     getEnvironmentFeatureStates,
     getIdentityFeatureState,
     getIdentityFeatureStates
-} from '../../../flagsmith-engine';
-import { CONSTANTS } from '../../../flagsmith-engine/features/constants';
-import { FeatureModel, FeatureStateModel } from '../../../flagsmith-engine/features/models';
-import { TraitModel } from '../../../flagsmith-engine/identities/traits/models';
+} from '../../../flagsmith-engine/index.js';
+import { CONSTANTS } from '../../../flagsmith-engine/features/constants.js';
+import { FeatureModel, FeatureStateModel } from '../../../flagsmith-engine/features/models.js';
+import { TraitModel } from '../../../flagsmith-engine/identities/traits/models.js';
 import {
     environment,
     environmentWithSegmentOverride,
@@ -17,7 +17,7 @@ import {
     identityInSegment,
     segmentConditionProperty,
     segmentConditionStringValue
-} from './utils';
+} from './utils.js';
 
 test('test_identity_get_feature_state_without_any_override', () => {
     const feature_state = getIdentityFeatureState(environment(), identity(), feature1().name);

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

@@ -2,18 +2,18 @@ import {
     ALL_RULE,
     CONDITION_OPERATORS,
     PERCENTAGE_SPLIT,
-} from '../../../../flagsmith-engine/segments/constants';
-import {SegmentConditionModel} from '../../../../flagsmith-engine/segments/models';
-import {traitsMatchSegmentCondition, evaluateIdentityInSegment} from "../../../../flagsmith-engine/segments/evaluators";
-import {TraitModel, IdentityModel} from "../../../../flagsmith-engine";
-import {environment} from "../utils";
-import { buildSegmentModel } from '../../../../flagsmith-engine/segments/util';
-import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing';
+} from '../../../../flagsmith-engine/segments/constants.js';
+import {SegmentConditionModel} from '../../../../flagsmith-engine/segments/models.js';
+import {traitsMatchSegmentCondition, evaluateIdentityInSegment} from "../../../../flagsmith-engine/segments/evaluators.js";
+import {TraitModel, IdentityModel} from "../../../../flagsmith-engine/index.js";
+import {environment} from "../utils.js";
+import { buildSegmentModel } from '../../../../flagsmith-engine/segments/util.js';
+import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
 
 
 // todo: work out how to implement this in a test function or before hook
-jest.mock('../../../../flagsmith-engine/utils/hashing', () => ({
-    getHashedPercentateForObjIds: jest.fn(() => 1)
+vi.mock('../../../../flagsmith-engine/utils/hashing', () => ({
+    getHashedPercentateForObjIds: vi.fn(() => 1)
 }));
 
 

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

@@ -1,5 +1,5 @@
-import { v4 as uuidv4 } from 'uuid';
-import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing';
+import { randomUUID as uuidv4 } from 'node:crypto';
+import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
 
 describe('getHashedPercentageForObjIds', () => {
     it.each([

package/tests/sdk/analytics.test.ts

@@ -1,10 +1,7 @@
-import fetch from 'node-fetch';
-import { analyticsProcessor } from './utils';
-
-jest.mock('node-fetch', () => jest.fn());
+import {analyticsProcessor, fetch} from './utils.js';
 
 afterEach(() => {
-    jest.clearAllMocks();
+    vi.resetAllMocks();
 });
 
 test('test_analytics_processor_track_feature_updates_analytics_data', () => {
@@ -29,15 +26,14 @@ test('test_analytics_processor_flush_post_request_data_match_ananlytics_data', a
     aP.trackFeature("myFeature2");
     await aP.flush();
     expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith('http://testUrlanalytics/flags/', {
+    expect(fetch).toHaveBeenCalledWith('http://testUrlanalytics/flags/', expect.objectContaining({
         body: '{"myFeature1":1,"myFeature2":1}',
         headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'test-key' },
         method: 'POST',
-        timeout: 3000
-    });
+    }));
 });
 
-jest.useFakeTimers()
+vi.useFakeTimers()
 test('test_analytics_processor_flush_post_request_data_match_ananlytics_data_test', async () => {
     const aP = analyticsProcessor();
     aP.trackFeature("myFeature1");
@@ -45,7 +41,7 @@ test('test_analytics_processor_flush_post_request_data_match_ananlytics_data_tes
         aP.trackFeature("myFeature2");
         expect(fetch).toHaveBeenCalledTimes(1);
     }, 15000);
-    jest.runOnlyPendingTimers();
+    vi.runOnlyPendingTimers();
 });
 
 test('test_analytics_processor_flush_early_exit_if_analytics_data_is_empty', async () => {
@@ -58,7 +54,7 @@ test('test_analytics_processor_flush_early_exit_if_analytics_data_is_empty', asy
 test('errors in fetch sending analytics data are swallowed', async () => {
     // Given
     // we mock the fetch function to throw and error to mimick a network failure
-    (fetch as jest.MockedFunction<typeof fetch>).mockRejectedValue(new Error('some error'));
+    fetch.mockRejectedValue('some error');
 
     // and create the processor and track a feature so there is some analytics data
     const processor = analyticsProcessor();
@@ -76,7 +72,6 @@ test('errors in fetch sending analytics data are swallowed', async () => {
 test('analytics is only flushed once even if requested concurrently', async () => {
     const processor = analyticsProcessor();
     processor.trackFeature('myFeature');
-    // @ts-ignore
     fetch.mockImplementation(() => {
         return new Promise((resolve, _) => {
             setTimeout(resolve, 1000)
@@ -86,7 +81,7 @@ test('analytics is only flushed once even if requested concurrently', async () =
         processor.flush(),
         processor.flush(),
     ])
-    jest.runOnlyPendingTimers();
+    vi.runOnlyPendingTimers();
     await flushes;
     expect(fetch).toHaveBeenCalledTimes(1)
 })

package/tests/sdk/data/identity-with-transient-traits.json

@@ -0,0 +1,41 @@
+{
+    "traits": [
+        {
+            "id": 1,
+            "trait_key": "some_trait",
+            "trait_value": "some_value"
+        },
+        {
+            "id": 2,
+            "trait_key": "transient_key",
+            "trait_value": "transient_value",
+            "transient": true
+        },
+        {
+            "id": 3,
+            "trait_key": "explicitly_non_transient_trait",
+            "trait_value": "non_transient_value",
+            "transient": false
+        }
+    ],
+    "flags": [
+        {
+            "id": 1,
+            "feature": {
+                "id": 1,
+                "name": "some_feature",
+                "created_date": "2019-08-27T14:53:45.698555Z",
+                "initial_value": null,
+                "description": null,
+                "default_enabled": false,
+                "type": "STANDARD",
+                "project": 1
+            },
+            "feature_state_value": "some-identity-with-transient-trait-value",
+            "enabled": true,
+            "environment": 1,
+            "identity": null,
+            "feature_segment": null
+        }
+    ]
+}

package/tests/sdk/data/transient-identity.json

@@ -0,0 +1,29 @@
+{
+    "traits": [
+        {
+            "id": 1,
+            "trait_key": "some_trait",
+            "trait_value": "some_value"
+        }
+    ],
+    "flags": [
+        {
+            "id": 1,
+            "feature": {
+                "id": 1,
+                "name": "some_feature",
+                "created_date": "2019-08-27T14:53:45.698555Z",
+                "initial_value": null,
+                "description": null,
+                "default_enabled": false,
+                "type": "STANDARD",
+                "project": 1
+            },
+            "feature_state_value": "some-transient-identity-value",
+            "enabled": false,
+            "environment": 1,
+            "identity": null,
+            "feature_segment": null
+        }
+    ]
+}