flagsmith-nodejs 1.1.3 → 2.0.0-beta.3

package/tests/sdk/flagsmith.test.ts

@@ -0,0 +1,203 @@
+import Flagsmith from '../../sdk';
+import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
+import fetch, { Headers } from 'node-fetch';
+import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON } from './utils';
+import { DefaultFlag } from '../../sdk/models';
+
+jest.mock('node-fetch');
+jest.mock('../../sdk/polling_manager');
+const { Response } = jest.requireActual('node-fetch');
+
+beforeEach(() => {
+    // @ts-ignore
+    jest.clearAllMocks();
+});
+
+test('test_flagsmith_starts_polling_manager_on_init_if_enabled', () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+    new Flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
+    expect(EnvironmentDataPollingManager).toBeCalled();
+});
+
+test('test_update_environment_sets_environment', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+    const flg = flagsmith();
+    await flg.updateEnvironment();
+    expect(flg.environment).toBeDefined();
+
+    // @ts-ignore
+    flg.environment.featureStates[0].featurestateUUID = undefined;
+    // @ts-ignore
+    flg.environment.project.segments[0].featureStates[0].featurestateUUID = undefined;
+    // @ts-ignore
+    const model = environmentModel(JSON.parse(environmentJSON()));
+    // @ts-ignore
+    model.featureStates[0].featurestateUUID = undefined;
+    // @ts-ignore
+    model.project.segments[0].featureStates[0].featurestateUUID = undefined;
+    expect(flg.environment).toStrictEqual(model);
+});
+
+test('test_get_identity_segments', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+    const flg = new Flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
+    const segments = await flg.getIdentitySegments('user', { age: 21 });
+    expect(segments[0].name).toEqual('regular_segment');
+    const segments2 = await flg.getIdentitySegments('user', { age: 41 });
+    expect(segments2.length).toEqual(0);
+});
+test('test_get_environment_flags_calls_api_when_no_local_environment', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+    const flg = flagsmith();
+    const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+
+    expect(fetch).toBeCalledTimes(1);
+    expect(allFlags[0].enabled).toBe(true);
+    expect(allFlags[0].value).toBe('some-value');
+    expect(allFlags[0].featureName).toBe('some_feature');
+});
+test('test_get_environment_flags_uses_local_environment_when_available', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+    const flg = flagsmith();
+    const model = environmentModel(JSON.parse(environmentJSON()));
+    flg.environment = model;
+
+    const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+    expect(fetch).toBeCalledTimes(0);
+    expect(allFlags[0].enabled).toBe(model.featureStates[0].enabled);
+    expect(allFlags[0].value).toBe(model.featureStates[0].getValue());
+    expect(allFlags[0].featureName).toBe(model.featureStates[0].feature.name);
+});
+test('test_get_identity_flags_calls_api_when_no_local_environment_no_traits', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+    const identifier = 'identifier';
+
+    const flg = flagsmith();
+
+    const identityFlags = (await flg.getIdentityFlags(identifier)).allFlags();
+
+    expect(identityFlags[0].enabled).toBe(true);
+    expect(identityFlags[0].value).toBe('some-value');
+    expect(identityFlags[0].featureName).toBe('some_feature');
+});
+test('test_get_identity_flags_calls_api_when_no_local_environment_with_traits', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+    const identifier = 'identifier';
+    const traits = { some_trait: 'some_value' };
+    const flg = flagsmith();
+
+    const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+
+    expect(identityFlags[0].enabled).toBe(true);
+    expect(identityFlags[0].value).toBe('some-value');
+    expect(identityFlags[0].featureName).toBe('some_feature');
+});
+
+test('test_default_flag_is_used_when_no_environment_flags_returned', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify([]))));
+
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
+
+    const flags = await flg.getEnvironmentFlags();
+    const flag = flags.getFlag('some_feature');
+    expect(flag.isDefault).toBe(true);
+    expect(flag.enabled).toBe(defaultFlag.enabled);
+    expect(flag.value).toBe(defaultFlag.value);
+});
+
+test('test_non_200_response_raises_flagsmith_api_error', async () => {
+    const errorResponse403 = new Response('403 Forbidden', {
+        status: 403
+    });
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(errorResponse403));
+
+    const flg = new Flagsmith({
+        environmentKey: 'some'
+    });
+
+    await expect(flg.getEnvironmentFlags()).rejects.toThrow();
+});
+test('test_default_flag_is_not_used_when_environment_flags_returned', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
+
+    const flags = await flg.getEnvironmentFlags();
+    const flag = flags.getFlag('some_feature');
+
+    expect(flag.isDefault).toBe(false);
+    expect(flag.value).not.toBe(defaultFlag.value);
+    expect(flag.value).toBe('some-value');
+});
+test('test_default_flag_is_not_used_when_identity_flags_returned', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
+
+    const flags = await flg.getIdentityFlags('identifier');
+    const flag = flags.getFlag('some_feature');
+
+    expect(flag.isDefault).toBe(false);
+    expect(flag.value).not.toBe(defaultFlag.value);
+    expect(flag.value).toBe('some-value');
+});
+
+test('test_default_flag_is_used_when_no_identity_flags_returned', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify({ flags: [], traits: [] }))));
+
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
+
+    const flags = await flg.getIdentityFlags('identifier');
+    const flag = flags.getFlag('some_feature');
+
+    expect(flag.isDefault).toBe(true);
+    expect(flag.value).toBe(defaultFlag.value);
+    expect(flag.enabled).toBe(defaultFlag.enabled);
+});

