@suprsend/node-sdk 0.1.0 → 1.0.0

package/dist/subscribers_bulk.js

@@ -0,0 +1,447 @@
+"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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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 _constants = require("./constants");
+
+var _signature = _interopRequireDefault(require("./signature"));
+
+var _bulk_response = _interopRequireDefault(require("./bulk_response"));
+
+var _subscriber = require("./subscriber");
+
+var _lodash = require("lodash");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+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; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var BulkSubscribersFactory = /*#__PURE__*/function () {
+  function BulkSubscribersFactory(config) {
+    (0, _classCallCheck2["default"])(this, BulkSubscribersFactory);
+    this.config = config;
+  }
+
+  (0, _createClass2["default"])(BulkSubscribersFactory, [{
+    key: "new_instance",
+    value: function new_instance() {
+      return new BulkSubscribers(this.config);
+    }
+  }]);
+  return BulkSubscribersFactory;
+}();
+
+exports["default"] = BulkSubscribersFactory;
+
+var _BulkSubscribersChunk = /*#__PURE__*/function () {
+  function _BulkSubscribersChunk(config) {
+    (0, _classCallCheck2["default"])(this, _BulkSubscribersChunk);
+    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;
+  }
+
+  (0, _createClass2["default"])(_BulkSubscribersChunk, [{
+    key: "__get_url",
+    value: function __get_url() {
+      var url_template = "event/";
+
+      if (this.config.include_signature_param) {
+        if (this.config.auth_enabled) {
+          url_template = url_template + "?verify=true";
+        } else {
+          url_template = url_template + "?verify=false";
+        }
+      }
+
+      var url_formatted = "".concat(this.config.base_url).concat(url_template);
+      return url_formatted;
+    }
+  }, {
+    key: "__common_headers",
+    value: function __common_headers() {
+      return {
+        "Content-Type": "application/json; charset=utf-8",
+        "User-Agent": this.config.user_agent
+      };
+    }
+  }, {
+    key: "__dynamic_headers",
+    value: function __dynamic_headers() {
+      return {
+        Date: new Date().toUTCString()
+      };
+    }
+  }, {
+    key: "__add_event_to_chunk",
+    value: function __add_event_to_chunk(event, event_size) {
+      //  First add size, then body to reduce effects of race condition
+      this.__running_size += event_size;
+
+      this.__chunk.push(event);
+
+      this.__running_length += 1;
+    }
+  }, {
+    key: "__check_limit_reached",
+    value: function __check_limit_reached() {
+      if (this.__running_length >= _constants.MAX_IDENTITY_EVENTS_IN_BULK_API || this.__running_size >= _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }, {
+    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.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new SuprsendError("workflow body (discounting attachment if any) too big - ".concat(event_size, " Bytes, must not cross ").concat(_constants.BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
+      }
+
+      if (this.__running_size + event_size > _constants.BODY_MAX_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, signature, response, ok_response, error_status;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                headers = _objectSpread(_objectSpread({}, this.__headers), this.__dynamic_headers());
+                content_text = JSON.stringify(this.__chunk); // Based on whether signature is required or not, add Authorization header
+
+                if (this.config.auth_enabled) {
+                  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 = 3;
+                _context.next = 6;
+                return _axios["default"].post(this.__url, content_text, {
+                  headers: headers
+                });
+
+              case 6:
+                response = _context.sent;
+                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(function (item) {
+                      return {
+                        record: item,
+                        error: response.statusText,
+                        code: response.status
+                      };
+                    })
+                  };
+                }
+
+                _context.next = 15;
+                break;
+
+              case 11:
+                _context.prev = 11;
+                _context.t0 = _context["catch"](3);
+                error_status = _context.t0.status || 500;
+                return _context.abrupt("return", {
+                  status: "fail",
+                  status_code: error_status,
+                  message: _context.t0.message,
+                  total: this.__chunk.length,
+                  success: 0,
+                  failure: this.__chunk.length,
+                  failed_records: this.__chunk.map(function (item) {
+                    return {
+                      record: item,
+                      error: _context.t0.message,
+                      code: error_status
+                    };
+                  })
+                });
+
+              case 15:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[3, 11]]);
+      }));
+
+      function trigger() {
+        return _trigger.apply(this, arguments);
+      }
+
+      return trigger;
+    }()
+  }]);
+  return _BulkSubscribersChunk;
+}();
+
+var BulkSubscribers = /*#__PURE__*/function () {
+  function BulkSubscribers(config) {
+    (0, _classCallCheck2["default"])(this, BulkSubscribers);
+    this.config = config;
+    this.__subscribers = [];
+    this.__pending_records = [];
+    this.chunks = [];
+    this.response = new _bulk_response["default"]();
+  }
+
+  (0, _createClass2["default"])(BulkSubscribers, [{
+    key: "__validate_subscriber_events",
+    value: function __validate_subscriber_events() {
+      if (!this.__subscribers) {
+        throw new SuprsendError("users list is empty in bulk request");
+      }
+
+      var _iterator = _createForOfIteratorHelper(this.__subscribers),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var sub = _step.value;
+          var is_part_of_bulk = true;
+          var warnings_list = sub.validate_body(is_part_of_bulk);
+
+          if (warnings_list) {
+            this.response.warnings = [].concat((0, _toConsumableArray2["default"])(this.response.warnings), (0, _toConsumableArray2["default"])(warnings_list));
+          }
+
+          var ev_arr = sub.events();
+
+          var _iterator2 = _createForOfIteratorHelper(ev_arr),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var ev = _step2.value;
+
+              var _sub$validate_event_s = sub.validate_event_size(ev),
+                  _sub$validate_event_s2 = (0, _slicedToArray2["default"])(_sub$validate_event_s, 2),
+                  ev_json = _sub$validate_event_s2[0],
+                  body_size = _sub$validate_event_s2[1];
+
+              this.__pending_records.push([ev_json, body_size]);
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      } 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 _BulkSubscribersChunk(this.config);
+      this.chunks.push(curr_chunk);
+
+      var entries = this.__pending_records.slice(start_idx).entries();
+
+      var _iterator3 = _createForOfIteratorHelper(entries),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _step3$value = (0, _slicedToArray2["default"])(_step3.value, 2),
+              rel_idx = _step3$value[0],
+              rec = _step3$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) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }, {
+    key: "append",
+    value: function append() {
+      for (var _len = arguments.length, subscribers = new Array(_len), _key = 0; _key < _len; _key++) {
+        subscribers[_key] = arguments[_key];
+      }
+
+      if (!subscribers) {
+        throw SuprsendError("users list empty. must pass one or more users");
+      }
+
+      for (var _i = 0, _subscribers = subscribers; _i < _subscribers.length; _i++) {
+        var sub = _subscribers[_i];
+
+        if (!sub) {
+          throw new SuprsendError("null/empty element found in bulk instance");
+        }
+
+        if (!(sub instanceof _subscriber.Subscriber)) {
+          throw new SuprsendError("element must be an instance of suprsend.Subscriber");
+        }
+
+        var sub_copy = (0, _lodash.cloneDeep)(sub);
+
+        this.__subscribers.push(sub_copy);
+      }
+    }
+  }, {
+    key: "trigger",
+    value: function trigger() {
+      this.save();
+    }
+  }, {
+    key: "save",
+    value: function () {
+      var _save = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _iterator4, _step4, _step4$value, c_idx, ch;
+
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                this.__validate_subscriber_events();
+
+                this.__chunkify();
+
+                _iterator4 = _createForOfIteratorHelper(this.chunks.entries());
+                _context2.prev = 3;
+
+                _iterator4.s();
+
+              case 5:
+                if ((_step4 = _iterator4.n()).done) {
+                  _context2.next = 13;
+                  break;
+                }
+
+                _step4$value = (0, _slicedToArray2["default"])(_step4.value, 2), c_idx = _step4$value[0], ch = _step4$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 = 10;
+                return ch.trigger();
+
+              case 10:
+                // merge response
+                this.response.merge_chunk_response(ch.response);
+
+              case 11:
+                _context2.next = 5;
+                break;
+
+              case 13:
+                _context2.next = 18;
+                break;
+
+              case 15:
+                _context2.prev = 15;
+                _context2.t0 = _context2["catch"](3);
+
+                _iterator4.e(_context2.t0);
+
+              case 18:
+                _context2.prev = 18;
+
+                _iterator4.f();
+
+                return _context2.finish(18);
+
+              case 21:
+                return _context2.abrupt("return", this.response);
+
+              case 22:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[3, 15, 18, 21]]);
+      }));
+
+      function save() {
+        return _save.apply(this, arguments);
+      }
+
+      return save;
+    }()
+  }]);
+  return BulkSubscribers;
+}();
+
+module.exports = exports.default;

