@suprsend/node-sdk 0.1.1 → 1.1.0

package/src/utils.js

@@ -1,6 +1,17 @@
 import os from "os";
 import fs from "fs";
+import { Validator } from "jsonschema";
 import { v4 as uuidv4 } from "uuid";
+import {
+  WORKFLOW_RUNTIME_KEYS_POTENTIAL_SIZE_IN_BYTES,
+  ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES,
+  ATTACHMENT_UPLOAD_ENABLED,
+  ALLOW_ATTACHMENTS_IN_BULK_API,
+} from "./constants";
+import { cloneDeep } from "lodash";
+
+const workflow_schema = require("./request_json/workflow.json");
+const event_schema = require("./request_json/event.json");
 
 export function base64Encode(file) {
   var body = fs.readFileSync(file);
@@ -26,6 +37,13 @@ export class SuprsendError extends Error {
   }
 }
 
+export class SuprsendConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SuprsendConfigError";
+  }
+}
+
 export function is_string(value) {
   return typeof value === "string";
 }
@@ -39,6 +57,8 @@ export function is_empty(value) {
     return Object.keys(value) <= 0;
   } else if (Array.isArray(value)) {
     return value.length <= 0;
+  } else {
+    return !value;
   }
 }
 
@@ -53,3 +73,119 @@ export function uuid() {
 export function epoch_milliseconds() {
   return Math.round(Date.now());
 }
+
+export function validate_workflow_body_schema(body) {
+  if (!body?.data) {
+    body.data = {};
+  }
+  if (!(body.data instanceof Object)) {
+    throw new SuprsendError("data must be a object");
+  }
+  const schema = workflow_schema;
+  var v = new Validator();
+  const validated_data = v.validate(body, schema);
+  if (validated_data.valid) {
+    return body;
+  } else {
+    const error_obj = validated_data.errors[0];
+    const error_msg = `${error_obj.property} ${error_obj.message}`;
+    throw new SuprsendError(error_msg);
+  }
+}
+
+export function validate_track_event_schema(body) {
+  if (!body?.properties) {
+    body.properties = {};
+  }
+  const schema = event_schema;
+  var v = new Validator();
+  const validated_data = v.validate(body, schema);
+  if (validated_data.valid) {
+    return body;
+  } else {
+    const error_obj = validated_data.errors[0];
+    const error_msg = `${error_obj.property} ${error_obj.message}`;
+    throw new SuprsendError(error_msg);
+  }
+}
+
+export function get_apparent_workflow_body_size(body, is_part_of_bulk) {
+  let extra_bytes = WORKFLOW_RUNTIME_KEYS_POTENTIAL_SIZE_IN_BYTES;
+  let apparent_body = body;
+  if (body?.data["$attachments"]) {
+    const num_attachments = body.data["$attachments"].length;
+    if (is_part_of_bulk) {
+      if (ALLOW_ATTACHMENTS_IN_BULK_API) {
+        if (ATTACHMENT_UPLOAD_ENABLED) {
+          extra_bytes +=
+            num_attachments * ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+          apparent_body = cloneDeep(body);
+          for (let attach_data of apparent_body["data"]["$attachments"]) {
+            delete attach_data["data"];
+          }
+        } else {
+          // pass
+        }
+      } else {
+        apparent_body = cloneDeep(body);
+        delete apparent_body["data"]["$attachments"];
+      }
+    } else {
+      if (ATTACHMENT_UPLOAD_ENABLED) {
+        extra_bytes += num_attachments * ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+        apparent_body = cloneDeep(body);
+        for (let attach_data of apparent_body["data"]["$attachments"]) {
+          delete attach_data["data"];
+        }
+      } else {
+        // pass
+      }
+    }
+  }
+  const body_size = JSON.stringify(apparent_body).length;
+  const apparent_body_size = body_size + extra_bytes;
+  return apparent_body_size;
+}
+
+export function get_apparent_event_size(event, is_part_of_bulk) {
+  let extra_bytes = 0;
+  let apparent_body = event;
+  if (event?.properties?.["$attachments"]) {
+    const num_attachments = event.properties["$attachments"].length;
+    if (is_part_of_bulk) {
+      if (ALLOW_ATTACHMENTS_IN_BULK_API) {
+        if (ATTACHMENT_UPLOAD_ENABLED) {
+          extra_bytes +=
+            num_attachments * ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+          apparent_body = cloneDeep(event);
+          for (let attach_data of apparent_body["properties"]["$attachments"]) {
+            delete attach_data["data"];
+          }
+        } else {
+          // pass
+        }
+      } else {
+        apparent_body = cloneDeep(body);
+        delete apparent_body["properties"]["$attachments"];
+      }
+    } else {
+      if (ATTACHMENT_UPLOAD_ENABLED) {
+        extra_bytes += num_attachments * ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+        apparent_body = cloneDeep(body);
+        for (let attach_data of apparent_body["properties"]["$attachments"]) {
+          delete attach_data["data"];
+        }
+      } else {
+        // pass
+      }
+    }
+  }
+  const body_size = JSON.stringify(apparent_body).length;
+  const apparent_size = body_size + extra_bytes;
+  return apparent_size;
+}
+
+export function get_apparent_identity_event_size(event) {
+  const body_size = JSON.stringify(event);
+  return body_size;
+}

package/src/workflow.js

@@ -1,85 +1,140 @@
-import get_request_signature from "./signature";
-import { Validator } from "jsonschema";
-import { SuprsendError } from "./utils";
 import axios from "axios";
+import get_request_signature from "./signature";
+import {
+  SuprsendError,
+  validate_workflow_body_schema,
+  get_apparent_workflow_body_size,
+} from "./utils";
+import get_attachment_json from "./attachment";
+import {
+  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
+  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
+} from "./constants";
+
+export default class Workflow {
+  constructor(body, kwargs = {}) {
+    if (!(body instanceof Object)) {
+      throw new SuprsendError("workflow body must be a json/dictionary");
+    }
+    this.body = body;
+    this.idempotency_key = kwargs?.idempotency_key;
+  }
 
-const workflow_schema = require("./request_json/workflow.json");
+  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 (!(this.body instanceof Object)) {
+      throw new SuprsendError("data must be a dictionary");
+    }
+    const attachment = get_attachment_json(
+      file_path,
+      file_name,
+      ignore_if_error
+    );
 
-class Workflow {
-  constructor(ss_instance, data) {
-    this.ss_instance = ss_instance;
-    this.data = data;
+    if (!this.body.data["$attachments"]) {
+      this.body["data"]["$attachments"] = [];
+    }
+    this.body["data"]["$attachments"].push(attachment);
+  }
+
+  get_final_json(config, is_part_of_bulk = false) {
+    // add idempotency key in body if present
+    if (this.idempotency_key) {
+      this.body["$idempotency_key"] = this.idempotency_key;
+    }
+    this.body = validate_workflow_body_schema(this.body);
+    const apparent_size = get_apparent_workflow_body_size(
+      this.body,
+      is_part_of_bulk
+    ); // review
+    if (apparent_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+      throw new SuprsendError(
+        `workflow body too big - ${apparent_size} Bytes, must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+      );
+    }
+    return [this.body, apparent_size];
+  }
+}
+
+export class _WorkflowTrigger {
+  constructor(config) {
+    this.config = config;
     this.url = this._get_url();
   }
 
   _get_url() {
     let url_template = "/trigger/";
-    if (this.ss_instance.include_signature_param) {
-      if (this.ss_instance.auth_enabled) {
+    if (this.config.include_signature_param) {
+      if (this.config.auth_enabled) {
         url_template = url_template + "?verify=true";
       } else {
         url_template = url_template + "?verify=false";
       }
     }
-    const url_formatted = `${this.ss_instance.base_url}${this.ss_instance.env_key}${url_template}`;
+    const url_formatted = `${this.config.base_url}${this.config.workspace_key}${url_template}`;
     return url_formatted;
   }
 
   _get_headers() {
     return {
-      "Content-Type": "application/json",
+      "Content-Type": "application/json; charset=utf-8",
       Date: new Date().toUTCString(),
-      "User-Agent": this.ss_instance.user_agent,
+      "User-Agent": this.config.user_agent,
     };
   }
 
-  async execute_workflow() {
+  trigger(workflow) {
+    const is_part_of_bulk = false;
+    const [workflow_body, body_size] = workflow.get_final_json(
+      this.config,
+      is_part_of_bulk
+    );
+    return this.send(workflow_body);
+  }
+
+  async send(workflow_body) {
     const headers = this._get_headers();
-    const content_text = JSON.stringify(this.data);
-    if (this.ss_instance.auth_enabled) {
+    const content_text = JSON.stringify(workflow_body);
+    if (this.config.auth_enabled) {
       const signature = get_request_signature(
         this.url,
         "POST",
         content_text,
         headers,
-        this.ss_instance.env_secret
+        this.config.workspace_secret
       );
-      headers["Authorization"] = `${this.ss_instance.env_key}:${signature}`;
+      headers["Authorization"] = `${this.config.workspace_key}:${signature}`;
     }
+
     try {
       const response = await axios.post(this.url, content_text, { headers });
-      return {
-        status_code: response.status,
-        success: true,
-        message: response.statusText,
-      };
+      const ok_response = Math.floor(response.status / 100) == 2;
+      if (ok_response) {
+        return {
+          success: true,
+          status: "success",
+          status_code: response.status,
+          message: response.statusText,
+        };
+      } else {
+        return {
+          success: false,
+          status: "fail",
+          status_code: response.status,
+          message: response.statusText,
+        };
+      }
     } catch (err) {
       return {
-        status_code: 400,
         success: false,
+        status: "fail",
+        status_code: err.status || 500,
         message: err.message,
       };
     }
   }
-
-  validate_data() {
-    if (!this.data?.data) {
-      this.data.data = {};
-    }
-    if (!(this.data.data instanceof Object)) {
-      throw new SuprsendError("data must be a object");
-    }
-    const schema = workflow_schema;
-    var v = new Validator();
-    const validated_data = v.validate(this.data, schema);
-    if (validated_data.valid) {
-      return this.data;
-    } else {
-      const error_obj = validated_data.errors[0];
-      const error_msg = `${error_obj.property} ${error_obj.message}`;
-      throw new SuprsendError(error_msg);
-    }
-  }
 }
-
-export default Workflow;

package/src/workflows_bulk.js

@@ -0,0 +1,236 @@
+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 } from "./utils";
+import Workflow from "./workflow";
+import { cloneDeep } from "lodash";
+import axios from "axios";
+import BulkResponse from "./bulk_response";
+import get_request_signature from "./signature";
+
+export class BulkWorkflowsFactory {
+  constructor(config) {
+    this.config = config;
+  }
+
+  new_instance() {
+    return new BulkWorkflows(this.config);
+  }
+}
+
+class _BulkWorkflowsChunk {
+  constructor(config) {
+    this.config = config;
+    this.__chunk = [];
+    this.__url = this.__get_url();
+    this.__headers = this.__common_headers();
+
+    this.__running_size = 0;
+    this.__running_length = 0;
+    this.response;
+  }
+
+  __get_url() {
+    let url_template = "/trigger/";
+    if (this.config.include_signature_param) {
+      if (this.config.auth_enabled) {
+        url_template = url_template + "?verify=true";
+      } else {
+        url_template = url_template + "?verify=false";
+      }
+    }
+    const url_formatted = `${this.config.base_url}${this.config.workspace_key}${url_template}`;
+    return url_formatted;
+  }
+
+  __common_headers() {
+    return {
+      "Content-Type": "application/json; charset=utf-8",
+      "User-Agent": this.config.user_agent,
+    };
+  }
+
+  __dynamic_headers() {
+    return {
+      Date: new Date().toUTCString(),
+    };
+  }
+
+  __add_body_to_chunk(body, body_size) {
+    //  First add size, then body to reduce effects of race condition
+    this.__running_size += body_size;
+    this.__chunk.push(body);
+    this.__running_length += 1;
+  }
+
+  __check_limit_reached() {
+    if (
+      this.__running_length >= MAX_WORKFLOWS_IN_BULK_API ||
+      this.__running_size >= BODY_MAX_APPARENT_SIZE_IN_BYTES
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  try_to_add_into_chunk(body, body_size) {
+    if (!body) {
+      return true;
+    }
+    if (this.__check_limit_reached()) {
+      return false;
+    }
+    if (body_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+      throw new SuprsendError(
+        `workflow body too big - ${body_size} Bytes, must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+      );
+    }
+    if (this.__running_size + body_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+      return false;
+    }
+    if (!ALLOW_ATTACHMENTS_IN_BULK_API) {
+      delete body.data["$attachments"];
+    }
+
+    this.__add_body_to_chunk(body, body_size);
+    return true;
+  }
+
+  async trigger() {
+    const headers = { ...this.__headers, ...this.__dynamic_headers() };
+    const content_text = JSON.stringify(this.__chunk);
+    // Based on whether signature is required or not, add Authorization header
+    if (this.config.auth_enabled) {
+      const signature = get_request_signature(
+        this.__url,
+        "POST",
+        content_text,
+        headers,
+        this.config.workspace_secret
+      );
+      headers["Authorization"] = `${this.config.workspace_key}:${signature}`;
+    }
+    try {
+      const response = await axios.post(this.__url, content_text, { headers });
+      const ok_response = Math.floor(response.status / 100) == 2;
+      if (ok_response) {
+        this.response = {
+          status: "success",
+          status_code: response.status,
+          total: this.__chunk.length,
+          success: this.__chunk.length,
+          failure: 0,
+          failed_records: [],
+        };
+      } else {
+        this.response = {
+          status: "fail",
+          status_code: response.status,
+          total: this.__chunk.length,
+          success: 0,
+          failure: this.__chunk.length,
+          failed_records: this.__chunk.map((item) => ({
+            record: item,
+            error: response.statusText,
+            code: response.status,
+          })),
+        };
+      }
+    } catch (err) {
+      const error_status = err.status || 500;
+      return {
+        status: "fail",
+        status_code: error_status,
+        message: err.message,
+        total: this.__chunk.length,
+        success: 0,
+        failure: this.__chunk.length,
+        failed_records: this.__chunk.map((item) => ({
+          record: item,
+          error: err.message,
+          code: error_status,
+        })),
+      };
+    }
+  }
+}
+
+class BulkWorkflows {
+  constructor(config) {
+    this.config = config;
+    this.__workflows = [];
+    this.__pending_records = [];
+    this.chunks = [];
+    this.response = new BulkResponse();
+  }
+
+  __validate_workflows() {
+    if (!this.__workflows) {
+      throw new SuprsendError("workflow list is empty in bulk request");
+    }
+    for (let wf of this.__workflows) {
+      const is_part_of_bulk = true;
+      const [wf_body, body_size] = wf.get_final_json(
+        this.config,
+        is_part_of_bulk
+      );
+      this.__pending_records.push([wf_body, body_size]);
+    }
+  }
+
+  __chunkify(start_idx = 0) {
+    const curr_chunk = new _BulkWorkflowsChunk(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) {
+        // create chunks from remaining records
+        this.__chunkify(start_idx + rel_idx);
+        // Don't forget to break. As current loop must not continue further
+        break;
+      }
+    }
+  }
+
+  append(...workflows) {
+    if (!workflows) {
+      throw new SuprsendError(
+        "workflow list empty. must pass one or more valid workflow instances"
+      );
+    }
+    for (let wf of workflows) {
+      if (!wf) {
+        throw new SuprsendError("null/empty element found in bulk instance");
+      }
+      if (!(wf instanceof Workflow)) {
+        throw new SuprsendError(
+          "element must be an instance of suprsend.Workflow"
+        );
+      }
+      const wf_copy = cloneDeep(wf);
+      this.__workflows.push(wf_copy);
+    }
+  }
+
+  async trigger() {
+    this.__validate_workflows();
+    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);
+    }
+    return this.response;
+  }
+}

package/dist/config.js

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var config = {
-  staging: "https://collector-staging.suprsend.workers.dev/",
-  prod: "https://hub.suprsend.com/"
-};
-var _default = config;
-exports["default"] = _default;
-module.exports = exports.default;

package/src/config.js

@@ -1,6 +0,0 @@
-const config = {
-  staging: "https://collector-staging.suprsend.workers.dev/",
-  prod: "https://hub.suprsend.com/",
-};
-
-export default config;