flagsmith-nodejs 1.0.9 → 2.0.0-beta.1

package/sdk/models.ts

@@ -0,0 +1,143 @@
+import { FeatureStateModel } from '../flagsmith-engine/features/models';
+import { AnalyticsProcessor } from './analytics';
+import { FlagsmithClientError } from './errors';
+
+export class BaseFlag {
+    enabled: boolean;
+    value: string | number | boolean | undefined;
+    isDefault: boolean;
+
+    constructor(
+        value: string | number | boolean | undefined,
+        enabled: boolean,
+        isDefault: boolean
+    ) {
+        this.value = value;
+        this.enabled = enabled;
+        this.isDefault = isDefault;
+    }
+}
+
+export class DefaultFlag extends BaseFlag {
+    constructor(value: string | number | boolean | undefined, enabled: boolean) {
+        super(value, enabled, true);
+    }
+}
+
+export class Flag extends BaseFlag {
+    featureId: number;
+    featureName: string;
+
+    constructor(params: {
+        value: string | number | boolean | undefined;
+        enabled: boolean;
+        isDefault?: boolean;
+        featureId: number;
+        featureName: string;
+    }) {
+        super(params.value, params.enabled, !!params.isDefault);
+        this.featureId = params.featureId;
+        this.featureName = params.featureName;
+    }
+
+    static fromFeatureStateModel(
+        fsm: FeatureStateModel,
+        identityId: number | string | undefined
+    ): Flag {
+        return new Flag({
+            value: fsm.getValue(identityId),
+            enabled: fsm.enabled,
+            featureId: fsm.feature.id,
+            featureName: fsm.feature.name
+        });
+    }
+
+    static fromAPIFlag(flagData: any): Flag {
+        return new Flag({
+            enabled: flagData['enabled'],
+            value: flagData['feature_state_value'] || flagData['value'],
+            featureId: flagData['feature']['id'],
+            featureName: flagData['feature']['name']
+        });
+    }
+}
+
+export class Flags {
+    flags: { [key: string]: Flag } = {};
+    defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    analyticsProcessor?: AnalyticsProcessor;
+
+    constructor(data: {
+        flags: { [key: string]: Flag };
+        defaultFlagHandler?: (v: string) => DefaultFlag;
+        analyticsProcessor?: AnalyticsProcessor;
+    }) {
+        this.flags = data.flags;
+        this.defaultFlagHandler = data.defaultFlagHandler;
+        this.analyticsProcessor = data.analyticsProcessor;
+    }
+
+    static fromFeatureStateModels(data: {
+        featureStates: FeatureStateModel[];
+        analyticsProcessor?: AnalyticsProcessor;
+        defaultFlagHandler?: (f: string) => DefaultFlag;
+        identityID?: string | number;
+    }): Flags {
+        const flags: { [key: string]: any } = {};
+        for (const fs of data.featureStates) {
+            flags[fs.feature.name] = Flag.fromFeatureStateModel(fs, data.identityID);
+        }
+        return new Flags({
+            flags: flags,
+            defaultFlagHandler: data.defaultFlagHandler,
+            analyticsProcessor: data.analyticsProcessor
+        });
+    }
+
+    static fromAPIFlags(data: {
+        apiFlags: { [key: string]: any }[];
+        analyticsProcessor?: AnalyticsProcessor;
+        defaultFlagHandler?: (v: string) => DefaultFlag;
+    }): Flags {
+        const flags: { [key: string]: any } = {};
+
+        for (const flagData of data.apiFlags) {
+            flags[flagData['feature']['name']] = Flag.fromAPIFlag(flagData);
+        }
+
+        return new Flags({
+            flags: flags,
+            defaultFlagHandler: data.defaultFlagHandler,
+            analyticsProcessor: data.analyticsProcessor
+        });
+    }
+
+    allFlags(): Flag[] {
+        return Object.values(this.flags);
+    }
+
+    getFlag(featureName: string): BaseFlag {
+        const flag = this.flags[featureName];
+
+        if (!flag) {
+            if (this.defaultFlagHandler) {
+                return this.defaultFlagHandler(featureName);
+            }
+            throw new FlagsmithClientError(`Feature does not exist: ${featureName}, implement defaultFlagHandler to handle this case.`);
+        }
+
+        if (this.analyticsProcessor && flag.featureId) {
+            this.analyticsProcessor.trackFeature(flag.featureId);
+        }
+
+        return flag;
+    }
+
+    getFeatureValue(featureName: string): any {
+        return this.getFlag(featureName).value;
+    }
+
+    isFeatureEnabled(featureName: string): boolean {
+        return this.getFlag(featureName).enabled;
+    }
+}

