@suprsend/node-sdk 1.9.1 → 1.11.0

package/dist/workflow_trigger_bulk.js

@@ -0,0 +1,316 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._BulkWorkflowTriggerChunk = exports.BulkWorkflowTrigger = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _axios = _interopRequireDefault(require("axios"));
+var _lodash = require("lodash");
+var _signature = _interopRequireDefault(require("./signature"));
+var _bulk_response = _interopRequireDefault(require("./bulk_response"));
+var _utils = require("./utils");
+var _workflow_request = _interopRequireDefault(require("./workflow_request"));
+var _constants = require("./constants");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var _BulkWorkflowTriggerChunk = /*#__PURE__*/function () {
+  function _BulkWorkflowTriggerChunk(config) {
+    (0, _classCallCheck2["default"])(this, _BulkWorkflowTriggerChunk);
+    this.config = config;
+    this.url = this.__url = "".concat(this.config.base_url, "trigger/");
+    this.__chunk = [];
+    this.__running_size = 0;
+    this.__running_length = 0;
+    this.response = null;
+  }
+  (0, _createClass2["default"])(_BulkWorkflowTriggerChunk, [{
+    key: "_get_headers",
+    value: function _get_headers() {
+      return {
+        "Content-Type": "application/json; charset=utf-8",
+        "User-Agent": this.config.user_agent,
+        Date: new Date().toUTCString()
+      };
+    }
+  }, {
+    key: "__add_body_to_chunk",
+    value: function __add_body_to_chunk(body, body_size) {
+      this.__running_size += body_size;
+      this.__chunk.push(body);
+      this.__running_length++;
+    }
+  }, {
+    key: "_check_limit_reached",
+    value: function _check_limit_reached() {
+      return this.__running_length >= _BulkWorkflowTriggerChunk._max_records_in_chunk || this.__running_size >= _BulkWorkflowTriggerChunk._chunk_apparent_size_in_bytes;
+    }
+  }, {
+    key: "try_to_add_into_chunk",
+    value: function try_to_add_into_chunk(body, body_size) {
+      if (!body) {
+        return true;
+      }
+      if (this._check_limit_reached()) {
+        return false;
+      }
+      if (body_size > _constants.SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.InputValueError("workflow body too big - ".concat(body_size, " Bytes, must not exceed ").concat(_constants.SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
+      }
+      if (this.__running_size + body_size > _BulkWorkflowTriggerChunk._chunk_apparent_size_in_bytes) {
+        return false;
+      }
+      if (!_constants.ALLOW_ATTACHMENTS_IN_BULK_API) {
+        delete body.data["$attachments"];
+      }
+      this.__add_body_to_chunk(body, body_size);
+      return true;
+    }
+  }, {
+    key: "trigger",
+    value: function () {
+      var _trigger = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var headers, content_text, signature, resp, resp_data;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                headers = this._get_headers();
+                content_text = JSON.stringify(this.__chunk);
+                signature = (0, _signature["default"])(this.__url, "POST", content_text, headers, this.config.workspace_secret);
+                headers["Authorization"] = "".concat(this.config.workspace_key, ":").concat(signature);
+                _context.prev = 4;
+                _context.next = 7;
+                return _axios["default"].post(this.__url, content_text, {
+                  headers: headers,
+                  transformResponse: [function (data) {
+                    return data;
+                  }] // dont assume type of response
+                });
+              case 7:
+                resp = _context.sent;
+                this.response = {
+                  status: "success",
+                  status_code: resp.status,
+                  total: this.__chunk.length,
+                  success: this.__chunk.length,
+                  failure: 0,
+                  failed_records: []
+                };
+                _context.next = 14;
+                break;
+              case 11:
+                _context.prev = 11;
+                _context.t0 = _context["catch"](4);
+                if (_context.t0 !== null && _context.t0 !== void 0 && _context.t0.response) {
+                  resp_data = _context.t0.response;
+                  this.response = {
+                    status: "fail",
+                    status_code: resp_data.status,
+                    total: this.__chunk.length,
+                    success: 0,
+                    failure: this.__chunk.length,
+                    failed_records: this.__chunk.map(function (record) {
+                      return {
+                        record: record,
+                        error: resp_data.data,
+                        code: resp_data.status
+                      };
+                    })
+                  };
+                } else {
+                  this.response = {
+                    status: "fail",
+                    status_code: 500,
+                    total: this.__chunk.length,
+                    success: 0,
+                    failure: this.__chunk.length,
+                    failed_records: this.__chunk.map(function (record) {
+                      return {
+                        record: record,
+                        error: _context.t0.message,
+                        code: 500
+                      };
+                    })
+                  };
+                }
+              case 14:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[4, 11]]);
+      }));
+      function trigger() {
+        return _trigger.apply(this, arguments);
+      }
+      return trigger;
+    }()
+  }]);
+  return _BulkWorkflowTriggerChunk;
+}();
+exports._BulkWorkflowTriggerChunk = _BulkWorkflowTriggerChunk;
+(0, _defineProperty2["default"])(_BulkWorkflowTriggerChunk, "_chunk_apparent_size_in_bytes", _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES);
+(0, _defineProperty2["default"])(_BulkWorkflowTriggerChunk, "_chunk_apparent_size_in_bytes_readable", _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE);
+(0, _defineProperty2["default"])(_BulkWorkflowTriggerChunk, "_max_records_in_chunk", _constants.MAX_WORKFLOWS_IN_BULK_API);
+var BulkWorkflowTrigger = /*#__PURE__*/function () {
+  function BulkWorkflowTrigger(config) {
+    (0, _classCallCheck2["default"])(this, BulkWorkflowTrigger);
+    this.config = config;
+    this.__workflows = [];
+    this.__pending_records = [];
+    this.chunks = [];
+    this.response = new _bulk_response["default"]();
+    // invalid_record json: {"record": workflow-json, "error": error_str, "code": 500}
+    this.__invalid_records = [];
+  }
+  (0, _createClass2["default"])(BulkWorkflowTrigger, [{
+    key: "__validate_workflows",
+    value: function __validate_workflows() {
+      var _iterator = _createForOfIteratorHelper(this.__workflows),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var wf = _step.value;
+          try {
+            var is_part_of_bulk = true;
+            var _wf$get_final_json = wf.get_final_json(this.config, is_part_of_bulk),
+              _wf$get_final_json2 = (0, _slicedToArray2["default"])(_wf$get_final_json, 2),
+              wf_body = _wf$get_final_json2[0],
+              body_size = _wf$get_final_json2[1];
+            this.__pending_records.push([wf_body, body_size]);
+          } catch (ex) {
+            var inv_rec = (0, _utils.invalid_record_json)(wf.as_json(), ex);
+            this.__invalid_records.push(inv_rec);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "__chunkify",
+    value: function __chunkify() {
+      var start_idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var curr_chunk = new _BulkWorkflowTriggerChunk(this.config);
+      this.chunks.push(curr_chunk);
+      var entries = this.__pending_records.slice(start_idx).entries();
+      var _iterator2 = _createForOfIteratorHelper(entries),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = (0, _slicedToArray2["default"])(_step2.value, 2),
+            rel_idx = _step2$value[0],
+            rec = _step2$value[1];
+          var 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;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }, {
+    key: "append",
+    value: function append() {
+      for (var _len = arguments.length, workflows = new Array(_len), _key = 0; _key < _len; _key++) {
+        workflows[_key] = arguments[_key];
+      }
+      if (!workflows.length) return;
+      for (var _i = 0, _workflows = workflows; _i < _workflows.length; _i++) {
+        var wf = _workflows[_i];
+        if (wf instanceof _workflow_request["default"]) {
+          var wf_copy = (0, _lodash.cloneDeep)(wf);
+          this.__workflows.push(wf_copy);
+        }
+      }
+    }
+  }, {
+    key: "trigger",
+    value: function () {
+      var _trigger2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var ch_response, _iterator3, _step3, _step3$value, c_idx, ch;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                this.__validate_workflows();
+                if (this.__invalid_records.length > 0) {
+                  ch_response = _bulk_response["default"].invalid_records_chunk_response(this.__invalid_records);
+                  this.response.merge_chunk_response(ch_response);
+                }
+                if (!this.__pending_records.length) {
+                  _context2.next = 25;
+                  break;
+                }
+                this.__chunkify();
+                _iterator3 = _createForOfIteratorHelper(this.chunks.entries());
+                _context2.prev = 5;
+                _iterator3.s();
+              case 7:
+                if ((_step3 = _iterator3.n()).done) {
+                  _context2.next = 15;
+                  break;
+                }
+                _step3$value = (0, _slicedToArray2["default"])(_step3.value, 2), c_idx = _step3$value[0], ch = _step3$value[1];
+                if (this.config.req_log_level > 0) {
+                  console.log("DEBUG: triggering api call for chunk: ".concat(cIdx));
+                }
+                // do api call
+                _context2.next = 12;
+                return ch.trigger();
+              case 12:
+                // merge response
+                this.response.merge_chunk_response(ch.response);
+              case 13:
+                _context2.next = 7;
+                break;
+              case 15:
+                _context2.next = 20;
+                break;
+              case 17:
+                _context2.prev = 17;
+                _context2.t0 = _context2["catch"](5);
+                _iterator3.e(_context2.t0);
+              case 20:
+                _context2.prev = 20;
+                _iterator3.f();
+                return _context2.finish(20);
+              case 23:
+                _context2.next = 26;
+                break;
+              case 25:
+                if (this.__invalid_records.length === 0) this.response.merge_chunk_response(_bulk_response["default"].empty_chunk_success_response());
+              case 26:
+                return _context2.abrupt("return", this.response);
+              case 27:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[5, 17, 20, 23]]);
+      }));
+      function trigger() {
+        return _trigger2.apply(this, arguments);
+      }
+      return trigger;
+    }()
+  }]);
+  return BulkWorkflowTrigger;
+}();
+exports.BulkWorkflowTrigger = BulkWorkflowTrigger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suprsend/node-sdk",
-  "version": "1.9.1",
+  "version": "1.11.0",
   "description": "Suprsend Node SDK to trigger workflow from backend",
   "main": "dist/index.js",
   "scripts": {

package/src/constants.js

@@ -1,7 +1,5 @@
 //  Default urls
 export const DEFAULT_URL = "https://hub.suprsend.com/";
-export const DEFAULT_UAT_URL =
-  "https://collector-staging.suprsend.workers.dev/";
 
 //  an Event should not have apparent body size of more than 100KB
 export const SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES = 100 * 1024; // 100 * 1024

package/src/index.js

@@ -2,6 +2,8 @@ import { SuprsendConfigError, InputValueError } from "./utils";
 import get_attachment_json from "./attachment";
 import Workflow, { _WorkflowTrigger } from "./workflow";
 import { BulkWorkflowsFactory } from "./workflows_bulk";
+import WorkflowTriggerRequest from "./workflow_request";
+import WorkflowsApi from "./workflow_api";
 import Event, { EventCollector } from "./event";
 import { BulkEventsFactory } from "./events_bulk";
 import SubscriberFactory from "./subscriber";
@@ -9,7 +11,8 @@ import BulkSubscribersFactory from "./subscribers_bulk";
 import { SubscriberListsApi, SubscriberListBroadcast } from "./subscriber_list";
 import BrandsApi from "./brands";
 import TenantsApi from "./tenant";
-import { DEFAULT_UAT_URL, DEFAULT_URL } from "./constants";
+import ObjectsApi from "./object";
+import { DEFAULT_URL } from "./constants";
 
 const package_json = require("../package.json");
 
@@ -35,6 +38,8 @@ class Suprsend {
 
     this.brands = new BrandsApi(this);
     this.tenants = new TenantsApi(this);
+    this.workflows = new WorkflowsApi(this);
+    this.objects = new ObjectsApi(this);
 
     this.subscriber_lists = new SubscriberListsApi(this);
 
@@ -72,11 +77,7 @@ class Suprsend {
       base_url = base_url.trim();
     }
     if (!base_url) {
-      if (this.config.is_staging) {
-        base_url = DEFAULT_UAT_URL;
-      } else {
-        base_url = DEFAULT_URL;
-      }
+      base_url = DEFAULT_URL;
     }
     base_url = base_url.trim();
     if (!base_url.endsWith("/")) {
@@ -86,6 +87,9 @@ class Suprsend {
   }
 
   add_attachment(body, file_path, kwargs = {}) {
+    console.warn(
+      'This method is deprecated. Use "WorkflowTriggerRequest.add_attachment()" instead'
+    );
     const file_name = kwargs?.file_name;
     const ignore_if_error = kwargs?.ignore_if_error ?? false;
     if (!body?.data) {
@@ -117,6 +121,7 @@ class Suprsend {
   }
 
   track(distinct_id, event_name, properties = {}, kwargs = {}) {
+    console.warn('This method is deprecated. Use "track_event(Event)" instead');
     const event = new Event(distinct_id, event_name, properties, kwargs);
     return this._eventcollector.collect(event);
   }
@@ -131,4 +136,10 @@ class Suprsend {
   }
 }
 
-export { Suprsend, Event, Workflow, SubscriberListBroadcast };
+export {
+  Suprsend,
+  Event,
+  Workflow,
+  SubscriberListBroadcast,
+  WorkflowTriggerRequest,
+};