flagsmith-nodejs 3.3.3 → 4.0.0

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentModel = exports.SegmentRuleModel = exports.SegmentConditionModel = exports.getMatchingFunctions = exports.semverMatchingFunction = exports.matchingFunctions = exports.any = exports.all = void 0;
+const semver = require("semver");
+const index_js_1 = require("../utils/index.js");
+const constants_js_1 = require("./constants.js");
+const util_js_1 = require("./util.js");
+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_js_1.CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => thisValue == otherValue,
+    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => otherValue > thisValue,
+    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => otherValue >= thisValue,
+    [constants_js_1.CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => thisValue > otherValue,
+    [constants_js_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => thisValue >= otherValue,
+    [constants_js_1.CONDITION_OPERATORS.NOT_EQUAL]: (thisValue, otherValue) => thisValue != otherValue,
+    [constants_js_1.CONDITION_OPERATORS.CONTAINS]: (thisValue, otherValue) => !!otherValue && otherValue.includes(thisValue),
+};
+exports.semverMatchingFunction = {
+    ...exports.matchingFunctions,
+    [constants_js_1.CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => semver.eq(thisValue, otherValue),
+    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => semver.gt(otherValue, thisValue),
+    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => semver.gte(otherValue, thisValue),
+    [constants_js_1.CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => semver.gt(thisValue, otherValue),
+    [constants_js_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => semver.gte(thisValue, otherValue),
+};
+const getMatchingFunctions = (semver) => (semver ? exports.semverMatchingFunction : exports.matchingFunctions);
+exports.getMatchingFunctions = getMatchingFunctions;
+class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS = {
+        [constants_js_1.NOT_CONTAINS]: 'evaluateNotContains',
+        [constants_js_1.REGEX]: 'evaluateRegex',
+        [constants_js_1.MODULO]: 'evaluateModulo',
+        [constants_js_1.IN]: 'evaluateIn'
+    };
+    operator;
+    value;
+    property_;
+    constructor(operator, value, property) {
+        this.operator = operator;
+        this.value = value;
+        this.property_ = property;
+    }
+    matchesTraitValue(traitValue) {
+        const evaluators = {
+            evaluateNotContains: (traitValue) => {
+                return typeof traitValue == "string" &&
+                    !!this.value &&
+                    !traitValue.includes(this.value?.toString());
+            },
+            evaluateRegex: (traitValue) => {
+                return !!this.value && !!traitValue?.toString().match(new RegExp(this.value));
+            },
+            evaluateModulo: (traitValue) => {
+                if (isNaN(parseFloat(traitValue)) || !this.value) {
+                    return false;
+                }
+                const parts = (this.value).split("|");
+                const [divisor, reminder] = [parseFloat(parts[0]), parseFloat(parts[1])];
+                return traitValue % divisor === reminder;
+            },
+            evaluateIn: (traitValue) => {
+                return this.value?.split(',').includes(traitValue.toString());
+            },
+        };
+        // 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 matchingFunctionSet = (0, exports.getMatchingFunctions)((0, util_js_1.isSemver)(this.value));
+        const matchingFunction = matchingFunctionSet[this.operator] || defaultFunction;
+        const traitType = (0, util_js_1.isSemver)(this.value) ? 'semver' : typeof traitValue;
+        const castToTypeOfTraitValue = (0, index_js_1.getCastingFunction)(traitType);
+        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_js_1.ANY_RULE]: exports.any,
+            [constants_js_1.ALL_RULE]: exports.all,
+            [constants_js_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 → cjs/flagsmith-engine}/segments/util.d.ts

@@ -1,4 +1,4 @@
-import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models';
+import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models.js';
 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 → cjs/flagsmith-engine}/segments/util.js

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

package/build/{flagsmith-engine → cjs/flagsmith-engine}/utils/collections.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStateModel } from '../features/models';
+import { FeatureStateModel } from '../features/models.js';
 export declare class IdentityFeaturesList extends Array<FeatureStateModel> {
 }

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

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

package/build/cjs/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/cjs/flagsmith-engine/utils/hashing/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHashedPercentateForObjIds = void 0;
+const node_crypto_1 = require("node:crypto");
+const md5 = (data) => (0, node_crypto_1.createHash)('md5').update(data).digest('hex');
+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
+/**
+ * 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 toHash = makeRepeated(objectIds, iterations).join(',');
+    const hashedValue = md5(toHash);
+    const hashedInt = BigInt('0x' + hashedValue);
+    const value = (Number((hashedInt % 9999n)) / 9998.0) * 100;
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
+    if (value === 100) {
+        /* istanbul ignore next */
+        return getHashedPercentateForObjIds(objectIds, iterations + 1);
+    }
+    return value;
+}
+exports.getHashedPercentateForObjIds = getHashedPercentateForObjIds;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/utils/index.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCastingFunction = void 0;
-var util_1 = require("../segments/util");
+const util_js_1 = require("../segments/util.js");
 function getCastingFunction(traitType) {
     switch (traitType) {
         case 'boolean':
-            return function (x) { return !['False', 'false'].includes(x); };
+            return (x) => !['False', 'false'].includes(x);
         case 'number':
-            return function (x) { return parseFloat(x); };
+            return (x) => parseFloat(x);
         case 'semver':
-            return function (x) { return (0, util_1.removeSemverSuffix)(x); };
+            return (x) => (0, util_js_1.removeSemverSuffix)(x);
         default:
-            return function (x) { return String(x); };
+            return (x) => String(x);
     }
 }
 exports.getCastingFunction = getCastingFunction;

