@suprsend/web-sdk 0.1.15 → 0.1.19

package/serviceworker/serviceworker.js

@@ -0,0 +1,119 @@
+var suprsend_config = {
+  api_url: "https://collector-staging.suprsend.workers.dev",
+  imgkit_root: "https://ik.imagekit.io/l0quatz6utm/",
+  api_events_route: "event/",
+};
+
+var valid_notification_params = [
+  "title",
+  "body",
+  "icon",
+  "image",
+  "badge",
+  "vibrate",
+  "sound",
+  "dir",
+  "tag",
+  "data",
+  "requireInteraction",
+  "renotify",
+  "silent",
+  "timestamp",
+  "actions",
+];
+
+const url_fields = ["image", "icon", "badge"];
+
+function safe_get(cb, default_value) {
+  let resp;
+  try {
+    resp = cb();
+  } catch (err) {
+    resp = default_value;
+  }
+  return resp;
+}
+
+function validate_notification(notification_obj) {
+  let validated_notification_obj = {};
+  for (var item in notification_obj) {
+    if (valid_notification_params.includes(item)) {
+      if (url_fields.includes(item)) {
+        validated_notification_obj[
+          item
+        ] = `${suprsend_config.imgkit_root}${notification_obj[item]}`;
+      } else {
+        validated_notification_obj[item] = notification_obj[item];
+      }
+    }
+  }
+  if (!(validated_notification_obj["actions"] instanceof Array)) {
+    delete validated_notification_obj["actions"];
+  }
+  return validated_notification_obj;
+}
+
+function track_data(body, method = "post") {
+  return fetch(
+    `${suprsend_config.api_url}/${suprsend_config.api_events_route}`,
+    {
+      method: method,
+      body: JSON.stringify(body),
+      headers: { "Content-Type": "application/json" },
+    }
+  );
+}
+
+self.addEventListener("push", function (e) {
+  var notification = e.data.json();
+  const validated_notification = validate_notification(notification);
+  console.log("Received notification", validated_notification);
+  track_data({
+    event: "$notification_delivered",
+    properties: {
+      id: safe_get(() => validated_notification.data.notification_id),
+    },
+  });
+  e.waitUntil(
+    self.registration.showNotification(
+      validated_notification.title || "",
+      validated_notification
+    )
+  );
+});
+
+self.addEventListener("notificationclose", function (e) {
+  var notification = e.notification;
+  console.log("Closed notification", notification);
+  track_data({
+    event: "$notification_dismiss",
+    properties: {
+      id: safe_get(() => notification.data.notification_id),
+    },
+  });
+});
+
+self.addEventListener("notificationclick", function (e) {
+  e.notification.close();
+  var notification = e.notification;
+  console.log("Clicked notification", notification);
+  track_data({
+    event: "$notification_clicked",
+    properties: {
+      id: safe_get(() => notification.data.notification_id),
+      label_id: e.action,
+    },
+  });
+  var launch_url_obj = safe_get(() => notification.data.launch_urls);
+  var redirect_url = "/";
+  if (launch_url_obj) {
+    if (e.action && launch_url_obj[e.action]) {
+      redirect_url = launch_url_obj[e.action];
+    } else if (launch_url_obj["default"]) {
+      redirect_url = launch_url_obj["default"];
+    }
+  } else {
+    redirect_url = "/";
+  }
+  clients.openWindow(redirect_url);
+});

package/src/config.js

@@ -1,11 +1,10 @@
 const package_data = require("../package.json");
 
-// suprsend sdk related config
 const config = {
   api_url: "https://hub.suprsend.com",
   sdk_version: package_data.version,
   batch_size: 20,
-  service_worker_file: "suprsend_service_worker.js",
+  service_worker_file: "serviceworker.js",
   sw_delay: 5000, //in ms,
 };
 

package/src/constants.js

