expf-sigma-node.js 3.2.12 → 3.3.1

package/package.json

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

@@ -135,9 +135,6 @@ var SigmaUserData = class {
       version: os.version || void 0
     };
   }
-  setUserId(userId) {
-    this.user.userId = userId;
-  }
   setIp(ip) {
     this.user.ip = ip;
   }
@@ -151,11 +148,133 @@ var SigmaUserData = class {
       });
     }
   }
+  setGeo(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+      return;
+    this.user.geo = data;
+  }
   clearFlags() {
     this.user.featureFlags = [];
   }
-  setGeo(data) {
-    this.user.geo = data;
+  removeInjectedProperties() {
+    this.user.appVersion = null;
+    this.user.userId = null;
+    this.user.profileId = null;
+    this.user.deviceId = null;
+    this.user.email = null;
+    this.user.custom = { name: null, value: null };
+  }
+  setUserId(userId) {
+    if (!userId)
+      this.user.userId = null;
+    this.user.userId = userId;
+  }
+  setDeviceId(deviceId) {
+    if (!deviceId)
+      this.user.deviceId = null;
+    this.user.deviceId = deviceId;
+  }
+  setProfileId(profileId) {
+    if (!profileId)
+      this.user.profileId = null;
+    this.user.profileId = profileId;
+  }
+  setEmail(email) {
+    if (!email)
+      this.user.email = null;
+    this.user.email = email;
+  }
+  setAppVersion(appVersion) {
+    if (!appVersion)
+      this.user.appVersion = null;
+    this.user.appVersion = appVersion;
+  }
+  setBrowserName(browserName) {
+    if (!browserName)
+      return;
+    this.user.browser.name = browserName;
+  }
+  setBrowserVersion(browserVersion) {
+    if (!browserVersion)
+      return;
+    this.user.browser.version = browserVersion;
+  }
+  setOsName(osName) {
+    if (!osName)
+      return;
+    this.user.os.name = osName;
+  }
+  setOsVersion(osVersion) {
+    if (!osVersion)
+      return;
+    this.user.os.version = osVersion;
+  }
+  setGeoCountry(country) {
+    this.user.geo.country = country;
+  }
+  setGeoCode(code) {
+    this.user.geo.code = code;
+  }
+  setGeoState(state) {
+    this.user.geo.state = state;
+  }
+  setGeoCity(city) {
+    this.user.geo.city = city;
+  }
+  setGeoIp(ip) {
+    this.user.geo.ip = ip;
+  }
+  setCustomProperty(key, value) {
+    if (typeof key !== "string")
+      return;
+    this.user.custom = { ...this.user.custom, [key]: value };
+  }
+  removeUserId() {
+    this.user.userId = null;
+  }
+  removeDeviceId() {
+    this.user.deviceId = null;
+  }
+  removeProfileId() {
+    this.user.profileId = null;
+  }
+  removeEmail() {
+    this.user.email = null;
+  }
+  removeAppVersion() {
+    this.user.appVersion = null;
+  }
+  removeBrowserName() {
+    this.user.browser.name = null;
+  }
+  removeBrowserVersion() {
+    this.user.browser.version = null;
+  }
+  removeOsName() {
+    this.user.os.name = null;
+  }
+  removeOsVersion() {
+    this.user.os.version = null;
+  }
+  removeGeoCountry() {
+    this.user.geo.country = null;
+  }
+  removeGeoCode() {
+    this.user.geo.code = null;
+  }
+  removeGeoState() {
+    this.user.geo.state = null;
+  }
+  removeGeoCity() {
+    this.user.geo.city = null;
+  }
+  removeGeoIp() {
+    this.user.geo.ip = null;
+  }
+  removeCustomProperty(key) {
+    if (!key || typeof key !== "string")
+      return;
+    delete this.user.custom[key];
   }
 };
 
