expf-sigma-node.js 3.3.6 → 3.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expf-sigma-node.js",
-  "version": "3.3.6",
+  "version": "3.4.1",
   "description": "expf-sigma-node.js lets you manage features flags and remote config across web, server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.",
   "main": "public/sigma.js",
   "keywords": [

package/public/sigma.js

@@ -918,25 +918,28 @@ var sigmaHashes_default = Hashes;
 
 // src/helpers/constants.js
 var defaultApi = "https://api.expf.ru/api/v1";
-var sigmaUserId = "sigmaUserId";
-var sigmaProfileId = "sigmaProfileId";
-var sigmaDeviceId = "sigmaDeviceId";
 var sigmaPrivateId = "sigmaPrivateId";
 var sigmaHash = "sigmaHash";
 var sigmaDataFileLastUpdate = "sigmaDataFileLastUpdate";
-var sigmaExpiration = "sigmaExpiration";
 var sigmaDataFile = "sigmaDataFile";
 var sigmaExperiments = "sigmaExperiments";
+var sigmaHoldouts = "sigmaHoldouts";
+var sigmaGeoData = "sigmaGeoData";
 var max_decimal_64 = 18446744073709552e3;
 var zeta = 8540717056e4;
 var SHA256 = new sigmaHashes_default.SHA256();
 var MD5 = new sigmaHashes_default.MD5();
-var expirationDate = 24 * 60 * 60 * 1e3;
 var secondsIn24Hours = 24 * 60 * 60;
-var sigmaGeoData = "sigmaGeoData";
 var defaultGeoCacheTTL = 5 * 60;
 var cacheStandardTimeToLive = 3600;
 var cacheCheckPeriod = 600;
+var experimentType = {
+  featureFlag: 1,
+  param: 2,
+  splitUrl: 3,
+  webBuilder: 4,
+  holdout: 5
+};
 var errorMessages = {
   emptyToken: "Please specify a token",
   APIRequestErrorConfig: {
@@ -958,9 +961,10 @@ var errorMessages = {
 };
 var signsForHash = ["equal", "not equal", "any of", "none of"];
 var prefixGroup = "sigma_group";
-var errorTypesInConfig = {
-  invalidJson: 'Sigma warning. Invalid type json "%value%" in config.',
-  invalidType: 'Sigma warning. Invalid type "%type%" in config.'
+var warnings = {
+  invalidJson: 'Sigma warning: Invalid type json "%value%" in config.',
+  invalidType: 'Sigma warning: Invalid type "%type%" in config.',
+  emptyHoldoutId: "Sigma warning: Empty holdout id"
 };
 var sdkName = "node.js";
 var statusSuccess = "success";
@@ -1183,7 +1187,7 @@ function doTypeConversion(type, value) {
           return JSON.parse("{}");
         return JSON.parse(value);
       } catch (e) {
-        console.error(errorTypesInConfig.invalidJson.replace("%value%", value), e);
+        console.error(warnings.invalidJson.replace("%value%", value), e);
         return null;
       }
     default:
@@ -1262,7 +1266,7 @@ function generateFilteredList(array, name) {
 }
 
 // package.json
-var version = "3.3.6";
+var version = "3.4.1";
 
 // src/helpers/sdkVersion.js
 var sdkVersion = version;
@@ -1337,28 +1341,9 @@ var Sigma = class {
       pathname: this.userData.pathname || null,
       ua: this.userData.ua || void 0
     });
-    this.setSplitIdsToCache(this.userData);
     this.makePrivateIdInCache();
     this.geoCache = new SigmaGeoCache(`${this.cache.get(sigmaPrivateId)}__${this.token}`);
   }
-  setSplitIdsToCache(userData) {
-    for (let [key, value] of Object.entries(userData)) {
-      if (!value || !String(value).trim().length)
-        continue;
-      switch (key) {
-        case "userId":
-          this.cache.set(sigmaUserId, String(value).trim());
-          this.cache.set(sigmaExpiration, new Date().getTime() + expirationDate);
-          break;
-        case "profileId":
-          this.cache.set(sigmaProfileId, String(value).trim());
-          break;
-        case "deviceId":
-          this.cache.set(sigmaDeviceId, String(value).trim());
-          break;
-      }
-    }
-  }
   makePrivateIdInCache() {
     if (!this.cache.get(sigmaPrivateId)) {
       this.cache.set(sigmaPrivateId, generateRandomId());
@@ -1483,11 +1468,10 @@ var Sigma = class {
     if (!this.cache.get(sigmaDataFile) || this.hasExpireCache()) {
       return this.saveToCache();
     }
-    return true;
   }
   updateGeoCache() {
     if (!this.geoCache.get(sigmaGeoData)) {
-      this.saveToGeoCache();
+      return this.saveToGeoCache();
     }
   }
   async getFlags() {
@@ -1627,19 +1611,15 @@ var Sigma = class {
   }
   switchSplitById(splitBy) {
     let id = null;
-    const cacheSigmaExpiration = this.cache.get(sigmaExpiration);
     switch (splitBy) {
       case "userId":
-        id = this.cache.get(sigmaUserId) || null;
-        if (typeof cacheSigmaExpiration !== "undefined" && new Date().getTime() >= Number(cacheSigmaExpiration)) {
-          id = null;
-        }
+        id = this.userData.userId ? String(this.userData.userId).trim() : null;
         break;
       case "profileId":
-        id = this.cache.get(sigmaProfileId) || null;
+        id = this.userData.profileId ? String(this.userData.profileId).trim() : null;
         break;
       case "deviceId":
-        id = this.cache.get(sigmaDeviceId) || null;
+        id = this.userData.deviceId ? String(this.userData.deviceId).trim() : null;
         break;
     }
     return id;
@@ -1705,20 +1685,31 @@ var Sigma = class {
     let groupIndex = null;
     let forcedUser = false;
     let splitById = null;
+    let userInHoldout = false;
     for (let i = 0; i < sigmaDataLs.experiments.length; i++) {
-      if (sigmaDataLs.experiments[i]["name"] === experimentName && checkBoolValue(sigmaDataLs.experiments[i]["layer_id"])) {
-        layer = sigmaDataLs.experiments[i]["layer_id"];
-        bounds = sigmaDataLs.experiments[i]["layer_bounds"];
-      }
-      if (sigmaDataLs.experiments[i]["name"] === experimentName && !experiment) {
-        splitById = this.getSplitById(sigmaDataLs.experiments[i]);
-        forcedUser = checkForcedList(sigmaDataLs.experiments[i].forced_user_list, splitById);
-        groupName = this.findUserInForcedGroup(sigmaDataLs.experiments[i]);
-        experiment = this.experimentDefinition(sigmaDataLs.experiments[i], groupName, forcedUser);
+      const experimentIndex = sigmaDataLs.experiments[i];
+      if (experimentIndex["name"] === experimentName && checkBoolValue(experimentIndex["layer_id"])) {
+        layer = experimentIndex["layer_id"];
+        bounds = experimentIndex["layer_bounds"];
+      }
+      if (experimentIndex["name"] === experimentName) {
+        splitById = this.getSplitById(experimentIndex);
+        forcedUser = checkForcedList(experimentIndex.forced_user_list, splitById);
+        groupName = this.findUserInForcedGroup(experimentIndex);
+        experiment = this.experimentDefinition(experimentIndex, groupName, forcedUser);
+        if (experimentIndex.holdouts && experimentIndex.holdouts.length) {
+          for (const holdoutName of experimentIndex.holdouts) {
+            userInHoldout = await this.getHoldout(holdoutName);
+            if (userInHoldout)
+              break;
+          }
+        }
         break;
       }
     }
     const localStorageGroupName = `${prefixGroup}_${experimentName}`;
+    if (this.cache.get(localStorageGroupName))
+      this.cache.remove(localStorageGroupName);
     if (experiment) {
       if (!groupName) {
         groupName = this.calcUserInGroup(
@@ -1731,11 +1722,18 @@ var Sigma = class {
           splitById
         );
       }
-      this.cache.set(localStorageGroupName, groupName);
-      groupIndex = experiment.groups.findIndex((i) => i.name == groupName);
+      if (experiment.type === experimentType.holdout) {
+        if (groupName)
+          this.cache.set(localStorageGroupName, groupName);
+        return groupName;
+      }
+      if (!userInHoldout) {
+        this.cache.set(localStorageGroupName, groupName);
+        groupIndex = experiment.groups.findIndex((i) => i.name == groupName);
+      }
     }
     const getParamValue = (paramName) => {
-      if (!paramName || !experiment) {
+      if (!paramName || !experiment || userInHoldout) {
         return null;
       }
       const groupName2 = this.cache.get(localStorageGroupName);
@@ -1758,7 +1756,7 @@ var Sigma = class {
       return paramValue;
     };
     const getFeatureValue = (flagName) => {
-      if (!flagName || !experiment) {
+      if (!flagName || !experiment || userInHoldout) {
         return null;
       }
       const groupName2 = this.cache.get(localStorageGroupName);
@@ -1786,10 +1784,11 @@ var Sigma = class {
     return {
       getParamValue,
       getFeatureValue,
-      groupIndex: groupIndex < 0 ? null : groupIndex
+      groupIndex: groupIndex < 0 ? null : groupIndex,
+      userInHoldout
     };
   }
-  async getAllUserExperiments() {
+  async getAllUserExperiments(estimateHoldouts = true) {
     await this.updateCache();
     await this.updateGeoCache();
     const sigmaDataLs = this.cache.parse(sigmaDataFile);
@@ -1797,33 +1796,70 @@ var Sigma = class {
       return null;
     let result = "";
     for (let i in sigmaDataLs.experiments) {
+      if (!estimateHoldouts && sigmaDataLs.experiments[i].type === experimentType.holdout)
+        continue;
       let layer = null;
       let bounds = [];
       let splitById = this.getSplitById(sigmaDataLs.experiments[i]);
       let forcedUser = checkForcedList(sigmaDataLs.experiments[i].forced_user_list, splitById);
       let userInGroupExperiment = this.findUserInForcedGroup(sigmaDataLs.experiments[i]);
       let experiment = this.experimentDefinition(sigmaDataLs.experiments[i], userInGroupExperiment, forcedUser);
-      if (experiment) {
-        if (checkBoolValue(experiment["layer_id"]) && !userInGroupExperiment) {
-          layer = experiment["layer_id"];
-          bounds = experiment["layer_bounds"];
-        }
-        if (!userInGroupExperiment) {
-          userInGroupExperiment = this.calcUserInGroup(
-            experiment.salt,
-            experiment.allocation,
-            experiment.groups,
-            forcedUser,
-            layer,
-            bounds,
-            splitById
+      let userInHoldout;
+      if (!experiment)
+        continue;
+      if (checkBoolValue(experiment["layer_id"]) && !userInGroupExperiment) {
+        layer = experiment["layer_id"];
+        bounds = experiment["layer_bounds"];
+      }
+      if (!userInGroupExperiment) {
+        userInGroupExperiment = this.calcUserInGroup(
+          experiment.salt,
+          experiment.allocation,
+          experiment.groups,
+          forcedUser,
+          layer,
+          bounds,
+          splitById
+        );
+      }
+      if (!userInGroupExperiment)
+        continue;
+      if (sigmaDataLs.experiments[i].holdouts && sigmaDataLs.experiments[i].holdouts.length > 0) {
+        for (const holdout of sigmaDataLs.experiments[i].holdouts) {
+          const foundingExperimentHoldout = sigmaDataLs.experiments.find((exp) => exp.name === holdout);
+          if (!foundingExperimentHoldout)
+            break;
+          const splitByHoldoutId = this.getSplitById(foundingExperimentHoldout);
+          if (!splitByHoldoutId)
+            continue;
+          const holdoutForcedUser = checkForcedList(foundingExperimentHoldout.forced_user_list, splitByHoldoutId);
+          let userInGroupHoldout = this.findUserInForcedGroup(foundingExperimentHoldout);
+          if (userInGroupHoldout) {
+            userInHoldout = true;
+            break;
+          }
+          const experimentByHoldout = this.experimentDefinition(foundingExperimentHoldout, userInGroupHoldout, holdoutForcedUser);
+          if (!experimentByHoldout)
+            continue;
+          userInGroupHoldout = this.calcUserInGroup(
+            experimentByHoldout.salt,
+            experimentByHoldout.allocation,
+            experimentByHoldout.groups,
+            holdoutForcedUser,
+            null,
+            [],
+            splitByHoldoutId
           );
+          if (userInGroupHoldout) {
+            userInHoldout = true;
+            break;
+          }
         }
       }
-      if (userInGroupExperiment) {
-        const groupIndex = experiment.groups.findIndex((i2) => i2.name == userInGroupExperiment);
-        result = result.concat(experiment.name).concat(".").concat(groupIndex).concat("|");
-      }
+      if (userInHoldout)
+        continue;
+      const groupIndex = experiment.groups.findIndex((i2) => i2.name == userInGroupExperiment);
+      result = result.concat(experiment.name).concat(".").concat(groupIndex).concat("|");
     }
     if (result.length > 0) {
       this.cache.set(sigmaExperiments, result.slice(0, -1));
@@ -1833,6 +1869,52 @@ var Sigma = class {
     }
     return null;
   }
+  async getHoldout(name) {
+    if (!name)
+      return console.log(warnings.emptyHoldoutId);
+    const holdoutGroup = await this.getExperiment(name);
+    if (holdoutGroup && typeof holdoutGroup === "string")
+      return true;
+    return false;
+  }
+  async getAllUserHoldouts() {
+    await this.updateCache();
+    const sigmaDataLs = await this.cache.parse(sigmaDataFile);
+    if (!sigmaDataLs.experiments.length)
+      return null;
+    let result = "";
+    for (const holdout of sigmaDataLs.experiments) {
+      if (holdout.type !== experimentType.holdout)
+        continue;
+      let userInGroupExperiment = false;
+      const layer = null;
+      const bounds = [];
+      const splitById = this.getSplitById(holdout);
+      const forcedUser = checkForcedList(holdout.forced_user_list, splitById);
+      const experiment = this.experimentDefinition(holdout, userInGroupExperiment, forcedUser);
+      if (!experiment)
+        continue;
+      userInGroupExperiment = this.calcUserInGroup(
+        experiment.salt,
+        experiment.allocation,
+        experiment.groups,
+        forcedUser,
+        layer,
+        bounds,
+        splitById
+      );
+      if (!userInGroupExperiment)
+        continue;
+      result = result.concat(holdout.name).concat(".").concat("0").concat("|");
+    }
+    if (result.length > 0) {
+      this.cache.set(sigmaHoldouts, result.slice(0, -1));
+      return result.slice(0, -1);
+    } else {
+      this.cache.remove(sigmaHoldouts);
+    }
+    return null;
+  }
   findUserInForcedGroup(experiment) {
     let groupName = false;
     for (const groupItem in experiment.groups) {
@@ -1916,10 +1998,6 @@ var Sigma = class {
     const data = await this.cache.get(sigmaHash);
     return data;
   }
-  async getCacheUserId() {
-    const data = await this.cache.get(sigmaUserId);
-    return data;
-  }
   checkConditionsStatement(ruleStatement, items) {
     let isSuccessRule = false;
     if (ruleStatement == "OR") {
@@ -1938,14 +2016,11 @@ var Sigma = class {
     }
   }
   clearUserProperties() {
-    this.clearCacheByKeys([
-      sigmaUserId,
-      sigmaDeviceId,
-      sigmaProfileId,
-      sigmaExpiration,
-      sigmaExperiments
-    ]);
+    this.userData.userId = void 0;
+    this.userData.profileId = void 0;
+    this.userData.deviceId = void 0;
     this.sigmaUserData.removeInjectedProperties();
+    this.clearCacheByKeys([sigmaExperiments]);
   }
   overwriteGeoCache(key, value) {
     const geoCache = this.geoCache.parse(sigmaGeoData);
@@ -1956,17 +2031,17 @@ var Sigma = class {
     return {
       setUserId: (userId) => {
         this.sigmaUserData.setUserId(userId);
-        this.cache.set(sigmaUserId, userId);
+        this.userData.userId = userId;
         return this.editUserProperties();
       },
       setDeviceId: (deviceId) => {
         this.sigmaUserData.setDeviceId(deviceId);
-        this.cache.set(sigmaDeviceId, deviceId);
+        this.userData.deviceId = deviceId;
         return this.editUserProperties();
       },
       setProfileId: (profileId) => {
         this.sigmaUserData.setProfileId(profileId);
-        this.cache.set(sigmaProfileId, profileId);
+        this.userData.profileId = profileId;
         return this.editUserProperties();
       },
       setEmail: (email) => {
@@ -2024,17 +2099,17 @@ var Sigma = class {
       },
       removeUserId: () => {
         this.sigmaUserData.removeUserId();
-        this.cache.remove(sigmaUserId);
+        this.userData.userId = void 0;
         return this.editUserProperties();
       },
       removeDeviceId: () => {
         this.sigmaUserData.removeDeviceId();
-        this.cache.remove(sigmaDeviceId);
+        this.userData.deviceId = void 0;
         return this.editUserProperties();
       },
       removeProfileId: () => {
         this.sigmaUserData.removeProfileId();
-        this.cache.remove(sigmaProfileId);
+        this.userData.profileId = void 0;
         return this.editUserProperties();
       },
       removeAppVersion: () => {