@@ -13,22 +13,22 @@ export const browser_useragent_map = {
   "Opera Mobile": ["Opera Mobi"],
   Opera: ["Opera"],
   "Internet Explorer": ["Trident", "MSIE"],
-  Chrome: ["Chrome"],
+  Chrome: ["Chrome", "CriOS"],
   Firefox: ["Firefox"],
   Safari: ["Safari"],
   Mozilla: ["Mozilla"],
 };
 
 export const browser_version_useragent_map = {
-  Edge: /Edge\/([0-9]+(\.[0-9]+)?)/,
-  "Opera Mini": /Opera Mini\/([0-9]+(\.[0-9]+)?)/,
-  "Opera Mobile": /Version\/([0-9]+(\.[0-9]+)?)/,
-  Opera: /Version\/([0-9]+(\.[0-9]+)?)/,
-  "Internet Explorer": "rv:",
-  Chrome: /Chrome\/([0-9]+(\.[0-9]+)?)/,
-  Firefox: /rv:([0-9]+(\.[0-9]+)?)/,
-  Safari: /Version\/([0-9]+(\.[0-9]+)?)/,
-  Mozilla: /rv:([0-9]+(\.[0-9]+)?)/,
+  Edge: [/Edge\/([0-9]+(\.[0-9]+)?)/],
+  "Opera Mini": [/Opera Mini\/([0-9]+(\.[0-9]+)?)/],
+  "Opera Mobile": [/Version\/([0-9]+(\.[0-9]+)?)/],
+  Opera: [/Version\/([0-9]+(\.[0-9]+)?)/],
+  "Internet Explorer": ["rv:"],
+  Chrome: [/Chrome\/([0-9]+(\.[0-9]+)?)/, /CriOS\/([0-9]+(\.[0-9]+)?)/],
+  Firefox: [/rv:([0-9]+(\.[0-9]+)?)/],
+  Safari: [/Version\/([0-9]+(\.[0-9]+)?)/],
+  Mozilla: [/rv:([0-9]+(\.[0-9]+)?)/],
 };
 
 export const os_useragent_map = {

package/src/errors.js

@@ -0,0 +1,20 @@
+export class SuprsendError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SuprsendError";
+  }
+}
+
+export class SSConfigurationError extends SuprsendError {
+  constructor(message) {
+    super(message);
+    this.name = "SuprsendConfigurationError";
+  }
+}
+
+export class SSValidationError extends SuprsendError {
+  constructor(message) {
+    super(message);
+    this.name = "SuprsendValidationError";
+  }
+}

package/src/index.js

@@ -3,26 +3,31 @@ import config from "./config";
 import User from "./user";
 import ServiceWorker from "./service_worker";
 import { constants } from "./constants";
