expf-sigma-node.js 3.2.3 → 3.2.5

package/package.json

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

@@ -783,9 +783,37 @@ 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 errorMessages = {
+  emptyToken: "Please specify a token",
+  APIRequestErrorConfig: {
+    token: "%token%",
+    userData: "%userData%",
+    detail: "Invalid request to sigma config json",
+    time: new Date().toLocaleString("ru-RU"),
+    cache: true
+  },
+  APIRequestErrorGeoData: {
+    token: "%token%",
+    userData: "%userData%",
+    detail: "Invalid request to sigma geo data",
+    time: new Date().toLocaleString("ru-RU")
+  },
+  saveLastUpdateError: "Save last update to cache",
+  isNoExperimentInCache: "Experiments not found in cache",
+  badConfig: "Bad config.json"
+};
+var signsForHash = ["equal", "not equal", "any of", "none of"];
+var prefixGroup = "sigma_group";
 
 // src/modules/sigmaCache.js
-var sigmaCache = new import_node_cache.default({ stdTTL: secondsIn24Hours });
+var sigmaCache = new import_node_cache.default({
+  stdTTL: cacheStandardTimeToLive,
+  checkperiod: cacheCheckPeriod
+});
 var SigmaCache = class {
   constructor(postfix) {
     this.postfix = "";
@@ -824,14 +852,16 @@ var SigmaCache = class {
 
 // src/modules/sigmaGeoCache.js
 var import_node_cache2 = __toESM(require("node-cache"));
-var defaultGeoCacheTTL = 5 * 60;
-var maxGeoCacheTTL = 120 * 60;
-var minGeoCacheTTL = 1 * 60;
-var sigmaGeoCache = new import_node_cache2.default({ stdTTL: secondsIn24Hours });
+var sigmaGeoCache = new import_node_cache2.default({
+  stdTTL: cacheStandardTimeToLive,
+  checkperiod: cacheCheckPeriod
+});
 var SigmaGeoCache = class {
+  maxGeoCacheTTL = 120 * 60;
+  minGeoCacheTTL = 1 * 60;
   constructor(postfix, geoCacheTTL) {
     this.geoCacheTTL = geoCacheTTL || defaultGeoCacheTTL;
-    if (geoCacheTTL > maxGeoCacheTTL || geoCacheTTL < minGeoCacheTTL) {
+    if (geoCacheTTL > this.maxGeoCacheTTL || geoCacheTTL < this.minGeoCacheTTL) {
       this.geoCacheTTL = defaultGeoCacheTTL;
     }
     this.postfix = "";
@@ -855,6 +885,12 @@ var SigmaGeoCache = class {
   keys() {
     return sigmaGeoCache.keys();
   }
+  parse(data) {
+    if (!this.get(data)) {
+      throw new Error(`${data} not found in cache`);
+    }
+    return JSON.parse(String(this.get(data)));
+  }
 };
 
 // src/helpers/checkBoolValue.js
@@ -909,20 +945,20 @@ function conditionOperation(userValue, conditionValues, operation, date, time) {
     return false;
   userValue = String(userValue);
   if (!Array.isArray(conditionValues))
-    conditionValues = String(conditionValues);
+    conditionValues = String(conditionValues).toLowerCase().trim();
   switch (operation.trim()) {
     case "equal":
-      return userValue.toLowerCase().trim() == conditionValues.toLowerCase().trim();
+      return userValue.toLowerCase().trim() == conditionValues;
     case "not equal":
-      return userValue.toLowerCase().trim() != conditionValues.toLowerCase().trim();
+      return userValue.toLowerCase().trim() != conditionValues;
     case "greater":
-      return compareVersions(userValue.trim(), conditionValues.trim());
+      return compareVersions(userValue.trim(), conditionValues);
     case "less":
-      return compareVersions(conditionValues.trim(), userValue.trim());
+      return compareVersions(conditionValues, userValue.trim());
     case "greater equal":
-      return compareVersions(userValue.trim(), conditionValues.trim(), false);
+      return compareVersions(userValue.trim(), conditionValues, false);
     case "less equal":
-      return compareVersions(conditionValues.trim(), userValue.trim(), false);
+      return compareVersions(conditionValues, userValue.trim(), false);
     case "any of":
       return conditionValues.includes(userValue);
     case "none of":
@@ -942,13 +978,11 @@ function conditionOperation(userValue, conditionValues, operation, date, time) {
       }
       return true;
     case "on date":
-      return Math.floor(
-        new Date(conditionValues.trim()).getTime() / (1e3 * 60 * 60 * 24)
-      ) == date;
+      return Math.floor(new Date(conditionValues.toString()).getTime() / (1e3 * 60 * 60 * 24)) == date;
     case "after time":
-      return new Date(conditionValues.trim()).getTime() / (1e3 * 60 * 60) < time;
+      return new Date(conditionValues.toString()).getTime() / (1e3 * 60 * 60) < time;
     case "before time":
-      return new Date(conditionValues.trim()).getTime() / (1e3 * 60 * 60) > time;
+      return new Date(conditionValues.toString()).getTime() / (1e3 * 60 * 60) > time;
     case "starts with":
       return userValue.startsWith(conditionValues);
     case "not starts with":
@@ -1069,15 +1103,16 @@ var Sigma = class {
     geoCacheTTL: null
   }) {
     if (!token) {
-      throw new Error("Please specify a token");
+      throw new Error(errorMessages.emptyToken);
     }
     this.token = token;
     this.userData = userData || {};
     cacheTTL < 10 ? this.cacheTTL = 10 : this.cacheTTL = cacheTTL;
-    this.api = options.api || `${defaultApi}`;
-    this.retries = options.retries || 3;
-    this.sigmaUserData = new SigmaUserData();
+    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({
       userId: this.userData.userId || null,
@@ -1096,9 +1131,9 @@ var Sigma = class {
       query: this.userData.query || null,
       pathname: this.userData.pathname || null
     });
-    this.geoCache = new SigmaGeoCache(this.token, options.geoCacheTTL);
     this.setSplitIdsToCache(this.userData);
     this.makePrivateIdInCache();
+    this.geoCache = new SigmaGeoCache(`${this.cache.get(sigmaPrivateId)}__${this.token}`, options.geoCacheTTL);
   }
   setSplitIdsToCache(userData) {
     for (let [key, value] of Object.entries(userData)) {
@@ -1119,12 +1154,9 @@ var Sigma = class {
     }
   }
   makePrivateIdInCache() {
-    let privateId = this.cache.get(sigmaPrivateId);
-    if (!privateId) {
-      privateId = generateRandomId();
-      this.cache.set(sigmaPrivateId, privateId);
+    if (!this.cache.get(sigmaPrivateId)) {
+      this.cache.set(sigmaPrivateId, generateRandomId());
     }
-    return privateId;
   }
   retryFetch(url, fetchOptions, retries = 3, timeout) {
     return new Promise((resolve, reject) => {
@@ -1133,7 +1165,7 @@ var Sigma = class {
       const wrapper = (n) => {
         (0, import_node_fetch.default)(url, fetchOptions).then((res) => resolve(res)).catch((err) => {
           if (n > 0) {
-            delay(1e3).then(() => {
+            delay(0).then(() => {
               wrapper(--n);
             });
           } else {
@@ -1156,84 +1188,70 @@ var Sigma = class {
         "user-id": this.cache.get(sigmaPrivateId)
       }
     };
-    if (method !== "GET") {
-      options.headers["Content-Type"] = "application/json; charset=utf-8";
-    }
     const data = await this.retryFetch(
       url,
       options,
       this.retries
     );
-    if (data.status !== 200) {
-      throw new Error(`${data.status} Token: ${this.token}`);
-    }
     return data.json();
   }
-  async getUserGeoData() {
-    try {
-      const data = await this.getDataFile(`${this.api}/geo`);
-      return data;
-    } catch (error) {
-      throw new Error(`Get geo: ${error}`);
+  async getConfig() {
+    let data;
+    const localStorageHash = this.cache.get(sigmaHash);
+    let hash;
+    data = await this.getDataFile(`${this.api}/config.json`);
+    if (this.sigmaUserData.platform) {
+      data = filterByPlatform(data, this.sigmaUserData.user.platform);
+    }
+    hash = await SHA256.hex(JSON.stringify(data));
+    if (!localStorageHash || localStorageHash !== hash) {
+      this.cache.set(sigmaHash, hash);
+      this.cache.set(sigmaDataFile, JSON.stringify(data));
     }
   }
-  async setUserGeoData() {
-    if (!this.userData.ip)
-      return;
-    const geoKey = `${this.userData.ip}__${this.token}`;
-    const foundingGeoKey = this.geoCache.keys().find((k) => k === geoKey);
-    if (foundingGeoKey) {
-      const userGeoData = this.geoCache.get(this.userData.ip);
-      this.sigmaUserData.setGeo(userGeoData);
-      return;
+  async getUserGeoData() {
+    if (this.userData.ip) {
+      const userGeoData = await this.getDataFile(`${this.api}/geo`);
+      this.geoCache.set(sigmaGeoData, JSON.stringify(userGeoData));
+    } else if (this.userData.geo) {
+      this.geoCache.set(sigmaGeoData, JSON.stringify(this.userData.geo));
     } else {
-      const userGeoData = await this.getUserGeoData();
-      this.geoCache.set(this.userData.ip, userGeoData);
-      this.sigmaUserData.setGeo(userGeoData);
+      this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
     }
   }
+  recordLastUpdateInCache() {
+    const timeRecord = Math.floor(Date.now() / 1e3);
+    this.cache.set(sigmaDataFileLastUpdate, timeRecord);
+  }
   async saveToCache() {
-    const { api } = this;
-    const localStorageHash = this.cache.get(sigmaHash);
-    try {
-      const timeRecord = Math.floor(Date.now() / 1e3);
-      this.cache.set(sigmaDataFileLastUpdate, timeRecord);
-    } catch (error) {
-      throw new Error(`save last update to cache: ${error},
-       token: ${this.token}
-      `);
-    }
-    let data;
     try {
-      data = await this.getDataFile(`${api}/config.json`);
-    } catch (error) {
+      await this.getConfig();
+    } catch {
+      errorMessages.APIRequestErrorConfig.userData = JSON.stringify(this.userData);
+      errorMessages.APIRequestErrorConfig.token = this.token;
       if (!this.cache.get(sigmaDataFile)) {
-        throw new Error(` Get config: ${error}`);
+        errorMessages.APIRequestErrorConfig.cache = false;
+        console.error(errorMessages.APIRequestErrorConfig);
+        throw new Error(JSON.stringify(errorMessages.APIRequestErrorConfig));
       } else {
-        console.error(`Get config: ${error}`);
-        return true;
+        errorMessages.APIRequestErrorConfig.cache = true;
+        console.error(errorMessages.APIRequestErrorConfig);
       }
     }
-    let hash;
     try {
-      if (typeof data !== "object") {
-        throw new Error(`typeof config.json is not an object`);
-      }
-      data = filterByPlatform(data, this.userData.platform || this.sigmaUserData.platform);
-      hash = await SHA256.hex(JSON.stringify(data));
-      if (!localStorageHash || localStorageHash !== hash) {
-        this.cache.set(sigmaHash, hash);
-        this.cache.set(sigmaDataFile, JSON.stringify(data));
-        this.sigmaUserData.clearFlags();
+      await this.getUserGeoData();
+    } catch {
+      if (!this.geoCache.get(sigmaGeoData)) {
+        this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
       }
-    } catch (error) {
-      throw new Error(`Save data to local storage`);
+      errorMessages.APIRequestErrorGeoData.token = this.token;
+      errorMessages.APIRequestErrorGeoData.userData = JSON.stringify(this.userData);
+      console.error(errorMessages.APIRequestErrorGeoData);
     }
+    this.recordLastUpdateInCache();
   }
   hasExpireCache() {
-    const lastUpdate = parseInt(
-      this.cache.get(sigmaDataFileLastUpdate)
-    );
+    const lastUpdate = Number(this.cache.get(sigmaDataFileLastUpdate));
     const currentTime = Math.floor(Date.now() / 1e3);
     if (currentTime > lastUpdate + this.cacheTTL) {
       return true;
@@ -1254,14 +1272,13 @@ var Sigma = class {
     return flags.feature_flags;
   }
   async checkFlag(flagName) {
-    if (!flagName) {
+    if (!flagName)
       return null;
-    }
     await this.updateCache();
-    await this.setUserGeoData();
     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) {
@@ -1320,9 +1337,8 @@ 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) {
@@ -1367,17 +1383,13 @@ var Sigma = class {
     }
     return null;
   }
-  getSplitById(experiment) {
-    if (!experiment)
-      return;
+  switchSplitById(splitBy) {
     let id = null;
-    if (!experiment.split_by) {
-      experiment.split_by = "userId";
-    }
-    switch (experiment.split_by) {
+    const cacheSigmaExpiration = this.cache.get(sigmaExpiration);
+    switch (splitBy) {
       case "userId":
         id = this.cache.get(sigmaUserId) || null;
-        if (this.cache.get(sigmaExpiration) && parseInt(new Date().getTime()) >= parseInt(this.cache.get(sigmaExpiration))) {
+        if (typeof cacheSigmaExpiration !== "undefined" && new Date().getTime() >= Number(cacheSigmaExpiration)) {
           id = null;
         }
         break;
@@ -1390,6 +1402,14 @@ var Sigma = class {
     }
     return id;
   }
+  getSplitById(experiment) {
+    if (!experiment)
+      return null;
+    if (!experiment.split_by) {
+      experiment.split_by = "userId";
+    }
+    return this.switchSplitById(experiment.split_by);
+  }
   checkTargetConditions(experiment) {
     if (experiment.targets && experiment.targets.conditions && experiment.targets.conditions.length > 0) {
       const targets = experiment.targets;
@@ -1415,7 +1435,7 @@ var Sigma = class {
     return false;
   }
   checkConditionSignForHash(condition) {
-    return ["equal", "not equal", "any of", "none of"].includes(condition);
+    return signsForHash.includes(condition);
   }
   experimentDefinition(experiment, forcedUserInGroup) {
     if (forcedUserInGroup) {
@@ -1428,15 +1448,13 @@ var Sigma = class {
     return null;
   }
   async getExperiment(experimentName) {
-    if (!experimentName) {
+    if (!experimentName)
       return null;
-    }
     await this.updateCache();
-    await this.setUserGeoData();
     const sigmaDataLs = await this.cache.parse(sigmaDataFile);
-    if (!sigmaDataLs.experiments) {
-      throw new Error("Experiments not found in cache");
-    }
+    this.sigmaUserData.setGeo(this.geoCache.parse(sigmaGeoData));
+    if (!sigmaDataLs.experiments)
+      throw new Error(errorMessages.isNoExperimentInCache);
     let experiment = null;
     let layer = null;
     let bounds = [];
@@ -1457,7 +1475,7 @@ var Sigma = class {
         break;
       }
     }
-    const localStorageGroupName = `sigma_group_${experimentName}`;
+    const localStorageGroupName = `${prefixGroup}_${experimentName}`;
     if (experiment) {
       if (!groupName) {
         groupName = this.calcUserInGroup(
@@ -1597,7 +1615,7 @@ var Sigma = class {
       }
     }
     if (!flagDefaultResult) {
-      throw new Error("bad config.json");
+      throw new Error(errorMessages.badConfig);
     }
     for (let flagIndex in flagRules) {
       const statement = flagRules[flagIndex].conditional_statement;