@suprsend/node-sdk 1.11.1 → 1.13.0

package/src/user_edit.js

@@ -0,0 +1,360 @@
+import {
+  uuid,
+  get_apparent_identity_event_size,
+  InputValueError,
+  epoch_milliseconds,
+  is_empty,
+  is_string,
+  is_object,
+} from "./utils";
+import _UserEditInternalHelper from "./user_edit_internal_helper";
+import {
+  IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
+  IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
+} from "./constants";
+
+class UserEdit {
+  constructor(config, distinct_id) {
+    this.config = config;
+    this.distinct_id = distinct_id;
+
+    this.__errors = [];
+    this.__info = [];
+
+    this.operations = [];
+    this._helper = new _UserEditInternalHelper();
+
+    this.__warnings_list = [];
+  }
+
+  get warnings() {
+    return this.__info;
+  }
+
+  get errors() {
+    return this.__errors;
+  }
+
+  get_payload() {
+    return { operations: this.operations };
+  }
+
+  get_async_payload() {
+    return {
+      $schema: "2",
+      $insert_id: uuid(),
+      $time: epoch_milliseconds(),
+      env: this.config.workspace_key,
+      distinct_id: this.distinct_id,
+      $user_operations: this.operations,
+      properties: { $ss_sdk_version: this.config.user_agent },
+    };
+  }
+
+  as_json_async() {
+    return {
+      distinct_id: this.distinct_id,
+      $user_operations: this.operations,
+      warnings: this.__warnings_list,
+    };
+  }
+
+  validate_payload_size(payload) {
+    const apparent_size = get_apparent_identity_event_size(payload);
+    if (apparent_size > IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+      throw new InputValueError(
+        `User Payload size too big - ${apparent_size} Bytes, ` +
+          `must not cross ${IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+      );
+    }
+    return [payload, apparent_size];
+  }
+
+  validate_body() {
+    this.__warnings_list = [];
+    if (!is_empty(this.__info)) {
+      const msg = `[distinct_id: ${this.distinct_id}]` + this.__info.join("\n");
+      this.__warnings_list.push(msg);
+      console.log(`WARNING: ${msg}`);
+    }
+    if (!is_empty(this.__errors)) {
+      const msg =
+        `[distinct_id: ${this.distinct_id}]` + this.__errors.join("\n");
+      this.__warnings_list.push(msg);
+      console.log(`ERROR: ${msg}`);
+    }
+    return this.__warnings_list;
+  }
+
+  _collect_operation() {
+    const resp = this._helper.get_operation_result();
+    if (!is_empty(resp["errors"])) {
+      this.__errors = [...this.__errors, ...resp["errors"]];
+    }
+    if (!is_empty(resp["info"])) {
+      this.__info = [...this.__info, ...resp["info"]];
+    }
+    if (!is_empty(resp["operation"])) {
+      this.operations.push(resp["operation"]);
+    }
+  }
+
+  append(arg1, arg2 = null) {
+    const caller = "append";
+    if (!is_string(arg1) && !is_object(arg1)) {
+      this.__errors.push(`[${caller}] arg1 must be either string or a dict`);
+      return;
+    }
+    if (is_string(arg1)) {
+      if (!arg2) {
+        this.__errors.push(
+          `[${caller}] if arg1 is a string, then arg2 must be passed`
+        );
+        return;
+      } else {
+        this._helper._append_kv(arg1, arg2, {}, caller);
+        this._collect_operation();
+      }
+    } else {
+      for (let item in arg1) {
+        this._helper._append_kv(item, arg1[item], arg1, caller);
+      }
+      this._collect_operation();
+    }
+  }
+
+  set(arg1, arg2 = null) {
+    const caller = "set";
+    if (!is_string(arg1) && !is_object(arg1)) {
+      this.__errors.push(`[${caller}] arg1 must be String or a dict`);
+      return;
+    }
+    if (typeof arg1 === "string") {
+      if (arg2 === null || arg2 === undefined) {
+        this.__errors.push(
+          `[${caller}] if arg1 is a string, then arg2 must be passed`
+        );
+        return;
+      } else {
+        this._helper._set_kv(arg1, arg2, caller);
+        this._collect_operation();
+      }
+    } else {
+      for (let item in arg1) {
+        this._helper._set_kv(item, arg1[item], arg1, caller);
+      }
+      this._collect_operation();
+    }
+  }
+
+  set_once(arg1, arg2 = null) {
+    const caller = "set_once";
+    if (!is_string(arg1) && !is_object(arg1)) {
+      this.__errors.push(`[${caller}] arg1 must be String or a dict`);
+      return;
+    }
+    if (is_string(arg1)) {
+      if (arg2 === null || arg2 === undefined) {
+        this.__errors.push(
+          `[${caller}] if arg1 is a string, then arg2 must be passed`
+        );
+        return;
+      } else {
+        this._helper._set_once_kv(arg1, arg2, caller);
+        this._collect_operation();
+      }
+    } else {
+      for (let item in arg1) {
+        this._helper._set_once_kv(item, arg1[item], arg1, caller);
+      }
+      this._collect_operation();
+    }
+  }
+
+  increment(arg1, arg2 = null) {
+    const caller = "increment";
+    if (!is_string(arg1) && !is_object(arg1)) {
+      this.__errors.push(`[${caller}] arg1 must be String or a dict`);
+      return;
+    }
+    if (is_string(arg1)) {
+      if (arg2 === null || arg2 === undefined) {
+        this.__errors.push(
+          `[${caller}] if arg1 is a string, then arg2 must be passed`
+        );
+        return;
+      } else {
+        this._helper._increment_kv(arg1, arg2, caller);
+        this._collect_operation();
+      }
+    } else {
+      for (let item in arg1) {
+        this._helper._increment_kv(item, arg1[item], arg1, caller);
+      }
+      this._collect_operation();
+    }
+  }
+
+  remove(arg1, arg2 = null) {
+    const caller = "remove";
+    if (!is_string(arg1) && !is_object(arg1)) {
+      this.__errors.push(`[${caller}] arg1 must be either string or a dict`);
+      return;
+    }
+    if (is_string(arg1)) {
+      if (arg2 === null || arg2 === undefined) {
+        this.__errors.push(
+          `[${caller}] if arg1 is a string, then arg2 must be passed`
+        );
+        return;
+      } else {
+        this._helper._remove_kv(arg1, arg2, {}, caller);
+        this._collect_operation();
+      }
+    } else {
+      for (let item in arg1) {
+        this._helper._remove_kv(item, arg1[item], arg1, caller);
+      }
+      this._collect_operation();
+    }
+  }
+
+  unset(key) {
+    const caller = "unset";
+    if (!is_string(key) && !Array.isArray(key)) {
+      this.__errors.push(
+        `[${caller}] key must be either String or List[string]`
+      );
+      return;
+    }
+    if (is_string(key)) {
+      this._helper._unset_k(key, caller);
+      this._collect_operation();
+    } else {
+      for (const k of key) {
+        this._helper._unset_k(k, caller);
+      }
+      this._collect_operation();
+    }
+  }
+
+  // ------------------------ Preferred language
+  set_preferred_language(lang_code) {
+    const caller = "set_preferred_language";
+    this._helper._set_preferred_language(lang_code, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ Timezone
+  set_timezone(timezone) {
+    const caller = "set_timezone";
+    this._helper._set_timezone(timezone, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ Email
+  add_email(value) {
+    const caller = "add_email";
+    this._helper._add_email(value, caller);
+    this._collect_operation();
+  }
+
+  remove_email(value) {
+    const caller = "remove_email";
+    this._helper._remove_email(value, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ SMS
+  add_sms(value) {
+    const caller = "add_sms";
+    this._helper._add_sms(value, caller);
+    this._collect_operation();
+  }
+
+  remove_sms(value) {
+    const caller = "remove_sms";
+    this._helper._remove_sms(value, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ Whatsapp
+  add_whatsapp(value) {
+    const caller = "add_whatsapp";
+    this._helper._add_whatsapp(value, caller);
+    this._collect_operation();
+  }
+
+  remove_whatsapp(value) {
+    const caller = "remove_whatsapp";
+    this._helper._remove_whatsapp(value, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ Androidpush
+  add_androidpush(value, provider = null) {
+    const caller = "add_androidpush";
+    this._helper._add_androidpush(value, provider, caller);
+    this._collect_operation();
+  }
+
+  remove_androidpush(value, provider = null) {
+    const caller = "remove_androidpush";
+    this._helper._remove_androidpush(value, provider, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ Iospush [providers: apns]
+  add_iospush(value, provider = null) {
+    const caller = "add_iospush";
+    this._helper._add_iospush(value, provider, caller);
+    this._collect_operation();
+  }
+
+  remove_iospush(value, provider = null) {
+    const caller = "remove_iospush";
+    this._helper._remove_iospush(value, provider, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ Webpush [providers: vapid]
+  add_webpush(value, provider = null) {
+    const caller = "add_webpush";
+    this._helper._add_webpush(value, provider, caller);
+    this._collect_operation();
+  }
+
+  remove_webpush(value, provider = null) {
+    const caller = "remove_webpush";
+    this._helper._remove_webpush(value, provider, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ Slack
+  add_slack(value) {
+    const caller = "add_slack";
+    this._helper._add_slack(value, caller);
+    this._collect_operation();
+  }
+
+  remove_slack(value) {
+    const caller = "remove_slack";
+    this._helper._remove_slack(value, caller);
+    this._collect_operation();
+  }
+
+  // ------------------------ MS Teams
+  add_ms_teams(value) {
+    const caller = "add_ms_teams";
+    this._helper._add_ms_teams(value, caller);
+    this._collect_operation();
+  }
+
+  remove_ms_teams(value) {
+    const caller = "remove_ms_teams";
+    this._helper._remove_ms_teams(value, caller);
+    this._collect_operation();
+  }
+}
+
+export default UserEdit;

package/src/user_edit_internal_helper.js

@@ -0,0 +1,297 @@
+import { is_empty, is_string } from "./utils";
+
+// ---------- Identity keys
+const IDENT_KEY_EMAIL = "$email";
+const IDENT_KEY_SMS = "$sms";
+const IDENT_KEY_ANDROIDPUSH = "$androidpush";
+const IDENT_KEY_IOSPUSH = "$iospush";
+const IDENT_KEY_WHATSAPP = "$whatsapp";
+const IDENT_KEY_WEBPUSH = "$webpush";
+const IDENT_KEY_SLACK = "$slack";
+const IDENT_KEY_MS_TEAMS = "$ms_teams";
+
+const IDENT_KEYS_ALL = [
+  IDENT_KEY_EMAIL,
+  IDENT_KEY_SMS,
+  IDENT_KEY_ANDROIDPUSH,
+  IDENT_KEY_IOSPUSH,
+  IDENT_KEY_WHATSAPP,
+  IDENT_KEY_WEBPUSH,
+  IDENT_KEY_SLACK,
+  IDENT_KEY_MS_TEAMS,
+];
+
+const KEY_ID_PROVIDER = "$id_provider";
+const KEY_PREFERRED_LANGUAGE = "$preferred_language";
+const KEY_TIMEZONE = "$timezone";
+
+class _UserEditInternalHelper {
+  constructor() {
+    this.__dict_set = {};
+    this.__dict_set_once = {};
+    this.__dict_increment = {};
+    this.__dict_append = {};
+    this.__dict_remove = {};
+    this.__list_unset = [];
+    this.__errors = [];
+    this.__info = [];
+  }
+
+  reset() {
+    this.__dict_set = {};
+    this.__dict_append = {};
+    this.__dict_remove = {};
+    this.__list_unset = [];
+    this.__dict_set_once = {};
+    this.__dict_increment = {};
+    this.__errors = [];
+    this.__info = [];
+  }
+
+  get_operation_result() {
+    const operation = this.__form_operation();
+    const ret_val = {
+      errors: this.__errors,
+      info: this.__info,
+      operation: operation,
+    };
+    this.reset();
+    return ret_val;
+  }
+
+  __form_operation() {
+    const event = {};
+    if (!is_empty(this.__dict_set)) {
+      event["$set"] = this.__dict_set;
+    }
+    if (!is_empty(this.__dict_set_once)) {
+      event["$set_once"] = this.__dict_set_once;
+    }
+    if (!is_empty(this.__dict_increment)) {
+      event["$add"] = this.__dict_increment;
+    }
+    if (!is_empty(this.__dict_append)) {
+      event["$append"] = this.__dict_append;
+    }
+    if (!is_empty(this.__dict_remove)) {
+      event["$remove"] = this.__dict_remove;
+    }
+    if (!is_empty(this.__list_unset)) {
+      event["$unset"] = this.__list_unset;
+    }
+    return event;
+  }
+
+  // ------------------------
+  __validate_key_basic(key, caller) {
+    if (!is_string(key)) {
+      this.__info.push(
+        `[${caller}] skipping key: ${key}. key must be a string`
+      );
+      return [key, false];
+    }
+    key = key.trim();
+    if (!key) {
+      this.__info.push(`[${caller}] skipping key: empty string`);
+      return [key, false];
+    }
+    return [key, true];
+  }
+
+  __is_identity_key(key) {
+    return IDENT_KEYS_ALL.includes(key);
+  }
+
+  // -------------------------
+  _append_kv(key, val, kwargs = {}, caller = "append") {
+    const [k, is_k_valid] = this.__validate_key_basic(key, caller);
+    if (!is_k_valid) return;
+    if (this.__is_identity_key(k)) {
+      this.__add_identity(k, val, kwargs, caller);
+    } else {
+      this.__dict_append[k] = val;
+    }
+  }
+
+  _remove_kv(key, val, kwargs = {}, caller = "remove") {
+    const [k, is_k_valid] = this.__validate_key_basic(key, caller);
+    if (!is_k_valid) return;
+    if (this.__is_identity_key(k)) {
+      this.__remove_identity(k, val, kwargs, caller);
+    } else {
+      this.__dict_remove[k] = val;
+    }
+  }
+
+  _unset_k(key, caller = "unset") {
+    const [k, is_k_valid] = this.__validate_key_basic(key, caller);
+    if (!is_k_valid) return;
+    this.__list_unset.push(k);
+  }
+
+  _set_kv(key, val, caller = "set") {
+    const [k, is_k_valid] = this.__validate_key_basic(key, caller);
+    if (!is_k_valid) return;
+    this.__dict_set[k] = val;
+  }
+
+  _set_once_kv(key, val, caller = "set_once") {
+    const [k, is_k_valid] = this.__validate_key_basic(key, caller);
+    if (!is_k_valid) return;
+    this.__dict_set_once[k] = val;
+  }
+
+  _increment_kv(key, val, caller = "increment") {
+    const [k, is_k_valid] = this.__validate_key_basic(key, caller);
+    if (!is_k_valid) return;
+    this.__dict_increment[k] = val;
+  }
+
+  _set_preferred_language(lang_code, caller) {
+    this.__dict_set[KEY_PREFERRED_LANGUAGE] = lang_code;
+  }
+
+  _set_timezone(timezone, caller) {
+    this.__dict_set[KEY_TIMEZONE] = timezone;
+  }
+
+  __add_identity(key, val, kwargs, caller) {
+    const new_caller = `${caller}:${key}`;
+    switch (key) {
+      case IDENT_KEY_EMAIL:
+        this._add_email(val, new_caller);
+        break;
+      case IDENT_KEY_SMS:
+        this._add_sms(val, new_caller);
+        break;
+      case IDENT_KEY_WHATSAPP:
+        this._add_whatsapp(val, new_caller);
+        break;
+      case IDENT_KEY_ANDROIDPUSH:
+        this._add_androidpush(val, kwargs[KEY_ID_PROVIDER], new_caller);
+        break;
+      case IDENT_KEY_IOSPUSH:
+        this._add_iospush(val, kwargs[KEY_ID_PROVIDER], new_caller);
+        break;
+      case IDENT_KEY_WEBPUSH:
+        this._add_webpush(val, kwargs[KEY_ID_PROVIDER], new_caller);
+        break;
+      case IDENT_KEY_SLACK:
+        this._add_slack(val, new_caller);
+        break;
+      case IDENT_KEY_MS_TEAMS:
+        this._add_ms_teams(val, new_caller);
+        break;
+    }
+  }
+
+  __remove_identity(key, val, kwargs, caller) {
+    const new_caller = `${caller}:${key}`;
+    switch (key) {
+      case IDENT_KEY_EMAIL:
+        this._remove_email(val, new_caller);
+        break;
+      case IDENT_KEY_SMS:
+        this._remove_sms(val, new_caller);
+        break;
+      case IDENT_KEY_WHATSAPP:
+        this._remove_whatsapp(val, new_caller);
+        break;
+      case IDENT_KEY_ANDROIDPUSH:
+        this._remove_androidpush(val, kwargs[KEY_ID_PROVIDER], new_caller);
+        break;
+      case IDENT_KEY_IOSPUSH:
+        this._remove_iospush(val, kwargs[KEY_ID_PROVIDER], new_caller);
+        break;
+      case IDENT_KEY_WEBPUSH:
+        this._remove_webpush(val, kwargs[KEY_ID_PROVIDER], new_caller);
+        break;
+      case IDENT_KEY_SLACK:
+        this._remove_slack(val, new_caller);
+        break;
+      case IDENT_KEY_MS_TEAMS:
+        this._remove_ms_teams(val, new_caller);
+        break;
+    }
+  }
+
+  // ------------------------ Email
+  _add_email(value, caller) {
+    this.__dict_append[IDENT_KEY_EMAIL] = value;
+  }
+
+  _remove_email(value, caller) {
+    this.__dict_remove[IDENT_KEY_EMAIL] = value;
+  }
+
+  // ------------------------ SMS
+  _add_sms(value, caller) {
+    this.__dict_append[IDENT_KEY_SMS] = value;
+  }
+
+  _remove_sms(value, caller) {
+    this.__dict_remove[IDENT_KEY_SMS] = value;
+  }
+
+  // ------------------------ Whatsapp
+  _add_whatsapp(value, caller) {
+    this.__dict_append[IDENT_KEY_WHATSAPP] = value;
+  }
+
+  _remove_whatsapp(value, caller) {
+    this.__dict_remove[IDENT_KEY_WHATSAPP] = value;
+  }
+
+  // ------------------------ Androidpush
+  _add_androidpush(value, provider, caller) {
+    this.__dict_append[IDENT_KEY_ANDROIDPUSH] = value;
+    this.__dict_append[KEY_ID_PROVIDER] = provider;
+  }
+
+  _remove_androidpush(value, provider, caller) {
+    this.__dict_remove[IDENT_KEY_ANDROIDPUSH] = value;
+    this.__dict_remove[KEY_ID_PROVIDER] = provider;
+  }
+
+  // ------------------------ Iospush
+  _add_iospush(value, provider, caller) {
+    this.__dict_append[IDENT_KEY_IOSPUSH] = value;
+    this.__dict_append[KEY_ID_PROVIDER] = provider;
+  }
+
+  _remove_iospush(value, provider, caller) {
+    this.__dict_remove[IDENT_KEY_IOSPUSH] = value;
+    this.__dict_remove[KEY_ID_PROVIDER] = provider;
+  }
+
+  // ------------------------ Webpush
+  _add_webpush(value, provider, caller) {
+    this.__dict_append[IDENT_KEY_WEBPUSH] = value;
+    this.__dict_append[KEY_ID_PROVIDER] = provider;
+  }
+
+  _remove_webpush(value, provider, caller) {
+    this.__dict_remove[IDENT_KEY_WEBPUSH] = value;
+    this.__dict_remove[KEY_ID_PROVIDER] = provider;
+  }
+
+  // ------------------------ Slack
+  _add_slack(value, caller) {
+    this.__dict_append[IDENT_KEY_SLACK] = value;
+  }
+
+  _remove_slack(value, caller) {
+    this.__dict_remove[IDENT_KEY_SLACK] = value;
+  }
+
+  // ------------------------ MS Teams
+  _add_ms_teams(value, caller) {
+    this.__dict_append[IDENT_KEY_MS_TEAMS] = value;
+  }
+
+  _remove_ms_teams(value, caller) {
+    this.__dict_remove[IDENT_KEY_MS_TEAMS] = value;
+  }
+}
+
+export default _UserEditInternalHelper;