expf-sigma-node.js 0.0.5 → 0.0.7

package/package.json

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

@@ -5651,16 +5651,21 @@ var SigmaUserData = class {
 var import_node_cache = __toESM(require_node_cache2());
 var sigmaCache = new import_node_cache.default();
 var SigmaCache = class {
+  constructor(postfix) {
+    this.postfix = "";
+    if (postfix)
+      this.postfix = "__" + postfix;
+  }
   get(key) {
     try {
-      return sigmaCache.get(key);
+      return sigmaCache.get(key + this.postfix);
     } catch (e) {
       console.log(e);
     }
   }
   set(key, value) {
     try {
-      sigmaCache.set(key, value);
+      sigmaCache.set(key + this.postfix, value);
       return;
     } catch (e) {
       console.log(e);
@@ -5777,24 +5782,32 @@ var js_cookie_default = api;
 var import_jshashes = __toESM(require_hashes());
 if (typeof import_node_fetch.default.default !== "undefined")
   import_node_fetch.default.default;
-var cache = new SigmaCache();
 var defaultApi = "https://api.expf.ru/api/v1";
-var sigmaUserData = new SigmaUserData();
 var sigmaUserId = "sigmaUserId";
 var sigmaDataFile = "sigmaDataFile";
+var sigmaExperiments = "sigmaExperiments";
 var SHA256 = new import_jshashes.default.SHA256();
 var MD5 = new import_jshashes.default.MD5();
+var max_decimal_64 = 18446744073709552e3;
+var zeta = 8540717056e4;
 var Sigma = class {
-  constructor(token, userData, cacheTTL = 10, api2, retries = 3) {
+  constructor(token, userData, cacheTTL = 10, options = {
+    api: "",
+    retries: "",
+    postfix: ""
+  }) {
     if (!token) {
       throw new Error("Please specify a token");
     }
     this.token = token;
     this.userData = userData || {};
     cacheTTL < 10 ? this.cacheTTL = 10 : this.cacheTTL = cacheTTL;
-    this.api = api2 || `${defaultApi}/config.json`;
-    this.retries = retries;
-    this.sigmaUserData = sigmaUserData;
+    this.api = options.api || `${defaultApi}/config.json`;
+    this.retries = options.retries || 3;
+    this.sigmaUserData = new SigmaUserData();
+    this.postfix = options.postfix || "";
+    this.cache = new SigmaCache(this.postfix);
+    this.userData.userId = this.validateUserDataUserId(this.userData.userId);
     this.sigmaUserData.init({
       userId: this.userData.userId || null,
       ip: this.userData.ip || null,
@@ -5802,13 +5815,24 @@ var Sigma = class {
       appVersion: this.userData.appVersion || null,
       custom: this.userData.custom || null
     });
-    if (!this.userData.userId) {
-      this.setUserCookie();
-      this.sigmaUserData.setUserId(cache.get(sigmaUserId));
-    } else {
-      cache.set(sigmaUserId, this.userData.userId);
-      this.sigmaUserData.setUserId(this.userData.userId);
+    this.cache.set(sigmaUserId, this.userData.userId);
+    this.setUserCookie();
+  }
+  validateUserDataUserId(userId) {
+    let hasMakeId = false;
+    if (typeof userId === "undefined") {
+      hasMakeId = true;
+    }
+    userId = String(userId).trim();
+    if (userId.length === 0) {
+      hasMakeId = true;
     }
+    if (hasMakeId && this.cache.get(sigmaUserId)) {
+      userId = this.cache.get(sigmaUserId);
+    } else if (hasMakeId) {
+      userId = this.makeIdCookie();
+    }
+    return userId;
   }
   delay(ms) {
     new Promise((resolve) => setTimeout(() => resolve(void 0), ms));
@@ -5863,10 +5887,10 @@ var Sigma = class {
   }
   async saveToCache() {
     const { api: api2 } = this;
-    const localStorageHash = cache.get("sigmaHash");
+    const localStorageHash = this.cache.get("sigmaHash");
     try {
       const timeRecord = Math.floor(Date.now() / 1e3);
-      cache.set("sigmaDataFileLastUpdate", timeRecord);
+      this.cache.set("sigmaDataFileLastUpdate", timeRecord);
     } catch (error) {
       throw new Error(`save last update to cache: ${error},
        token: ${this.token}
@@ -5874,19 +5898,19 @@ var Sigma = class {
     }
     try {
       const userGeoData = await this.getUserGeoData();
-      if (!cache.get("sigmaGeoData") || cache.get("sigmaGeoData", { location: "none" }) && userGeoData) {
-        cache.set("sigmaGeoData", JSON.stringify(userGeoData));
+      if (!this.cache.get("sigmaGeoData") || this.cache.get("sigmaGeoData", { location: "none" }) && userGeoData) {
+        this.cache.set("sigmaGeoData", JSON.stringify(userGeoData));
         this.sigmaUserData.clearFlags();
       }
     } catch (error) {
-      cache.set("sigmaGeoData", JSON.stringify({ location: "none" }));
+      this.cache.set("sigmaGeoData", JSON.stringify({ location: "none" }));
       console.error(error);
     }
     let data;
     try {
       data = await this.getDataFile(`${api2}`);
     } catch (error) {
-      if (!cache.get(sigmaDataFile)) {
+      if (!this.cache.get(sigmaDataFile)) {
         throw new Error(`
         Get data: ${error},
         token: ${this.token},
@@ -5904,8 +5928,8 @@ var Sigma = class {
       }
       hash = await SHA256.hex(JSON.stringify(data));
       if (!localStorageHash || localStorageHash !== hash) {
-        cache.set("sigmaHash", hash);
-        cache.set(sigmaDataFile, JSON.stringify(data));
+        this.cache.set("sigmaHash", hash);
+        this.cache.set(sigmaDataFile, JSON.stringify(data));
         this.sigmaUserData.clearFlags();
       }
     } catch (error) {
@@ -5913,17 +5937,17 @@ var Sigma = class {
     }
   }
   setUserCookie() {
-    let uin = cache.get(sigmaUserId);
+    let uin = this.cache.get(sigmaUserId);
     if (!uin) {
       uin = js_cookie_default.get(sigmaUserId);
-      cache.set(sigmaUserId, uin);
+      this.cache.set(sigmaUserId, uin);
     } else {
       js_cookie_default.set(sigmaUserId, uin);
     }
     if (!uin) {
       uin = this.makeIdCookie();
       js_cookie_default.set(sigmaUserId, uin);
-      cache.set(sigmaUserId, uin);
+      this.cache.set(sigmaUserId, uin);
     }
     return;
   }
@@ -5936,7 +5960,7 @@ var Sigma = class {
   }
   hasExpireCache() {
     const lastUpdate = parseInt(
-      cache.get("sigmaDataFileLastUpdate")
+      this.cache.get("sigmaDataFileLastUpdate")
     );
     const currentTime = Math.floor(Date.now() / 1e3);
     if (currentTime > lastUpdate + this.cacheTTL) {
@@ -5945,14 +5969,14 @@ var Sigma = class {
     return false;
   }
   updateCache() {
-    if (!cache.get("sigmaDataFile") || this.hasExpireCache()) {
+    if (!this.cache.get("sigmaDataFile") || this.hasExpireCache()) {
       return this.saveToCache();
     }
     return true;
   }
   async getFlags() {
     await this.updateCache();
-    const flags = cache.parse("sigmaDataFile");
+    const flags = this.cache.parse("sigmaDataFile");
     if (!flags.feature_flags)
       return;
     return flags.feature_flags;
@@ -5962,10 +5986,10 @@ var Sigma = class {
       return false;
     }
     await this.updateCache();
-    const cacheKey = cache.parse("sigmaDataFile");
+    const cacheKey = this.cache.parse("sigmaDataFile");
     if (!cacheKey.feature_flags)
       return;
-    const geoData = await cache.parse("sigmaGeoData");
+    const geoData = await this.cache.parse("sigmaGeoData");
     this.sigmaUserData.setGeo(geoData);
     let flag = null;
     for (let i = 0; i < cacheKey.feature_flags.length; i++) {
@@ -6067,29 +6091,32 @@ var Sigma = class {
       case "on date":
         return Math.floor(
           new Date(conditionValues.trim()).getTime() / (1e3 * 60 * 60 * 60 * 24)
-        ) == sigmaUserData.user.date;
+        ) == this.sigmaUserData.user.date;
       case "after time":
         return Math.floor(
           new Date(conditionValues.trim()).getTime() / (1e3 * 60 * 60)
-        ) < sigmaUserData.user.time;
+        ) < this.sigmaUserData.user.time;
       case "before time":
         return Math.floor(
           new Date(conditionValues.trim()).getTime() / (1e3 * 60 * 60)
-        ) > sigmaUserData.user.time;
+        ) > this.sigmaUserData.user.time;
       default:
         return false;
     }
   }
   getUserParamValue(paramKey) {
+    if (!paramKey)
+      return false;
     const user = this.sigmaUserData.user;
     if (paramKey.includes(".")) {
       const paramsArray = paramKey.split(".");
       const parent = paramsArray[0];
       const child = paramsArray[1];
+      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) {
@@ -6117,17 +6144,15 @@ var Sigma = class {
     return hash;
   }
   calcUserInGroup(salt, exposureRate, controlBucketPerc, forcedExp = false, layer = null, layerBounds = []) {
-    const max_decimal_64 = 2 ** 64;
-    const zeta = 8540717056;
-    const userId = sigmaUserData.user.userId ? sigmaUserData.user.userId : cache.get(sigmaUserId);
+    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 * 1e4 / max_decimal_64;
+    const R = this.digestHash(md5R) * zeta / max_decimal_64;
     let md5L = null;
     if (!layer || !layerBounds.length) {
       return this.getUserGroup(R, exposureRate, controlBucketPerc, forcedExp);
     } else {
       md5L = MD5.hex(String(userId) + layer);
-      const L = this.digestHash(md5L) * zeta * 1e4 / max_decimal_64;
+      const L = this.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) {
@@ -6159,7 +6184,7 @@ var Sigma = class {
       return false;
     }
     await this.updateCache();
-    const sigmaDataLs = cache.parse(sigmaDataFile);
+    const sigmaDataLs = this.cache.parse(sigmaDataFile);
     let experiment = null;
     let layer = null;
     let bounds = [];
@@ -6176,7 +6201,7 @@ var Sigma = class {
         bounds = sigmaDataLs.experiments[i]["layer_bounds"];
       }
       if (sigmaDataLs.experiments[i]["name"] === experimentName && !experiment) {
-        forcedUser = this.checkForcedList(sigmaDataLs.experiments[i].forced_user_list, sigmaUserData.user.userId);
+        forcedUser = this.checkForcedList(sigmaDataLs.experiments[i].forced_user_list, this.sigmaUserData.user.userId);
         experiment = sigmaDataLs.experiments[i];
         break;
       }
@@ -6191,13 +6216,13 @@ var Sigma = class {
         layer,
         bounds
       );
-      cache.set(localStorageGroupName, userInGroupExperiment);
+      this.cache.set(localStorageGroupName, userInGroupExperiment);
     }
     const getParamValue = (paramName) => {
       if (!paramName || !experiment) {
         return false;
       }
-      const groupName = cache.get(localStorageGroupName);
+      const groupName = this.cache.get(localStorageGroupName);
       let params = null;
       for (let i = 0; i < experiment.params.length; i++) {
         if (experiment.params[i]["name"] === paramName) {
@@ -6223,7 +6248,7 @@ var Sigma = class {
       if (!flagName || !experiment) {
         return false;
       }
-      const groupName = cache.get(localStorageGroupName);
+      const groupName = this.cache.get(localStorageGroupName);
       let flagExperiment = null;
       for (let i = 0; i < experiment.feature_flags.length; i++) {
         if (experiment.feature_flags[i]["name"] === flagName) {
@@ -6251,7 +6276,7 @@ var Sigma = class {
   }
   async getAllUserExperiments() {
     await this.updateCache();
-    const sigmaDataLs = cache.parse(sigmaDataFile);
+    const sigmaDataLs = this.cache.parse(sigmaDataFile);
     if (!sigmaDataLs.experiments.length)
       return false;
     let result = "";
@@ -6267,7 +6292,7 @@ var Sigma = class {
         experiment.salt,
         experiment.allocation,
         experiment.groups,
-        this.checkForcedList(experiment.forced_user_list, sigmaUserData.user.userId),
+        this.checkForcedList(experiment.forced_user_list, this.sigmaUserData.user.userId),
         layer,
         bounds
       );
@@ -6277,7 +6302,7 @@ var Sigma = class {
       }
     }
     if (result.length > 0) {
-      cache.set("sigmaExperiments", result.slice(0, -1));
+      this.cache.set(sigmaExperiments, result.slice(0, -1));
       return result.slice(0, -1);
     }
     return false;
@@ -6371,19 +6396,19 @@ var Sigma = class {
     return value;
   }
   async getCacheDataFile() {
-    const data = await cache.get(sigmaDataFile);
+    const data = await this.cache.get(sigmaDataFile);
     return data;
   }
   async getCacheHash() {
-    const data = await cache.get("sigmaHash");
+    const data = await this.cache.get("sigmaHash");
     return data;
   }
   async getCacheGeoData() {
-    const data = await cache.get("sigmaGeoData");
+    const data = await this.cache.get("sigmaGeoData");
     return data;
   }
   async getCacheUserId() {
-    const data = await cache.get(sigmaUserId);
+    const data = await this.cache.get(sigmaUserId);
     return data;
   }
 };