flagsmith-nodejs 2.0.0-beta.4 → 2.0.0-beta.5

package/build/sdk/index.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flagsmith = void 0;
+const flagsmith_engine_1 = require("../flagsmith-engine");
+const util_1 = require("../flagsmith-engine/environments/util");
+const models_1 = require("../flagsmith-engine/identities/models");
+const models_2 = require("../flagsmith-engine/identities/traits/models");
+const analytics_1 = require("./analytics");
+const errors_1 = require("./errors");
+const models_3 = require("./models");
+const polling_manager_1 = require("./polling_manager");
+const utils_1 = require("./utils");
+const evaluators_1 = require("../flagsmith-engine/segments/evaluators");
+const DEFAULT_API_URL = 'https://api.flagsmith.com/api/v1/';
+class Flagsmith {
+    environmentKey;
+    apiUrl = DEFAULT_API_URL;
+    customHeaders;
+    requestTimeoutSeconds;
+    enableLocalEvaluation = false;
+    environmentRefreshIntervalSeconds = 60;
+    retries;
+    enableAnalytics = false;
+    defaultFlagHandler;
+    environmentFlagsUrl;
+    identitiesUrl;
+    environmentUrl;
+    environmentDataPollingManager;
+    environment;
+    analyticsProcessor;
+    /**
+     * A Flagsmith client.
+     *
+     * Provides an interface for interacting with the Flagsmith http API.
+     * Basic Usage::
+     *
+     * import flagsmith from Flagsmith
+     * const flagsmith = new Flagsmith({environmentKey: '<your API key>'});
+     * const environmentFlags = flagsmith.getEnvironmentFlags();
+     * const featureEnabled = environmentFlags.isFeatureEnabled('foo');
+     * const identityFlags = flagsmith.getIdentityFlags('identifier', {'foo': 'bar'});
+     * const featureEnabledForIdentity = identityFlags.isFeatureEnabled("foo")
+     *
+     *  @param {string} data.environmentKey: The environment key obtained from Flagsmith interface
+        @param {string} data.apiUrl: Override the URL of the Flagsmith API to communicate with
+        @param  data.customHeaders: Additional headers to add to requests made to the
+            Flagsmith API
+        @param {number} data.requestTimeoutSeconds: Number of seconds to wait for a request to
+            complete before terminating the request
+        @param {boolean} data.enableLocalEvaluation: Enables local evaluation of flags
+        @param {number} data.environmentRefreshIntervalSeconds: If using local evaluation,
+            specify the interval period between refreshes of local environment data
+        @param {number} data.retries: a urllib3.Retry object to use on all http requests to the
+            Flagsmith API
+        @param {boolean} data.enableAnalytics: if enabled, sends additional requests to the Flagsmith
+            API to power flag analytics charts
+        @param data.defaultFlagHandler: callable which will be used in the case where
+            flags cannot be retrieved from the API or a non existent feature is
+            requested
+     */
+    constructor(data) {
+        this.environmentKey = data.environmentKey;
+        this.apiUrl = data.apiUrl || this.apiUrl;
+        this.customHeaders = data.customHeaders;
+        this.requestTimeoutSeconds = data.requestTimeoutSeconds;
+        this.enableLocalEvaluation = data.enableLocalEvaluation;
+        this.environmentRefreshIntervalSeconds =
+            data.environmentRefreshIntervalSeconds || this.environmentRefreshIntervalSeconds;
+        this.retries = data.retries;
+        this.enableAnalytics = data.enableAnalytics || false;
+        this.defaultFlagHandler = data.defaultFlagHandler;
+        this.environmentFlagsUrl = `${this.apiUrl}flags/`;
+        this.identitiesUrl = `${this.apiUrl}identities/`;
+        this.environmentUrl = `${this.apiUrl}environment-document/`;
+        if (this.enableLocalEvaluation) {
+            if (!this.environmentKey.startsWith('ser.')) {
+                console.error('In order to use local evaluation, please generate a server key in the environment settings page.');
+            }
+            this.environmentDataPollingManager = new polling_manager_1.EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds);
+            this.environmentDataPollingManager.start();
+            this.updateEnvironment();
+        }
+        this.analyticsProcessor = data.enableAnalytics
+            ? new analytics_1.AnalyticsProcessor({
+                environmentKey: this.environmentKey,
+                baseApiUrl: this.apiUrl,
+                timeout: this.requestTimeoutSeconds
+            })
+            : undefined;
+    }
+    /**
+     * Get all the default for flags for the current environment.
+     *
+     * @returns Flags object holding all the flags for the current environment.
+     */
+    async getEnvironmentFlags() {
+        if (this.environment) {
+            return new Promise(resolve => resolve(this.getEnvironmentFlagsFromDocument()));
+        }
+        return this.getEnvironmentFlagsFromApi();
+    }
+    /**
+     * Get all the flags for the current environment for a given identity. Will also
+        upsert all traits to the Flagsmith API for future evaluations. Providing a
+        trait with a value of None will remove the trait from the identity if it exists.
+     *
+     * @param  {string} identifier a unique identifier for the identity in the current
+            environment, e.g. email address, username, uuid
+     * @param  {{[key:string]:any}} traits? a dictionary of traits to add / update on the identity in
+            Flagsmith, e.g. {"num_orders": 10}
+     * @returns Flags object holding all the flags for the given identity.
+     */
+    getIdentityFlags(identifier, traits) {
+        traits = traits || {};
+        if (this.enableLocalEvaluation) {
+            return new Promise(resolve => this.environmentPromise.then(() => {
+                resolve(this.getIdentityFlagsFromDocument(identifier, traits || {}));
+            }));
+        }
+        return this.getIdentityFlagsFromApi(identifier, traits);
+    }
+    /**
+     * Get the segments for the current environment for a given identity. Will also
+        upsert all traits to the Flagsmith API for future evaluations. Providing a
+        trait with a value of None will remove the trait from the identity if it exists.
+     *
+     * @param  {string} identifier a unique identifier for the identity in the current
+            environment, e.g. email address, username, uuid
+     * @param  {{[key:string]:any}} traits? a dictionary of traits to add / update on the identity in
+            Flagsmith, e.g. {"num_orders": 10}
+     * @returns Segments that the given identity belongs to.
+     */
+    getIdentitySegments(identifier, traits) {
+        traits = traits || {};
+        if (this.enableLocalEvaluation) {
+            return this.environmentPromise.then(() => {
+                return new Promise(resolve => {
+                    const identityModel = this.buildIdentityModel(identifier, Object.keys(traits || {}).map(key => ({
+                        key,
+                        value: traits?.[key]
+                    })));
+                    const segments = (0, evaluators_1.getIdentitySegments)(this.environment, identityModel);
+                    return resolve(segments);
+                });
+            });
+        }
+        console.error('This function is only permitted with local evaluation.');
+        return Promise.resolve([]);
+    }
+    /**
+     * Updates the environment state for local flag evaluation.
+     * Sets a local promise to prevent race conditions in getIdentityFlags / getIdentitySegments.
+     * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
+     */
+    async updateEnvironment() {
+        const request = this.getEnvironmentFromApi();
+        if (!this.environmentPromise) {
+            this.environmentPromise = request.then(res => {
+                this.environment = res;
+            });
+            await this.environmentPromise;
+        }
+        else {
+            this.environment = await request;
+        }
+    }
+    async getJSONResponse(url, method, body) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.environmentKey) {
+            headers['X-Environment-Key'] = this.environmentKey;
+        }
+        if (this.customHeaders) {
+            for (const [k, v] of Object.entries(this.customHeaders)) {
+                headers[k] = v;
+            }
+        }
+        const data = await (0, utils_1.retryFetch)(url, {
+            method: method,
+            timeout: this.requestTimeoutSeconds || undefined,
+            body: JSON.stringify(body),
+            headers: headers
+        }, this.retries, 1000, (this.requestTimeoutSeconds || 10) * 1000);
+        if (data.status !== 200) {
+            throw new errors_1.FlagsmithAPIError(`Invalid request made to Flagsmith API. Response status code: ${data.status}`);
+        }
+        return data.json();
+    }
+    /**
+     * This promise ensures that the environment is retrieved before attempting to locally evaluate.
+     */
+    environmentPromise;
+    async getEnvironmentFromApi() {
+        const environment_data = await this.getJSONResponse(this.environmentUrl, 'GET');
+        return (0, util_1.buildEnvironmentModel)(environment_data);
+    }
+    getEnvironmentFlagsFromDocument() {
+        return models_3.Flags.fromFeatureStateModels({
+            featureStates: (0, flagsmith_engine_1.getEnvironmentFeatureStates)(this.environment),
+            analyticsProcessor: this.analyticsProcessor,
+            defaultFlagHandler: this.defaultFlagHandler
+        });
+    }
+    getIdentityFlagsFromDocument(identifier, traits) {
+        const identityModel = this.buildIdentityModel(identifier, Object.keys(traits).map(key => ({
+            key,
+            value: traits[key]
+        })));
+        const featureStates = (0, flagsmith_engine_1.getIdentityFeatureStates)(this.environment, identityModel);
+        return models_3.Flags.fromFeatureStateModels({
+            featureStates: featureStates,
+            analyticsProcessor: this.analyticsProcessor,
+            defaultFlagHandler: this.defaultFlagHandler
+        });
+    }
+    async getEnvironmentFlagsFromApi() {
+        try {
+            const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
+            return models_3.Flags.fromAPIFlags({
+                apiFlags: apiFlags,
+                analyticsProcessor: this.analyticsProcessor,
+                defaultFlagHandler: this.defaultFlagHandler
+            });
+        }
+        catch (e) {
+            if (this.defaultFlagHandler) {
+                return new models_3.Flags({
+                    flags: {},
+                    defaultFlagHandler: this.defaultFlagHandler
+                });
+            }
+            throw e;
+        }
+    }
+    async getIdentityFlagsFromApi(identifier, traits) {
+        try {
+            const data = (0, utils_1.generateIdentitiesData)(identifier, traits);
+            const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
+            return models_3.Flags.fromAPIFlags({
+                apiFlags: jsonResponse['flags'],
+                analyticsProcessor: this.analyticsProcessor,
+                defaultFlagHandler: this.defaultFlagHandler
+            });
+        }
+        catch (e) {
+            if (this.defaultFlagHandler) {
+                return new models_3.Flags({
+                    flags: {},
+                    defaultFlagHandler: this.defaultFlagHandler
+                });
+            }
+            throw e;
+        }
+    }
+    buildIdentityModel(identifier, traits) {
+        if (!this.environment) {
+            throw new errors_1.FlagsmithClientError('Unable to build identity model when no local environment present.');
+        }
+        const traitModels = traits.map(trait => new models_2.TraitModel(trait.key, trait.value));
+        return new models_1.IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
+    }
+}
+exports.Flagsmith = Flagsmith;
+exports.default = Flagsmith;

package/build/sdk/models.d.ts

@@ -0,0 +1,55 @@
+import { FeatureStateModel } from '../flagsmith-engine/features/models';
+import { AnalyticsProcessor } from './analytics';
+export declare class BaseFlag {
+    enabled: boolean;
+    value: string | number | boolean | undefined;
+    isDefault: boolean;
+    constructor(value: string | number | boolean | undefined, enabled: boolean, isDefault: boolean);
+}
+export declare class DefaultFlag extends BaseFlag {
+    constructor(value: string | number | boolean | undefined, enabled: boolean);
+}
+export declare class Flag extends BaseFlag {
+    featureId: number;
+    featureName: string;
+    constructor(params: {
+        value: string | number | boolean | undefined;
+        enabled: boolean;
+        isDefault?: boolean;
+        featureId: number;
+        featureName: string;
+    });
+    static fromFeatureStateModel(fsm: FeatureStateModel, identityId: number | string | undefined): Flag;
+    static fromAPIFlag(flagData: any): Flag;
+}
+export declare class Flags {
+    flags: {
+        [key: string]: Flag;
+    };
+    defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    analyticsProcessor?: AnalyticsProcessor;
+    constructor(data: {
+        flags: {
+            [key: string]: Flag;
+        };
+        defaultFlagHandler?: (v: string) => DefaultFlag;
+        analyticsProcessor?: AnalyticsProcessor;
+    });
+    static fromFeatureStateModels(data: {
+        featureStates: FeatureStateModel[];
+        analyticsProcessor?: AnalyticsProcessor;
+        defaultFlagHandler?: (f: string) => DefaultFlag;
+        identityID?: string | number;
+    }): Flags;
+    static fromAPIFlags(data: {
+        apiFlags: {
+            [key: string]: any;
+        }[];
+        analyticsProcessor?: AnalyticsProcessor;
+        defaultFlagHandler?: (v: string) => DefaultFlag;
+    }): Flags;
+    allFlags(): Flag[];
+    getFlag(featureName: string): BaseFlag;
+    getFeatureValue(featureName: string): any;
+    isFeatureEnabled(featureName: string): boolean;
+}

package/build/sdk/models.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flags = exports.Flag = exports.DefaultFlag = exports.BaseFlag = void 0;
+class BaseFlag {
+    enabled;
+    value;
+    isDefault;
+    constructor(value, enabled, isDefault) {
+        this.value = value;
+        this.enabled = enabled;
+        this.isDefault = isDefault;
+    }
+}
+exports.BaseFlag = BaseFlag;
+class DefaultFlag extends BaseFlag {
+    constructor(value, enabled) {
+        super(value, enabled, true);
+    }
+}
+exports.DefaultFlag = DefaultFlag;
+class Flag extends BaseFlag {
+    featureId;
+    featureName;
+    constructor(params) {
+        super(params.value, params.enabled, !!params.isDefault);
+        this.featureId = params.featureId;
+        this.featureName = params.featureName;
+    }
+    static fromFeatureStateModel(fsm, identityId) {
+        return new Flag({
+            value: fsm.getValue(identityId),
+            enabled: fsm.enabled,
+            featureId: fsm.feature.id,
+            featureName: fsm.feature.name
+        });
+    }
+    static fromAPIFlag(flagData) {
+        return new Flag({
+            enabled: flagData['enabled'],
+            value: flagData['feature_state_value'] || flagData['value'],
+            featureId: flagData['feature']['id'],
+            featureName: flagData['feature']['name']
+        });
+    }
+}
+exports.Flag = Flag;
+class Flags {
+    flags = {};
+    defaultFlagHandler;
+    analyticsProcessor;
+    constructor(data) {
+        this.flags = data.flags;
+        this.defaultFlagHandler = data.defaultFlagHandler;
+        this.analyticsProcessor = data.analyticsProcessor;
+    }
+    static fromFeatureStateModels(data) {
+        const flags = {};
+        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) {
+        const flags = {};
+        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() {
+        return Object.values(this.flags);
+    }
+    getFlag(featureName) {
+        const flag = this.flags[featureName];
+        if (!flag) {
+            if (this.defaultFlagHandler) {
+                return this.defaultFlagHandler(featureName);
+            }
+            return { enabled: false, isDefault: true, value: undefined };
+        }
+        if (this.analyticsProcessor && flag.featureId) {
+            this.analyticsProcessor.trackFeature(flag.featureId);
+        }
+        return flag;
+    }
+    getFeatureValue(featureName) {
+        return this.getFlag(featureName).value;
+    }
+    isFeatureEnabled(featureName) {
+        return this.getFlag(featureName).enabled;
+    }
+}
+exports.Flags = Flags;

package/build/sdk/polling_manager.d.ts

@@ -0,0 +1,9 @@
+import Flagsmith from '.';
+export declare class EnvironmentDataPollingManager {
+    private interval?;
+    private main;
+    private refreshIntervalSeconds;
+    constructor(main: Flagsmith, refreshIntervalSeconds: number);
+    start(): void;
+    stop(): void;
+}

package/build/sdk/polling_manager.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentDataPollingManager = void 0;
+class EnvironmentDataPollingManager {
+    interval;
+    main;
+    refreshIntervalSeconds;
+    constructor(main, refreshIntervalSeconds) {
+        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);
+    }
+}
+exports.EnvironmentDataPollingManager = EnvironmentDataPollingManager;

