flagsmith-nodejs 6.0.0 → 6.1.0

package/tests/sdk/flagsmith.test.ts

@@ -29,26 +29,26 @@ 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_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 +69,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 +81,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 +99,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 +109,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 +131,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 +143,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 +155,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 +163,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 +205,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 +213,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 +252,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 +277,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 +313,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');
 });

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/**']
+        }
     }
-  },
-})
+});