@suprsend/node-sdk 1.12.0 → 1.13.0

package/src/users_api.js

@@ -1,65 +1,212 @@
 import get_request_signature from "./signature";
-import { SuprsendApiError } from "./utils";
+import { SuprsendApiError, InputValueError } from "./utils";
 import axios from "axios";
+import UserEdit from "./user_edit";
+import BulkUsersEdit from "./users_edit_bulk";
 
 export default class UsersApi {
   constructor(config) {
     this.config = config;
     this.list_url = `${this.config.base_url}v1/user/`;
+    this.bulk_url = `${this.config.base_url}v1/bulk/user/`;
   }
 
-  get_headers() {
+  __get_headers() {
     return {
       "Content-Type": "application/json; charset=utf-8",
       "User-Agent": this.config.user_agent,
-      Date: new Date().toISOString(), // Adjust to your header date format
+      Date: new Date().toISOString(),
     };
   }
 
-  validate_distinct_id(distinct_id) {
-    if (!distinct_id || distinct_id.trim() === "") {
+  async list(options = null) {
+    const encoded_options = options
+      ? new URLSearchParams(options).toString()
+      : "";
+    const url = `${this.list_url}${
+      encoded_options ? `?${encoded_options}` : ""
+    }`;
+    const headers = this.__get_headers();
+
+    // Signature and Authorization-header
+    const sig = get_request_signature(
+      url,
+      "GET",
+      "",
+      headers,
+      this.config.workspace_secret
+    );
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
+
+    try {
+      const resp = await axios.get(url, { headers });
+      return resp.data;
+    } catch (error) {
+      throw new SuprsendApiError(err);
+    }
+  }
+
+  _validate_distinct_id(distinct_id) {
+    if (!distinct_id || !distinct_id.trim()) {
       throw new Error("missing distinct_id");
     }
     return distinct_id.trim();
   }
 
   detail_url(distinct_id) {
-    return `${this.list_url}${encodeURIComponent(distinct_id)}/`;
+    distinct_id = this._validate_distinct_id(distinct_id);
+    const distinct_id_encoded = encodeURIComponent(distinct_id);
+    return `${this.list_url}${distinct_id_encoded}/`;
   }
 
   async get(distinct_id) {
-    const validated_distinct_id = this.validate_distinct_id(distinct_id);
-    const url = this.detail_url(validated_distinct_id);
-    const headers = this.get_headers();
-    const signature = get_request_signature(
+    const url = this.detail_url(distinct_id);
+    const headers = this.__get_headers();
+
+    // Signature and Authorization-header
+    const sig = get_request_signature(
       url,
       "GET",
       "",
       headers,
       this.config.workspace_secret
     );
-    headers["Authorization"] = `${this.config.workspace_key}:${signature}`;
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
 
     try {
-      const response = await axios.get(url, { headers });
-      return response.data;
-    } catch (err) {
+      const resp = await axios.get(url, { headers });
+      return resp.data;
+    } catch (error) {
       throw new SuprsendApiError(err);
     }
   }
 
+  async upsert(distinct_id, payload = null) {
+    const url = this.detail_url(distinct_id);
+    payload = payload || {};
+    const headers = this.__get_headers();
+    const content_text = JSON.stringify(payload);
+    const sig = get_request_signature(
+      url,
+      "POST",
+      content_text,
+      headers,
+      this.config.workspace_secret
+    );
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
+
+    try {
+      const resp = await axios.post(url, content_text, { headers });
+      return resp.data;
+    } catch (error) {
+      throw new SuprsendApiError(err);
+    }
+  }
+
+  async async_edit(edit_instance) {
+    if (!edit_instance) {
+      throw new InputValueError("instance is required");
+    }
+    edit_instance.validate_body();
+    const a_payload = edit_instance.get_async_payload();
+    edit_instance.validate_payload_size(a_payload);
+
+    const content_text = JSON.stringify(a_payload);
+    const url = `${this.config.base_url}event/`;
+    const headers = this.__get_headers();
+    const sig = get_request_signature(
+      url,
+      "POST",
+      content_text,
+      headers,
+      this.config.workspace_secret
+    );
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
+
+    try {
+      const resp = await axios.post(url, content_text, { headers });
+      if (resp.status >= 200 && resp.status < 300) {
+        return {
+          success: true,
+          status: "success",
+          status_code: resp.status,
+          message: resp.data,
+        };
+      } else {
+        throw new SuprsendApiError(resp.statusText);
+      }
+    } catch (error) {
+      throw new SuprsendApiError(error);
+    }
+  }
+
+  async edit(edit_ins_or_distinct_id, edit_payload) {
+    let payload, url;
+    if (edit_ins_or_distinct_id instanceof UserEdit) {
+      const edit_ins = edit_ins_or_distinct_id;
+      edit_ins.validate_body();
+      payload = edit_ins.get_payload();
+      url = this.detail_url(edit_ins.distinct_id);
+    } else {
+      const distinct_id = edit_ins_or_distinct_id;
+      payload = edit_payload || {};
+      url = this.detail_url(distinct_id);
+    }
+
+    const headers = this.__get_headers();
+    const content_text = JSON.stringify(payload);
+    // Signature and Authorization-header
+    const sig = get_request_signature(
+      url,
+      "PATCH",
+      content_text,
+      headers,
+      this.config.workspace_secret
+    );
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
+
+    try {
+      const resp = await axios.patch(url, content_text, { headers });
+      return resp.data;
+    } catch (error) {
+      throw new SuprsendApiError(error);
+    }
+  }
+
+  async merge(distinct_id, from_user_id) {
+    const url = `${this.detail_url(distinct_id)}merge/`;
+    const payload = { from_user_id: from_user_id };
+    const headers = this.__get_headers();
+    const content_text = JSON.stringify(payload);
+    const sig = get_request_signature(
+      url,
+      "POST",
+      content_text,
+      headers,
+      this.config.workspace_secret
+    );
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
+
+    try {
+      const resp = await axios.post(url, content_text, { headers });
+      return resp.data;
+    } catch (error) {
+      throw new SuprsendApiError(error);
+    }
+  }
+
   async delete(distinct_id) {
-    const validated_distinct_id = this.validate_distinct_id(distinct_id);
-    const url = this.detail_url(validated_distinct_id);
-    const headers = this.get_headers();
-    const signature = get_request_signature(
+    const url = this.detail_url(distinct_id);
+    const headers = this.__get_headers();
+
+    const sig = get_request_signature(
       url,
       "DELETE",
       "",
       headers,
       this.config.workspace_secret
     );
-    headers["Authorization"] = `${this.config.workspace_key}:${signature}`;
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
 
     try {
       const response = await axios.delete(url, { headers });
@@ -68,17 +215,42 @@ export default class UsersApi {
       } else {
         throw new SuprsendApiError(response.statusText);
       }
-    } catch (err) {
-      throw new SuprsendApiError(err);
+    } catch (error) {
+      throw new SuprsendApiError(error);
+    }
+  }
+
+  async bulk_delete(payload) {
+    payload = payload || {};
+    const url = this.bulk_url;
+    const headers = this.__get_headers();
+    const content_text = JSON.stringify(payload);
+    const sig = get_request_signature(
+      url,
+      "DELETE",
+      content_text,
+      headers,
+      this.config.workspace_secret
+    );
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
+
+    try {
+      const resp = await axios.delete(url, { data: content_text, headers });
+      if (resp.status >= 200 && resp.status < 300) {
+        return { success: true, status_code: resp.status };
+      } else {
+        throw new SuprsendApiError(resp.statusText);
+      }
+    } catch (error) {
+      throw new SuprsendApiError(error);
     }
   }
 
   async get_objects_subscribed_to(distinct_id, options = {}) {
-    const validated_distinct_id = this.validate_distinct_id(distinct_id);
     const params = new URLSearchParams(options).toString();
-    const url = this.detail_url(validated_distinct_id);
+    const url = this.detail_url(distinct_id);
     const subscription_url = `${url}subscribed_to/object/?${params}`;
-    const headers = this.get_headers();
+    const headers = this.__get_headers();
     const signature = get_request_signature(
       subscription_url,
       "GET",
@@ -97,11 +269,10 @@ export default class UsersApi {
   }
 
   async get_lists_subscribed_to(distinct_id, options = {}) {
-    const validated_distinct_id = this.validate_distinct_id(distinct_id);
     const params = new URLSearchParams(options).toString();
-    const url = this.detail_url(validated_distinct_id);
+    const url = this.detail_url(distinct_id);
     const subscription_url = `${url}subscribed_to/list/?${params}`;
-    const headers = this.get_headers();
+    const headers = this.__get_headers();
     const signature = get_request_signature(
       subscription_url,
       "GET",
@@ -118,4 +289,13 @@ export default class UsersApi {
       throw new SuprsendApiError(err);
     }
   }
+
+  get_edit_instance(distinct_id) {
+    distinct_id = this._validate_distinct_id(distinct_id);
+    return new UserEdit(this.config, distinct_id);
+  }
+
+  get_bulk_edit_instance() {
+    return new BulkUsersEdit(this.config);
+  }
 }

package/src/users_edit_bulk.js

@@ -0,0 +1,211 @@
+import axios from "axios";
+import {
+  IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
+  IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
+  BODY_MAX_APPARENT_SIZE_IN_BYTES,
+  MAX_IDENTITY_EVENTS_IN_BULK_API,
+} from "./constants";
+import get_request_signature from "./signature";
+import { invalid_record_json, uuid, InputValueError } from "./utils";
+import { cloneDeep } from "lodash";
+import BulkResponse from "./bulk_response";
+import UserEdit from "./user_edit";
+
+class _BulkUsersEditChunk {
+  constructor(config) {
+    this._chunk_apparent_size_in_bytes = BODY_MAX_APPARENT_SIZE_IN_BYTES;
+    this._max_records_in_chunk = MAX_IDENTITY_EVENTS_IN_BULK_API;
+    this.config = config;
+    this.__chunk = [];
+    this.__url = `${this.config.base_url}event/`;
+    this.__running_size = 0;
+    this.__running_length = 0;
+    this.response = null;
+  }
+
+  __get_headers() {
+    return {
+      "Content-Type": "application/json; charset=utf-8",
+      "User-Agent": this.config.user_agent,
+      Date: new Date().toUTCString(),
+    };
+  }
+
+  __add_event_to_chunk(event, event_size) {
+    this.__running_size += event_size;
+    this.__chunk.push(event);
+    this.__running_length += 1;
+  }
+
+  __check_limit_reached() {
+    return (
+      this.__running_length >= this._max_records_in_chunk ||
+      this.__running_size >= this._chunk_apparent_size_in_bytes
+    );
+  }
+
+  try_to_add_into_chunk(event, event_size) {
+    if (!event) return true;
+    if (this.__check_limit_reached()) return false;
+
+    if (event_size > IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+      throw new InputValueError(
+        `Event too big - ${event_size} Bytes, ` +
+          `must not cross ${IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+      );
+    }
+
+    if (this.__running_size + event_size > this._chunk_apparent_size_in_bytes) {
+      return false;
+    }
+
+    this.__add_event_to_chunk(event, event_size);
+    return true;
+  }
+
+  async trigger() {
+    const headers = this.__get_headers();
+    const content_text = JSON.stringify(this.__chunk);
+
+    const sig = get_request_signature(
+      this.__url,
+      "POST",
+      content_text,
+      headers,
+      this.config.workspace_secret
+    );
+    headers["Authorization"] = `${this.config.workspace_key}:${sig}`;
+
+    try {
+      const resp = await axios.post(this.__url, content_text, { headers });
+      const ok_response = Math.floor(resp.status / 100) == 2;
+      if (ok_response) {
+        this.response = {
+          status: "success",
+          status_code: resp.status,
+          total: this.__chunk.length,
+          success: this.__chunk.length,
+          failure: 0,
+          failed_records: [],
+        };
+      } else {
+        this.response = {
+          status: "fail",
+          status_code: resp.status,
+          total: this.__chunk.length,
+          success: 0,
+          failure: this.__chunk.length,
+          failed_records: this.__chunk.map((item) => ({
+            record: item,
+            error: resp.statusText,
+            code: resp.status,
+          })),
+        };
+      }
+    } catch (error) {
+      const error_status = err.status || 500;
+      this.response = {
+        status: "fail",
+        status_code: error_status,
+        total: this.__chunk.length,
+        success: 0,
+        failure: this.__chunk.length,
+        failed_records: this.__chunk.map((c) => ({
+          record: c,
+          error: error.message,
+          code: error_status,
+        })),
+      };
+    }
+  }
+}
+
+class BulkUsersEdit {
+  constructor(config) {
+    this.config = config;
+    this.__users = [];
+    this.__pending_records = [];
+    this.__invalid_records = [];
+    this.chunks = [];
+    this.response = new BulkResponse();
+  }
+
+  __validate_users() {
+    for (const u of this.__users) {
+      try {
+        const warnings_list = u.validate_body();
+        if (warnings_list) {
+          this.response.warnings = [
+            ...this.response.warnings,
+            ...warnings_list,
+          ];
+        }
+        const pl = u.get_async_payload();
+        const [pl_json, pl_size] = u.validate_payload_size(pl);
+        this.__pending_records.push([pl_json, pl_size]);
+      } catch (ex) {
+        const inv_rec = invalid_record_json(u.as_json_async(), ex);
+        this.__invalid_records.push(inv_rec);
+      }
+    }
+  }
+
+  __chunkify(start_idx = 0) {
+    const curr_chunk = new _BulkUsersEditChunk(this.config);
+    this.chunks.push(curr_chunk);
+    const entries = this.__pending_records.slice(start_idx).entries();
+    for (const [rel_idx, rec] of entries) {
+      const is_added = curr_chunk.try_to_add_into_chunk(rec[0], rec[1]);
+      if (!is_added) {
+        this.__chunkify(start_idx + rel_idx);
+        break;
+      }
+    }
+  }
+
+  append(...users) {
+    if (!users) return;
+    for (const u of users) {
+      if (u && u instanceof UserEdit) {
+        const u_copy = cloneDeep(u);
+        this.__users.push(u_copy);
+      }
+    }
+  }
+
+  async save() {
+    this.__validate_users();
+
+    if (this.__invalid_records.length > 0) {
+      const ch_response = BulkResponse.invalid_records_chunk_response(
+        this.__invalid_records
+      );
+      this.response.merge_chunk_response(ch_response);
+    }
+
+    if (this.__pending_records.length > 0) {
+      this.__chunkify();
+      for (const [c_idx, ch] of this.chunks.entries()) {
+        if (this.config.req_log_level > 0) {
+          console.log(`DEBUG: triggering api call for chunk: ${c_idx}`);
+        }
+        // do api call
+        await ch.trigger();
+        // merge response
+        this.response.merge_chunk_response(ch.response);
+      }
+    } else {
+      // if no records. i.e. invalid_records.length and pending_records.length both are 0
+      // then add empty success response
+      if (this.__invalid_records.length === 0) {
+        this.response.merge_chunk_response(
+          BulkResponse.empty_chunk_success_response()
+        );
+      }
+    }
+
+    return this.response;
+  }
+}
+
+export default BulkUsersEdit;

package/src/workflow.js

@@ -1,15 +1,14 @@
 import axios from "axios";
 import get_request_signature from "./signature";
 import {
-  SuprsendError,
   validate_workflow_body_schema,
   get_apparent_workflow_body_size,
   InputValueError,
 } from "./utils";
 import get_attachment_json from "./attachment";
 import {
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
+  BODY_MAX_APPARENT_SIZE_IN_BYTES,
+  BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
 } from "./constants";
 
 export default class Workflow {
@@ -68,9 +67,9 @@ export default class Workflow {
       this.body,
       is_part_of_bulk
     ); // review
-    if (apparent_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+    if (apparent_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {
       throw new InputValueError(
-        `workflow body too big - ${apparent_size} Bytes, must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+        `workflow body too big - ${apparent_size} Bytes, must not cross ${BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
     return [this.body, apparent_size];

package/src/workflow_request.js

@@ -5,8 +5,8 @@ import {
 } from "./utils";
 import get_attachment_json from "./attachment";
 import {
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
+  BODY_MAX_APPARENT_SIZE_IN_BYTES,
+  BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
 } from "./constants";
 
 export default class WorkflowTriggerRequest {
@@ -67,9 +67,9 @@ export default class WorkflowTriggerRequest {
       this.body,
       is_part_of_bulk
     );
-    if (apparent_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+    if (apparent_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {
       throw new InputValueError(
-        `workflow body too big - ${apparent_size} Bytes, must not exceed ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+        `workflow body too big - ${apparent_size} Bytes, must not exceed ${BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
 

package/src/workflow_trigger_bulk.js

@@ -5,8 +5,6 @@ import BulkResponse from "./bulk_response";
 import { invalid_record_json, InputValueError } from "./utils";
 import WorkflowTriggerRequest from "./workflow_request";
 import {
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
   BODY_MAX_APPARENT_SIZE_IN_BYTES,
   BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
   MAX_WORKFLOWS_IN_BULK_API,
@@ -58,9 +56,9 @@ export class _BulkWorkflowTriggerChunk {
     if (this._check_limit_reached()) {
       return false;
     }
-    if (body_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+    if (body_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {
       throw new InputValueError(
-        `workflow body too big - ${body_size} Bytes, must not exceed ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+        `workflow body too big - ${body_size} Bytes, must not exceed ${BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
     if (

package/src/workflows_bulk.js

@@ -1,12 +1,10 @@
 import {
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
   BODY_MAX_APPARENT_SIZE_IN_BYTES,
   BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
   MAX_WORKFLOWS_IN_BULK_API,
   ALLOW_ATTACHMENTS_IN_BULK_API,
 } from "./constants";
-import { SuprsendError, invalid_record_json, InputValueError } from "./utils";
+import { invalid_record_json, InputValueError } from "./utils";
 import Workflow from "./workflow";
 import { cloneDeep } from "lodash";
 import axios from "axios";
@@ -77,9 +75,9 @@ class _BulkWorkflowsChunk {
     if (this.__check_limit_reached()) {
       return false;
     }
-    if (body_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+    if (body_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {
       throw new InputValueError(
-        `workflow body too big - ${body_size} Bytes, must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+        `workflow body too big - ${body_size} Bytes, must not cross ${BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
     if (this.__running_size + body_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {