expf-sigma-node.js 3.2.11 → 3.3.0

package/package.json

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

@@ -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];
   }
 };
 
@@ -1066,6 +1185,8 @@ function doTypeConversion(type, value) {
       return parseFloat(value);
     case "json":
       try {
+        if (value === "")
+          return JSON.parse("{}");
         return JSON.parse(value);
       } catch (e) {
         console.error(errorTypesInConfig.invalidJson.replace("%value%", value), e);
@@ -1139,7 +1260,7 @@ function generateFilteredList(array, name) {
 }
 
 // package.json
-var version = "3.2.11";
+var version = "3.3.0";
 
 // src/helpers/sdkVersion.js
 var sdkVersion = version;
@@ -1173,11 +1294,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,
@@ -1271,7 +1392,7 @@ var Sigma = class {
     } else if (this.userData.geo) {
       this.geoCache.set(sigmaGeoData, JSON.stringify(this.userData.geo));
     } else {
-      this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
+      this.geoCache.set(sigmaGeoData, JSON.stringify({}));
     }
   }
   recordLastUpdateInCache() {
@@ -1297,7 +1418,7 @@ var Sigma = class {
       await this.getUserGeoData();
     } catch {
       if (!this.geoCache.get(sigmaGeoData)) {
-        this.geoCache.set(sigmaGeoData, JSON.stringify({ location: "none" }));
+        this.geoCache.set(sigmaGeoData, JSON.stringify({}));
       }
       errorMessages.APIRequestErrorGeoData.token = this.token;
       errorMessages.APIRequestErrorGeoData.userData = JSON.stringify(this.userData);
@@ -1491,8 +1612,8 @@ var Sigma = class {
   checkConditionSignForHash(condition) {
     return signsForHash.includes(condition);
   }
-  experimentDefinition(experiment, forcedUserInGroup) {
-    if (forcedUserInGroup) {
+  experimentDefinition(experiment, forcedUserInGroup, forcedUser) {
+    if (forcedUserInGroup || forcedUser) {
       return experiment;
     } else if (experiment.targets && experiment.targets.conditions.length > 0 && this.checkTargetConditions(experiment)) {
       return experiment;
@@ -1525,7 +1646,7 @@ var Sigma = class {
         splitById = this.getSplitById(sigmaDataLs.experiments[i]);
         forcedUser = checkForcedList(sigmaDataLs.experiments[i].forced_user_list, splitById);
         groupName = this.findUserInForcedGroup(sigmaDataLs.experiments[i]);
-        experiment = this.experimentDefinition(sigmaDataLs.experiments[i], groupName);
+        experiment = this.experimentDefinition(sigmaDataLs.experiments[i], groupName, forcedUser);
         break;
       }
     }
@@ -1610,8 +1731,9 @@ var Sigma = class {
       let layer = null;
       let bounds = [];
       let splitById = this.getSplitById(sigmaDataLs.experiments[i]);
+      let forcedUser = checkForcedList(sigmaDataLs.experiments[i].forced_user_list, splitById);
       let userInGroupExperiment = this.findUserInForcedGroup(sigmaDataLs.experiments[i]);
-      let experiment = this.experimentDefinition(sigmaDataLs.experiments[i], userInGroupExperiment);
+      let experiment = this.experimentDefinition(sigmaDataLs.experiments[i], userInGroupExperiment, forcedUser);
       if (experiment) {
         if (checkBoolValue(experiment["layer_id"]) && !userInGroupExperiment) {
           layer = experiment["layer_id"];
@@ -1622,7 +1744,7 @@ var Sigma = class {
             experiment.salt,
             experiment.allocation,
             experiment.groups,
-            checkForcedList(experiment.forced_user_list, splitById),
+            forcedUser,
             layer,
             bounds,
             splitById
@@ -1741,6 +1863,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: