flagsmith-nodejs 1.1.2 → 1.1.3

package/build/sdk/index.js

@@ -1,215 +0,0 @@
-"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 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) {
-            this.environmentDataPollingManager = new polling_manager_1.EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds);
-            this.environmentDataPollingManager.start();
-        }
-        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.environment) {
-            return new Promise(resolve => resolve(this.getIdentityFlagsFromDocument(identifier, traits || {})));
-        }
-        return this.getIdentityFlagsFromApi(identifier, traits);
-    }
-    /**
-     * Updates the environment state for local flag evaluation.
-     * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
-     */
-    async updateEnvironment() {
-        this.environment = await this.getEnvironmentFromApi();
-    }
-    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();
-    }
-    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;
-// export = Flagsmith;

package/build/sdk/models.d.ts

@@ -1,55 +0,0 @@
-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

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Flags = exports.Flag = exports.DefaultFlag = exports.BaseFlag = void 0;
-const errors_1 = require("./errors");
-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);
-            }
-            throw new errors_1.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) {
-        return this.getFlag(featureName).value;
-    }
-    isFeatureEnabled(featureName) {
-        return this.getFlag(featureName).enabled;
-    }
-}
-exports.Flags = Flags;

package/build/sdk/polling_manager.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1,31 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,45 +0,0 @@
-"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;