expf-sigma-node.js 3.3.0 → 3.3.1

package/package.json

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

@@ -963,6 +963,10 @@ var errorTypesInConfig = {
   invalidType: 'Sigma warning. Invalid type "%type%" in config.'
 };
 var sdkName = "node.js";
+var statusSuccess = "success";
+var statusFailed = "failed";
+var status200 = 200;
+var status400 = 400;
 
 // src/modules/sigmaCache.js
 var sigmaCache = new import_node_cache.default({
@@ -1155,11 +1159,6 @@ function conditionOperation(userValue, conditionValues, operation, date, time) {
   }
 }
 
-// src/helpers/delay.js
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(() => resolve(void 0), ms));
-}
-
 // src/helpers/digestHash.js
 function digestHash(string) {
   let hash = 0, i, chr;
@@ -1260,11 +1259,42 @@ function generateFilteredList(array, name) {
 }
 
 // package.json
-var version = "3.3.0";
+var version = "3.3.1";
 
 // src/helpers/sdkVersion.js
 var sdkVersion = version;
 
+// src/helpers/isLocalOrIPv6.js
+var blackListLocalIps = [
+  ["192.168.0.0", "192.168.255.255"],
+  ["172.0.0.0", "172.255.255.255"],
+  ["10.0.0.0", "10.255.255.255"],
+  ["127.0.0.0", "127.255.255.255"],
+  ["100.64.0.0", "100.127.255.255"]
+];
+function isLocalOrIPv6(ip) {
+  let isLocalIpOrIPv6 = false;
+  if (typeof ip !== "string")
+    return isLocalIpOrIPv6 = true;
+  const dotCount = ip.split(".").length - 1;
+  if (dotCount !== 3)
+    return isLocalIpOrIPv6 = true;
+  function ipToNumber(ip2) {
+    const parts = ip2.split(".");
+    return (parseInt(parts[0]) << 24) + (parseInt(parts[1]) << 16) + (parseInt(parts[2]) << 8) + parseInt(parts[3]);
+  }
+  const ipNumber = ipToNumber(ip);
+  for (const i in blackListLocalIps) {
+    const startRange = ipToNumber(blackListLocalIps[i][0]);
+    const endRange = ipToNumber(blackListLocalIps[i][1]);
+    if (ipNumber >= startRange && ipNumber <= endRange) {
+      isLocalIpOrIPv6 = true;
+      break;
+    }
+  }
+  return isLocalIpOrIPv6;
+}
+
 // src/sigma.js
 if (typeof import_node_fetch.default.default !== "undefined")
   import_node_fetch.default.default;
@@ -1332,67 +1362,76 @@ var Sigma = class {
       this.cache.set(sigmaPrivateId, generateRandomId());
     }
   }
-  retryFetch(url, fetchOptions, retries = 3, timeout) {
-    return new Promise((resolve, reject) => {
-      if (timeout)
-        setTimeout(() => reject("error: timeout"), timeout);
-      const wrapper = (n) => {
-        (0, import_node_fetch.default)(url, fetchOptions).then((res) => resolve(res)).catch((err) => {
-          if (n > 0) {
-            delay(0).then(() => {
-              wrapper(--n);
-            });
-          } else {
-            reject(err);
-          }
-        });
-      };
-      wrapper(retries);
-    });
-  }
-  async getDataFile(url, method, body) {
-    const options = {
-      method: method || "GET",
-      body,
-      credentials: "same-origin",
-      headers: {
-        "ip": this.userData.ip,
-        "X-Real-IP": this.userData.ip,
-        token: this.token,
-        "user-id": this.cache.get(sigmaPrivateId),
-        "sdk-name": sdkName,
-        "sdk-version": sdkVersion
-      }
+  async getDataFile(url) {
+    let data;
+    let sigmaData = {
+      status: "",
+      statusCode: "",
+      data: null
     };
-    const data = await this.retryFetch(
-      url,
-      options,
-      this.retries
-    );
-    return data.json();
+    const controller = new AbortController();
+    try {
+      data = await (0, import_node_fetch.default)(url, {
+        headers: {
+          ip: this.userData.ip || "",
+          "X-Real-IP": this.userData.ip || "",
+          token: this.token,
+          "user-id": generateRandomId(),
+          "sdk-name": sdkName,
+          "sdk-version": sdkVersion
+        },
+        signal: controller.signal
+      });
+      sigmaData.status = data.status === status200 ? statusSuccess : statusFailed;
+      sigmaData.statusCode = data.status;
+      sigmaData.data = data.status === status200 ? await data.json() : null;
+    } catch {
+      controller.abort();
+      sigmaData.status = statusFailed;
+      sigmaData.statusCode = status400;
+      sigmaData.data = null;
+    }
+    return sigmaData;
   }
   async getConfig() {
     let data;
     const localStorageHash = this.cache.get(sigmaHash);
     let hash;
     data = await this.getDataFile(`${this.api}/config.json`);
-    if (this.userData.platform) {
-      data = filterByPlatform(data, this.userData.platform);
+    if (data.status === statusSuccess) {
+      if (this.userData.platform) {
+        data.data = filterByPlatform(data.data, this.userData.platform);
+      }
+      hash = await SHA256.hex(JSON.stringify(data.data));
+      if (!localStorageHash || localStorageHash !== hash) {
+        this.cache.set(sigmaHash, hash);
+        this.cache.set(sigmaDataFile, JSON.stringify(data.data));
+      }
+      return;
     }
-    hash = await SHA256.hex(JSON.stringify(data));
-    if (!localStorageHash || localStorageHash !== hash) {
-      this.cache.set(sigmaHash, hash);
-      this.cache.set(sigmaDataFile, JSON.stringify(data));
+    if (data.status === statusFailed) {
+      if (!this.cache.get(sigmaDataFile)) {
+        throw new Error(errorMessages.APIRequestErrorConfig.detail);
+      }
     }
+    return;
   }
   async getUserGeoData() {
+    if (this.userData.ip && isLocalOrIPv6(this.userData.ip)) {
+      this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
+      return;
+    }
     if (this.userData.ip) {
       const userGeoData = await this.getDataFile(`${this.api}/geo`);
-      this.geoCache.set(sigmaGeoData, JSON.stringify(userGeoData));
+      if (userGeoData.status === statusSuccess) {
+        this.geoCache.set(sigmaGeoData, JSON.stringify(userGeoData.data));
+      } else {
+        this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
+      }
     } else if (this.userData.geo) {
       this.geoCache.set(sigmaGeoData, JSON.stringify(this.userData.geo));
     } else {
-      this.geoCache.set(sigmaGeoData, JSON.stringify({}));
+      this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
     }
   }
   recordLastUpdateInCache() {
@@ -1418,11 +1457,8 @@ var Sigma = class {
       await this.getUserGeoData();
     } catch {
       if (!this.geoCache.get(sigmaGeoData)) {
-        this.geoCache.set(sigmaGeoData, JSON.stringify({}));
+        this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
       }
-      errorMessages.APIRequestErrorGeoData.token = this.token;
-      errorMessages.APIRequestErrorGeoData.userData = JSON.stringify(this.userData);
-      console.error(errorMessages.APIRequestErrorGeoData);
     }
     this.recordLastUpdateInCache();
   }