flagsmith-nodejs 1.1.1 → 1.1.2

package/build/flagsmith-engine/segments/evaluators.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateIdentityInSegment = exports.getIdentitySegments = void 0;
+const hashing_1 = require("../utils/hashing");
+const constants_1 = require("./constants");
+function getIdentitySegments(environment, identity, overrideTraits) {
+    return environment.project.segments.filter(segment => evaluateIdentityInSegment(identity, segment, overrideTraits));
+}
+exports.getIdentitySegments = getIdentitySegments;
+function evaluateIdentityInSegment(identity, segment, overrideTraits) {
+    return (segment.rules.length > 0 &&
+        segment.rules.filter(rule => traitsMatchSegmentRule(overrideTraits || identity.identityTraits, rule, segment.id, identity.compositeKey)).length === segment.rules.length);
+}
+exports.evaluateIdentityInSegment = evaluateIdentityInSegment;
+function traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId) {
+    const matchesConditions = rule.conditions.length > 0
+        ? rule.matchingFunction()(rule.conditions.map(condition => traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId)))
+        : true;
+    return (matchesConditions &&
+        rule.rules.filter(rule => traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId)).length === rule.rules.length);
+}
+function traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId) {
+    if (condition.operator == constants_1.PERCENTAGE_SPLIT) {
+        return (0, hashing_1.getHashedPercentateForObjIds)([segmentId, identityId]) <= parseFloat(condition.value);
+    }
+    const traits = identityTraits.filter(t => t.traitKey === condition.property_);
+    const trait = traits.length > 0 ? traits[0] : undefined;
+    return trait ? condition.matchesTraitValue(trait.traitValue) : false;
+}

package/build/flagsmith-engine/segments/models.d.ts

@@ -0,0 +1,31 @@
+import { FeatureStateModel } from '../features/models';
+export declare const all: (iterable: Array<any>) => boolean;
+export declare const any: (iterable: Array<any>) => boolean;
+export declare const matchingFunctions: {
+    [x: string]: (thisValue: any, otherValue: any) => any;
+};
+export declare class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS: {
+        [key: string]: string;
+    };
+    operator: string;
+    value: string;
+    property_: string | undefined;
+    constructor(operator: string, value: string, property?: string);
+    matchesTraitValue(traitValue: any): any;
+}
+export declare class SegmentRuleModel {
+    type: string;
+    rules: SegmentRuleModel[];
+    conditions: SegmentConditionModel[];
+    constructor(type: string);
+    static none(iterable: Array<any>): boolean;
+    matchingFunction(): CallableFunction;
+}
+export declare class SegmentModel {
+    id: number;
+    name: string;
+    rules: SegmentRuleModel[];
+    featureStates: FeatureStateModel[];
+    constructor(id: number, name: string);
+}

