expf-sigma-node.js 3.3.5 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expf-sigma-node.js",
-  "version": "3.3.5",
+  "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";
@@ -1017,13 +1026,7 @@ var sigmaGeoCache = new import_node_cache2.default({
   checkperiod: cacheCheckPeriod
 });
 var SigmaGeoCache = class {
-  maxGeoCacheTTL = 120 * 60;
-  minGeoCacheTTL = 1 * 60;
-  constructor(postfix, geoCacheTTL) {
-    this.geoCacheTTL = geoCacheTTL || defaultGeoCacheTTL;
-    if (geoCacheTTL > this.maxGeoCacheTTL || geoCacheTTL < this.minGeoCacheTTL) {
-      this.geoCacheTTL = defaultGeoCacheTTL;
-    }
+  constructor(postfix) {
     this.postfix = "";
     if (postfix)
       this.postfix = "__" + postfix;
@@ -1037,7 +1040,7 @@ var SigmaGeoCache = class {
   }
   set(key, value) {
     try {
-      return sigmaGeoCache.set(key + this.postfix, value, this.geoCacheTTL);
+      return sigmaGeoCache.set(key + this.postfix, value);
     } catch (e) {
       console.log(e);
     }
@@ -1189,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:
@@ -1268,7 +1271,7 @@ function generateFilteredList(array, name) {
 }
 
 // package.json
-var version = "3.3.5";
+var version = "3.4.0";
 
 // src/helpers/sdkVersion.js
 var sdkVersion = version;
@@ -1323,7 +1326,6 @@ var Sigma = class {
     this.api = options.api || defaultApi;
     this.retries = options.retries || 2;
     this.postfix = options.postfix || "";
-    this.geoCacheTTL = options.geoCacheTTL || defaultGeoCacheTTL;
     this.sigmaUserData = new SigmaUserData();
     this.cache = new SigmaCache(this.postfix);
     this.sigmaUserData.init({
@@ -1346,7 +1348,7 @@ var Sigma = class {
     });
     this.setSplitIdsToCache(this.userData);
     this.makePrivateIdInCache();
-    this.geoCache = new SigmaGeoCache(`${this.cache.get(sigmaPrivateId)}__${this.token}`, options.geoCacheTTL);
+    this.geoCache = new SigmaGeoCache(`${this.cache.get(sigmaPrivateId)}__${this.token}`);
   }
   setSplitIdsToCache(userData) {
     for (let [key, value] of Object.entries(userData)) {
@@ -1463,14 +1465,20 @@ var Sigma = class {
         console.error(errorMessages.APIRequestErrorConfig);
       }
     }
+    this.recordLastUpdateInCache();
+  }
+  async saveToGeoCache() {
     try {
       await this.getUserGeoData();
-    } catch {
+      this.geoCache.get(sigmaGeoData) ? this.sigmaUserData.setGeo(this.geoCache.parse(sigmaGeoData)) : this.sigmaUserData.setGeo("{}");
+    } catch (error) {
       if (!this.geoCache.get(sigmaGeoData)) {
         this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
       }
+      errorMessages.APIRequestErrorGeoData.token = this.token;
+      errorMessages.APIRequestErrorGeoData.userData = JSON.stringify(this.userData);
+      console.error(error, errorMessages.APIRequestErrorGeoData);
     }
-    this.recordLastUpdateInCache();
   }
   hasExpireCache() {
     const lastUpdate = Number(this.cache.get(sigmaDataFileLastUpdate));
@@ -1484,7 +1492,11 @@ var Sigma = class {
     if (!this.cache.get(sigmaDataFile) || this.hasExpireCache()) {
       return this.saveToCache();
     }
-    return true;
+  }
+  updateGeoCache() {
+    if (!this.geoCache.get(sigmaGeoData)) {
+      return this.saveToGeoCache();
+    }
   }
   async getFlags() {
     await this.updateCache();
@@ -1497,10 +1509,10 @@ var Sigma = class {
     if (!flagName)
       return null;
     await this.updateCache();
+    await this.updateGeoCache();
     const cacheKey = this.cache.parse(sigmaDataFile);
     if (!cacheKey.feature_flags)
       return;
-    this.sigmaUserData.setGeo(this.geoCache.parse(sigmaGeoData));
     let flag = null;
     const expName = this.getExperimentByFeatureFlag(cacheKey, flagName);
     if (expName) {
@@ -1521,8 +1533,8 @@ var Sigma = class {
   async getUserFeatureFlagsDetails() {
     const featureFlags = [];
     await this.updateCache();
+    await this.updateGeoCache();
     const sigmaDataLs = await this.cache.parse(sigmaDataFile);
-    this.sigmaUserData.setGeo(this.geoCache.parse(sigmaGeoData));
     if (sigmaDataLs.feature_flags.length > 0) {
       for (const flag in sigmaDataLs.feature_flags) {
         const ffName = sigmaDataLs.feature_flags[flag].name;
@@ -1689,6 +1701,7 @@ var Sigma = class {
     if (!experimentName)
       return null;
     await this.updateCache();
+    await this.updateGeoCache();
     const sigmaDataLs = await this.cache.parse(sigmaDataFile);
     this.sigmaUserData.setGeo(this.geoCache.parse(sigmaGeoData));
     if (!sigmaDataLs.experiments)
@@ -1700,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(
@@ -1726,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);
@@ -1753,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);
@@ -1781,43 +1812,82 @@ 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);
     if (!sigmaDataLs.experiments.length)
       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));
@@ -1827,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) {