package/build/{index.d.ts → cjs/index.d.ts}

@@ -1,3 +1,3 @@
-export { AnalyticsProcessor, FlagsmithAPIError, FlagsmithClientError, EnvironmentDataPollingManager, FlagsmithCache, DefaultFlag, Flags, default } from './sdk';
-export { FlagsmithConfig } from './sdk/types';
-export { EnvironmentModel, FeatureStateModel, IdentityModel, TraitModel, SegmentModel, OrganisationModel } from './flagsmith-engine';
+export { AnalyticsProcessor, FlagsmithAPIError, FlagsmithClientError, EnvironmentDataPollingManager, FlagsmithCache, DefaultFlag, Flags, Flagsmith, } from './sdk/index.js';
+export { FlagsmithConfig } from './sdk/types.js';
+export { EnvironmentModel, FeatureStateModel, IdentityModel, TraitModel, SegmentModel, OrganisationModel } from './flagsmith-engine/index.js';

package/build/cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganisationModel = exports.SegmentModel = exports.TraitModel = exports.IdentityModel = exports.FeatureStateModel = exports.EnvironmentModel = exports.Flagsmith = exports.Flags = exports.DefaultFlag = exports.EnvironmentDataPollingManager = exports.FlagsmithClientError = exports.FlagsmithAPIError = exports.AnalyticsProcessor = void 0;
+var index_js_1 = require("./sdk/index.js");
+Object.defineProperty(exports, "AnalyticsProcessor", { enumerable: true, get: function () { return index_js_1.AnalyticsProcessor; } });
+Object.defineProperty(exports, "FlagsmithAPIError", { enumerable: true, get: function () { return index_js_1.FlagsmithAPIError; } });
+Object.defineProperty(exports, "FlagsmithClientError", { enumerable: true, get: function () { return index_js_1.FlagsmithClientError; } });
+Object.defineProperty(exports, "EnvironmentDataPollingManager", { enumerable: true, get: function () { return index_js_1.EnvironmentDataPollingManager; } });
+Object.defineProperty(exports, "DefaultFlag", { enumerable: true, get: function () { return index_js_1.DefaultFlag; } });
+Object.defineProperty(exports, "Flags", { enumerable: true, get: function () { return index_js_1.Flags; } });
+Object.defineProperty(exports, "Flagsmith", { enumerable: true, get: function () { return index_js_1.Flagsmith; } });
+var index_js_2 = require("./flagsmith-engine/index.js");
+Object.defineProperty(exports, "EnvironmentModel", { enumerable: true, get: function () { return index_js_2.EnvironmentModel; } });
+Object.defineProperty(exports, "FeatureStateModel", { enumerable: true, get: function () { return index_js_2.FeatureStateModel; } });
+Object.defineProperty(exports, "IdentityModel", { enumerable: true, get: function () { return index_js_2.IdentityModel; } });
+Object.defineProperty(exports, "TraitModel", { enumerable: true, get: function () { return index_js_2.TraitModel; } });
+Object.defineProperty(exports, "SegmentModel", { enumerable: true, get: function () { return index_js_2.SegmentModel; } });
+Object.defineProperty(exports, "OrganisationModel", { enumerable: true, get: function () { return index_js_2.OrganisationModel; } });

package/build/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/build/{sdk → cjs/sdk}/analytics.d.ts

@@ -1,4 +1,5 @@
 import { Logger } from 'pino';
