expf-sigma-node.js 0.0.7 → 0.1.0

package/package.json

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

@@ -5780,6 +5780,109 @@ var js_cookie_default = api;
 
 // src/sigma.js
 var import_jshashes = __toESM(require_hashes());
+
+// src/helpers/checkBoolValue.js
+function checkBoolValue(value) {
+  if (value)
+    return true;
+  return false;
+}
+
+// src/helpers/checkForcedList.js
+function checkForcedList(usersList, data) {
+  if (usersList.length) {
+    for (let id2 in usersList) {
+      if (usersList[id2] == data) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/helpers/compareVersions.js
+function compareVersions(versionA, versionB, strict = true) {
+  let resultCompare;
+  const versionsLength = Math.max(versionA.length, versionB.length);
+  versionA = (versionA + "").split(".");
+  versionB = (versionB + "").split(".");
+  for (let i = 0; i < versionsLength; i++) {
+    if (versionA[i] === void 0) {
+      versionA[i] = "0";
+    }
+    if (versionB[i] === void 0) {
+      versionB[i] = "0";
+    }
+    resultCompare = parseInt(versionA[i], 10) - parseInt(versionB[i], 10);
+    if (resultCompare !== 0) {
+      return resultCompare < 0 ? false : true;
+    }
+  }
+  if (strict) {
+    return false;
+  }
+  if (!strict) {
+    return true;
+  }
+}
+
+// src/helpers/delay.js
+function delay(ms) {
+  new Promise((resolve) => setTimeout(() => resolve(void 0), ms));
+}
+
+// src/helpers/digestHash.js
+function digestHash(string) {
+  let hash = 0, i, chr;
+  if (string.length === 0)
+    return hash;
+  for (i = 0; i < string.length; i++) {
+    chr = string.charCodeAt(i);
+    hash = (hash << 5) - hash + chr;
+    hash |= 0;
+  }
+  return hash;
+}
+
+// src/helpers/doTypeConversion.js
+function doTypeConversion(type, value) {
+  if (type === "string")
+    return value;
+  if (type === "bool") {
+    return value === "true" ? true : false;
+  }
+  if (type === "integer" || type === "number")
+    return parseFloat(value);
+  return value;
+}
+
+// src/helpers/makeIdCookie.js
+function makeIdCookie() {
+  let text = "";
+  let possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  for (let i = 0; i < 80; i++)
+    text += possible.charAt(Math.floor(Math.random() * possible.length));
+  return text;
+}
+
+// src/helpers/getUserGroup.js
+function getUserGroup(salt, exposureRate, controlBucketPerc, forcedExp) {
+  let userInGroup = "a";
+  let currentDiapason = 0;
+  if (Math.abs(salt) / 100 <= parseFloat(exposureRate) * 100 || forcedExp) {
+    let bucket = Math.abs(salt) % 100;
+    for (let i = 0; i < controlBucketPerc.length; i++) {
+      currentDiapason += controlBucketPerc[i].weight * 100;
+      if (bucket <= currentDiapason) {
+        return userInGroup = controlBucketPerc[i].name;
+      }
+    }
+    return userInGroup;
+  }
+  return false;
+}
+
+// src/sigma.js
 if (typeof import_node_fetch.default.default !== "undefined")
   import_node_fetch.default.default;
 var defaultApi = "https://api.expf.ru/api/v1";
@@ -5830,13 +5933,10 @@ var Sigma = class {
     if (hasMakeId && this.cache.get(sigmaUserId)) {
       userId = this.cache.get(sigmaUserId);
     } else if (hasMakeId) {
-      userId = this.makeIdCookie();
+      userId = makeIdCookie();
     }
     return userId;
   }
-  delay(ms) {
-    new Promise((resolve) => setTimeout(() => resolve(void 0), ms));
-  }
   retryFetch(url, fetchOptions, retries = 3, timeout) {
     return new Promise((resolve, reject) => {
       if (timeout)
@@ -5844,7 +5944,7 @@ var Sigma = class {
       const wrapper = (n) => {
         (0, import_node_fetch.default)(url, fetchOptions).then((res) => resolve(res)).catch((err) => {
           if (n > 0) {
-            this.delay(1e3);
+            delay(1e3);
             wrapper(--n);
           } else {
             reject(err);
@@ -5945,19 +6045,12 @@ var Sigma = class {
       js_cookie_default.set(sigmaUserId, uin);
     }
     if (!uin) {
-      uin = this.makeIdCookie();
+      uin = makeIdCookie();
       js_cookie_default.set(sigmaUserId, uin);
       this.cache.set(sigmaUserId, uin);
     }
     return;
   }
-  makeIdCookie() {
-    let text = "";
-    let possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    for (let i = 0; i < 80; i++)
-      text += possible.charAt(Math.floor(Math.random() * possible.length));
-    return text;
-  }
   hasExpireCache() {
     const lastUpdate = parseInt(
       this.cache.get("sigmaDataFileLastUpdate")
@@ -5993,8 +6086,6 @@ var Sigma = class {
     this.sigmaUserData.setGeo(geoData);
     let flag = null;
     for (let i = 0; i < cacheKey.feature_flags.length; i++) {
-      if (cacheKey.feature_flags[i]["is_active"] == "false")
-        continue;
       if (cacheKey.feature_flags[i]["name"] === flagName) {
         flag = cacheKey.feature_flags[i];
         break;
@@ -6021,30 +6112,6 @@ var Sigma = class {
     }
     return flagValue;
   }
-  compareVersions(versionA, versionB, strict = true) {
-    let resultCompare;
-    const versionsLength = Math.max(versionA.length, versionB.length);
-    versionA = (versionA + "").split(".");
-    versionB = (versionB + "").split(".");
-    for (let i = 0; i < versionsLength; i++) {
-      if (versionA[i] === void 0) {
-        versionA[i] = "0";
-      }
-      if (versionB[i] === void 0) {
-        versionB[i] = "0";
-      }
-      resultCompare = parseInt(versionA[i], 10) - parseInt(versionB[i], 10);
-      if (resultCompare !== 0) {
-        return resultCompare < 0 ? false : true;
-      }
-    }
-    if (strict) {
-      return false;
-    }
-    if (!strict) {
-      return true;
-    }
-  }
   conditionOperation(userValue, conditionValues, operation) {
     !operation ? operation = "=" : operation;
     if (!userValue || typeof userValue === "undefined")
@@ -6055,17 +6122,17 @@ var Sigma = class {
       case "not equal":
         return userValue.toLowerCase().trim() != conditionValues.toLowerCase().trim();
       case "greater":
-        return this.compareVersions(conditionValues.trim(), userValue.trim());
+        return compareVersions(conditionValues.trim(), userValue.trim());
       case "less":
-        return this.compareVersions(userValue.trim(), conditionValues.trim());
+        return compareVersions(userValue.trim(), conditionValues.trim());
       case "greater equal":
-        return this.compareVersions(
+        return compareVersions(
           conditionValues.trim(),
           userValue.trim(),
           false
         );
       case "less equal":
-        return this.compareVersions(
+        return compareVersions(
           userValue.trim(),
           conditionValues.trim(),
           false
@@ -6104,10 +6171,11 @@ var Sigma = class {
         return false;
     }
   }
-  getUserParamValue(paramKey) {
+  getUserParamValue(paramKey, privateFlag = null) {
     if (!paramKey)
       return false;
     const user = this.sigmaUserData.user;
+    let defaultValue = null;
     if (paramKey.includes(".")) {
       const paramsArray = paramKey.split(".");
       const parent = paramsArray[0];
@@ -6115,107 +6183,87 @@ var Sigma = class {
       if (!child)
         return false;
       const isSetParentInUserData = Object.keys(user).find((i) => i === parent);
-      if (!user[isSetParentInUserData])
+      if (!user[isSetParentInUserData]) {
         return false;
+      }
       const userObject = Object.entries(user[isSetParentInUserData]);
       for (let [userParamKey, userParamValue] of userObject) {
         if (userParamKey == child) {
-          return userParamValue;
+          defaultValue = userParamValue;
+          break;
         }
       }
     } else {
       for (let [key, value] of Object.entries(user)) {
         if (key == paramKey) {
-          return value;
+          defaultValue = value;
+          break;
         }
       }
     }
-    return false;
-  }
-  digestHash(string) {
-    let hash = 0, i, chr;
-    if (string.length === 0)
-      return hash;
-    for (i = 0; i < string.length; i++) {
-      chr = string.charCodeAt(i);
-      hash = (hash << 5) - hash + chr;
-      hash |= 0;
-    }
-    return hash;
+    if (privateFlag && defaultValue)
+      return MD5.hex(defaultValue);
+    return defaultValue;
   }
   calcUserInGroup(salt, exposureRate, controlBucketPerc, forcedExp = false, layer = null, layerBounds = []) {
     const userId = this.sigmaUserData.user.userId ? this.sigmaUserData.user.userId : this.cache.get(sigmaUserId);
     const md5R = MD5.hex(String(userId) + salt);
-    const R = this.digestHash(md5R) * zeta / max_decimal_64;
+    const R = digestHash(md5R) * zeta / max_decimal_64;
     let md5L = null;
-    if (!layer || !layerBounds.length) {
-      return this.getUserGroup(R, exposureRate, controlBucketPerc, forcedExp);
+    if (!layer && !layerBounds.length || forcedExp) {
+      return getUserGroup(R, exposureRate, controlBucketPerc, forcedExp);
     } else {
       md5L = MD5.hex(String(userId) + layer);
-      const L = this.digestHash(md5L) * zeta / max_decimal_64;
+      const L = digestHash(md5L) * zeta / max_decimal_64;
       for (let i in layerBounds) {
         const result = Math.abs(L / 10);
         if (result <= layerBounds[i].lower_bound || layerBounds[i].upper_bound <= result) {
           continue;
         } else {
-          return this.getUserGroup(R, exposureRate, controlBucketPerc, forcedExp);
+          return getUserGroup(R, exposureRate, controlBucketPerc, forcedExp);
         }
       }
     }
     return false;
   }
-  getUserGroup(salt, exposureRate, controlBucketPerc, forcedExp) {
-    let userInGroup = "a";
-    let currentDiaposon = 0;
-    if (Math.abs(salt) / 100 <= parseFloat(exposureRate) * 100 || forcedExp) {
-      let bucket = Math.abs(salt) % 100;
-      for (let i = 0; i < controlBucketPerc.length; i++) {
-        currentDiaposon += controlBucketPerc[i].weight * 100;
-        if (bucket <= currentDiaposon) {
-          return userInGroup = controlBucketPerc[i].name;
-        }
-      }
-      return userInGroup;
-    }
-    return false;
-  }
   async getExperiment(experimentName) {
     if (!experimentName) {
       return false;
     }
     await this.updateCache();
-    const sigmaDataLs = this.cache.parse(sigmaDataFile);
+    const sigmaDataLs = await this.cache.parse(sigmaDataFile);
+    if (!sigmaDataLs.experiments) {
+      throw new Error("Experiments not found in cache");
+    }
     let experiment = null;
     let layer = null;
     let bounds = [];
     let userInGroupExperiment = null;
     let forcedUser = false;
-    if (!sigmaDataLs.experiments) {
-      throw new Error("experiments in cache not found");
-    }
     for (let i = 0; i < sigmaDataLs.experiments.length; i++) {
-      if (sigmaDataLs.experiments[i]["is_active"] == "false")
-        continue;
-      if (sigmaDataLs.experiments[i]["name"] === experimentName && this.checkBoolValue(sigmaDataLs.experiments[i]["layer_id"])) {
+      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) {
-        forcedUser = this.checkForcedList(sigmaDataLs.experiments[i].forced_user_list, this.sigmaUserData.user.userId);
+        forcedUser = checkForcedList(sigmaDataLs.experiments[i].forced_user_list, this.sigmaUserData.user.userId);
         experiment = sigmaDataLs.experiments[i];
         break;
       }
     }
     const localStorageGroupName = `sigma_group_${experimentName}`;
     if (experiment) {
-      userInGroupExperiment = this.calcUserInGroup(
-        experiment.salt,
-        experiment.allocation,
-        experiment.groups,
-        forcedUser,
-        layer,
-        bounds
-      );
+      userInGroupExperiment = this.findUserInForcedGroup(experiment);
+      if (!userInGroupExperiment) {
+        userInGroupExperiment = this.calcUserInGroup(
+          experiment.salt,
+          experiment.allocation,
+          experiment.groups,
+          forcedUser,
+          layer,
+          bounds
+        );
+      }
       this.cache.set(localStorageGroupName, userInGroupExperiment);
     }
     const getParamValue = (paramName) => {
@@ -6236,7 +6284,7 @@ var Sigma = class {
       let paramValue = null;
       for (let item in params.values) {
         if (params.values[item].group === groupName) {
-          paramValue = params.values[item].value;
+          paramValue = doTypeConversion(params.type, params.values[item].value);
         }
       }
       if (!paramValue) {
@@ -6284,18 +6332,21 @@ var Sigma = class {
       const experiment = sigmaDataLs.experiments[i];
       let layer = null;
       let bounds = [];
-      if (this.checkBoolValue(experiment["layer_id"])) {
+      let group = this.findUserInForcedGroup(experiment);
+      if (checkBoolValue(experiment["layer_id"]) && !group) {
         layer = experiment["layer_id"];
         bounds = experiment["layer_bounds"];
       }
-      const group = this.calcUserInGroup(
-        experiment.salt,
-        experiment.allocation,
-        experiment.groups,
-        this.checkForcedList(experiment.forced_user_list, this.sigmaUserData.user.userId),
-        layer,
-        bounds
-      );
+      if (!group) {
+        group = this.calcUserInGroup(
+          experiment.salt,
+          experiment.allocation,
+          experiment.groups,
+          checkForcedList(experiment.forced_user_list, this.sigmaUserData.user.userId),
+          layer,
+          bounds
+        );
+      }
       if (group) {
         const groupIndex = experiment.groups.findIndex((i2) => i2.name == group);
         result = result.concat(experiment.name).concat(".").concat(groupIndex).concat("|");
@@ -6307,20 +6358,19 @@ var Sigma = class {
     }
     return false;
   }
-  checkForcedList(usersList, data) {
-    if (usersList.length) {
-      for (let id2 in usersList) {
-        if (usersList[id2] == data) {
-          return true;
+  findUserInForcedGroup(experiment) {
+    let groupName = false;
+    for (const groupItem in experiment.groups) {
+      const forcedList = experiment.groups[groupItem].forced_user_list;
+      if (forcedList && forcedList.length) {
+        for (const item in forcedList) {
+          if (forcedList[item] === this.sigmaUserData.user.userId) {
+            return groupName = experiment.groups[groupItem].name;
+          }
         }
       }
     }
-    return false;
-  }
-  checkBoolValue(value) {
-    if (value)
-      return true;
-    return false;
+    return groupName;
   }
   findingSpotCondition(flag, saveToUser) {
     let flagRules = flag.rules;
@@ -6347,7 +6397,7 @@ var Sigma = class {
         const conditions = flagRules[rule].conditions;
         let results = [];
         for (let i in conditions) {
-          let userValue = this.getUserParamValue(conditions[i].name);
+          let userValue = this.getUserParamValue(conditions[i].name, flag.is_private);
           results.push(
             this.conditionOperation(
               userValue,
@@ -6365,7 +6415,7 @@ var Sigma = class {
           const findingItem = results.find((item) => item === false);
           findingItem === false ? isSuccessRule : isSuccessRule = true;
         }
-        let ruleValue = this.doTypeConversion(flag.type, flagRules[rule].value);
+        let ruleValue = doTypeConversion(flag.type, flagRules[rule].value);
         if (isSuccessRule) {
           if (saveToUser) {
             saveToUser.addFlag(flag.name, {
@@ -6377,7 +6427,7 @@ var Sigma = class {
           return ruleValue;
         }
       }
-      let defaultValue = this.doTypeConversion(flagDefaultResult.type, flagDefaultResult.value);
+      let defaultValue = doTypeConversion(flagDefaultResult.type, flagDefaultResult.value);
       if (saveToUser) {
         flagDefaultResult.value = defaultValue;
         saveToUser.addFlag(flag.name, flagDefaultResult);
@@ -6385,16 +6435,6 @@ var Sigma = class {
       return defaultValue;
     }
   }
-  doTypeConversion(type, value) {
-    if (type === "string")
-      return value;
-    if (type === "bool") {
-      return value === "true" ? true : false;
-    }
-    if (type === "integer")
-      return parseFloat(value);
-    return value;
-  }
   async getCacheDataFile() {
     const data = await this.cache.get(sigmaDataFile);
     return data;