flagsmith-nodejs 6.0.1 → 6.2.0

package/tests/sdk/flagsmith.test.ts

@@ -9,7 +9,7 @@ import {
     badFetch
 } from './utils.js';
 import { DefaultFlag, Flags } from '../../sdk/models.js';
-import { delay } from '../../sdk/utils.js';
+import { delay, getUserAgent } from '../../sdk/utils.js';
 import { EnvironmentModel } from '../../flagsmith-engine/environments/models.js';
 import { BaseOfflineHandler } from '../../sdk/offline_handlers.js';
 import { Agent } from 'undici';
@@ -29,26 +29,180 @@ test('test_flagsmith_local_evaluation_key_required', () => {
             environmentKey: 'bad.key',
             enableLocalEvaluation: true
         });
-    }).toThrow('Using local evaluation requires a server-side environment key')
+    }).toThrow('Using local evaluation requires a server-side environment key');
 });
 
 test('test_update_environment_sets_environment', async () => {
     const flg = flagsmith({
-        environmentKey: 'ser.key',
+        environmentKey: 'ser.key'
     });
     const model = environmentModel(JSON.parse(environmentJSON));
     expect(await flg.getEnvironment()).toStrictEqual(model);
 });
 
+test('test_update_environment_handles_paginated_document', async () => {
+    type EnvDocumentMockResponse = {
+        responseHeader: string | null;
+        page: any;
+    };
+
+    const createMockFetch = (pages: EnvDocumentMockResponse[]) => {
+        let callCount = 0;
+        return vi.fn((url: string, options?: RequestInit) => {
+            if (url.includes('/environment-document')) {
+                const document = envDocumentMockResponse[callCount];
+                if (document) {
+                    callCount++;
+
+                    const responseHeaders: Record<string, string> = {};
+
+                    if (document.responseHeader) {
+                        responseHeaders['Link'] = `<${document.responseHeader}>; rel="next"`;
+                    }
+
+                    return Promise.resolve(
+                        new Response(JSON.stringify(document.page), {
+                            status: 200,
+                            headers: responseHeaders
+                        })
+                    );
+                }
+            }
+            return Promise.resolve(new Response('unknown url ' + url, { status: 404 }));
+        });
+    };
+
+    const envDocumentMockResponse: EnvDocumentMockResponse[] = [
+        {
+            responseHeader: '/api/v1/environment-document?page=2',
+            page: {
+                id: 1,
+                api_key: 'test-key',
+                project: {
+                    id: 1,
+                    name: 'test',
+                    organisation: {
+                        id: 1,
+                        name: 'Test Org',
+                        feature_analytics: false,
+                        persist_trait_data: true,
+                        stop_serving_flags: false
+                    },
+                    hide_disabled_flags: false,
+                    segments: []
+                },
+                feature_states: [
+                    {
+                        feature_state_value: 'first_page_feature_state',
+                        multivariate_feature_state_values: [],
+                        django_id: 81027,
+                        feature: {
+                            id: 15058,
+                            type: 'STANDARD',
+                            name: 'string_feature'
+                        },
+                        enabled: false
+                    },
+                    {
+                        feature_state_value: 'second_page_feature_state',
+                        multivariate_feature_state_values: [],
+                        django_id: 81027,
+                        feature: {
+                            id: 15058,
+                            type: 'STANDARD',
+                            name: 'string_feature'
+                        },
+                        enabled: false
+                    },
+                    {
+                        feature_state_value: 'third_page_feature_state',
+                        multivariate_feature_state_values: [],
+                        django_id: 81027,
+                        feature: {
+                            id: 15058,
+                            type: 'STANDARD',
+                            name: 'string_feature'
+                        },
+                        enabled: false
+                    }
+                ],
+                identity_overrides: [{ id: 1, identifier: 'user1' }]
+            }
+        },
+        {
+            responseHeader: '/api/v1/environment-document?page=3',
+            page: {
+                api_key: 'test-key',
+                project: {
+                    id: 1,
+                    name: 'test',
+                    organisation: {
+                        id: 1,
+                        name: 'Test Org',
+                        feature_analytics: false,
+                        persist_trait_data: true,
+                        stop_serving_flags: false
+                    },
+                    hide_disabled_flags: false,
+                    segments: []
+                },
+                feature_states: [],
+                identity_overrides: [{ id: 2, identifier: 'user2' }]
+            }
+        },
+        {
+            responseHeader: null,
+            page: {
+                api_key: 'test-key',
+                project: {
+                    id: 1,
+                    name: 'test',
+                    organisation: {
+                        id: 1,
+                        name: 'Test Org',
+                        feature_analytics: false,
+                        persist_trait_data: true,
+                        stop_serving_flags: false
+                    },
+                    hide_disabled_flags: false,
+                    segments: []
+                },
+                feature_states: [],
+                identity_overrides: [{ id: 2, identifier: 'user3' }]
+            }
+        }
+    ];
+
+    const flg = new Flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true,
+        fetch: createMockFetch(envDocumentMockResponse)
+    });
+
+    const environment = await flg.getEnvironment();
+
+    expect(environment.identityOverrides).toHaveLength(3);
+    expect(environment.identityOverrides[0].identifier).toBe('user1');
+    expect(environment.identityOverrides[1].identifier).toBe('user2');
+    expect(environment.identityOverrides[2].identifier).toBe('user3');
+    expect(environment.featureStates).toHaveLength(3);
+    expect(environment.featureStates[0].getValue()).toBe('first_page_feature_state');
+    expect(environment.featureStates[1].getValue()).toBe('second_page_feature_state');
+    expect(environment.featureStates[2].getValue()).toBe('third_page_feature_state');
+    expect(environment.project.name).toBe('test');
+    expect(environment.project.organisation.name).toBe('Test Org');
+    expect(environment.project.organisation.id).toBe(1);
+});
+
 test('test_set_agent_options', async () => {
-    const agent = new Agent({})
+    const agent = new Agent({});
 
     fetch.mockImplementationOnce((url, options) => {
         //@ts-ignore I give up
         if (options.dispatcher !== agent) {
-            throw new Error("Agent has not been set on retry fetch")
+            throw new Error('Agent has not been set on retry fetch');
         }
-        return Promise.resolve(new Response(environmentJSON))
+        return Promise.resolve(new Response(environmentJSON));
     });
 
     const flg = flagsmith({
@@ -69,7 +223,6 @@ test('test_get_identity_segments', async () => {
     expect(segments2.length).toEqual(0);
 });
 
-
 test('test_get_identity_segments_empty_without_local_eval', async () => {
     const flg = new Flagsmith({
         environmentKey: 'ser.key',
@@ -82,7 +235,7 @@ test('test_get_identity_segments_empty_without_local_eval', async () => {
 test('test_update_environment_uses_req_when_inited', async () => {
     const flg = flagsmith({
         environmentKey: 'ser.key',
-        enableLocalEvaluation: true,
+        enableLocalEvaluation: true
     });
 
     delay(400);
@@ -100,7 +253,7 @@ test('test_isFeatureEnabled_environment', async () => {
     const flg = new Flagsmith({
         environmentKey: 'key',
         defaultFlagHandler: defaultFlagHandler,
-        enableAnalytics: true,
+        enableAnalytics: true
     });
 
     const flags = await flg.getEnvironmentFlags();
@@ -110,9 +263,9 @@ test('test_isFeatureEnabled_environment', async () => {
 });
 
 test('test_fetch_recovers_after_single_API_error', async () => {
-    fetch.mockRejectedValueOnce('Error during fetching the API response')
+    fetch.mockRejectedValueOnce('Error during fetching the API response');
     const flg = flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
     const flags = await flg.getEnvironmentFlags();
@@ -132,7 +285,7 @@ test.each([
             enableLocalEvaluation,
             environmentKey,
             defaultFlagHandler: () => new DefaultFlag('some-default-value', true),
-            fetch: badFetch,
+            fetch: badFetch
         });
         const flags = await flg.getEnvironmentFlags();
         const flag = flags.getFlag('some_feature');
@@ -144,9 +297,9 @@ test.each([
 
 test('default flag handler used when timeout occurs', async () => {
     fetch.mockImplementation(async (...args) => {
-        const forever = new Promise(() => {})
-        await forever
-        throw new Error('waited forever')
+        const forever = new Promise(() => {});
+        await forever;
+        throw new Error('waited forever');
     });
 
     const defaultFlag = new DefaultFlag('some-default-value', true);
@@ -156,7 +309,7 @@ test('default flag handler used when timeout occurs', async () => {
     const flg = flagsmith({
         environmentKey: 'key',
         defaultFlagHandler: defaultFlagHandler,
-        requestTimeoutSeconds: 0.0001,
+        requestTimeoutSeconds: 0.0001
     });
 
     const flags = await flg.getEnvironmentFlags();
@@ -164,35 +317,32 @@ test('default flag handler used when timeout occurs', async () => {
     expect(flag.isDefault).toBe(true);
     expect(flag.enabled).toBe(defaultFlag.enabled);
     expect(flag.value).toBe(defaultFlag.value);
-})
+});
 
 test('request timeout uses default if not provided', async () => {
-
     const flg = new Flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
     expect(flg.requestTimeoutMs).toBe(10000);
-})
+});
 
 test('test_throws_when_no_identityFlags_returned_due_to_error', async () => {
     const flg = flagsmith({
         environmentKey: 'key',
-        fetch: badFetch,
+        fetch: badFetch
     });
 
-    await expect(async () => await flg.getIdentityFlags('identifier'))
-        .rejects
-        .toThrow();
+    await expect(async () => await flg.getIdentityFlags('identifier')).rejects.toThrow();
 });
 
 test('test onEnvironmentChange is called when provided', async () => {
-    const callback = vi.fn()
+    const callback = vi.fn();
 
     const flg = new Flagsmith({
         environmentKey: 'ser.key',
         enableLocalEvaluation: true,
-        onEnvironmentChange: callback,
+        onEnvironmentChange: callback
     });
 
     fetch.mockRejectedValueOnce(new Error('API error'));
@@ -209,7 +359,7 @@ test('test onEnvironmentChange is called after error', async () => {
         environmentKey: 'ser.key',
         enableLocalEvaluation: true,
         onEnvironmentChange: callback,
-        fetch: badFetch,
+        fetch: badFetch
     });
     await flg.updateEnvironment();
     expect(callback).toHaveBeenCalled();
@@ -217,15 +367,17 @@ test('test onEnvironmentChange is called after error', async () => {
 
 test('getIdentityFlags throws error if identifier is empty string', async () => {
     const flg = flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
-    await expect(flg.getIdentityFlags('')).rejects.toThrow('`identifier` argument is missing or invalid.');
-})
+    await expect(flg.getIdentityFlags('')).rejects.toThrow(
+        '`identifier` argument is missing or invalid.'
+    );
+});
 
 test('getIdentitySegments throws error if identifier is empty string', async () => {
     const flg = flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
     await expect(flg.getIdentitySegments('')).rejects.toThrow(
@@ -254,15 +406,13 @@ test('offline_mode', async () => {
     expect(flag.enabled).toBe(true);
     expect(flag.value).toBe('offline-value');
 
-
-    const identityFlags: Flags = await flg.getIdentityFlags("identity");
+    const identityFlags: Flags = await flg.getIdentityFlags('identity');
     flag = identityFlags.getFlag('some_feature');
     expect(flag.isDefault).toBe(false);
     expect(flag.enabled).toBe(true);
     expect(flag.value).toBe('offline-value');
 });
 
-
 test('test_flagsmith_uses_offline_handler_if_set_and_no_api_response', async () => {
     // Given
     const environment: EnvironmentModel = environmentModel(JSON.parse(offlineEnvironmentJSON));
@@ -281,14 +431,13 @@ test('test_flagsmith_uses_offline_handler_if_set_and_no_api_response', async ()
     vi.spyOn(flg, 'getEnvironmentFlags');
     vi.spyOn(flg, 'getIdentityFlags');
 
-
     flg.environmentFlagsUrl = 'http://some.flagsmith.com/api/v1/environment-flags';
     flg.identitiesUrl = 'http://some.flagsmith.com/api/v1/identities';
 
     // Mock a 500 Internal Server Error response
     const errorResponse = new Response(null, {
         status: 500,
-        statusText: 'Internal Server Error',
+        statusText: 'Internal Server Error'
     });
 
     fetch.mockResolvedValue(errorResponse);
@@ -318,25 +467,28 @@ test('cannot use offline mode without offline handler', () => {
 
 test('cannot use both default handler and offline handler', () => {
     // When and Then
-    expect(() => flagsmith({
-        offlineHandler: new BaseOfflineHandler(),
-        defaultFlagHandler: () => new DefaultFlag('foo', true)
-    })).toThrowError('ValueError: Cannot use both defaultFlagHandler and offlineHandler.');
+    expect(() =>
+        flagsmith({
+            offlineHandler: new BaseOfflineHandler(),
+            defaultFlagHandler: () => new DefaultFlag('foo', true)
+        })
+    ).toThrowError('ValueError: Cannot use both defaultFlagHandler and offlineHandler.');
 });
 
 test('cannot create Flagsmith client in remote evaluation without API key', () => {
     // When and Then
-    expect(() => new Flagsmith({ environmentKey: '' })).toThrowError('ValueError: environmentKey is required.');
+    expect(() => new Flagsmith({ environmentKey: '' })).toThrowError(
+        'ValueError: environmentKey is required.'
+    );
 });
 
-
 test('test_localEvaluation_true__identity_overrides_evaluated', async () => {
     const flg = flagsmith({
         environmentKey: 'ser.key',
         enableLocalEvaluation: true
     });
 
-    await flg.updateEnvironment()
+    await flg.updateEnvironment();
     const flags = await flg.getIdentityFlags('overridden-id');
     expect(flags.getFeatureValue('some_feature')).toEqual('some-overridden-value');
 });
@@ -360,3 +512,10 @@ test('getIdentityFlags succeeds if initial fetch failed then succeeded', async (
     const flags2 = await flg.getIdentityFlags('test-user');
     expect(flags2.isFeatureEnabled('some_feature')).toBe(true);
 });
+
+test('get_user_agent_extracts_version_from_package_json', async () => {
+    const userAgent = getUserAgent();
+    const packageJson = require('../../package.json');
+
+    expect(userAgent).toBe(`flagsmith-nodejs-sdk/${packageJson.version}`);
+});

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

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

package/tests/sdk/polling.test.ts

@@ -39,7 +39,6 @@ test('test_polling_manager_handles_double_start', async () => {
     expect(flagsmith.updateEnvironment).toHaveBeenCalled();
 });
 
-
 test('test_polling_manager_calls_update_environment_on_each_refresh', async () => {
     const flagsmith = new Flagsmith({
         environmentKey: 'key'

package/tests/sdk/utils.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'fs';
 import { buildEnvironmentModel } from '../../flagsmith-engine/environments/util.js';
 import { AnalyticsProcessor } from '../../sdk/analytics.js';
-import Flagsmith, {FlagsmithConfig} from '../../sdk/index.js';
+import Flagsmith, { FlagsmithConfig } from '../../sdk/index.js';
 import { Fetch, FlagsmithCache } from '../../sdk/types.js';
 import { Flags } from '../../sdk/models.js';
 
@@ -21,31 +21,36 @@ export class TestCache implements FlagsmithCache {
 
 export const fetch = vi.fn((url: string, options?: RequestInit) => {
     const headers = options?.headers as Record<string, string>;
-    if (!headers) throw new Error('missing request headers')
+    if (!headers) throw new Error('missing request headers');
     const env = headers['X-Environment-Key'];
-    if (!env) return Promise.resolve(new Response('missing x-environment-key header', { status: 404 }));
+    if (!env)
+        return Promise.resolve(new Response('missing x-environment-key header', { status: 404 }));
     if (url.includes('/environment-document')) {
         if (env.startsWith('ser.')) {
-            return Promise.resolve(new Response(environmentJSON, { status: 200 }))
+            return Promise.resolve(new Response(environmentJSON, { status: 200 }));
         }
-        return Promise.resolve(new Response('environment-document called without a server-side key', { status: 401 }))
+        return Promise.resolve(
+            new Response('environment-document called without a server-side key', { status: 401 })
+        );
     }
-    if (url.includes("/flags")) {
-        return Promise.resolve(new Response(flagsJSON, { status: 200 }))
+    if (url.includes('/flags')) {
+        return Promise.resolve(new Response(flagsJSON, { status: 200 }));
     }
-    if (url.includes("/identities")) {
-        return Promise.resolve(new Response(identitiesJSON, { status: 200 }))
+    if (url.includes('/identities')) {
+        return Promise.resolve(new Response(identitiesJSON, { status: 200 }));
     }
-    return Promise.resolve(new Response('unknown url ' + url, { status: 404 }))
+    return Promise.resolve(new Response('unknown url ' + url, { status: 404 }));
 });
 
-export const badFetch: Fetch = () => { throw new Error('fetch failed')}
+export const badFetch: Fetch = () => {
+    throw new Error('fetch failed');
+};
 
 export function analyticsProcessor() {
     return new AnalyticsProcessor({
         environmentKey: 'test-key',
         analyticsUrl: 'http://testUrl/analytics/flags/',
-        fetch: (url, options) => fetch(url.toString(), options),
+        fetch: (url, options) => fetch(url.toString(), options)
     });
 }
 
@@ -59,22 +64,25 @@ export function flagsmith(params: FlagsmithConfig = {}) {
         environmentRefreshIntervalSeconds: 0,
         requestRetryDelayMilliseconds: 0,
         fetch: (url, options) => fetch(url.toString(), options),
-        ...params,
+        ...params
     });
 }
 
 export const environmentJSON = readFileSync(DATA_DIR + 'environment.json', 'utf-8');
 
-export const offlineEnvironmentJSON = readFileSync(DATA_DIR + 'offline-environment.json', 'utf-8')
+export const offlineEnvironmentJSON = readFileSync(DATA_DIR + 'offline-environment.json', 'utf-8');
 
 export function environmentModel(environmentJSON: any) {
     return buildEnvironmentModel(environmentJSON);
 }
 
-export const flagsJSON = readFileSync(DATA_DIR + 'flags.json', 'utf-8')
+export const flagsJSON = readFileSync(DATA_DIR + 'flags.json', 'utf-8');
 
-export const identitiesJSON = readFileSync(DATA_DIR + 'identities.json', 'utf-8')
+export const identitiesJSON = readFileSync(DATA_DIR + 'identities.json', 'utf-8');
 
-export const transientIdentityJSON = readFileSync(DATA_DIR + 'transient-identity.json', 'utf-8')
+export const transientIdentityJSON = readFileSync(DATA_DIR + 'transient-identity.json', 'utf-8');
 
-export const identityWithTransientTraitsJSON = readFileSync(DATA_DIR + 'identity-with-transient-traits.json', 'utf-8')
+export const identityWithTransientTraitsJSON = readFileSync(
+    DATA_DIR + 'identity-with-transient-traits.json',
+    'utf-8'
+);

package/vitest.config.ts

@@ -1,18 +1,13 @@
-import { defineConfig } from 'vitest/config'
+import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
-  test: {
-    globals: true,
-    restoreMocks: true,
-    coverage: {
-      reporter: ['text'],
-      exclude: [
-          'build/**'
-      ],
-      include: [
-          'sdk/**',
-          'flagsmith-engine/**',
-      ]
+    test: {
+        globals: true,
+        restoreMocks: true,
+        coverage: {
+            reporter: ['text'],
+            exclude: ['build/**'],
+            include: ['sdk/**', 'flagsmith-engine/**']
+        }
     }
-  },
-})
+});