package/dist/utils.js

@@ -5,15 +5,20 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SuprsendError = void 0;
+exports.SuprsendError = exports.SuprsendConfigError = void 0;
 exports.base64Encode = base64Encode;
 exports.epoch_milliseconds = epoch_milliseconds;
+exports.get_apparent_event_size = get_apparent_event_size;
+exports.get_apparent_identity_event_size = get_apparent_identity_event_size;
+exports.get_apparent_workflow_body_size = get_apparent_workflow_body_size;
 exports.has_special_char = void 0;
 exports.is_empty = is_empty;
 exports.is_object = is_object;
 exports.is_string = is_string;
 exports.resolveTilde = resolveTilde;
 exports.uuid = uuid;
+exports.validate_track_event_schema = validate_track_event_schema;
+exports.validate_workflow_body_schema = validate_workflow_body_schema;
 
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
@@ -31,12 +36,28 @@ var _os = _interopRequireDefault(require("os"));
 
 var _fs = _interopRequireDefault(require("fs"));
 
+var _jsonschema = require("jsonschema");
+
 var _uuid = require("uuid");
 
+var _constants = require("./constants");
+
+var _lodash = require("lodash");
+
+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; }
+
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
+var workflow_schema = require("./request_json/workflow.json");
+
+var event_schema = require("./request_json/event.json");
+
 function base64Encode(file) {
   var body = _fs["default"].readFileSync(file);
 
@@ -74,6 +95,25 @@ var SuprsendError = /*#__PURE__*/function (_Error) {
 
 exports.SuprsendError = SuprsendError;
 
+var SuprsendConfigError = /*#__PURE__*/function (_Error2) {
+  (0, _inherits2["default"])(SuprsendConfigError, _Error2);
+
+  var _super2 = _createSuper(SuprsendConfigError);
+
+  function SuprsendConfigError(message) {
+    var _this2;
+
+    (0, _classCallCheck2["default"])(this, SuprsendConfigError);
+    _this2 = _super2.call(this, message);
+    _this2.name = "SuprsendConfigError";
+    return _this2;
+  }
+
+  return SuprsendConfigError;
+}( /*#__PURE__*/(0, _wrapNativeSuper2["default"])(Error));
+
+exports.SuprsendConfigError = SuprsendConfigError;
+
 function is_string(value) {
   return typeof value === "string";
 }
@@ -87,6 +127,8 @@ function is_empty(value) {
     return Object.keys(value) <= 0;
   } else if (Array.isArray(value)) {
     return value.length <= 0;
+  } else {
+    return !value;
   }
 }
 
@@ -104,4 +146,171 @@ function uuid() {
 
 function epoch_milliseconds() {
   return Math.round(Date.now());
+}
+
+function validate_workflow_body_schema(body) {
+  if (!(body !== null && body !== void 0 && body.data)) {
+    body.data = {};
+  }
+
+  if (!(body.data instanceof Object)) {
+    throw new SuprsendError("data must be a object");
+  }
+
+  var schema = workflow_schema;
+  var v = new _jsonschema.Validator();
+  var validated_data = v.validate(body, schema);
+
+  if (validated_data.valid) {
+    return body;
+  } else {
+    var error_obj = validated_data.errors[0];
+    var error_msg = "".concat(error_obj.property, " ").concat(error_obj.message);
+    throw new SuprsendError(error_msg);
+  }
+}
+
+function validate_track_event_schema(body) {
+  if (!(body !== null && body !== void 0 && body.properties)) {
+    body.properties = {};
+  }
+
+  var schema = event_schema;
+  var v = new _jsonschema.Validator();
+  var validated_data = v.validate(body, schema);
+
+  if (validated_data.valid) {
+    return body;
+  } else {
+    var error_obj = validated_data.errors[0];
+    var error_msg = "".concat(error_obj.property, " ").concat(error_obj.message);
+    throw new SuprsendError(error_msg);
+  }
+}
+
+function get_apparent_workflow_body_size(body, is_part_of_bulk) {
+  var extra_bytes = _constants.WORKFLOW_RUNTIME_KEYS_POTENTIAL_SIZE_IN_BYTES;
+  var apparent_body = body;
+
+  if (body !== null && body !== void 0 && body.data["$attachments"]) {
+    var num_attachments = body.data["$attachments"].length;
+
+    if (is_part_of_bulk) {
+      if (_constants.ALLOW_ATTACHMENTS_IN_BULK_API) {
+        if (_constants.ATTACHMENT_UPLOAD_ENABLED) {
+          extra_bytes += num_attachments * _constants.ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+          apparent_body = (0, _lodash.cloneDeep)(body);
+
+          var _iterator = _createForOfIteratorHelper(apparent_body["data"]["$attachments"]),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var attach_data = _step.value;
+              delete attach_data["data"];
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        } else {// pass
+        }
+      } else {
+        apparent_body = (0, _lodash.cloneDeep)(body);
+        delete apparent_body["data"]["$attachments"];
+      }
+    } else {
+      if (_constants.ATTACHMENT_UPLOAD_ENABLED) {
+        extra_bytes += num_attachments * _constants.ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+        apparent_body = (0, _lodash.cloneDeep)(body);
+
+        var _iterator2 = _createForOfIteratorHelper(apparent_body["data"]["$attachments"]),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _attach_data = _step2.value;
+            delete _attach_data["data"];
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      } else {// pass
+      }
+    }
+  }
+
+  var body_size = JSON.stringify(apparent_body).length;
+  var apparent_body_size = body_size + extra_bytes;
+  return apparent_body_size;
+}
+
+function get_apparent_event_size(event, is_part_of_bulk) {
+  var _event$properties;
+
+  var extra_bytes = 0;
+  var apparent_body = event;
+
+  if (event !== null && event !== void 0 && (_event$properties = event.properties) !== null && _event$properties !== void 0 && _event$properties["$attachments"]) {
+    var num_attachments = event.properties["$attachments"].length;
+
+    if (is_part_of_bulk) {
+      if (_constants.ALLOW_ATTACHMENTS_IN_BULK_API) {
+        if (_constants.ATTACHMENT_UPLOAD_ENABLED) {
+          extra_bytes += num_attachments * _constants.ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+          apparent_body = (0, _lodash.cloneDeep)(event);
+
+          var _iterator3 = _createForOfIteratorHelper(apparent_body["properties"]["$attachments"]),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var attach_data = _step3.value;
+              delete attach_data["data"];
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        } else {// pass
+        }
+      } else {
+        apparent_body = (0, _lodash.cloneDeep)(body);
+        delete apparent_body["properties"]["$attachments"];
+      }
+    } else {
+      if (_constants.ATTACHMENT_UPLOAD_ENABLED) {
+        extra_bytes += num_attachments * _constants.ATTACHMENT_URL_POTENTIAL_SIZE_IN_BYTES;
+        apparent_body = (0, _lodash.cloneDeep)(body);
+
+        var _iterator4 = _createForOfIteratorHelper(apparent_body["properties"]["$attachments"]),
+            _step4;
+
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _attach_data2 = _step4.value;
+            delete _attach_data2["data"];
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      } else {// pass
+      }
+    }
+  }
+
+  var body_size = JSON.stringify(apparent_body).length;
+  var apparent_size = body_size + extra_bytes;
+  return apparent_size;
+}
+
+function get_apparent_identity_event_size(event) {
+  var body_size = JSON.stringify(event);
+  return body_size;
 }