@@ -844,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({
@@ -1036,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;
@@ -1141,11 +1259,42 @@ function generateFilteredList(array, name) {
 }
 
 // package.json
-var version = "3.2.12";
+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;
@@ -1175,11 +1324,11 @@ var Sigma = class {
       ip: this.userData.ip || null,
       email: this.userData.email || null,
       appVersion: this.userData.appVersion || null,
-      custom: this.userData.custom || null,
+      custom: this.userData.custom || {},
       deviceCategory: this.userData.deviceCategory || null,
       browser: this.userData.browser || this.sigmaUserData.getUserBrowser(this.userData.ua),
       os: this.userData.os || this.sigmaUserData.getUserOs(this.userData.ua),
-      geo: this.userData.geo || null,
+      geo: this.userData.geo || {},
       domain: this.userData.domain || null,
       url: this.userData.url || null,
       query: this.userData.query || null,
@@ -1213,63 +1362,72 @@ 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 {
@@ -1301,9 +1459,6 @@ var Sigma = class {
       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(errorMessages.APIRequestErrorGeoData);
     }
     this.recordLastUpdateInCache();
   }
@@ -1744,6 +1899,166 @@ var Sigma = class {
     }
     return isSuccessRule;
   }
+  clearCacheByKeys(keys) {
+    for (const key in keys) {
+      this.cache.remove(keys[key]);
+    }
+  }
+  clearUserProperties() {
+    this.clearCacheByKeys([
+      sigmaUserId,
+      sigmaDeviceId,
+      sigmaProfileId,
+      sigmaExpiration,
+      sigmaExperiments
+    ]);
+    this.sigmaUserData.removeInjectedProperties();
+  }
+  overwriteGeoCache(key, value) {
+    const geoCache = this.geoCache.parse(sigmaGeoData);
+    geoCache[key] = value;
+    this.geoCache.set(sigmaGeoData, JSON.stringify(geoCache));
+  }
+  editUserProperties() {
+    return {
+      setUserId: (userId) => {
+        this.sigmaUserData.setUserId(userId);
+        this.cache.set(sigmaUserId, userId);
+        return this.editUserProperties();
+      },
+      setDeviceId: (deviceId) => {
+        this.sigmaUserData.setDeviceId(deviceId);
+        this.cache.set(sigmaDeviceId, deviceId);
+        return this.editUserProperties();
+      },
+      setProfileId: (profileId) => {
+        this.sigmaUserData.setProfileId(profileId);
+        this.cache.set(sigmaProfileId, profileId);
+        return this.editUserProperties();
+      },
+      setEmail: (email) => {
+        this.sigmaUserData.setEmail(email);
+        return this.editUserProperties();
+      },
+      setAppVersion: (appVersion) => {
+        this.sigmaUserData.setAppVersion(appVersion);
+        return this.editUserProperties();
+      },
+      setBrowserName: (browserName) => {
+        this.sigmaUserData.setBrowserName(browserName);
+        return this.editUserProperties();
+      },
+      setBrowserVersion: (browserVersion) => {
+        this.sigmaUserData.setBrowserVersion(browserVersion);
+        return this.editUserProperties();
+      },
+      setOsName: (osName) => {
+        this.sigmaUserData.setOsName(osName);
+        return this.editUserProperties();
+      },
+      setOsVersion: (osVersion) => {
+        this.sigmaUserData.setOsVersion(osVersion);
+        return this.editUserProperties();
+      },
+      setGeoCountry: (country) => {
+        this.sigmaUserData.setGeoCountry(country);
+        this.overwriteGeoCache("country", country);
+        return this.editUserProperties();
+      },
+      setGeoCode: (code) => {
+        this.sigmaUserData.setGeoCode(code);
+        this.overwriteGeoCache("code", code);
+        return this.editUserProperties();
+      },
+      setGeoState: (state) => {
+        this.sigmaUserData.setGeoState(state);
+        this.overwriteGeoCache("state", state);
+        return this.editUserProperties();
+      },
+      setGeoCity: (city) => {
+        this.sigmaUserData.setGeoCity(city);
+        this.overwriteGeoCache("city", city);
+        return this.editUserProperties();
+      },
+      setGeoIp: (ip) => {
+        this.sigmaUserData.setGeoIp(ip);
+        this.overwriteGeoCache("ip", ip);
+        return this.editUserProperties();
+      },
+      setCustomProperty: (key, value) => {
+        this.sigmaUserData.setCustomProperty(key, value);
+        return this.editUserProperties();
+      },
+      removeUserId: () => {
+        this.sigmaUserData.removeUserId();
+        this.cache.remove(sigmaUserId);
+        return this.editUserProperties();
+      },
+      removeDeviceId: () => {
+        this.sigmaUserData.removeDeviceId();
+        this.cache.remove(sigmaDeviceId);
+        return this.editUserProperties();
+      },
+      removeProfileId: () => {
+        this.sigmaUserData.removeProfileId();
+        this.cache.remove(sigmaProfileId);
+        return this.editUserProperties();
+      },
+      removeAppVersion: () => {
+        this.sigmaUserData.removeAppVersion();
+        return this.editUserProperties();
+      },
+      removeBrowserName: () => {
+        this.sigmaUserData.removeBrowserName();
+        return this.editUserProperties();
+      },
+      removeBrowserVersion: () => {
+        this.sigmaUserData.removeBrowserVersion();
+        return this.editUserProperties();
+      },
+      removeEmail: () => {
+        this.sigmaUserData.removeEmail();
+        return this.editUserProperties();
+      },
+      removeOsName: () => {
+        this.sigmaUserData.removeOsName();
+        return this.editUserProperties();
+      },
+      removeOsVersion: () => {
+        this.sigmaUserData.removeOsVersion();
+        return this.editUserProperties();
+      },
+      removeGeoCountry: () => {
+        this.sigmaUserData.removeGeoCountry();
+        this.overwriteGeoCache("country", null);
+        return this.editUserProperties();
+      },
+      removeGeoCode: () => {
+        this.sigmaUserData.removeGeoCode();
+        this.overwriteGeoCache("code", null);
+        return this.editUserProperties();
+      },
+      removeGeoState: () => {
+        this.sigmaUserData.removeGeoState();
+        this.overwriteGeoCache("state", null);
+        return this.editUserProperties();
+      },
+      removeGeoCity: () => {
+        this.sigmaUserData.removeGeoCity();
+        this.overwriteGeoCache("city", null);
+        return this.editUserProperties();
+      },
+      removeGeoIp: () => {
+        this.sigmaUserData.removeGeoIp();
+        this.overwriteGeoCache("ip", null);
+        return this.editUserProperties();
+      },
+      removeCustomProperty: (key) => {
+        this.sigmaUserData.removeCustomProperty(key);
+        return this.editUserProperties();
+      }
+    };
+  }
 };
 var sigma_default = Sigma;
 // Annotate the CommonJS export names for ESM import in node: