@suprsend/node-sdk 1.7.1 → 1.8.0

package/src/event.js

@@ -6,6 +6,7 @@ import {
   epoch_milliseconds,
   validate_track_event_schema,
   get_apparent_event_size,
+  InputValueError,
 } from "./utils";
 import get_request_signature from "./signature";
 import axios from "axios";
@@ -32,38 +33,36 @@ export default class Event {
     this.properties = properties;
     this.idempotency_key = kwargs?.idempotency_key;
     this.brand_id = kwargs?.brand_id;
-    // --- validate
-    this.__validate_distinct_id();
-    this.__validate_event_name();
-    this.__validate_properties();
+
+    // default values
+    if (!this.properties) {
+      this.properties = {};
+    }
   }
 
   __validate_distinct_id() {
-    if (this.distinct_id instanceof String) {
-      throw new SuprsendError(
+    if (typeof this.distinct_id !== "string") {
+      throw new InputValueError(
         "distinct_id must be a string. an Id which uniquely identify a user in your app"
       );
     }
     const distinct_id = this.distinct_id.trim();
     if (!distinct_id) {
-      throw new SuprsendError("distinct_id missing");
+      throw new InputValueError("distinct_id missing");
     }
     this.distinct_id = distinct_id;
   }
 
   __validate_properties() {
-    if (!this.properties) {
-      this.properties = {};
-    }
     if (!(this.properties instanceof Object)) {
-      throw new SuprsendError("properties must be a dictionary");
+      throw new InputValueError("properties must be a dictionary");
     }
   }
 
   __check_event_prefix(event_name) {
     if (!RESERVED_EVENT_NAMES.includes(event_name)) {
       if (has_special_char(event_name)) {
-        throw new SuprsendError(
+        throw new InputValueError(
           "event_names starting with [$,ss_] are reserved by SuprSend"
         );
       }
@@ -72,9 +71,12 @@ export default class Event {
 
   __validate_event_name() {
     if (!is_string(this.event_name)) {
-      throw new SuprsendError("event_name must be a string");
+      throw new InputValueError("event_name must be a string");
     }
     const event_name = this.event_name.trim();
+    if (!event_name) {
+      throw new InputValueError("event_name missing");
+    }
     this.__check_event_prefix(event_name);
     this.event_name = event_name;
   }
@@ -82,11 +84,25 @@ export default class Event {
   add_attachment(file_path, kwargs = {}) {
     const file_name = kwargs?.file_name;
     const ignore_if_error = kwargs?.ignore_if_error ?? false;
+
+    // if properties is not a dict, not raising error while adding attachment.
+    if (!(this.properties instanceof Object)) {
+      console.log(
+        "WARNING: attachment cannot be added. please make sure properties is a dictionary. Event" +
+          JSON.stringify(this.as_json())
+      );
+      return;
+    }
+
     const attachment = get_attachment_json(
       file_path,
       file_name,
       ignore_if_error
     );
+
+    if (!attachment) {
+      return;
+    }
     // --- add the attachment to properties->$attachments
     if (!this.properties["$attachments"]) {
       this.properties["$attachments"] = [];
@@ -95,6 +111,11 @@ export default class Event {
   }
 
   get_final_json(config, is_part_of_bulk = false) {
+    // --- validate
+    this.__validate_distinct_id();
+    this.__validate_event_name();
+    this.__validate_properties();
+
     const super_props = { $ss_sdk_version: config.user_agent };
     let event_dict = {
       $insert_id: uuid(),
@@ -113,12 +134,27 @@ export default class Event {
     event_dict = validate_track_event_schema(event_dict);
     const apparent_size = get_apparent_event_size(event_dict, is_part_of_bulk);
     if (apparent_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
-      throw new SuprsendError(
+      throw new InputValueError(
         `Event size too big - ${apparent_size} Bytes,must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
     return [event_dict, apparent_size];
   }
+
+  as_json() {
+    const event_dict = {
+      event: this.event_name,
+      distinct_id: this.distinct_id,
+      properties: this.properties,
+    };
+    if (this.idempotency_key) {
+      event_dict["$idempotency_key"] = this.idempotency_key;
+    }
+    if (this.brand_id) {
+      event_dict["brand_id"] = this.brand_id;
+    }
+    return event_dict;
+  }
 }
 
 export class EventCollector {

package/src/events_bulk.js

@@ -9,7 +9,7 @@ import {
 import get_request_signature from "./signature";
 import BulkResponse from "./bulk_response";
 import Event from "./event";
-import { SuprsendError } from "./utils";
+import { InputValueError, SuprsendError, invalid_record_json } from "./utils";
 import { cloneDeep } from "lodash";
 import axios from "axios";
 
@@ -79,7 +79,7 @@ class _BulkEventsChunk {
       return false;
     }
     if (event_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
-      throw new SuprsendError(
+      throw new InputValueError(
         `Event properties too big - ${event_size} Bytes, must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
@@ -159,19 +159,23 @@ class BulkEvents {
     this.__pending_records = [];
     this.chunks = [];
     this.response = new BulkResponse();
+    // invalid_record json: {"record": event-json, "error": error_str, "code": 500}
+    this.__invalid_records = [];
   }
 
   __validate_events() {
-    if (!this.__events) {
-      throw new SuprsendError("events list is empty in bulk request");
-    }
     for (let ev of this.__events) {
-      const is_part_of_bulk = true;
-      const [ev_json, body_size] = ev.get_final_json(
-        this.config,
-        is_part_of_bulk
-      );
-      this.__pending_records.push([ev_json, body_size]);
+      try {
+        const is_part_of_bulk = true;
+        const [ev_json, body_size] = ev.get_final_json(
+          this.config,
+          is_part_of_bulk
+        );
+        this.__pending_records.push([ev_json, body_size]);
+      } catch (ex) {
+        const inv_rec = invalid_record_json(ev.as_json(), ex);
+        this.__invalid_records.push(inv_rec);
+      }
     }
   }
 
@@ -192,35 +196,44 @@ class BulkEvents {
 
   append(...events) {
     if (!events) {
-      throw new SuprsendError(
-        "events list empty. must pass one or more events"
-      );
+      return;
     }
     for (let ev of events) {
-      if (!ev) {
-        throw new SuprsendError("null/empty element found in bulk instance");
-      }
-      if (!(ev instanceof Event)) {
-        throw new SuprsendError(
-          "element must be an instance of suprsend.Event"
-        );
+      if (ev && ev instanceof Event) {
+        const ev_copy = cloneDeep(ev);
+        this.__events.push(ev_copy);
       }
-      const ev_copy = cloneDeep(ev);
-      this.__events.push(ev_copy);
     }
   }
 
   async trigger() {
     this.__validate_events();
-    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}`);
+    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) {
+      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()
+        );
       }
-      // do api call
-      await ch.trigger();
-      // merge response
-      this.response.merge_chunk_response(ch.response);
     }
     return this.response;
   }

package/src/index.js

@@ -1,4 +1,4 @@
-import { SuprsendError, SuprsendConfigError } from "./utils";
+import { SuprsendConfigError, InputValueError } from "./utils";
 import get_attachment_json from "./attachment";
 import Workflow, { _WorkflowTrigger } from "./workflow";
 import { BulkWorkflowsFactory } from "./workflows_bulk";
@@ -85,11 +85,11 @@ class Suprsend {
   add_attachment(body, file_path, kwargs = {}) {
     const file_name = kwargs?.file_name;
     const ignore_if_error = kwargs?.ignore_if_error ?? false;
-    if (!body.data) {
+    if (!body?.data) {
       body.data = {};
     }
-    if (!body.data instanceof Object) {
-      throw new SuprsendError("data must be an object");
+    if (!(body.data instanceof Object)) {
+      throw new InputValueError("data must be an object");
     }
     const attachment = get_attachment_json(
       file_path,
@@ -120,7 +120,9 @@ class Suprsend {
 
   track_event(event) {
     if (!(event instanceof Event)) {
-      throw new SuprsendError("argument must be an instance of suprsend.Event");
+      throw new InputValueError(
+        "argument must be an instance of suprsend.Event"
+      );
     }
     return this._eventcollector.collect(event);
   }

package/src/subscriber.js

@@ -6,6 +6,7 @@ import {
   is_empty,
   is_string,
   get_apparent_identity_event_size,
+  InputValueError,
 } from "./utils";
 import get_request_signature from "./signature";
 import axios from "axios";
@@ -27,13 +28,13 @@ export default class SubscriberFactory {
 
   get_instance(distinct_id) {
     if (!is_string(distinct_id)) {
-      throw new SuprsendError(
+      throw new InputValueError(
         "distinct_id must be a string. an Id which uniquely identify a user in your app"
       );
     }
     distinct_id = distinct_id.trim();
     if (!distinct_id) {
-      throw new SuprsendError("distinct_id must be passed");
+      throw new InputValueError("distinct_id must be passed");
     }
     return new Subscriber(this.config, distinct_id);
   }
@@ -50,6 +51,7 @@ export class Subscriber {
     this.__info = [];
     this.user_operations = [];
     this._helper = new _SubscriberInternalHelper();
+    this.__warnings_list = [];
   }
 
   __get_url() {
@@ -82,10 +84,20 @@ export class Subscriber {
     };
   }
 
+  as_json() {
+    const event_dict = {
+      distinct_id: this.distinct_id,
+      $user_operations: this.user_operations,
+      warnings: this.__warnings_list,
+    };
+
+    return event_dict;
+  }
+
   validate_event_size(event_dict) {
     const apparent_size = get_apparent_identity_event_size(event_dict);
     if (apparent_size > IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
-      throw new SuprsendError(
+      throw new InputValueError(
         `User Event size too big - ${apparent_size} Bytes, must not cross ${IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
@@ -93,25 +105,25 @@ export class Subscriber {
   }
 
   validate_body(is_part_of_bulk = false) {
-    const warnings_list = [];
+    this.__warnings_list = [];
     if (!is_empty(this.__info)) {
       const msg = `[distinct_id: ${this.distinct_id}]${this.__info.join("\n")}`;
-      warnings_list.push(msg);
+      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"
       )}`;
-      warnings_list.push(msg);
+      this.__warnings_list.push(msg);
       const err_msg = `ERROR: ${msg}`;
       if (is_part_of_bulk) {
         console.log(err_msg);
       } else {
-        throw new SuprsendError(err_msg);
+        throw new InputValueError(err_msg);
       }
     }
-    return warnings_list;
+    return this.__warnings_list;
   }
 
   async save() {

package/src/subscriber_list.js

@@ -5,6 +5,7 @@ import {
   get_apparent_list_broadcast_body_size,
   uuid,
   epoch_milliseconds,
+  InputValueError,
 } from "./utils";
 import get_request_signature from "./signature";
 import axios from "axios";
@@ -12,17 +13,51 @@ import {
   SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
   SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
 } from "./constants";
+import get_attachment_json from "./attachment";
 
 class SubscriberListBroadcast {
   constructor(body, kwargs = {}) {
     if (!(body instanceof Object)) {
-      throw new SuprsendError("broadcast body must be a json/dictionary");
+      throw new InputValueError("broadcast body must be a json/dictionary");
     }
     this.body = body;
     this.idempotency_key = kwargs?.idempotency_key;
     this.brand_id = kwargs?.brand_id;
   }
 
+  add_attachment(file_path, kwargs = {}) {
+    const file_name = kwargs?.file_name;
+    const ignore_if_error = kwargs?.ignore_if_error ?? false;
+
+    if (!this.body?.["data"]) {
+      this.body["data"] = {};
+    }
+    // if body["data"] is not a dict, not raising error while adding attachment.
+    if (!(this.body["data"] instanceof Object)) {
+      console.log(
+        "WARNING: attachment cannot be added. please make sure body['data'] is a dictionary. " +
+          "SubscriberListBroadcast" +
+          JSON.stringify(this.as_json())
+      );
+      return;
+    }
+    const attachment = get_attachment_json(
+      file_path,
+      file_name,
+      ignore_if_error
+    );
+    if (!attachment) {
+      return;
+    }
+
+    //  --- add the attachment to body->data->$attachments
+    if (!this.body["data"]?.["$attachments"]) {
+      this.body["data"]["$attachments"] = [];
+    }
+    // -----
+    this.body["data"]["$attachments"].push(attachment);
+  }
+
   get_final_json() {
     this.body["$insert_id"] = uuid();
     this.body["$time"] = epoch_milliseconds();
@@ -35,12 +70,24 @@ class SubscriberListBroadcast {
     this.body = validate_list_broadcast_body_schema(this.body);
     const apparent_size = get_apparent_list_broadcast_body_size(this.body);
     if (apparent_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
-      throw new SuprsendError(
+      throw new InputValueError(
         `SubscriberListBroadcast body too big - ${apparent_size} Bytes, must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
     return [this.body, apparent_size];
   }
+
+  as_json() {
+    const body_dict = { ...this.body };
+    if (this.idempotency_key) {
+      body_dict["$idempotency_key"] = this.idempotency_key;
+    }
+    if (this.brand_id) {
+      body_dict["brand_id"] = this.brand_id;
+    }
+    // -----
+    return body_dict;
+  }
 }
 
 class SubscriberListsApi {
@@ -243,7 +290,7 @@ class SubscriberListsApi {
 
   async broadcast(broadcast_instance) {
     if (!(broadcast_instance instanceof SubscriberListBroadcast)) {
-      throw new SuprsendError(
+      throw new InputValueError(
         "argument must be an instance of suprsend.SubscriberListBroadcast"
       );
     }

package/src/subscribers_bulk.js

@@ -9,6 +9,7 @@ import BulkResponse from "./bulk_response";
 import { Subscriber } from "./subscriber";
 import { cloneDeep } from "lodash";
 import axios from "axios";
+import { invalid_record_json, InputValueError } from "./utils";
 
 export default class BulkSubscribersFactory {
   constructor(config) {
@@ -75,7 +76,7 @@ class _BulkSubscribersChunk {
       return false;
     }
     if (event_size > IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
-      throw new SuprsendError(
+      throw new InputValueError(
         `Event too big - ${event_size} Bytes, must not cross ${IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
@@ -152,21 +153,29 @@ class BulkSubscribers {
     this.__pending_records = [];
     this.chunks = [];
     this.response = new BulkResponse();
+
+    // invalid_record json: {"record": event-json, "error": error_str, "code": 500}
+    this.__invalid_records = [];
   }
 
   __validate_subscriber_events() {
-    if (!this.__subscribers) {
-      throw new SuprsendError("users list is empty in bulk request");
-    }
     for (let sub of this.__subscribers) {
-      const is_part_of_bulk = true;
-      const warnings_list = sub.validate_body(is_part_of_bulk);
-      if (warnings_list) {
-        this.response.warnings = [...this.response.warnings, ...warnings_list];
+      try {
+        const is_part_of_bulk = true;
+        const warnings_list = sub.validate_body(is_part_of_bulk);
+        if (warnings_list) {
+          this.response.warnings = [
+            ...this.response.warnings,
+            ...warnings_list,
+          ];
+        }
+        const ev = sub.get_events();
+        const [ev_json, body_size] = sub.validate_event_size(ev);
+        this.__pending_records.push([ev_json, body_size]);
+      } catch (ex) {
+        const inv_rec = invalid_record_json(sub.as_json(), ex);
+        this.__invalid_records.push(inv_rec);
       }
-      const ev = sub.get_events();
-      const [ev_json, body_size] = sub.validate_event_size(ev);
-      this.__pending_records.push([ev_json, body_size]);
     }
   }
 
@@ -187,19 +196,13 @@ class BulkSubscribers {
 
   append(...subscribers) {
     if (!subscribers) {
-      throw SuprsendError("users list empty. must pass one or more users");
+      return;
     }
     for (let sub of subscribers) {
-      if (!sub) {
-        continue;
+      if (sub && sub instanceof Subscriber) {
+        const sub_copy = cloneDeep(sub);
+        this.__subscribers.push(sub_copy);
       }
-      if (!(sub instanceof Subscriber)) {
-        throw new SuprsendError(
-          "element must be an instance of suprsend.Subscriber"
-        );
-      }
-      const sub_copy = cloneDeep(sub);
-      this.__subscribers.push(sub_copy);
     }
   }
 
@@ -209,16 +212,33 @@ class BulkSubscribers {
 
   async save() {
     this.__validate_subscriber_events();
-    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}`);
+    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) {
+      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()
+        );
       }
-      // do api call
-      await ch.trigger();
-      // merge response
-      this.response.merge_chunk_response(ch.response);
     }
+
     return this.response;
   }
 }

package/src/utils.js

@@ -58,6 +58,13 @@ export class SuprsendApiError extends Error {
   }
 }
 
+export class InputValueError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InputValueError";
+  }
+}
+
 export function is_string(value) {
   return typeof value === "string";
 }
@@ -93,7 +100,7 @@ export function validate_workflow_body_schema(body) {
     body.data = {};
   }
   if (!(body.data instanceof Object)) {
-    throw new SuprsendError("data must be a object");
+    throw new InputValueError("data must be a object");
   }
   const schema = workflow_schema;
   var v = new Validator();
@@ -128,7 +135,7 @@ export function validate_list_broadcast_body_schema(body) {
     body.data = {};
   }
   if (!(body.data instanceof Object)) {
-    throw new SuprsendError("data must be a object");
+    throw new InputValueError("data must be a object");
   }
   const schema = list_broadcast_schema;
   var v = new Validator();
@@ -227,3 +234,15 @@ export function get_apparent_list_broadcast_body_size(body) {
   const body_size = JSON.stringify(body).length;
   return body_size;
 }
+
+export function invalid_record_json(failed_record, err) {
+  let err_str;
+  if (err instanceof InputValueError) {
+    err_str = err.message;
+  } else {
+    // includes SuprsendValidationError,
+    // OR any other error
+    err_str = `${err.message}\n${err.stack}`;
+  }
+  return { record: failed_record, error: err_str, code: 500 };
+}