@suprsend/node-sdk 1.11.1 → 1.13.0

package/dist/users_edit_bulk.js

@@ -0,0 +1,312 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+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 _axios = _interopRequireDefault(require("axios"));
+var _constants = require("./constants");
+var _signature = _interopRequireDefault(require("./signature"));
+var _utils = require("./utils");
+var _lodash = require("lodash");
+var _bulk_response = _interopRequireDefault(require("./bulk_response"));
+var _user_edit = _interopRequireDefault(require("./user_edit"));
+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 _BulkUsersEditChunk = /*#__PURE__*/function () {
+  function _BulkUsersEditChunk(config) {
+    (0, _classCallCheck2["default"])(this, _BulkUsersEditChunk);
+    this._chunk_apparent_size_in_bytes = _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES;
+    this._max_records_in_chunk = _constants.MAX_IDENTITY_EVENTS_IN_BULK_API;
+    this.config = config;
+    this.__chunk = [];
+    this.__url = "".concat(this.config.base_url, "event/");
+    this.__running_size = 0;
+    this.__running_length = 0;
+    this.response = null;
+  }
+  (0, _createClass2["default"])(_BulkUsersEditChunk, [{
+    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_event_to_chunk",
+    value: function __add_event_to_chunk(event, event_size) {
+      this.__running_size += event_size;
+      this.__chunk.push(event);
+      this.__running_length += 1;
+    }
+  }, {
+    key: "__check_limit_reached",
+    value: function __check_limit_reached() {
+      return this.__running_length >= this._max_records_in_chunk || this.__running_size >= this._chunk_apparent_size_in_bytes;
+    }
+  }, {
+    key: "try_to_add_into_chunk",
+    value: function try_to_add_into_chunk(event, event_size) {
+      if (!event) return true;
+      if (this.__check_limit_reached()) return false;
+      if (event_size > _constants.IDENTITY_SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.InputValueError("Event too big - ".concat(event_size, " Bytes, ") + "must not cross ".concat(_constants.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;
+    }
+  }, {
+    key: "trigger",
+    value: function () {
+      var _trigger = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var headers, content_text, sig, resp, ok_response, error_status;
+        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);
+                sig = (0, _signature["default"])(this.__url, "POST", content_text, headers, this.config.workspace_secret);
+                headers["Authorization"] = "".concat(this.config.workspace_key, ":").concat(sig);
+                _context.prev = 4;
+                _context.next = 7;
+                return _axios["default"].post(this.__url, content_text, {
+                  headers: headers
+                });
+              case 7:
+                resp = _context.sent;
+                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(function (item) {
+                      return {
+                        record: item,
+                        error: resp.statusText,
+                        code: resp.status
+                      };
+                    })
+                  };
+                }
+                _context.next = 16;
+                break;
+              case 12:
+                _context.prev = 12;
+                _context.t0 = _context["catch"](4);
+                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(function (c) {
+                    return {
+                      record: c,
+                      error: _context.t0.message,
+                      code: error_status
+                    };
+                  })
+                };
+              case 16:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[4, 12]]);
+      }));
+      function trigger() {
+        return _trigger.apply(this, arguments);
+      }
+      return trigger;
+    }()
+  }]);
+  return _BulkUsersEditChunk;
+}();
+var BulkUsersEdit = /*#__PURE__*/function () {
+  function BulkUsersEdit(config) {
+    (0, _classCallCheck2["default"])(this, BulkUsersEdit);
+    this.config = config;
+    this.__users = [];
+    this.__pending_records = [];
+    this.__invalid_records = [];
+    this.chunks = [];
+    this.response = new _bulk_response["default"]();
+  }
+  (0, _createClass2["default"])(BulkUsersEdit, [{
+    key: "__validate_users",
+    value: function __validate_users() {
+      var _iterator = _createForOfIteratorHelper(this.__users),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var u = _step.value;
+          try {
+            var warnings_list = u.validate_body();
+            if (warnings_list) {
+              this.response.warnings = [].concat((0, _toConsumableArray2["default"])(this.response.warnings), (0, _toConsumableArray2["default"])(warnings_list));
+            }
+            var pl = u.get_async_payload();
+            var _u$validate_payload_s = u.validate_payload_size(pl),
+              _u$validate_payload_s2 = (0, _slicedToArray2["default"])(_u$validate_payload_s, 2),
+              pl_json = _u$validate_payload_s2[0],
+              pl_size = _u$validate_payload_s2[1];
+            this.__pending_records.push([pl_json, pl_size]);
+          } catch (ex) {
+            var inv_rec = (0, _utils.invalid_record_json)(u.as_json_async(), 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 _BulkUsersEditChunk(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) {
+            this.__chunkify(start_idx + rel_idx);
+            break;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }, {
+    key: "append",
+    value: function append() {
+      for (var _len = arguments.length, users = new Array(_len), _key = 0; _key < _len; _key++) {
+        users[_key] = arguments[_key];
+      }
+      if (!users) return;
+      for (var _i = 0, _users = users; _i < _users.length; _i++) {
+        var u = _users[_i];
+        if (u && u instanceof _user_edit["default"]) {
+          var u_copy = (0, _lodash.cloneDeep)(u);
+          this.__users.push(u_copy);
+        }
+      }
+    }
+  }, {
+    key: "save",
+    value: function () {
+      var _save = (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_users();
+                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 > 0)) {
+                  _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(c_idx));
+                }
+                // 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 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(_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 save() {
+        return _save.apply(this, arguments);
+      }
+      return save;
+    }()
+  }]);
+  return BulkUsersEdit;
+}();
+var _default = BulkUsersEdit;
+exports["default"] = _default;
+module.exports = exports.default;

package/dist/workflow.js

@@ -71,8 +71,8 @@ var Workflow = /*#__PURE__*/function () {
       }
       this.body = (0, _utils.validate_workflow_body_schema)(this.body);
       var apparent_size = (0, _utils.get_apparent_workflow_body_size)(this.body, is_part_of_bulk); // review
-      if (apparent_size > _constants.SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
-        throw new _utils.InputValueError("workflow body too big - ".concat(apparent_size, " Bytes, must not cross ").concat(_constants.SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
+      if (apparent_size > _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.InputValueError("workflow body too big - ".concat(apparent_size, " Bytes, must not cross ").concat(_constants.BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
       }
       return [this.body, apparent_size];
     }

package/dist/workflow_request.js

@@ -66,8 +66,8 @@ var WorkflowTriggerRequest = /*#__PURE__*/function () {
       }
       this.body = (0, _utils.validate_workflow_trigger_body_schema)(this.body);
       var apparent_size = (0, _utils.get_apparent_workflow_body_size)(this.body, is_part_of_bulk);
-      if (apparent_size > _constants.SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
-        throw new _utils.InputValueError("workflow body too big - ".concat(apparent_size, " Bytes, must not exceed ").concat(_constants.SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
+      if (apparent_size > _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.InputValueError("workflow body too big - ".concat(apparent_size, " Bytes, must not exceed ").concat(_constants.BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
       }
       return [this.body, apparent_size];
     }

package/dist/workflow_trigger_bulk.js

@@ -61,8 +61,8 @@ var _BulkWorkflowTriggerChunk = /*#__PURE__*/function () {
       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 (body_size > _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.InputValueError("workflow body too big - ".concat(body_size, " Bytes, must not exceed ").concat(_constants.BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
       }
       if (this.__running_size + body_size > _BulkWorkflowTriggerChunk._chunk_apparent_size_in_bytes) {
         return false;

package/dist/workflows_bulk.js

@@ -94,8 +94,8 @@ var _BulkWorkflowsChunk = /*#__PURE__*/function () {
       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 cross ").concat(_constants.SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
+      if (body_size > _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.InputValueError("workflow body too big - ".concat(body_size, " Bytes, must not cross ").concat(_constants.BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
       }
       if (this.__running_size + body_size > _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
         return false;

package/package.json

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

package/src/constants.js

@@ -1,10 +1,6 @@
 //  Default urls
 export const DEFAULT_URL = "https://hub.suprsend.com/";
 
-//  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
-export const SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE = "100KB";
-
 // a API call should not have apparent body size of more than 800KB
 export const BODY_MAX_APPARENT_SIZE_IN_BYTES = 800 * 1024; // 800 * 1024
 export const BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE = "800KB";

package/src/event.js

@@ -1,6 +1,5 @@
 import {
   is_string,
-  SuprsendError,
   has_special_char,
   uuid,
   epoch_milliseconds,
@@ -12,8 +11,8 @@ import get_request_signature from "./signature";
 import axios from "axios";
 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";
 
 const RESERVED_EVENT_NAMES = [
@@ -137,9 +136,9 @@ 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) {
+    if (apparent_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {
       throw new InputValueError(
-        `Event size too big - ${apparent_size} Bytes,must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+        `Event size too big - ${apparent_size} Bytes,must not cross ${BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
     return [event_dict, apparent_size];

package/src/events_bulk.js

@@ -1,6 +1,4 @@
 import {
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES,
-  SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
   ALLOW_ATTACHMENTS_IN_BULK_API,
   BODY_MAX_APPARENT_SIZE_IN_BYTES,
   BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE,
@@ -9,7 +7,7 @@ import {
 import get_request_signature from "./signature";
 import BulkResponse from "./bulk_response";
 import Event from "./event";
-import { InputValueError, SuprsendError, invalid_record_json } from "./utils";
+import { InputValueError, invalid_record_json } from "./utils";
 import { cloneDeep } from "lodash";
 import axios from "axios";
 
@@ -78,9 +76,9 @@ class _BulkEventsChunk {
     if (this.__check_limit_reached()) {
       return false;
     }
-    if (event_size > SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES) {
+    if (event_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {
       throw new InputValueError(
-        `Event properties too big - ${event_size} Bytes, must not cross ${SINGLE_EVENT_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
+        `Event properties too big - ${event_size} Bytes, must not cross ${BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE}`
       );
     }
     if (this.__running_size + event_size > BODY_MAX_APPARENT_SIZE_IN_BYTES) {

package/src/index.js

@@ -11,8 +11,12 @@ import BulkSubscribersFactory from "./subscribers_bulk";
 import { SubscriberListsApi, SubscriberListBroadcast } from "./subscriber_list";
 import BrandsApi from "./brands";
 import TenantsApi from "./tenant";
-import ObjectsApi from "./object";
+import ObjectsApi from "./objects_api";
 import { DEFAULT_URL } from "./constants";
+import UsersApi from "./users_api";
+import ObjectEdit from "./object_edit";
+import UserEdit from "./user_edit";
+import BulkUsersEdit from "./users_edit_bulk";
 
 const package_json = require("../package.json");
 
@@ -40,6 +44,7 @@ class Suprsend {
     this.tenants = new TenantsApi(this);
     this.workflows = new WorkflowsApi(this);
     this.objects = new ObjectsApi(this);
+    this.users = new UsersApi(this);
 
     this.subscriber_lists = new SubscriberListsApi(this);
 
@@ -142,4 +147,7 @@ export {
   Workflow,
   SubscriberListBroadcast,
   WorkflowTriggerRequest,
+  ObjectEdit,
+  UserEdit,
+  BulkUsersEdit,
 };