package/tests/sdk/polling.test.ts

@@ -0,0 +1,34 @@
+import Flagsmith from '../../sdk';
+import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
+import { delay } from '../../sdk/utils';
+jest.mock('../../sdk');
+jest.mock('node-fetch');
+
+beforeEach(() => {
+    // @ts-ignore
+    Flagsmith.mockClear();
+});
+
+test('test_polling_manager_calls_update_environment_on_start', async () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key'
+    });
+
+    const pollingManager = new EnvironmentDataPollingManager(flagsmith, 0.1);
+    pollingManager.start();
+    await delay(500);
+    pollingManager.stop();
+    expect(flagsmith.updateEnvironment).toHaveBeenCalled();
+});
+
+test('test_polling_manager_calls_update_environment_on_each_refresh', async () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key'
+    });
+
+    const pollingManager = new EnvironmentDataPollingManager(flagsmith, 0.1);
+    pollingManager.start();
+    await delay(450);
+    pollingManager.stop();
+    expect(flagsmith.updateEnvironment).toHaveBeenCalledTimes(5);
+});

package/tests/sdk/utils.ts

@@ -0,0 +1,39 @@
+import { readFileSync } from 'fs';
+import { buildEnvironmentModel } from '../../flagsmith-engine/environments/util';
+import { AnalyticsProcessor } from '../../sdk/analytics';
+import Flagsmith from '../../sdk';
+
+const DATA_DIR = __dirname + '/data/';
+
+export function analyticsProcessor() {
+    return new AnalyticsProcessor({
+        environmentKey: 'test-key',
+        baseApiUrl: 'http://testUrl'
+    });
+}
+
+export function apiKey(): string {
+    return 'sometestfakekey';
+}
+
+export function flagsmith() {
+    return new Flagsmith({
+        environmentKey: apiKey()
+    });
+}
+
+export function environmentJSON() {
+    return readFileSync(DATA_DIR + 'environment.json', 'utf-8');
+}
+
+export function environmentModel(environmentJSON: any) {
+    return buildEnvironmentModel(environmentJSON);
+}
+
+export function flagsJSON() {
+    return readFileSync(DATA_DIR + 'flags.json', 'utf-8');
+}
+
+export function identitiesJSON() {
+    return readFileSync(DATA_DIR + 'identities.json', 'utf-8');
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "include": [
+    "./flagsmith-engine",
+    "./sdk",
+    "./index.ts"
+  ],
+  "compilerOptions": {
+    "outDir": "./build",
+    "target": "ESNext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "declaration": true,
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

package/flagsmith-core.js

@@ -1,243 +0,0 @@
-let fetch = require('node-fetch');
-// https://github.com/node-fetch/node-fetch/issues/450
-if (typeof fetch.default !== "undefined") fetch = fetch.default
-
-module.exports = class FlagsmithCore {
-    normalizeFlags(flags) {
-        const _flags = {};
-
-        for (const { feature, enabled, feature_state_value } of flags) {
-            const normalizedKey = feature.name.toLowerCase().replace(/ /g, '_');
-            _flags[normalizedKey] = {
-                enabled,
-                value: feature_state_value
-            };
-        }
-
-        return _flags;
-    }
-
-    normalizeTraits(traits) {
-        const _traits = {};
-
-        for (const { trait_key, trait_value } of traits) {
-            const normalizedKey = trait_key.toLowerCase().replace(/ /g, '_');
-            _traits[normalizedKey] = trait_value;
-        }
-
-        return _traits;
-    }
-
-    async getJSON(url, method, body) {
-        const { environmentID } = this;
-        const options = {
-            method: method || 'GET',
-            body,
-            headers: {
-                'x-environment-key': environmentID
-            }
-        };
-
-        if (method !== 'GET') {
-            options.headers['Content-Type'] = 'application/json; charset=utf-8';
-        }
-
-        const res = await fetch(url, options);
-        const result = await res.json();
-
-        if (res.status >= 400) {
-            throw new Error(result.detail);
-        }
-
-        return result;
-    }
-
-    init({ environmentID, api, onError, cache }) {
-        if (!environmentID) {
-            throw new Error('Please specify a environment id');
-        }
-
-        this.environmentID = environmentID;
-
-        this.api = api || 'https://api.flagsmith.com/api/v1';
-        this.onError = onError;
-
-        if (cache) {
-            const missingMethods = [];
-
-            ['has', 'get', 'set'].forEach(method => {
-                if (!cache[method]) missingMethods.push(method);
-            });
-
-            if (missingMethods.length > 0) {
-                throw new Error(
-                    `Please implement the following methods in your cache: ${missingMethods.join(
-                        ', '
-                    )}`
-                );
-            }
-        }
-
-        this.cache = cache;
-    }
-
-    async getFlags() {
-        if (this.cache && (await this.cache.has('flags'))) {
-            return this.cache.get('flags');
-        }
-
-        const { onError, api } = this;
-
-        try {
-            const flags = await this.getJSON(`${api}/flags/`);
-            const normalizedFlags = this.normalizeFlags(flags);
-
-            if (this.cache) await this.cache.set('flags', normalizedFlags);
-
-            return normalizedFlags;
-        } catch (err) {
-            onError && onError({ message: err.message });
-            throw err;
-        }
-    }
-
-    async getFlagsForUser(identity) {
-        const cacheKey = `flags-${identity}`;
-
-        if (this.cache && (await this.cache.has(cacheKey))) {
-            return this.cache.get(cacheKey);
-        }
-
-        const { onError, api } = this;
-
-        if (!identity) {
-            const errMsg = 'getFlagsForUser() called without a user identity';
-            onError && onError({ message: errMsg });
-            throw new Error(errMsg);
-        }
-
-        try {
-            const { flags } = await this.getJSON(`${api}/identities/?identifier=${identity}`);
-            const normalizedFlags = this.normalizeFlags(flags);
-
-            if (this.cache) await this.cache.set(cacheKey, normalizedFlags);
-
-            return normalizedFlags;
-        } catch (err) {
-            onError && onError({ message: err.message });
-            throw err;
-        }
-    }
-
-    async getUserIdentity(identity) {
-        const cacheKey = `flags_traits-${identity}`;
-
-        if (this.cache && (await this.cache.has(cacheKey))) {
-            return this.cache.get(cacheKey);
-        }
-
-        const { onError, api } = this;
-
-        if (!identity) {
-            const errMsg = 'getUserIdentity() called without a user identity';
-            onError && onError({ message: errMsg });
-            throw new Error(errMsg);
-        }
-
-        try {
-            const { flags, traits } = await this.getJSON(
-                `${api}/identities/?identifier=${identity}`
-            );
-
-            const normalizedFlags = this.normalizeFlags(flags);
-            const normalizedTraits = this.normalizeTraits(traits);
-            const res = { flags: normalizedFlags, traits: normalizedTraits };
-
-            if (this.cache) await this.cache.set(cacheKey, res);
-
-            return res;
-        } catch (err) {
-            onError && onError({ message: err.message });
-            throw err;
-        }
-    }
-
-    async getValue(key, userId) {
-        const flags = userId ? await this.getFlagsForUser(userId) : await this.getFlags();
-
-        return this.getValueFromFeatures(key, flags);
-    }
-
-    async hasFeature(key, userId) {
-        const flags = userId ? await this.getFlagsForUser(userId) : await this.getFlags();
-
-        return this.checkFeatureEnabled(key, flags);
-    }
-
-    getValueFromFeatures(key, flags) {
-        if (!flags) return null;
-
-        const flag = flags[key];
-
-        //todo record check for value
-        return flag ? flag.value : null;
-    }
-
-    checkFeatureEnabled(key, flags) {
-        if (!flags) return false;
-
-        const flag = flags[key];
-        return flag && flag.enabled;
-    }
-
-    async getTrait(identity, key) {
-        const { onError } = this;
-
-        if (!identity || !key) {
-            const errMsg = `getTrait() called without a ${
-                !identity ? 'user identity' : 'trait key'
-            }`;
-            onError && onError({ message: errMsg });
-            throw new Error(errMsg);
-        }
-
-        try {
-            const { traits } = await this.getUserIdentity(identity);
-            return traits[key];
-        } catch (err) {
-            onError && onError({ message: err.message });
-            throw err;
-        }
-    }
-
-    async setTrait(identity, key, value) {
-        const { onError, api } = this;
-
-        if (!identity || !key) {
-            const errMsg = `setTrait() called without a ${
-                !identity ? 'user identity' : 'trait key'
-            }`;
-            onError &&
-                onError({
-                    message: errMsg
-                });
-            throw new Error(errMsg);
-        }
-
-        const body = {
-            identity: {
-                identifier: identity
-            },
-            trait_key: key,
-            trait_value: value
-        };
-
-        try {
-            await this.getJSON(`${api}/traits/`, 'POST', JSON.stringify(body));
-            return await this.getUserIdentity(identity);
-        } catch (err) {
-            onError && onError({ message: err.message });
-            throw err;
-        }
-    }
-};

package/index.d.ts

@@ -1,85 +0,0 @@
-declare module 'flagsmith-nodejs' {
-    /**
-     * Initialise the sdk against a particular environment
-     */
-    export function init(config: {
-        environmentID: string;
-        onError?: Function;
-        defaultFlags?: string[];
-        api?: string;
-        cache?: ICache;
-    }): void;
-
-    /**
-     * Get the whether a flag is enabled e.g. flagsmith.hasFeature("powerUserFeature")
-     */
-    export function hasFeature(key: string): Promise<boolean>;
-
-    /**
-     * Get the value of a whether a flag is enabled for a user e.g. flagsmith.hasFeature("powerUserFeature", 1234)
-     */
-    export function hasFeature(key: string, userId: string): Promise<boolean>;
-
-    /**
-     * Get the value of a particular remote config e.g. flagsmith.getValue("font_size")
-     */
-    export function getValue(key: string): Promise<string | number | boolean>;
-
-    /**
-     * Get the value of a particular remote config for a specified user e.g. flagsmith.getValue("font_size", 1234)
-     */
-    export function getValue(key: string, userId: string): Promise<string | number | boolean>;
-
-    /**
-     * Trigger a manual fetch of the environment features
-     */
-    export function getFlags(): Promise<IFlags>;
-
-    /**
-     * Trigger a manual fetch of the environment features for a given user id
-     */
-    export function getFlagsForUser(userId: string): Promise<IFlags>;
-
-    /**
-     * Trigger a manual fetch of both the environment features and users' traits for a given user id
-     */
-    export function getUserIdentity(userId: string): Promise<IUserIdentity>;
-
-    /**
-     * Trigger a manual fetch of a specific trait for a given user id
-     */
-    export function getTrait(userId: string, key: string): Promise<ITraits>;
-
-    /**
-     * Set a specific trait for a given user id
-     */
-    export function setTrait(
-        userId: string,
-        key: string,
-        value: string | number | boolean
-    ): Promise<IUserIdentity>;
-
-    interface IFeature {
-        enabled: boolean;
-        value?: string | number | boolean;
-    }
-
-    interface IFlags {
-        [key: string]: IFeature;
-    }
-
-    interface ITraits {
-        [key: string]: string;
-    }
-
-    interface IUserIdentity {
-        flags: IFeature;
-        traits: ITraits;
-    }
-
-    interface ICache {
-        has(key: string): boolean | Promise<boolean>;
-        get(key: string): any | Promise<any>;
-        set(key: string, val: any): void | Promise<void>;
-    }
-}

package/index.js

@@ -1,3 +0,0 @@
-const FlagsmithCore = require('./flagsmith-core');
-
-module.exports = new FlagsmithCore();