@suprsend/node-sdk 0.1.1 → 1.0.0

package/dist/events_bulk.js

@@ -0,0 +1,424 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BulkEventsFactory = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+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 _event = _interopRequireDefault(require("./event"));
+
+var _utils = require("./utils");
+
+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 BulkEventsFactory = /*#__PURE__*/function () {
+  function BulkEventsFactory(config) {
+    (0, _classCallCheck2["default"])(this, BulkEventsFactory);
+    this.config = config;
+  }
+
+  (0, _createClass2["default"])(BulkEventsFactory, [{
+    key: "new_instance",
+    value: function new_instance() {
+      return new BulkEvents(this.config);
+    }
+  }]);
+  return BulkEventsFactory;
+}();
+
+exports.BulkEventsFactory = BulkEventsFactory;
+
+var _BulkEventsChunk = /*#__PURE__*/function () {
+  function _BulkEventsChunk(config) {
+    (0, _classCallCheck2["default"])(this, _BulkEventsChunk);
+    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"])(_BulkEventsChunk, [{
+    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_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 _utils.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;
+      }
+
+      if (!_constants.ALLOW_ATTACHMENTS_IN_BULK_API) {
+        delete event.properties["$attachments"];
+      }
+
+      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 _BulkEventsChunk;
+}();
+
+var BulkEvents = /*#__PURE__*/function () {
+  function BulkEvents(config) {
+    (0, _classCallCheck2["default"])(this, BulkEvents);
+    this.config = config;
+    this.__events = [];
+    this.__pending_records = [];
+    this.chunks = [];
+    this.response = new _bulk_response["default"]();
+  }
+
+  (0, _createClass2["default"])(BulkEvents, [{
+    key: "__validate_events",
+    value: function __validate_events() {
+      if (!this.__events) {
+        throw new _utils.SuprsendError("events list is empty in bulk request");
+      }
+
+      var _iterator = _createForOfIteratorHelper(this.__events),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var ev = _step.value;
+          var is_part_of_bulk = true;
+
+          var _ev$get_final_json = ev.get_final_json(this.config, is_part_of_bulk),
+              _ev$get_final_json2 = (0, _slicedToArray2["default"])(_ev$get_final_json, 2),
+              ev_json = _ev$get_final_json2[0],
+              body_size = _ev$get_final_json2[1];
+
+          this.__pending_records.push([ev_json, body_size]);
+        }
+      } 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 _BulkEventsChunk(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, events = new Array(_len), _key = 0; _key < _len; _key++) {
+        events[_key] = arguments[_key];
+      }
+
+      if (!events) {
+        throw new _utils.SuprsendError("events list empty. must pass one or more events");
+      }
+
+      for (var _i = 0, _events = events; _i < _events.length; _i++) {
+        var ev = _events[_i];
+
+        if (!ev) {
+          throw new _utils.SuprsendError("null/empty element found in bulk instance");
+        }
+
+        if (!(ev instanceof _event["default"])) {
+          throw new _utils.SuprsendError("element must be an instance of suprsend.Event");
+        }
+
+        var ev_copy = (0, _lodash.cloneDeep)(ev);
+
+        this.__events.push(ev_copy);
+      }
+    }
+  }, {
+    key: "trigger",
+    value: function () {
+      var _trigger2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _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_events();
+
+                this.__chunkify();
+
+                _iterator3 = _createForOfIteratorHelper(this.chunks.entries());
+                _context2.prev = 3;
+
+                _iterator3.s();
+
+              case 5:
+                if ((_step3 = _iterator3.n()).done) {
+                  _context2.next = 13;
+                  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 = 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);
+
+                _iterator3.e(_context2.t0);
+
+              case 18:
+                _context2.prev = 18;
+
+                _iterator3.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 trigger() {
+        return _trigger2.apply(this, arguments);
+      }
+
+      return trigger;
+    }()
+  }]);
+  return BulkEvents;
+}();

package/dist/index.js

@@ -2,57 +2,103 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+Object.defineProperty(exports, "Event", {
+  enumerable: true,
+  get: function get() {
+    return _event["default"];
+  }
+});
+exports.Suprsend = void 0;
+Object.defineProperty(exports, "Workflow", {
+  enumerable: true,
+  get: function get() {
+    return _workflow["default"];
+  }
+});
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _config = _interopRequireDefault(require("./config"));
+var _utils = require("./utils");
 
-var _workflow = _interopRequireDefault(require("./workflow"));
+var _attachment = _interopRequireDefault(require("./attachment"));
 
-var _path = _interopRequireDefault(require("path"));
+var _workflow = _interopRequireWildcard(require("./workflow"));
 
-var _mimeTypes = _interopRequireDefault(require("mime-types"));
+var _workflows_bulk = require("./workflows_bulk");
 
-var _utils = require("./utils");
+var _event = _interopRequireWildcard(require("./event"));
 
-var _identity = _interopRequireDefault(require("./identity"));
+var _events_bulk = require("./events_bulk");
 
