@suprsend/node-sdk 0.1.1 → 1.0.0

package/dist/workflow.js

@@ -5,74 +5,145 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+exports["default"] = exports._WorkflowTrigger = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _signature = _interopRequireDefault(require("./signature"));
+var _axios = _interopRequireDefault(require("axios"));
 
-var _jsonschema = require("jsonschema");
+var _signature = _interopRequireDefault(require("./signature"));
 
 var _utils = require("./utils");
 
-var _axios = _interopRequireDefault(require("axios"));
+var _attachment = _interopRequireDefault(require("./attachment"));
 
-var workflow_schema = require("./request_json/workflow.json");
+var _constants = require("./constants");
 
 var Workflow = /*#__PURE__*/function () {
-  function Workflow(ss_instance, data) {
+  function Workflow(body, idempotency_key) {
     (0, _classCallCheck2["default"])(this, Workflow);
-    this.ss_instance = ss_instance;
-    this.data = data;
-    this.url = this._get_url();
+
+    if (!(body instanceof Object)) {
+      throw new _utils.SuprsendError("workflow body must be a json/dictionary");
+    }
+
+    this.body = body;
+    this.idempotency_key = idempotency_key;
   }
 
   (0, _createClass2["default"])(Workflow, [{
+    key: "add_attachment",
+    value: function add_attachment() {
+      var file_path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+
+      if (!this.body.data) {
+        this.body.data = {};
+      }
+
+      if (!(this.body instanceof Object)) {
+        throw new _utils.SuprsendError("data must be a dictionary");
+      }
+
+      var attachment = (0, _attachment["default"])(file_path);
+
+      if (!this.body.data["$attachments"]) {
+        this.body["data"]["$attachments"] = [];
+      }
+
+      this.body["data"]["$attachments"].push(attachment);
+    }
+  }, {
+    key: "get_final_json",
+    value: function get_final_json(config) {
+      var is_part_of_bulk = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      // add idempotency key in body if present
+      if (this.idempotency_key) {
+        this.body["$idempotency_key"] = this.idempotency_key;
+      }
+
+      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.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.SuprsendError("workflow body (discounting attachment if any) too big - ".concat(apparent_size, " Bytes, must not cross ").concat(_constants.BODY_MAX_APPARENT_SIZE_IN_BYTES_READABLE));
+      }
+
+      return [this.body, apparent_size];
+    }
+  }]);
+  return Workflow;
+}();
+
+exports["default"] = Workflow;
+
+var _WorkflowTrigger = /*#__PURE__*/function () {
+  function _WorkflowTrigger(config) {
+    (0, _classCallCheck2["default"])(this, _WorkflowTrigger);
+    this.config = config;
+    this.url = this._get_url();
+  }
+
+  (0, _createClass2["default"])(_WorkflowTrigger, [{
     key: "_get_url",
     value: function _get_url() {
       var 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";
         }
       }
 
-      var url_formatted = "".concat(this.ss_instance.base_url).concat(this.ss_instance.env_key).concat(url_template);
+      var url_formatted = "".concat(this.config.base_url).concat(this.config.workspace_key).concat(url_template);
       return url_formatted;
     }
   }, {
     key: "_get_headers",
     value: function _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
       };
     }
   }, {
-    key: "execute_workflow",
+    key: "trigger",
+    value: function trigger(workflow) {
+      var is_part_of_bulk = false;
+
+      var _workflow$get_final_j = workflow.get_final_json(this.config, is_part_of_bulk),
+          _workflow$get_final_j2 = (0, _slicedToArray2["default"])(_workflow$get_final_j, 2),
+          workflow_body = _workflow$get_final_j2[0],
+          body_size = _workflow$get_final_j2[1];
+
+      return this.send(workflow_body);
+    }
+  }, {
+    key: "send",
     value: function () {
-      var _execute_workflow = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
-        var headers, content_text, signature, response;
+      var _send = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(workflow_body) {
+        var headers, content_text, signature, response, ok_response;
         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.data);
+                content_text = JSON.stringify(workflow_body);
 
-                if (this.ss_instance.auth_enabled) {
-                  signature = (0, _signature["default"])(this.url, "POST", content_text, headers, this.ss_instance.env_secret);
-                  headers["Authorization"] = "".concat(this.ss_instance.env_key, ":").concat(signature);
+                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;
@@ -83,64 +154,58 @@ var Workflow = /*#__PURE__*/function () {
 
               case 6:
                 response = _context.sent;
+                ok_response = Math.floor(response.status / 100) == 2;
+
+                if (!ok_response) {
+                  _context.next = 12;
+                  break;
+                }
+
                 return _context.abrupt("return", {
-                  status_code: response.status,
                   success: true,
+                  status: "success",
+                  status_code: response.status,
                   message: response.statusText
                 });
 
-              case 10:
-                _context.prev = 10;
+              case 12:
+                return _context.abrupt("return", {
+                  success: false,
+                  status: "fail",
+                  status_code: response.status,
+                  message: response.statusText
+                });
+
+              case 13:
+                _context.next = 18;
+                break;
+
+              case 15:
+                _context.prev = 15;
                 _context.t0 = _context["catch"](3);
                 return _context.abrupt("return", {
-                  status_code: 400,
                   success: false,
+                  status: "fail",
+                  status_code: _context.t0.status || 500,
                   message: _context.t0.message
                 });
 
-              case 13:
+              case 18:
               case "end":
                 return _context.stop();
             }
           }
-        }, _callee, this, [[3, 10]]);
+        }, _callee, this, [[3, 15]]);
       }));
 