+import { SSConfigurationError } from "./errors";
 
 var suprSendInstance;
 export var init_at;
 
 class SuprSend {
-  setCustomConfigProperty(key, value = "", mandatory = false) {
-    if (value) {
-      config[key] = value;
-    } else {
-      if (mandatory) {
-        throw Error("Mandatory Key Missing:", key);
-      }
+  init(ENV_API_KEY, SIGNING_KEY, config_keys = {}) {
+    config_keys.env = ENV_API_KEY;
+    config_keys.signing_key = SIGNING_KEY;
+    init_at = new Date();
+    var distinct_id = utils.get_cookie(constants.distinct_id);
+    if (!suprSendInstance) {
+      suprSendInstance = {};
+      this.setCustomConfig(config_keys);
     }
-  }
-
-  setCustomConfig(config_keys) {
-    this.setCustomConfigProperty("env_key", config_keys.env, true);
-    this.setCustomConfigProperty("signing_key", config_keys.signing_key, true);
-    this.setCustomConfigProperty("api_url", config_keys?.api_url);
-    this.setCustomConfigProperty("vapid_key", config_keys?.vapid_key);
+    if (!distinct_id) {
+      distinct_id = utils.uuid();
+      utils.set_cookie(constants.distinct_id, distinct_id);
+    }
+    suprSendInstance.distinct_id = distinct_id;
+    this.user = new User(suprSendInstance);
+    this.sw = new ServiceWorker(suprSendInstance);
+    this.sw.update_subscription();
+    SuprSend.setEnvProperties();
+    utils.schedule_flush();
   }
 
   static setEnvProperties() {
@@ -41,25 +46,25 @@ class SuprSend {
     };
   }
 
-  init(ENV_API_KEY, SIGNING_KEY, config_keys = {}) {
-    config_keys.env = ENV_API_KEY;
-    config_keys.signing_key = SIGNING_KEY;
-    init_at = new Date();
-    var distinct_id = utils.get_cookie(constants.distinct_id);
-    if (!suprSendInstance) {
-      suprSendInstance = {};
-      this.setCustomConfig(config_keys);
-    }
-    if (!distinct_id) {
-      distinct_id = utils.uuid();
-      utils.set_cookie(constants.distinct_id, distinct_id);
+  setCustomConfigProperty(key, value = "", mandatory = false) {
+    if (value) {
+      config[key] = value;
+    } else {
+      if (mandatory) {
+        throw new SSConfigurationError(`Mandatory Key Missing: ${key}`);
+      }
     }
-    suprSendInstance.distinct_id = distinct_id;
-    this.user = new User(suprSendInstance);
-    this.sw = new ServiceWorker(suprSendInstance);
-    this.sw.update_subscription();
-    SuprSend.setEnvProperties();
-    utils.schedule_flush();
+  }
+
+  setCustomConfig(config_keys) {
+    this.setCustomConfigProperty("env_key", config_keys.env, true);
+    this.setCustomConfigProperty("signing_key", config_keys.signing_key, true);
+    this.setCustomConfigProperty("api_url", config_keys?.api_url);
+    this.setCustomConfigProperty("vapid_key", config_keys?.vapid_key);
+    this.setCustomConfigProperty(
+      "service_worker_file",
+      config_keys?.sw_file_name
+    );
   }
 
   set_super_properties(props = {}) {
@@ -67,13 +72,19 @@ class SuprSend {
       constants.super_properties_key
     );
     let new_super_props = { ...existing_super_properties, ...props };
+    let formatted_super_props = {};
+    for (let key in new_super_props) {
+      if (!utils.has_special_char(key)) {
+        formatted_super_props[key] = new_super_props[key];
+      }
+    }
     utils.set_local_storage_item(
       constants.super_properties_key,
-      JSON.stringify(new_super_props)
+      JSON.stringify(formatted_super_props)
     );
     suprSendInstance.env_properties = {
       ...suprSendInstance.env_properties,
-      ...new_super_props,
+      ...formatted_super_props,
     };
   }
 
@@ -94,25 +105,27 @@ class SuprSend {
   }
 
   track(event, props = {}) {
-    if (event != undefined) {
-      const super_props = utils.get_parsed_local_store_data(
-        constants.super_properties_key
-      );
-      const formatted_data = utils.format_props({
-        ...props,
-        ...suprSendInstance.env_properties,
-        ...super_props,
-        $current_url: window.location.href,
-      });
-      utils.batch_or_call({
-        event: String(event),
-        distinct_id: suprSendInstance.distinct_id,
-        env: config.env_key,
-        properties: formatted_data,
-        $insert_id: utils.uuid(),
-        $time: utils.epoch_milliseconds(),
-      });
+    if (event === undefined) {
+      return;
     }
+    const super_props = utils.get_parsed_local_store_data(
+      constants.super_properties_key
+    );
+    const formatted_data = utils.format_props({ key: props });
+    const final_data = {
+      ...formatted_data,
+      ...suprSendInstance.env_properties,
+      ...super_props,
+      $current_url: window.location.href,
+    };
+    utils.batch_or_call({
+      event: String(event),
+      distinct_id: suprSendInstance.distinct_id,
+      env: config.env_key,
+      properties: final_data,
+      $insert_id: utils.uuid(),
+      $time: utils.epoch_milliseconds(),
+    });
   }
 
   reset() {

package/src/user.js

@@ -1,12 +1,13 @@
 import utils from "./utils";
 import config from "./config";
+import { parsePhoneNumber } from "libphonenumber-js";
 
 class User {
   constructor(instance) {
     this.instance = instance;
   }
 
-  _call_indetity(properties) {
+  _call_indentity(properties) {
     utils.batch_or_call({
       env: config.env_key,
       distinct_id: this.instance.distinct_id,
@@ -14,59 +15,99 @@ class User {
     });
   }
 
+  _allow_special_char_events = (key) => {
+    return (
+      key === "$email" ||
+      key === "$whatsapp" ||
+      key === "$sms" ||
+      key?.["$webpush"]
+    );
+  };
+
+  _convert_to_number(obj) {
+    if (!utils.is_empty(obj)) {
+      for (let key in obj) {
+        const number = Number(obj[key]);
+        if (!number) {
+          delete obj[key];
+        } else {
+          obj[key] = number;
+        }
+      }
+    }
+    return obj;
+  }
+
+  _validate_mobile_and_send(key, mobile) {
+    try {
+      const mobile_number = parsePhoneNumber(mobile);
+      if (mobile_number.isValid()) {
+        this.append(key, mobile);
+      } else {
+        console.log("Suprsend: Provide valid Mobile number");
+      }
+    } catch (err) {
+      console.log("Suprsend: Provide valid Mobile number");
+    }
+  }
+
   set(key, value) {
-    const body = utils.format_props(key, value);
-    if (body) {
-      this._call_indetity({ $set: body });
+    const data = utils.format_props({ key, value });
+    if (!utils.is_empty(data)) {
+      this._call_indentity({ $set: data });
     }
   }
 
   set_once(key, value) {
-    const body = utils.format_props(key, value);
-    if (body) {
-      this._call_indetity({ $set_once: body });
+    const data = utils.format_props({ key, value });
+    if (!utils.is_empty(data)) {
+      this._call_indentity({ $set_once: data });
     }
   }
 
   increment(key, value = 1) {
-    const body = utils.format_props(key, value);
-    if (body) {
-      let keys_list = Object.keys(body);
-      for (let i = 0; i < keys_list.length; i++) {
-        const key_value = keys_list[i];
-        const is_number = Number(body[key_value]);
-        if (!is_number) {
-          delete body[key_value];
-        }
-      }
-      this._call_indetity({ $add: body });
+    const data = utils.format_props({ key, value });
+    const formatted_data = this._convert_to_number(data);
+    if (!utils.is_empty(formatted_data)) {
+      this._call_indentity({ $add: formatted_data });
     }
   }
 
   append(key, value) {
-    const body = utils.format_props(key, value);
-    if (body) {
-      this._call_indetity({ $append: body });
+    const allow_special_tags = this._allow_special_char_events(key);
+    const data = utils.format_props({ key, value, allow_special_tags });
+    if (!utils.is_empty(data)) {
+      this._call_indentity({ $append: data });
     }
   }
 
   remove(key, value) {
-    const body = utils.format_props(key, value);
-    if (body) {
-      this._call_indetity({ $remove: body });
+    const allow_special_tags = this._allow_special_char_events(key);
+    const data = utils.format_props({ key, value, allow_special_tags });
+    if (!utils.is_empty(data)) {
+      this._call_indentity({ $remove: data });
     }
   }
 
   unset(key) {
     let formatted_data;
     if (typeof key === "string") {
-      formatted_data = [String(key)];
-    } else if (key instanceof Array) {
-      formatted_data = key.map((item) => String(item));
-    } else {
-      return;
+      if (!utils.has_special_char(key)) {
+        formatted_data = [key];
+      } else {
+        console.log("Suprsend: key cannot start with $ or ss_");
+      }
+    } else if (Array.isArray(key)) {
+      formatted_data = [];
+      key.forEach((item) => {
+        if (!utils.has_special_char(String(item))) {
+          formatted_data.push(String(item));
+        }
+      });
+    }
+    if (!utils.is_empty(formatted_data)) {
+      this._call_indentity({ $unset: formatted_data });
     }
-    this._call_indetity({ $unset: formatted_data });
   }
 
   add_email(email = "") {
@@ -78,7 +119,7 @@ class User {
   }
 
   add_sms(mobile = "") {
-    this.append("$sms", mobile);
+    this._validate_mobile_and_send("$sms", mobile);
   }
 
   remove_sms(mobile = "") {
@@ -86,10 +127,10 @@ class User {
   }
 
   add_whatsapp(mobile = "") {
-    this.append("$whatsapp", mobile);
+    this._validate_mobile_and_send("$whatsapp", mobile);
   }
 
-  remove_sms(mobile = "") {
+  remove_whatsapp(mobile = "") {
     this.remove("$whatsapp", mobile);
   }
 

package/src/utils.js

@@ -96,18 +96,22 @@ function browser() {
       }
     }
   }
+  return "";
 }
 
 function browser_version() {
   const userAgent = navigator.userAgent;
   const browser_name = browser();
-  const regex = browser_version_useragent_map[browser_name];
-  if (regex) {
-    const result = userAgent.match(regex);
-    if (result && result.length > 1) {
-      return result[1];
+  for (let regex_item of browser_version_useragent_map[browser_name]) {
+    const regex = regex_item;
+    if (regex) {
+      const result = userAgent.match(regex);
+      if (result && result.length > 1) {
+        return result[1];
+      }
     }
   }
+  return "";
 }
 
 function os() {
@@ -117,6 +121,7 @@ function os() {
       return i;
     }
   }
+  return "";
 }
 
 async function api(route, body, method = "POST") {
@@ -195,18 +200,23 @@ function batch_or_call(body) {
   }
 }
 
-function format_props(key, value) {
+function format_props({ key, value, allow_special_tags = false }) {
   var formatted_data;
   if (key instanceof Object) {
     formatted_data = {};
-    let keys_list = Object.keys(key);
-    for (let i = 0; i < keys_list.length; i++) {
-      const value = keys_list[i];
-      if (key[value] !== undefined) {
-        formatted_data[String(value)] = key[value];
+    for (let item in key) {
+      if (key[item] !== undefined) {
+        if (!allow_special_tags && has_special_char(item)) {
+          continue;
+        }
+        formatted_data[String(item)] = key[item];
       }
     }
   } else if (value != undefined) {
+    if (!allow_special_tags && has_special_char(String(key))) {
+      console.log("Suprsend: key cannot start with $ or ss_");
+      return;
+    }
     formatted_data = { [String(key)]: value };
   }
   return formatted_data;
@@ -225,6 +235,21 @@ function urlB64ToUint8Array(base64String) {
   return outputArray;
 }
 
+const has_special_char = (str) => {
+  return str.startsWith("$") || str?.toLowerCase()?.startsWith("ss_");
+};
+
+const is_empty = (value) => {
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  } else if (value instanceof Object) {
+    return Object.keys(value).length === 0;
+  } else {
+    const empty_values = ["", null, undefined];
+    return empty_values.includes(value);
+  }
+};
+
 export default {
   uuid,
   epoch_milliseconds,
@@ -244,4 +269,6 @@ export default {
   format_props,
   urlB64ToUint8Array,
   batch_or_call,
+  has_special_char,
+  is_empty,
 };