-var _event = _interopRequireDefault(require("./event"));
+var _subscriber = _interopRequireDefault(require("./subscriber"));
+
+var _subscribers_bulk = _interopRequireDefault(require("./subscribers_bulk"));
+
+var _constants = require("./constants");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 var package_json = require("../package.json");
 
 var Suprsend = /*#__PURE__*/function () {
-  function Suprsend(workspace_env, workspace_secret) {
+  function Suprsend(workspace_key, workspace_secret) {
     var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     (0, _classCallCheck2["default"])(this, Suprsend);
-    this.env_key = workspace_env;
-    this.env_secret = workspace_secret;
+    this.workspace_key = workspace_key;
+    this.workspace_secret = workspace_secret;
     this.config = config;
     this.base_url = this._get_url(config.base_url);
     this.auth_enabled = config.auth_enabled !== false;
     this.include_signature_param = config.include_signature_param !== false;
     this.user_agent = "suprsend/".concat(package_json.version, ";node/").concat(process.version.slice(1));
-    this.user = new _identity["default"](this);
-    this._eventcollector = new _event["default"](this);
+    this._workflow_trigger = new _workflow._WorkflowTrigger(this);
+    this._eventcollector = new _event.EventCollector(this);
+    this._bulk_workflows = new _workflows_bulk.BulkWorkflowsFactory(this);
+    this._bulk_events = new _events_bulk.BulkEventsFactory(this);
+    this._bulk_users = new _subscribers_bulk["default"](this);
+    this._user = new _subscriber["default"](this);
 
     this._validate();
   }
 
   (0, _createClass2["default"])(Suprsend, [{
+    key: "bulk_workflows",
+    get: function get() {
+      return this._bulk_workflows;
+    }
+  }, {
+    key: "bulk_events",
+    get: function get() {
+      return this._bulk_events;
+    }
+  }, {
+    key: "bulk_users",
+    get: function get() {
+      return this._bulk_users;
+    }
+  }, {
+    key: "user",
+    get: function get() {
+      return this._user;
+    }
+  }, {
     key: "_validate",
     value: function _validate() {
-      if (!this.env_key) {
-        throw new _utils.SuprsendError("Missing Mandatory WORKSPACE_ENVIRONEMENT");
-      } else if (!this.env_secret) {
-        throw new _utils.SuprsendError("Missing Mandatory WORKSPACE_SECRET");
+      if (!this.workspace_key) {
+        throw new _utils.SuprsendConfigError("Missing workspace_key");
+      } else if (!this.workspace_secret) {
+        throw new _utils.SuprsendConfigError("Missing workspace_secret");
       } else if (!this.base_url) {
-        throw new _utils.SuprsendError("Missing Mandatory base url");
+        throw new _utils.SuprsendConfigError("Missing base_url");
       }
     }
   }, {
@@ -64,9 +110,9 @@ var Suprsend = /*#__PURE__*/function () {
 
       if (!base_url) {
         if (this.config.is_staging) {
-          base_url = _config["default"].staging;
+          base_url = _constants.DEFAULT_UAT_URL;
         } else {
-          base_url = _config["default"].prod;
+          base_url = _constants.DEFAULT_URL;
         }
       }
 
@@ -89,7 +135,7 @@ var Suprsend = /*#__PURE__*/function () {
         throw new _utils.SuprsendError("data must be an object");
       }
 
-      var attachment = this._get_attachment_json_for_file(file_path);
+      var attachment = (0, _attachment["default"])(file_path);
 
       if (!body.data["$attachments"]) {
         body["data"]["$attachments"] = [];
@@ -98,34 +144,38 @@ var Suprsend = /*#__PURE__*/function () {
       body["data"]["$attachments"].push(attachment);
       return body;
     }
-  }, {
-    key: "_get_attachment_json_for_file",
-    value: function _get_attachment_json_for_file(file_path) {
-      var abs_path = _path["default"].resolve((0, _utils.resolveTilde)(file_path));
-
-      return {
-        filename: _path["default"].basename(abs_path),
-        contentType: _mimeTypes["default"].lookup(abs_path),
-        data: (0, _utils.base64Encode)(abs_path)
-      };
-    }
   }, {
     key: "trigger_workflow",
     value: function trigger_workflow(data) {
-      var wf = new _workflow["default"](this, data);
-      wf.validate_data();
-      return wf.execute_workflow();
+      var wf_ins;
+
+      if (data instanceof _workflow["default"]) {
+        wf_ins = data;
+      } else {
+        wf_ins = new _workflow["default"](data);
+      }
+
+      return this._workflow_trigger.trigger(wf_ins);
     }
   }, {
     key: "track",
     value: function track(distinct_id, event_name) {
       var properties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      return this._eventcollector.collect(distinct_id, event_name, properties);
+      var idempotency_key = arguments.length > 3 ? arguments[3] : undefined;
+      var event = new _event["default"](distinct_id, event_name, properties, idempotency_key);
+      return this._eventcollector.collect(event);
+    }
+  }, {
+    key: "track_event",
+    value: function track_event(event) {
+      if (!(event instanceof _event["default"])) {
+        throw new _utils.SuprsendError("argument must be an instance of suprsend.Event");
+      }
+
+      return this._eventcollector.collect(event);
     }
   }]);
   return Suprsend;
 }();
 
-var _default = Suprsend;
-exports["default"] = _default;
-module.exports = exports.default;
+exports.Suprsend = Suprsend;

package/dist/request_json/event.json

@@ -6,6 +6,11 @@
   "$comment": "Json schema for Track event",
   "type": "object",
   "properties": {
+    "$idempotency_key": {
+      "type": ["string", "null"],
+      "maxLength": 64,
+      "description": "unique id provided by client for request"
+    },
     "$insert_id": {
       "type": "string",
       "minLength": 36,