expf-sigma-node.js 3.3.6 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expf-sigma-node.js",
-  "version": "3.3.6",
+  "version": "3.4.0",
   "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

@@ -927,16 +927,24 @@ 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 +966,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 +1192,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 +1271,7 @@ function generateFilteredList(array, name) {
 }
 
 // package.json
-var version = "3.3.6";
+var version = "3.4.0";
 
 // src/helpers/sdkVersion.js
 var sdkVersion = version;
@@ -1483,11 +1492,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() {
@@ -1705,20 +1713,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 +1750,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 +1784,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 +1812,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 +1824,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 +1897,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) {