+import { Fetch } from "./types.js";
 export declare class AnalyticsProcessor {
     private analyticsEndpoint;
     private environmentKey;
@@ -9,6 +10,7 @@ export declare class AnalyticsProcessor {
     private requestTimeoutMs;
     private logger;
     private currentFlush;
+    private customFetch;
     /**
      * AnalyticsProcessor is used to track how often individual Flags are evaluated within
      * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
@@ -23,6 +25,7 @@ export declare class AnalyticsProcessor {
         baseApiUrl: string;
         requestTimeoutMs?: number;
         logger?: Logger;
+        fetch?: Fetch;
     });
     /**
      * Sends all the collected data to the api asynchronously and resets the timer

package/build/cjs/sdk/analytics.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsProcessor = void 0;
+const pino_1 = require("pino");
+const ANALYTICS_ENDPOINT = 'analytics/flags/';
+// Used to control how often we send data(in seconds)
+const ANALYTICS_TIMER = 10;
+class AnalyticsProcessor {
+    analyticsEndpoint;
+    environmentKey;
+    lastFlushed;
+    analyticsData;
+    requestTimeoutMs = 3000;
+    logger;
+    currentFlush;
+    customFetch;
+    /**
+     * 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.requestTimeoutMs used to tell requests to stop waiting for a response after a
+            given number of milliseconds
+     */
+    constructor(data) {
+        this.analyticsEndpoint = data.baseApiUrl + ANALYTICS_ENDPOINT;
+        this.environmentKey = data.environmentKey;
+        this.lastFlushed = Date.now();
+        this.analyticsData = {};
+        this.requestTimeoutMs = data.requestTimeoutMs || this.requestTimeoutMs;
+        this.logger = data.logger || (0, pino_1.pino)();
+        this.customFetch = data.fetch ?? fetch;
+    }
+    /**
+     * Sends all the collected data to the api asynchronously and resets the timer
+     */
+    async flush() {
+        if (this.currentFlush || !Object.keys(this.analyticsData).length) {
+            return;
+        }
+        try {
+            this.currentFlush = this.customFetch(this.analyticsEndpoint, {
+                method: 'POST',
+                body: JSON.stringify(this.analyticsData),
+                signal: AbortSignal.timeout(this.requestTimeoutMs),
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Environment-Key': this.environmentKey
+                }
+            });
+            await this.currentFlush;
+        }
+        catch (error) {
+            // We don't want failing to write analytics to cause any exceptions in the main
+            // thread so we just swallow them here.
+            this.logger.warn('Failed to post analytics to Flagsmith API. Not clearing data, will retry.');
+            return;
+        }
+        finally {
+            this.currentFlush = undefined;
+        }
+        this.analyticsData = {};
+        this.lastFlushed = Date.now();
+    }
+    trackFeature(featureName) {
+        this.analyticsData[featureName] = (this.analyticsData[featureName] || 0) + 1;
+        if (Date.now() - this.lastFlushed > ANALYTICS_TIMER * 1000) {
+            this.flush();
+        }
+    }
+}
+exports.AnalyticsProcessor = AnalyticsProcessor;

package/build/cjs/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 → cjs/sdk}/index.d.ts

@@ -1,23 +1,23 @@
-import { RequestInit } from 'node-fetch';
-import { EnvironmentModel } from '../flagsmith-engine/environments/models';
-import { IdentityModel } from '../flagsmith-engine/identities/models';
-import { BaseOfflineHandler } from './offline_handlers';
-import { DefaultFlag, Flags } from './models';
-import { EnvironmentDataPollingManager } from './polling_manager';
-import { SegmentModel } from '../flagsmith-engine/segments/models';
-import { FlagsmithConfig } from './types';
-export { AnalyticsProcessor } from './analytics';
-export { FlagsmithAPIError, FlagsmithClientError } from './errors';
-export { DefaultFlag, Flags } from './models';
-export { EnvironmentDataPollingManager } from './polling_manager';
-export { FlagsmithCache, FlagsmithConfig } from './types';
+import { Dispatcher } from 'undici-types';
+import { EnvironmentModel } from '../flagsmith-engine/index.js';
+import { IdentityModel } from '../flagsmith-engine/index.js';
+import { BaseOfflineHandler } from './offline_handlers.js';
+import { DefaultFlag, Flags } from './models.js';
+import { EnvironmentDataPollingManager } from './polling_manager.js';
+import { SegmentModel } from '../flagsmith-engine/index.js';
+import { FlagsmithConfig, FlagsmithTraitValue, ITraitConfig } from './types.js';
+export { AnalyticsProcessor } from './analytics.js';
+export { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
+export { DefaultFlag, Flags } from './models.js';
+export { EnvironmentDataPollingManager } from './polling_manager.js';
+export { FlagsmithCache, FlagsmithConfig } from './types.js';
 export declare class Flagsmith {
     environmentKey?: string;
     apiUrl?: string;
     customHeaders?: {
         [key: string]: any;
     };
-    agent: RequestInit['agent'];
+    agent?: Dispatcher;
     requestTimeoutMs?: number;
     enableLocalEvaluation?: boolean;
     environmentRefreshIntervalSeconds: number;
@@ -36,6 +36,7 @@ export declare class Flagsmith {
     private onEnvironmentChange?;
     private analyticsProcessor?;
     private logger;
+    private customFetch;
     /**
      * A Flagsmith client.
      *
@@ -87,13 +88,13 @@ export declare class Flagsmith {
      *
      * @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}
+     * @param  {{[key:string]:any | ITraitConfig}} traits? a dictionary of traits to add / update on the identity in
+            Flagsmith, e.g. {"num_orders": 10} or {age: {value: 30, transient: true}}
      * @returns Flags object holding all the flags for the given identity.
      */
     getIdentityFlags(identifier: string, traits?: {
-        [key: string]: any;
-    }): Promise<Flags>;
+        [key: string]: FlagsmithTraitValue | ITraitConfig;
+    }, transient?: boolean): Promise<Flags>;
     /**
      * 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