package/sdk/polling_manager.ts

@@ -0,0 +1,31 @@
+import { Flagsmith } from '.';
+
+export class EnvironmentDataPollingManager {
+    private interval?: NodeJS.Timer;
+    private main: Flagsmith;
+    private refreshIntervalSeconds: number;
+
+    constructor(main: Flagsmith, refreshIntervalSeconds: number) {
+        this.main = main;
+        this.refreshIntervalSeconds = refreshIntervalSeconds;
+    }
+
+    start() {
+        const updateEnvironment = () => {
+            if(this.interval) clearInterval(this.interval)
+            this.interval = setInterval(async () => {
+                await this.main.updateEnvironment();
+            }, this.refreshIntervalSeconds * 1000);
+        };
+        // todo: this call should be awaited for getIdentityFlags/getEnvironmentFlags when enableLocalEvaluation is true
+        this.main.updateEnvironment()
+        updateEnvironment()
+    }
+
+    stop() {
+        if (!this.interval) {
+            return;
+        }
+        clearInterval(this.interval);
+    }
+}

package/sdk/utils.ts

@@ -0,0 +1,45 @@
+import fetch, { Response } from 'node-fetch';
+// @ts-ignore
+if (typeof fetch.default !== 'undefined') fetch = fetch.default;
+
+export function generateIdentitiesData(identifier: string, traits?: { [key: string]: any }) {
+    const traitsGenerated = Object.values(traits || {}).map(trait => ({
+        trait_key: trait[0],
+        trait_value: trait[1]
+    }));
+    return {
+        identifier: identifier,
+        traits: traitsGenerated
+    };
+}
+
+export const delay = (ms: number) =>
+    new Promise(resolve => setTimeout(() => resolve(undefined), ms));
+
+export const retryFetch = (
+    url: string,
+    fetchOptions = {},
+    retries = 3,
+    retryDelay = 1000,
+    timeout: number
+): Promise<Response> => {
+    return new Promise((resolve, reject) => {
+        // check for timeout
+        if (timeout) setTimeout(() => reject('error: timeout'), timeout);
+
+        const wrapper = (n: number) => {
+            fetch(url, fetchOptions)
+                .then(res => resolve(res))
+                .catch(async err => {
+                    if (n > 0) {
+                        await delay(retryDelay);
+                        wrapper(--n);
+                    } else {
+                        reject(err);
+                    }
+                });
+        };
+
+        wrapper(retries);
+    });
+};

package/tests/engine/e2e/engine.test.ts

@@ -0,0 +1,51 @@
+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';
+
+function extractTestCases(
+    filePath: string
+): {
+    environment: EnvironmentModel;
+    identity: IdentityModel;
+    response: any;
+}[] {
+    const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+    const environmentModel = buildEnvironmentModel(data['environment']);
+    const test_data = data['identities_and_responses'].map((test_case: any) => {
+        const identity = buildIdentityModel(test_case['identity']);
+
+        return {
+            environment: environmentModel,
+            identity: identity,
+            response: test_case['response']
+        };
+    });
+    return test_data;
+}
+
+test('Test Engine', () => {
+    const testCases = extractTestCases(
+        __dirname + '/../engine-tests/engine-test-data/data/environment_n9fbf9h3v4fFgH3U3ngWhb.json'
+    );
+    for (const testCase of testCases) {
+        const engine_response = getIdentityFeatureStates(testCase.environment, testCase.identity);
+        const sortedEngineFlags = engine_response.sort((a, b) =>
+            a.feature.name > b.feature.name ? 1 : -1
+        );
+        const sortedAPIFlags = testCase.response['flags'].sort((a: any, b: any) =>
+            a.feature.name > b.feature.name ? 1 : -1
+        );
+
+        expect(sortedEngineFlags.length).toBe(sortedAPIFlags.length);
+
+        for (let i = 0; i < sortedEngineFlags.length; i++) {
+            expect(sortedEngineFlags[i].getValue(testCase.identity.djangoID)).toBe(
+                sortedAPIFlags[i]['feature_state_value']
+            );
+            expect(sortedEngineFlags[i].enabled).toBe(sortedAPIFlags[i]['enabled']);
+        }
+    }
+});