-      function execute_workflow() {
-        return _execute_workflow.apply(this, arguments);
+      function send(_x) {
+        return _send.apply(this, arguments);
       }
 
-      return execute_workflow;
+      return send;
     }()
-  }, {
-    key: "validate_data",
-    value: function validate_data() {
-      var _this$data;
-
-      if (!((_this$data = this.data) !== null && _this$data !== void 0 && _this$data.data)) {
-        this.data.data = {};
-      }
-
-      if (!(this.data.data instanceof Object)) {
-        throw new _utils.SuprsendError("data must be a object");
-      }
-
-      var schema = workflow_schema;
-      var v = new _jsonschema.Validator();
-      var validated_data = v.validate(this.data, schema);
-
-      if (validated_data.valid) {
-        return this.data;
-      } else {
-        var error_obj = validated_data.errors[0];
-        var error_msg = "".concat(error_obj.property, " ").concat(error_obj.message);
-        throw new _utils.SuprsendError(error_msg);
-      }
-    }
   }]);
-  return Workflow;
+  return _WorkflowTrigger;
 }();
 
-var _default = Workflow;
-exports["default"] = _default;
-module.exports = exports.default;
+exports._WorkflowTrigger = _WorkflowTrigger;

package/dist/workflows_bulk.js

@@ -0,0 +1,424 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BulkWorkflowsFactory = 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 _utils = require("./utils");
+
+var _workflow = _interopRequireDefault(require("./workflow"));
+
+var _lodash = require("lodash");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _bulk_response = _interopRequireDefault(require("./bulk_response"));
+
+var _signature = _interopRequireDefault(require("./signature"));
+
+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 BulkWorkflowsFactory = /*#__PURE__*/function () {
+  function BulkWorkflowsFactory(config) {
+    (0, _classCallCheck2["default"])(this, BulkWorkflowsFactory);
+    this.config = config;
+  }
+
+  (0, _createClass2["default"])(BulkWorkflowsFactory, [{
+    key: "new_instance",
+    value: function new_instance() {
+      return new BulkWorkflows(this.config);
+    }
+  }]);
+  return BulkWorkflowsFactory;
+}();
+
+exports.BulkWorkflowsFactory = BulkWorkflowsFactory;
+
+var _BulkWorkflowsChunk = /*#__PURE__*/function () {
+  function _BulkWorkflowsChunk(config) {
+    (0, _classCallCheck2["default"])(this, _BulkWorkflowsChunk);
+    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"])(_BulkWorkflowsChunk, [{
+    key: "__get_url",
+    value: function __get_url() {
+      var 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";
+        }
+      }
+
+      var url_formatted = "".concat(this.config.base_url).concat(this.config.workspace_key).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_body_to_chunk",
+    value: function __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;
+    }
+  }, {
+    key: "__check_limit_reached",
+    value: function __check_limit_reached() {
+      if (this.__running_length >= _constants.MAX_WORKFLOWS_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(body, body_size) {
+      if (!body) {
+        return true;
+      }
+
+      if (this.__check_limit_reached()) {
+        return false;
+      }
+
+      if (body_size > _constants.BODY_MAX_APPARENT_SIZE_IN_BYTES) {
+        throw new _utils.SuprsendError("workflow body (discounting attachment if any) 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;
+      }
+
+      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, 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 _BulkWorkflowsChunk;
+}();
+
+var BulkWorkflows = /*#__PURE__*/function () {
+  function BulkWorkflows(config) {
+    (0, _classCallCheck2["default"])(this, BulkWorkflows);
+    this.config = config;
+    this.__workflows = [];
+    this.__pending_records = [];
+    this.chunks = [];
+    this.response = new _bulk_response["default"]();
+  }
+
+  (0, _createClass2["default"])(BulkWorkflows, [{
+    key: "__validate_workflows",
+    value: function __validate_workflows() {
+      if (!this.__workflows) {
+        throw new _utils.SuprsendError("workflow list is empty in bulk request");
+      }
+
+      var _iterator = _createForOfIteratorHelper(this.__workflows),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var wf = _step.value;
+          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 (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 _BulkWorkflowsChunk(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) {
+        throw new _utils.SuprsendError("workflow list empty. must pass one or more valid workflow instances");
+      }
+
+      for (var _i = 0, _workflows = workflows; _i < _workflows.length; _i++) {
+        var wf = _workflows[_i];
+
+        if (!wf) {
+          throw new _utils.SuprsendError("null/empty element found in bulk instance");
+        }
+
+        if (!(wf instanceof _workflow["default"])) {
+          throw new _utils.SuprsendError("element must be an instance of suprsend.Workflow");
+        }
+
+        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 _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();
+
+                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 BulkWorkflows;
+}();