flagsmith-nodejs 3.0.0 → 3.0.1

package/.github/workflows/publish.yml

@@ -20,6 +20,6 @@ jobs:
           registry-url: 'https://registry.npmjs.org'
 
       - run: npm ci
-      - run: npm publish
+      - run: npm run deploy
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/build/flagsmith-engine/environments/integrations/models.d.ts

@@ -0,0 +1,4 @@
+export declare class IntegrationModel {
+    api_key?: string;
+    base_url?: string;
+}

package/build/flagsmith-engine/environments/integrations/models.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationModel = void 0;
+var IntegrationModel = /** @class */ (function () {
+    function IntegrationModel() {
+        this.api_key = undefined;
+        this.base_url = undefined;
+    }
+    return IntegrationModel;
+}());
+exports.IntegrationModel = IntegrationModel;

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

@@ -0,0 +1,25 @@
+import { FeatureStateModel } from '../features/models';
+import { ProjectModel } from '../projects/models';
+import { IntegrationModel } from './integrations/models';
+export declare class EnvironmentAPIKeyModel {
+    id: number;
+    key: string;
+    createdAt: number;
+    name: string;
+    clientApiKey: string;
+    expiresAt?: number;
+    active: boolean;
+    constructor(id: number, key: string, createdAt: number, name: string, clientApiKey: string, expiresAt?: number);
+    isValid(): boolean;
+}
+export declare class EnvironmentModel {
+    id: number;
+    apiKey: string;
+    project: ProjectModel;
+    featureStates: FeatureStateModel[];
+    amplitude_config?: IntegrationModel;
+    segment_config?: IntegrationModel;
+    mixpanel_config?: IntegrationModel;
+    heap_config?: IntegrationModel;
+    constructor(id: number, apiKey: string, project: ProjectModel);
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentModel = exports.EnvironmentAPIKeyModel = void 0;
+var EnvironmentAPIKeyModel = /** @class */ (function () {
+    function EnvironmentAPIKeyModel(id, key, createdAt, name, clientApiKey, expiresAt) {
+        this.active = true;
+        this.id = id;
+        this.key = key;
+        this.createdAt = createdAt;
+        this.name = name;
+        this.clientApiKey = clientApiKey;
+        this.expiresAt = expiresAt;
+    }
+    EnvironmentAPIKeyModel.prototype.isValid = function () {
+        return !!this.active && (!this.expiresAt || this.expiresAt > Date.now());
+    };
+    return EnvironmentAPIKeyModel;
+}());
+exports.EnvironmentAPIKeyModel = EnvironmentAPIKeyModel;
+var EnvironmentModel = /** @class */ (function () {
+    function EnvironmentModel(id, apiKey, project) {
+        this.featureStates = [];
+        this.id = id;
+        this.apiKey = apiKey;
+        this.project = project;
+    }
+    return EnvironmentModel;
+}());
+exports.EnvironmentModel = EnvironmentModel;

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

@@ -0,0 +1,3 @@
+import { EnvironmentAPIKeyModel, EnvironmentModel } from './models';
+export declare function buildEnvironmentModel(environmentJSON: any): EnvironmentModel;
+export declare function buildEnvironmentAPIKeyModel(apiKeyJSON: any): EnvironmentAPIKeyModel;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnvironmentAPIKeyModel = exports.buildEnvironmentModel = void 0;
+var util_1 = require("../features/util");
+var util_2 = require("../projects/util");
+var models_1 = require("./models");
+function buildEnvironmentModel(environmentJSON) {
+    var project = (0, util_2.buildProjectModel)(environmentJSON.project);
+    var featureStates = environmentJSON.feature_states.map(function (fs) {
+        return (0, util_1.buildFeatureStateModel)(fs);
+    });
+    var environmentModel = new models_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
+    environmentModel.featureStates = featureStates;
+    return environmentModel;
+}
+exports.buildEnvironmentModel = buildEnvironmentModel;
+function buildEnvironmentAPIKeyModel(apiKeyJSON) {
+    var model = new models_1.EnvironmentAPIKeyModel(apiKeyJSON.id, apiKeyJSON.key, Date.parse(apiKeyJSON.created_at), apiKeyJSON.name, apiKeyJSON.client_api_key);
+    return model;
+}
+exports.buildEnvironmentAPIKeyModel = buildEnvironmentAPIKeyModel;

package/build/flagsmith-engine/features/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CONSTANTS: {
+    STANDARD: string;
+    MULTIVARIATE: string;
+};

package/build/flagsmith-engine/features/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSTANTS = void 0;
+exports.CONSTANTS = {
+    STANDARD: 'STANDARD',
+    MULTIVARIATE: 'MULTIVARIATE'
+};

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

@@ -0,0 +1,37 @@
+export declare class FeatureModel {
+    id: number;
+    name: string;
+    type: string;
+    constructor(id: number, name: string, type: string);
+    eq(other: FeatureModel): boolean;
+}
+export declare class MultivariateFeatureOptionModel {
+    value: any;
+    id: number | undefined;
+    constructor(value: any, id?: number);
+}
+export declare class MultivariateFeatureStateValueModel {
+    multivariateFeatureOption: MultivariateFeatureOptionModel;
+    percentageAllocation: number;
+    id: number;
+    mvFsValueUuid: string;
+    constructor(multivariate_feature_option: MultivariateFeatureOptionModel, percentage_allocation: number, id: number, mvFsValueUuid?: string);
+}
+export declare class FeatureStateModel {
+    feature: FeatureModel;
+    enabled: boolean;
+    djangoID: number;
+    featurestateUUID: string;
+    featureSegment?: FeatureSegment;
+    private value;
+    multivariateFeatureStateValues: MultivariateFeatureStateValueModel[];
+    constructor(feature: FeatureModel, enabled: boolean, djangoID: number, value?: any, featurestateUuid?: string);
+    setValue(value: any): void;
+    getValue(identityId?: number | string): any;
+    isHigherSegmentPriority(other: FeatureStateModel): boolean;
+    getMultivariateValue(identityID: number | string): any;
+}
+export declare class FeatureSegment {
+    priority: number;
+    constructor(priority: number);
+}

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

@@ -0,0 +1,122 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureSegment = exports.FeatureStateModel = exports.MultivariateFeatureStateValueModel = exports.MultivariateFeatureOptionModel = exports.FeatureModel = void 0;
+var uuid_1 = require("uuid");
+var hashing_1 = require("../utils/hashing");
+var FeatureModel = /** @class */ (function () {
+    function FeatureModel(id, name, type) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+    }
+    FeatureModel.prototype.eq = function (other) {
+        return !!other && this.id === other.id;
+    };
+    return FeatureModel;
+}());
+exports.FeatureModel = FeatureModel;
+var MultivariateFeatureOptionModel = /** @class */ (function () {
+    function MultivariateFeatureOptionModel(value, id) {
+        this.value = value;
+        this.id = id;
+    }
+    return MultivariateFeatureOptionModel;
+}());
+exports.MultivariateFeatureOptionModel = MultivariateFeatureOptionModel;
+var MultivariateFeatureStateValueModel = /** @class */ (function () {
+    function MultivariateFeatureStateValueModel(multivariate_feature_option, percentage_allocation, id, mvFsValueUuid) {
+        this.mvFsValueUuid = (0, uuid_1.v4)();
+        this.id = id;
+        this.percentageAllocation = percentage_allocation;
+        this.multivariateFeatureOption = multivariate_feature_option;
+        this.mvFsValueUuid = mvFsValueUuid || this.mvFsValueUuid;
+    }
+    return MultivariateFeatureStateValueModel;
+}());
+exports.MultivariateFeatureStateValueModel = MultivariateFeatureStateValueModel;
+var FeatureStateModel = /** @class */ (function () {
+    function FeatureStateModel(feature, enabled, djangoID, value, featurestateUuid) {
+        if (featurestateUuid === void 0) { featurestateUuid = (0, uuid_1.v4)(); }
+        this.featurestateUUID = (0, uuid_1.v4)();
+        this.multivariateFeatureStateValues = [];
+        this.feature = feature;
+        this.enabled = enabled;
+        this.djangoID = djangoID;
+        this.value = value;
+        this.featurestateUUID = featurestateUuid;
+    }
+    FeatureStateModel.prototype.setValue = function (value) {
+        this.value = value;
+    };
+    FeatureStateModel.prototype.getValue = function (identityId) {
+        if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
+            return this.getMultivariateValue(identityId);
+        }
+        return this.value;
+    };
+    /*
+        Returns `True` if `this` is higher segment priority than `other`
+        (i.e. has lower value for featureSegment.priority)
+        NOTE:
+            A segment will be considered higher priority only if:
+            1. `other` does not have a feature segment(i.e: it is an environment feature state or it's a
+            feature state with feature segment but from an old document that does not have `featureSegment.priority`)
+            but `this` does.
+            2. `other` have a feature segment with high priority
+    */
+    FeatureStateModel.prototype.isHigherSegmentPriority = function (other) {
+        if (!other.featureSegment || !this.featureSegment) {
+            return !!this.featureSegment && !other.featureSegment;
+        }
+        return this.featureSegment.priority < other.featureSegment.priority;
+    };
+    FeatureStateModel.prototype.getMultivariateValue = function (identityID) {
+        var e_1, _a;
+        var percentageValue = (0, hashing_1.getHashedPercentateForObjIds)([
+            this.djangoID || this.featurestateUUID,
+            identityID
+        ]);
+        var startPercentage = 0;
+        var sortedF = this.multivariateFeatureStateValues.sort(function (a, b) {
+            return a.id - b.id;
+        });
+        try {
+            for (var sortedF_1 = __values(sortedF), sortedF_1_1 = sortedF_1.next(); !sortedF_1_1.done; sortedF_1_1 = sortedF_1.next()) {
+                var myValue = sortedF_1_1.value;
+                var limit = myValue.percentageAllocation + startPercentage;
+                if (startPercentage <= percentageValue && percentageValue < limit) {
+                    return myValue.multivariateFeatureOption.value;
+                }
+                startPercentage = limit;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (sortedF_1_1 && !sortedF_1_1.done && (_a = sortedF_1.return)) _a.call(sortedF_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return this.value;
+    };
+    return FeatureStateModel;
+}());
+exports.FeatureStateModel = FeatureStateModel;
+var FeatureSegment = /** @class */ (function () {
+    function FeatureSegment(priority) {
+        this.priority = priority;
+    }
+    return FeatureSegment;
+}());
+exports.FeatureSegment = FeatureSegment;

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

@@ -0,0 +1,4 @@
+import { FeatureModel, FeatureSegment, FeatureStateModel } from './models';
+export declare function buildFeatureModel(featuresModelJSON: any): FeatureModel;
+export declare function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStateModel;
+export declare function buildFeatureSegment(featureSegmentJSON: any): FeatureSegment;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFeatureSegment = exports.buildFeatureStateModel = exports.buildFeatureModel = void 0;
+var models_1 = require("./models");
+function buildFeatureModel(featuresModelJSON) {
+    return new models_1.FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
+}
+exports.buildFeatureModel = buildFeatureModel;
+function buildFeatureStateModel(featuresStateModelJSON) {
+    var featureStateModel = new models_1.FeatureStateModel(buildFeatureModel(featuresStateModelJSON.feature), featuresStateModelJSON.enabled, featuresStateModelJSON.django_id, featuresStateModelJSON.feature_state_value, featuresStateModelJSON.uuid);
+    featureStateModel.featureSegment = featuresStateModelJSON.feature_segment ?
+        buildFeatureSegment(featuresStateModelJSON.feature_segment) :
+        undefined;
+    var multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
+        ? featuresStateModelJSON.multivariate_feature_state_values.map(function (fsv) {
+            var featureOption = new models_1.MultivariateFeatureOptionModel(fsv.multivariate_feature_option.value, fsv.multivariate_feature_option.id);
+            return new models_1.MultivariateFeatureStateValueModel(featureOption, fsv.percentage_allocation, fsv.id);
+        })
+        : [];
+    featureStateModel.multivariateFeatureStateValues = multivariateFeatureStateValues;
+    return featureStateModel;
+}
+exports.buildFeatureStateModel = buildFeatureStateModel;
+function buildFeatureSegment(featureSegmentJSON) {
+    return new models_1.FeatureSegment(featureSegmentJSON.priority);
+}
+exports.buildFeatureSegment = buildFeatureSegment;

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

@@ -0,0 +1,15 @@
+import { IdentityFeaturesList } from '../utils/collections';
+import { TraitModel } from './traits/models';
+export declare class IdentityModel {
+    identifier: string;
+    environmentApiKey: string;
+    createdDate?: number;
+    identityFeatures: IdentityFeaturesList;
+    identityTraits: TraitModel[];
+    identityUuid: string;
+    djangoID: number | undefined;
+    constructor(created_date: string, identityTraits: TraitModel[], identityFeatures: IdentityFeaturesList, environmentApiKey: string, identifier: string, identityUuid?: string, djangoID?: number);
+    get compositeKey(): string;
+    static generateCompositeKey(env_key: string, identifier: string): string;
+    updateTraits(traits: TraitModel[]): void;
+}

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

@@ -0,0 +1,113 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityModel = void 0;
+var collections_1 = require("../utils/collections");
+var uuidv4 = require('uuid').v4;
+var IdentityModel = /** @class */ (function () {
+    function IdentityModel(created_date, identityTraits, identityFeatures, environmentApiKey, identifier, identityUuid, djangoID) {
+        this.identityUuid = identityUuid || uuidv4();
+        this.createdDate = Date.parse(created_date) || Date.now();
+        this.identityTraits = identityTraits;
+        this.identityFeatures = new (collections_1.IdentityFeaturesList.bind.apply(collections_1.IdentityFeaturesList, __spreadArray([void 0], __read(identityFeatures), false)))();
+        this.environmentApiKey = environmentApiKey;
+        this.identifier = identifier;
+        this.djangoID = djangoID;
+    }
+    Object.defineProperty(IdentityModel.prototype, "compositeKey", {
+        get: function () {
+            return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IdentityModel.generateCompositeKey = function (env_key, identifier) {
+        return "".concat(env_key, "_").concat(identifier);
+    };
+    IdentityModel.prototype.updateTraits = function (traits) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var existingTraits = new Map();
+        try {
+            for (var _d = __values(this.identityTraits), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var trait = _e.value;
+                existingTraits.set(trait.traitKey, trait);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var traits_1 = __values(traits), traits_1_1 = traits_1.next(); !traits_1_1.done; traits_1_1 = traits_1.next()) {
+                var trait = traits_1_1.value;
+                if (!!trait.traitValue) {
+                    existingTraits.set(trait.traitKey, trait);
+                }
+                else {
+                    existingTraits.delete(trait.traitKey);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (traits_1_1 && !traits_1_1.done && (_b = traits_1.return)) _b.call(traits_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        this.identityTraits = [];
+        try {
+            for (var _f = __values(existingTraits.entries()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
+                this.identityTraits.push(v);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    return IdentityModel;
+}());
+exports.IdentityModel = IdentityModel;

package/build/flagsmith-engine/identities/traits/models.d.ts

@@ -0,0 +1,5 @@
+export declare class TraitModel {
+    traitKey: string;
+    traitValue: any;
+    constructor(key: string, value: any);
+}

package/build/flagsmith-engine/identities/traits/models.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraitModel = void 0;
+var TraitModel = /** @class */ (function () {
+    function TraitModel(key, value) {
+        this.traitKey = key;
+        this.traitValue = value;
+    }
+    return TraitModel;
+}());
+exports.TraitModel = TraitModel;

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

@@ -0,0 +1,4 @@
+import { IdentityModel } from './models';
+import { TraitModel } from './traits/models';
+export declare function buildTraitModel(traitJSON: any): TraitModel;
+export declare function buildIdentityModel(identityJSON: any): IdentityModel;

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

@@ -0,0 +1,46 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIdentityModel = exports.buildTraitModel = void 0;
+var util_1 = require("../features/util");
+var collections_1 = require("../utils/collections");
+var models_1 = require("./models");
+var models_2 = require("./traits/models");
+function buildTraitModel(traitJSON) {
+    return new models_2.TraitModel(traitJSON.trait_key, traitJSON.trait_value);
+}
+exports.buildTraitModel = buildTraitModel;
+function buildIdentityModel(identityJSON) {
+    var featureList = identityJSON.identity_features
+        ? new (collections_1.IdentityFeaturesList.bind.apply(collections_1.IdentityFeaturesList, __spreadArray([void 0], __read(identityJSON.identity_features.map(function (f) { return (0, util_1.buildFeatureStateModel)(f); })), false)))() : [];
+    var model = new models_1.IdentityModel(identityJSON.created_date, identityJSON.identity_traits
+        ? identityJSON.identity_traits.map(function (trait) { return buildTraitModel(trait); })
+        : [], featureList, identityJSON.environment_api_key, identityJSON.identifier, identityJSON.identity_uuid);
+    model.djangoID = identityJSON.django_id;
+    return model;
+}
+exports.buildIdentityModel = buildIdentityModel;

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

@@ -0,0 +1,15 @@
+import { EnvironmentModel } from './environments/models';
+import { FeatureStateModel } from './features/models';
+import { IdentityModel } from './identities/models';
+import { TraitModel } from './identities/traits/models';
+export { EnvironmentModel } from './environments/models';
+export { IntegrationModel } from './environments/integrations/models';
+export { FeatureStateModel } from './features/models';
+export { IdentityModel } from './identities/models';
+export { TraitModel } from './identities/traits/models';
+export { SegmentModel } from './segments/models';
+export { OrganisationModel } from './organisations/models';
+export declare function getIdentityFeatureState(environment: EnvironmentModel, identity: IdentityModel, featureName: string, overrideTraits?: TraitModel[]): FeatureStateModel;
+export declare function getIdentityFeatureStates(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): FeatureStateModel[];
+export declare function getEnvironmentFeatureState(environment: EnvironmentModel, featureName: string): FeatureStateModel;
+export declare function getEnvironmentFeatureStates(environment: EnvironmentModel): FeatureStateModel[];