flagsmith-nodejs 3.3.3 → 4.0.0-beta.1

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,9 +1,9 @@
 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';
 
 function extractTestCases(
     filePath: string

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 { 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
+        }
+    ]
+}

package/tests/sdk/flagsmith-cache.test.ts

@@ -1,14 +1,7 @@
-import fetch, { Headers } from 'node-fetch';
-import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON, TestCache } from './utils';
-
-jest.mock('node-fetch');
-jest.mock('../../sdk/polling_manager');
-
-const { Response } = jest.requireActual('node-fetch');
+import { fetch, environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON, TestCache } from './utils.js';
 
 beforeEach(() => {
-  // @ts-ignore
-  jest.clearAllMocks();
+  vi.clearAllMocks();
 });
 
 test('test_wrong_cache_interface_throws_an_error', async () => {
@@ -21,14 +14,13 @@ test('test_wrong_cache_interface_throws_an_error', async () => {
 });
 
 test('test_empty_cache_not_read_but_populated', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const flg = flagsmith({ cache });
-  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+  const allFlags = (await flg.getEnvironmentFlags()).allFlags();
 
   expect(set).toBeCalled();
   expect(await cache.has('flags')).toBe(true);
@@ -40,11 +32,10 @@ test('test_empty_cache_not_read_but_populated', async () => {
 });
 
 test('test_api_not_called_when_cache_present', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const flg = flagsmith({ cache });
   await (await flg.getEnvironmentFlags()).allFlags();
@@ -60,13 +51,11 @@ test('test_api_not_called_when_cache_present', async () => {
 });
 
 test('test_api_called_twice_when_no_cache', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockImplementation(() => Promise.resolve(new Response(flagsJSON)));
 
   const flg = flagsmith();
   await (await flg.getEnvironmentFlags()).allFlags();
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
   const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
 
   expect(fetch).toBeCalledTimes(2);
@@ -76,14 +65,13 @@ test('test_api_called_twice_when_no_cache', async () => {
 });
 
 test('test_get_environment_flags_uses_local_environment_when_available', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const flg = flagsmith({ cache });
-  const model = environmentModel(JSON.parse(environmentJSON()));
+  const model = environmentModel(JSON.parse(environmentJSON));
   flg.environment = model;
 
   const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
@@ -96,11 +84,10 @@ test('test_get_environment_flags_uses_local_environment_when_available', async (
 });
 
 test('test_cache_used_for_identity_flags', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+  fetch.mockResolvedValue(new Response(identitiesJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const identifier = 'identifier';
   const traits = { some_trait: 'some_value' };
@@ -120,11 +107,10 @@ test('test_cache_used_for_identity_flags', async () => {
 });
 
 test('test_cache_used_for_identity_flags_local_evaluation', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+  fetch.mockResolvedValue(new Response(environmentJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const identifier = 'identifier';
   const traits = { some_trait: 'some_value' };
@@ -146,5 +132,3 @@ test('test_cache_used_for_identity_flags_local_evaluation', async () => {
   expect(identityFlags[0].value).toBe('some-value');
   expect(identityFlags[0].featureName).toBe('some_feature');
 });
-
-test('test_cache_used_for_all_flags', async () => { });