flagsmith-nodejs 6.1.0 → 7.0.2

package/tests/sdk/flagsmith-identity-flags.test.ts

@@ -9,6 +9,7 @@ import {
     badFetch
 } from './utils.js';
 import { DefaultFlag } from '../../sdk/models.js';
+import { getUserAgent } from '../../sdk/utils.js';
 
 vi.mock('../../sdk/polling_manager');
 
@@ -150,7 +151,11 @@ test('test_transient_identity', async () => {
         `https://edge.api.flagsmith.com/api/v1/identities/`,
         expect.objectContaining({
             method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'sometestfakekey' },
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Environment-Key': 'sometestfakekey',
+                'User-Agent': getUserAgent()
+            },
             body: JSON.stringify({ identifier, traits: traitsInRequest, transient })
         })
     );
@@ -191,7 +196,11 @@ test('test_identity_with_transient_traits', async () => {
         `https://edge.api.flagsmith.com/api/v1/identities/`,
         expect.objectContaining({
             method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'sometestfakekey' },
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Environment-Key': 'sometestfakekey',
+                'User-Agent': getUserAgent()
+            },
             body: JSON.stringify({ identifier, traits: traitsInRequest })
         })
     );

package/tests/sdk/flagsmith.test.ts

@@ -9,13 +9,17 @@ 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';
 
+const isEsmBuild = process.env.ESM_BUILD === 'true';
+
 vi.mock('../../sdk/polling_manager');
-test('test_flagsmith_starts_polling_manager_on_init_if_enabled', () => {
+
+// Skip in ESM build: vi.mock doesn't work with external modules
+test.skipIf(isEsmBuild)('test_flagsmith_starts_polling_manager_on_init_if_enabled', () => {
     new Flagsmith({
         environmentKey: 'ser.key',
         enableLocalEvaluation: true
@@ -32,7 +36,8 @@ test('test_flagsmith_local_evaluation_key_required', () => {
     }).toThrow('Using local evaluation requires a server-side environment key');
 });
 
-test('test_update_environment_sets_environment', async () => {
+// Skip in ESM build: instanceof fails across module boundaries
+test.skipIf(isEsmBuild)('test_update_environment_sets_environment', async () => {
     const flg = flagsmith({
         environmentKey: 'ser.key'
     });
@@ -40,6 +45,160 @@ test('test_update_environment_sets_environment', async () => {
     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({});
 
@@ -358,3 +517,31 @@ test('getIdentityFlags succeeds if initial fetch failed then succeeded', async (
     const flags2 = await flg.getIdentityFlags('test-user');
     expect(flags2.isFeatureEnabled('some_feature')).toBe(true);
 });
+
+// Skip in ESM build: require() path resolution differs
+test.skipIf(isEsmBuild)('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}`);
+});
+
+test('Flags.fromEvaluationResult throws error when metadata.id is missing', () => {
+    const evaluationResult = {
+        flags: {
+            test_feature: {
+                enabled: true,
+                name: 'test_feature',
+                value: 'test_value',
+                reason: 'DEFAULT',
+                metadata: {}
+            }
+        },
+        segments: []
+    };
+
+    expect(() => Flags.fromEvaluationResult(evaluationResult as any)).toThrow(
+        'FlagResult metadata.id is missing for feature "test_feature". ' +
+            'This indicates a bug in the SDK, please report it.'
+    );
+});

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

@@ -7,8 +7,10 @@ import * as offlineEnvironment from './data/offline-environment.json';
 vi.mock('fs');
 
 const offlineEnvironmentString = JSON.stringify(offlineEnvironment);
+const isEsmBuild = process.env.ESM_BUILD === 'true';
 
-test('local file handler', () => {
+// Skip in ESM build: instanceof fails across module boundaries
+test.skipIf(isEsmBuild)('local file handler', () => {
     const environmentDocumentFilePath = '/some/path/environment.json';
 
     // Mock the fs.readFileSync function to return environmentJson

package/vitest.config.esm.ts

@@ -0,0 +1,34 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+/**
+ * Vitest config for testing against the built ESM output.
+ * This catches CJS/ESM interop issues (like jsonpath) that don't surface
+ * when testing TypeScript source directly.
+ *
+ * Run with: npm run test:esm-build (after npm run build)
+ */
+export default defineConfig({
+    test: {
+        globals: true,
+        restoreMocks: true,
+        exclude: ['**/node_modules/**'],
+        server: {
+            deps: {
+                // Don't transform built ESM - test it as-is
+                external: [/build\/esm/]
+            }
+        }
+    },
+    resolve: {
+        alias: {
+            // Redirect source imports to built ESM output
+            '../../../flagsmith-engine': path.resolve(__dirname, 'build/esm/flagsmith-engine'),
+            '../../../../flagsmith-engine': path.resolve(__dirname, 'build/esm/flagsmith-engine'),
+            '../../../sdk': path.resolve(__dirname, 'build/esm/sdk'),
+            '../../../../sdk': path.resolve(__dirname, 'build/esm/sdk'),
+            '../../sdk': path.resolve(__dirname, 'build/esm/sdk'),
+            '../sdk': path.resolve(__dirname, 'build/esm/sdk')
+        }
+    }
+});