package/build/sdk/utils.d.ts

@@ -0,0 +1,12 @@
+import { Response } from 'node-fetch';
+export declare function generateIdentitiesData(identifier: string, traits?: {
+    [key: string]: any;
+}): {
+    identifier: string;
+    traits: {
+        trait_key: string;
+        trait_value: any;
+    }[];
+};
+export declare const delay: (ms: number) => Promise<unknown>;
+export declare const retryFetch: (url: string, fetchOptions: {} | undefined, retries: number | undefined, retryDelay: number | undefined, timeout: number) => Promise<Response>;

package/build/sdk/utils.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryFetch = exports.delay = exports.generateIdentitiesData = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+// @ts-ignore
+if (typeof node_fetch_1.default.default !== 'undefined')
+    node_fetch_1.default = node_fetch_1.default.default;
+function generateIdentitiesData(identifier, traits) {
+    const traitsGenerated = Object.entries(traits || {}).map(trait => ({
+        trait_key: trait[0],
+        trait_value: trait[1]
+    }));
+    return {
+        identifier: identifier,
+        traits: traitsGenerated
+    };
+}
+exports.generateIdentitiesData = generateIdentitiesData;
+const delay = (ms) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
+exports.delay = delay;
+const retryFetch = (url, fetchOptions = {}, retries = 3, retryDelay = 1000, timeout) => {
+    return new Promise((resolve, reject) => {
+        // check for timeout
+        if (timeout)
+            setTimeout(() => reject('error: timeout'), timeout);
+        const wrapper = (n) => {
+            (0, node_fetch_1.default)(url, fetchOptions)
+                .then(res => resolve(res))
+                .catch(async (err) => {
+                if (n > 0) {
+                    await (0, exports.delay)(retryDelay);
+                    wrapper(--n);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        };
+        wrapper(retries);
+    });
+};
+exports.retryFetch = retryFetch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.5",
   "description": "Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.",
   "main": "build/index.js",
   "repository": {

package/.tool-versions

@@ -1 +0,0 @@
-nodejs 16.14.0