package/build/flagsmith-engine/segments/models.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentModel = exports.SegmentRuleModel = exports.SegmentConditionModel = exports.matchingFunctions = exports.any = exports.all = void 0;
+const utils_1 = require("../utils");
+const constants_1 = require("./constants");
+const all = (iterable) => iterable.filter(e => !!e).length === iterable.length;
+exports.all = all;
+const any = (iterable) => iterable.filter(e => !!e).length > 0;
+exports.any = any;
+exports.matchingFunctions = {
+    [constants_1.CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => thisValue == otherValue,
+    [constants_1.CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => otherValue > thisValue,
+    [constants_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => otherValue >= thisValue,
+    [constants_1.CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => thisValue > otherValue,
+    [constants_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => thisValue >= otherValue,
+    [constants_1.CONDITION_OPERATORS.NOT_EQUAL]: (thisValue, otherValue) => thisValue != otherValue,
+    [constants_1.CONDITION_OPERATORS.CONTAINS]: (thisValue, otherValue) => otherValue.includes(thisValue),
+    [constants_1.CONDITION_OPERATORS.NOT_CONTAINS]: (thisValue, otherValue) => !otherValue.includes(thisValue)
+};
+class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS = {
+        [constants_1.NOT_CONTAINS]: 'evaluateNotContains',
+        [constants_1.REGEX]: 'evaluateRegex'
+    };
+    operator;
+    value;
+    property_;
+    constructor(operator, value, property) {
+        this.operator = operator;
+        this.value = value;
+        this.property_ = property;
+    }
+    matchesTraitValue(traitValue) {
+        const evaluators = {
+            evaluateNotContains: (traitValue) => {
+                return !traitValue.includes(this.value);
+            },
+            evaluateRegex: (traitValue) => {
+                return !!traitValue.match(new RegExp(this.value));
+            }
+        };
+        // TODO: move this logic to the evaluator module
+        if (this.EXCEPTION_OPERATOR_METHODS[this.operator]) {
+            const evaluatorFunction = evaluators[this.EXCEPTION_OPERATOR_METHODS[this.operator]];
+            return evaluatorFunction(traitValue);
+        }
+        const defaultFunction = (x, y) => false;
+        const matchingFunction = exports.matchingFunctions[this.operator] || defaultFunction;
+        const castToTypeOfTraitValue = (0, utils_1.getCastingFunction)(traitValue);
+        return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
+    }
+}
+exports.SegmentConditionModel = SegmentConditionModel;
+class SegmentRuleModel {
+    type;
+    rules = [];
+    conditions = [];
+    constructor(type) {
+        this.type = type;
+    }
+    static none(iterable) {
+        return iterable.filter(e => !!e).length === 0;
+    }
+    matchingFunction() {
+        return {
+            [constants_1.ANY_RULE]: exports.any,
+            [constants_1.ALL_RULE]: exports.all,
+            [constants_1.NONE_RULE]: SegmentRuleModel.none
+        }[this.type];
+    }
+}
+exports.SegmentRuleModel = SegmentRuleModel;
+class SegmentModel {
+    id;
+    name;
+    rules = [];
+    featureStates = [];
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
+}
+exports.SegmentModel = SegmentModel;

package/build/flagsmith-engine/segments/util.d.ts

@@ -0,0 +1,4 @@
+import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models';
+export declare function buildSegmentConditionModel(segmentConditionJSON: any): SegmentConditionModel;
+export declare function buildSegmentRuleModel(ruleModelJSON: any): SegmentRuleModel;
+export declare function buildSegmentModel(segmentModelJSON: any): SegmentModel;

package/build/flagsmith-engine/segments/util.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSegmentModel = exports.buildSegmentRuleModel = exports.buildSegmentConditionModel = void 0;
+const util_1 = require("../features/util");
+const models_1 = require("./models");
+function buildSegmentConditionModel(segmentConditionJSON) {
+    return new models_1.SegmentConditionModel(segmentConditionJSON.operator, segmentConditionJSON.value, segmentConditionJSON.property_);
+}
+exports.buildSegmentConditionModel = buildSegmentConditionModel;
+function buildSegmentRuleModel(ruleModelJSON) {
+    const ruleModel = new models_1.SegmentRuleModel(ruleModelJSON.type);
+    ruleModel.rules = ruleModelJSON.rules.map((r) => buildSegmentRuleModel(r));
+    ruleModel.conditions = ruleModelJSON.conditions.map((c) => buildSegmentConditionModel(c));
+    return ruleModel;
+}
+exports.buildSegmentRuleModel = buildSegmentRuleModel;
+function buildSegmentModel(segmentModelJSON) {
+    const model = new models_1.SegmentModel(segmentModelJSON.id, segmentModelJSON.name);
+    model.featureStates = segmentModelJSON['feature_states'].map((fs) => (0, util_1.buildFeatureStateModel)(fs));
+    model.rules = segmentModelJSON['rules'].map((r) => buildSegmentRuleModel(r));
+    return model;
+}
+exports.buildSegmentModel = buildSegmentModel;

package/build/flagsmith-engine/utils/collections.d.ts

@@ -0,0 +1,4 @@
+import { FeatureStateModel } from '../features/models';
+export declare class IdentityFeaturesList extends Array<FeatureStateModel> {
+    push(...e: FeatureStateModel[]): number;
+}

package/build/flagsmith-engine/utils/collections.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityFeaturesList = void 0;
+class IdentityFeaturesList extends Array {
+    push(...e) {
+        for (const [_, item] of e.entries()) {
+            for (const [k, v] of this.entries()) {
+                if (v.djangoID === item.djangoID) {
+                    throw new Error('feature state for this feature already exists');
+                }
+            }
+        }
+        return super.push(...e);
+    }
+}
+exports.IdentityFeaturesList = IdentityFeaturesList;

package/build/flagsmith-engine/utils/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class FeatureStateNotFound extends Error {
+}

package/build/flagsmith-engine/utils/errors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureStateNotFound = void 0;
+class FeatureStateNotFound extends Error {
+}
+exports.FeatureStateNotFound = FeatureStateNotFound;

package/build/flagsmith-engine/utils/hashing/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @param  {} iterations=1 num times to include each id in the generated string to hash
+ * @returns number number between 0 (inclusive) and 100 (exclusive)
+ */
+export declare function getHashedPercentateForObjIds(objectIds: Array<any>, iterations?: number): number;

package/build/flagsmith-engine/utils/hashing/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHashedPercentateForObjIds = void 0;
+const md5_1 = __importDefault(require("md5"));
+const big_integer_1 = __importDefault(require("big-integer"));
+const makeRepeated = (arr, repeats) => Array.from({ length: repeats }, () => arr).flat();
+// https://stackoverflow.com/questions/12532871/how-to-convert-a-very-large-hex-number-to-decimal-in-javascript
+function h2d(s) {
+    function add(x, y) {
+        var c = 0, r = [];
+        var x = x.split('').map(Number);
+        var y = y.split('').map(Number);
+        while (x.length || y.length) {
+            var s = (x.pop() || 0) + (y.pop() || 0) + c;
+            r.unshift(s < 10 ? s : s - 10);
+            c = s < 10 ? 0 : 1;
+        }
+        if (c)
+            r.unshift(c);
+        return r.join('');
+    }
+    var dec = '0';
+    s.split('').forEach(function (chr) {
+        var n = parseInt(chr, 16);
+        for (var t = 8; t; t >>= 1) {
+            dec = add(dec, dec);
+            if (n & t)
+                dec = add(dec, '1');
+        }
+    });
+    return dec;
+}
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @param  {} iterations=1 num times to include each id in the generated string to hash
+ * @returns number number between 0 (inclusive) and 100 (exclusive)
+ */
+function getHashedPercentateForObjIds(objectIds, iterations = 1) {
+    let to_hash = makeRepeated(objectIds, iterations).join(',');
+    const hashedValue = (0, md5_1.default)(to_hash);
+    const hashedInt = (0, big_integer_1.default)(h2d(hashedValue));
+    const value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
+    if (value === 100) {
+        return getHashedPercentateForObjIds(objectIds, iterations + 1);
+    }
+    return value;
+}
+exports.getHashedPercentateForObjIds = getHashedPercentateForObjIds;

package/build/flagsmith-engine/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function getCastingFunction(input: any): CallableFunction;

package/build/flagsmith-engine/utils/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCastingFunction = void 0;
+function getCastingFunction(input) {
+    switch (typeof input) {
+        case 'boolean':
+            return (x) => !['False', 'false'].includes(x);
+        case 'number':
+            return (x) => parseFloat(x);
+        default:
+            return (x) => String(x);
+    }
+}
+exports.getCastingFunction = getCastingFunction;

package/build/index.d.ts

@@ -0,0 +1 @@
+export { Flagsmith } from './sdk';

package/build/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flagsmith = void 0;
+const sdk_1 = __importDefault(require("./sdk"));
+var sdk_2 = require("./sdk");
+Object.defineProperty(exports, "Flagsmith", { enumerable: true, get: function () { return sdk_2.Flagsmith; } });
+// export default Flagsmith;
+module.exports = sdk_1.default;

package/build/sdk/analytics.d.ts

@@ -0,0 +1,28 @@
+export declare class AnalyticsProcessor {
+    private analyticsEndpoint;
+    private environmentKey;
+    private lastFlushed;
+    analyticsData: {
+        [key: string]: any;
+    };
+    private timeout;
+    /**
+     * AnalyticsProcessor is used to track how often individual Flags are evaluated within
+     * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
+     *
+     * @param data.environmentKey environment key obtained from the Flagsmith UI
+     * @param data.baseApiUrl base api url to override when using self hosted version
+     * @param data.timeout used to tell requests to stop waiting for a response after a
+            given number of seconds
+     */
+    constructor(data: {
+        environmentKey: string;
+        baseApiUrl: string;
+        timeout?: number;
+    });
+    /**
+     * Sends all the collected data to the api asynchronously and resets the timer
+     */
+    flush(): Promise<void>;
+    trackFeature(featureId: number): void;
+}

package/build/sdk/analytics.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsProcessor = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const ANALYTICS_ENDPOINT = 'analytics/flags/';
+// Used to control how often we send data(in seconds)
+const ANALYTICS_TIMER = 10;
+const delay = (ms) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
+class AnalyticsProcessor {
+    analyticsEndpoint;
+    environmentKey;
+    lastFlushed;
+    analyticsData;
+    timeout = 3;
+    /**
+     * AnalyticsProcessor is used to track how often individual Flags are evaluated within
+     * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
+     *
+     * @param data.environmentKey environment key obtained from the Flagsmith UI
+     * @param data.baseApiUrl base api url to override when using self hosted version
+     * @param data.timeout used to tell requests to stop waiting for a response after a
+            given number of seconds
+     */
+    constructor(data) {
+        this.analyticsEndpoint = data.baseApiUrl + ANALYTICS_ENDPOINT;
+        this.environmentKey = data.environmentKey;
+        this.lastFlushed = Date.now();
+        this.analyticsData = {};
+        this.timeout = data.timeout || this.timeout;
+    }
+    /**
+     * Sends all the collected data to the api asynchronously and resets the timer
+     */
+    async flush() {
+        if (!Object.keys(this.analyticsData).length) {
+            return;
+        }
+        await (0, node_fetch_1.default)(this.analyticsEndpoint, {
+            method: 'POST',
+            body: JSON.stringify(this.analyticsData),
+            timeout: this.timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Environment-Key': this.environmentKey
+            }
+        });
+        this.analyticsData = {};
+        this.lastFlushed = Date.now();
+    }
+    trackFeature(featureId) {
+        this.analyticsData[featureId] = (this.analyticsData[featureId] || 0) + 1;
+        if (Date.now() - this.lastFlushed > ANALYTICS_TIMER * 1000) {
+            this.flush();
+        }
+    }
+}
+exports.AnalyticsProcessor = AnalyticsProcessor;

package/build/sdk/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class FlagsmithClientError extends Error {
+}
+export declare class FlagsmithAPIError extends Error {
+}

package/build/sdk/errors.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagsmithAPIError = exports.FlagsmithClientError = void 0;
+class FlagsmithClientError extends Error {
+}
+exports.FlagsmithClientError = FlagsmithClientError;
+class FlagsmithAPIError extends Error {
+}
+exports.FlagsmithAPIError = FlagsmithAPIError;

package/build/sdk/index.d.ts

@@ -0,0 +1,98 @@
+import { EnvironmentModel } from '../flagsmith-engine/environments/models';
+import { DefaultFlag, Flags } from './models';
+import { EnvironmentDataPollingManager } from './polling_manager';
+export declare class Flagsmith {
+    environmentKey?: string;
+    apiUrl: string;
+    customHeaders?: {
+        [key: string]: any;
+    };
+    requestTimeoutSeconds?: number;
+    enableLocalEvaluation?: boolean;
+    environmentRefreshIntervalSeconds: number;
+    retries?: any;
+    enableAnalytics: boolean;
+    defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    environmentFlagsUrl: string;
+    identitiesUrl: string;
+    environmentUrl: string;
+    environmentDataPollingManager?: EnvironmentDataPollingManager;
+    environment: EnvironmentModel;
+    private 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: {
+        environmentKey: string;
+        apiUrl?: string;
+        customHeaders?: {
+            [key: string]: any;
+        };
+        requestTimeoutSeconds?: number;
+        enableLocalEvaluation?: boolean;
+        environmentRefreshIntervalSeconds?: number;
+        retries?: any;
+        enableAnalytics?: boolean;
+        defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    });
+    /**
+     * Get all the default for flags for the current environment.
+     *
+     * @returns Flags object holding all the flags for the current environment.
+     */
+    getEnvironmentFlags(): Promise<Flags>;
+    /**
+     * 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: string, traits?: {
+        [key: string]: any;
+    }): Promise<Flags>;
+    /**
+     * Updates the environment state for local flag evaluation.
+     * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
+     */
+    updateEnvironment(): Promise<void>;
+    private getJSONResponse;
+    private getEnvironmentFromApi;
+    private getEnvironmentFlagsFromDocument;
+    private getIdentityFlagsFromDocument;
+    private getEnvironmentFlagsFromApi;
+    private getIdentityFlagsFromApi;
+    private buildIdentityModel;
+}
+export default Flagsmith;