roboto-js 1.0.21 → 1.1.2

package/dist/cjs/rbt_api.cjs

@@ -7,6 +7,7 @@ exports["default"] = void 0;
 var _axios = _interopRequireDefault(require("axios"));
 var _cryptoJs = _interopRequireDefault(require("crypto-js"));
 var _rbt_object = _interopRequireDefault(require("./rbt_object.cjs"));
+var _rbt_user = _interopRequireDefault(require("./rbt_user.cjs"));
 var _rbt_file = _interopRequireDefault(require("./rbt_file.cjs"));
 var _lodash = _interopRequireDefault(require("lodash"));
 var _idb = require("idb");
@@ -73,6 +74,14 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
       }
       return initLocalDb;
     }()
+    /**
+       * Logs in a user and stores the authToken.
+       *
+       * @param {Object} params - The login parameters.
+       * @param {string} params.email - The email of the user.
+       * @param {string} params.password - The password of the user.
+       * @returns {Promise<Object>} - The response data from the API.
+       */
   }, {
     key: "login",
     value: function () {
@@ -119,213 +128,581 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
       }
       return login;
     }()
+  }, {
+    key: "logout",
+    value: function () {
+      var _logout = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+        var response;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return this.axios.post('/user_service/logoutUser');
+            case 3:
+              response = _context3.sent;
+              if (!(response.data.ok === false)) {
+                _context3.next = 6;
+                break;
+              }
+              return _context3.abrupt("return", this._handleError(response));
+            case 6:
+              // Clear the iac_session and remove the auth token from axios headers
+              this.iac_session = null;
+              if (this.axios.defaults.headers.common['authtoken']) {
+                delete this.axios.defaults.headers.common['authtoken'];
+              }
+
+              // Clear localStorage if it's being used
+              if (typeof localStorage !== 'undefined') {
+                localStorage.removeItem('authtoken');
+              }
+
+              // Return some kind of success response or the response from the server
+              return _context3.abrupt("return", response.data);
+            case 12:
+              _context3.prev = 12;
+              _context3.t0 = _context3["catch"](0);
+              this._handleError(_context3.t0);
+            case 15:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[0, 12]]);
+      }));
+      function logout() {
+        return _logout.apply(this, arguments);
+      }
+      return logout;
+    }()
+  }, {
+    key: "loadCurrentUser",
+    value: function () {
+      var _loadCurrentUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+        var params, _response$data, response, userData, User;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              // TODO - get the actual user from the session
+              params = {
+                id: 'superuser_tom'
+              };
+              _context4.prev = 1;
+              _context4.next = 4;
+              return this.axios.post('/user_service/loadUser', [params]);
+            case 4:
+              response = _context4.sent;
+              userData = response === null || response === void 0 || (_response$data = response.data) === null || _response$data === void 0 ? void 0 : _response$data.user;
+              User = new _rbt_user["default"]({
+                id: userData.id
+              }, this.axios);
+              User.setData(userData);
+              return _context4.abrupt("return", User);
+            case 11:
+              _context4.prev = 11;
+              _context4.t0 = _context4["catch"](1);
+              return _context4.abrupt("return", this._handleError(_context4.t0));
+            case 14:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[1, 11]]);
+      }));
+      function loadCurrentUser() {
+        return _loadCurrentUser.apply(this, arguments);
+      }
+      return loadCurrentUser;
+    }()
+  }, {
+    key: "refreshAuthToken",
+    value: function () {
+      var _refreshAuthToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(authtoken) {
+        var response;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+            case 3:
+              response = _context5.sent;
+              return _context5.abrupt("return", response.data);
+            case 7:
+              _context5.prev = 7;
+              _context5.t0 = _context5["catch"](0);
+              this._handleError(_context5.t0);
+            case 10:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[0, 7]]);
+      }));
+      function refreshAuthToken(_x2) {
+        return _refreshAuthToken.apply(this, arguments);
+      }
+      return refreshAuthToken;
+    }()
+    /**
+     * Registers a new user.
+     *
+     * @param {Object} dataHash - The data for the new user.
+     * @returns {Promise<RbtObject>} - The newly created user as an RbtObject.
+     *
+     */
   }, {
     key: "registerUser",
     value: function () {
-      var _registerUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+      var _registerUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
         var dataHash,
           response,
           record,
-          _args3 = arguments;
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
+          _args6 = arguments;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
-              dataHash = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {};
-              _context3.prev = 1;
-              _context3.next = 4;
+              dataHash = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : {};
+              _context6.prev = 1;
+              _context6.next = 4;
               return this.axios.post('/user_service/registerUser', [dataHash]);
             case 4:
-              response = _context3.sent;
+              response = _context6.sent;
               record = response.data;
               if (dataHash) {
                 record.data = dataHash;
               }
-              return _context3.abrupt("return", new _rbt_object["default"](record, this.axios));
+              return _context6.abrupt("return", new _rbt_object["default"](record, this.axios));
             case 10:
-              _context3.prev = 10;
-              _context3.t0 = _context3["catch"](1);
-              return _context3.abrupt("return", this._handleError(_context3.t0));
-            case 13:
+              _context6.prev = 10;
+              _context6.t0 = _context6["catch"](1);
+              debugger;
+              return _context6.abrupt("return", this._handleError(_context6.t0));
+            case 14:
             case "end":
-              return _context3.stop();
+              return _context6.stop();
           }
-        }, _callee3, this, [[1, 10]]);
+        }, _callee6, this, [[1, 10]]);
       }));
       function registerUser() {
         return _registerUser.apply(this, arguments);
       }
       return registerUser;
     }()
+    /**
+     * Creates a new file in the system.
+     *
+     * @param {Object} dataHash - The data for the new file.
+     * @returns {Promise<RbtFile>} - The newly created file as an RbtFile.
+     * 
+     */
   }, {
     key: "createFile",
     value: function () {
-      var _createFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(dataHash) {
+      var _createFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(dataHash) {
         var response, record;
-        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
             case 0:
-              _context4.prev = 0;
-              _context4.next = 3;
+              _context7.prev = 0;
+              _context7.next = 3;
               return this.axios.post('/object_service/createObject', ['<@filekit.file>', dataHash]);
             case 3:
-              response = _context4.sent;
+              response = _context7.sent;
               record = response.data;
               if (dataHash) {
                 record.data = dataHash;
               }
-              return _context4.abrupt("return", new _rbt_file["default"](record, this.axios, this.localDb));
+              return _context7.abrupt("return", new _rbt_file["default"](record, this.axios, this.localDb));
             case 9:
-              _context4.prev = 9;
-              _context4.t0 = _context4["catch"](0);
-              return _context4.abrupt("return", this._handleError(_context4.t0));
+              _context7.prev = 9;
+              _context7.t0 = _context7["catch"](0);
+              return _context7.abrupt("return", this._handleError(_context7.t0));
             case 12:
             case "end":
-              return _context4.stop();
+              return _context7.stop();
           }
-        }, _callee4, this, [[0, 9]]);
+        }, _callee7, this, [[0, 9]]);
       }));
-      function createFile(_x2) {
+      function createFile(_x3) {
         return _createFile.apply(this, arguments);
       }
       return createFile;
     }()
+    /**
+     * Creates a new object of the given type.
+     *
+     * @param {string} type - The type of object to create.
+     * @param {Object} dataHash - The data for the new object.
+     * @returns {Promise<RbtObject>} - The newly created object as an RbtObject.
+     */
   }, {
     key: "create",
     value: function () {
-      var _create = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(type) {
+      var _create = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(type) {
         var dataHash,
           response,
           record,
-          _args5 = arguments;
-        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+          _args8 = arguments;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
             case 0:
-              dataHash = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : {};
-              _context5.prev = 1;
-              _context5.next = 4;
+              dataHash = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : {};
+              _context8.prev = 1;
+              _context8.next = 4;
               return this.axios.post('/object_service/createObject', [type, dataHash]);
             case 4:
-              response = _context5.sent;
+              response = _context8.sent;
               record = response.data;
               if (dataHash) {
                 record.data = dataHash;
               }
-              return _context5.abrupt("return", new _rbt_object["default"](record, this.axios));
+              return _context8.abrupt("return", new _rbt_object["default"](record, this.axios, {
+                isNew: true
+              }));
             case 10:
-              _context5.prev = 10;
-              _context5.t0 = _context5["catch"](1);
-              return _context5.abrupt("return", this._handleError(_context5.t0));
+              _context8.prev = 10;
+              _context8.t0 = _context8["catch"](1);
+              return _context8.abrupt("return", this._handleError(_context8.t0));
             case 13:
             case "end":
-              return _context5.stop();
+              return _context8.stop();
           }
-        }, _callee5, this, [[1, 10]]);
+        }, _callee8, this, [[1, 10]]);
       }));
-      function create(_x3) {
+      function create(_x4) {
         return _create.apply(this, arguments);
       }
       return create;
     }()
+    /**
+     * Queries objects of a given type based on specified parameters.
+     *
+     * @param {string} type - The type of object to query, specified as a doctree.typedef.
+     * @param {Object} params - The query parameters, including optional filters and configurations.
+     * @returns {Promise<Array<RbtObject>>} - An array of queried objects as RbtObjects.
+     *
+     * The `params` object can include the following properties:
+     * - where: A SQL-like where clause string for filtering the results.
+     * - orderBy: An object specifying the ordering of the results. It should include:
+     *    - column: The attribute name to sort by. This must be either a column in the @doctree.model schema or an indexed type attribute.
+     *    - direction: The sort direction, either 'ASC' for ascending or 'DESC' for descending.
+     * - limit: An object to control the pagination of results. It includes:
+     *    - offset: The starting point from where to fetch the results.
+     *    - results: The maximum number of results to return.
+     * - resolveReferences: An array of attribute names whose references should be resolved in the returned objects.
+     * - timeout: A numerical value in milliseconds to set a maximum time limit for the query execution.
+     *
+     * Example usage:
+     *   query("<@testuser>", {
+     *     where: 'email="tom@pospa.com"',
+     *     orderBy: { column: 'timeCreated', direction: 'DESC' },
+     *     limit: { offset: 0, results: 50 },
+     *     resolveReferences: ['translatableContent']
+     *   });
+     *
+     * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
+     */
   }, {
     key: "query",
     value: function () {
-      var _query = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(type) {
+      var _query = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(type) {
         var _this = this;
         var params,
           defaultOrderBy,
+          defaultLimit,
           mergedParams,
           response,
-          _args6 = arguments;
-        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+          _args9 = arguments;
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
             case 0:
-              params = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : {};
-              _context6.prev = 1;
+              params = _args9.length > 1 && _args9[1] !== undefined ? _args9[1] : {};
+              _context9.prev = 1;
               params.type = type;
 
-              // default 
+              // Default ordering and pagination
               defaultOrderBy = {
                 orderBy: {
                   column: 'timeCreated',
                   direction: 'DESC'
                 }
               };
-              mergedParams = _objectSpread(_objectSpread({}, defaultOrderBy), params);
-              _context6.next = 7;
+              defaultLimit = {
+                limit: {
+                  offset: 0,
+                  results: 50
+                }
+              }; // Merge defaults with provided params
+              mergedParams = _objectSpread(_objectSpread(_objectSpread({}, defaultOrderBy), defaultLimit), params);
+              _context9.next = 8;
               return this.axios.post('/object_service/queryObjects', [mergedParams]);
-            case 7:
-              response = _context6.sent;
+            case 8:
+              response = _context9.sent;
               if (!(response.data.ok === false)) {
-                _context6.next = 10;
+                _context9.next = 11;
                 break;
               }
-              return _context6.abrupt("return", this._handleError(response));
-            case 10:
+              return _context9.abrupt("return", this._handleError(response));
+            case 11:
               // Process items into RbtObject instances
               if (Array.isArray(response.data.items)) {
                 response.data.items = response.data.items.map(function (record) {
-                  return new _rbt_object["default"](record, _this.axios);
+                  return new _rbt_object["default"](record, _this.axios, {
+                    isNew: true
+                  });
                 });
               }
-              return _context6.abrupt("return", response.data.items);
-            case 14:
-              _context6.prev = 14;
-              _context6.t0 = _context6["catch"](1);
-              return _context6.abrupt("return", this._handleError(_context6.t0));
-            case 17:
+              return _context9.abrupt("return", response.data.items);
+            case 15:
+              _context9.prev = 15;
+              _context9.t0 = _context9["catch"](1);
+              return _context9.abrupt("return", this._handleError(_context9.t0));
+            case 18:
             case "end":
-              return _context6.stop();
+              return _context9.stop();
           }
-        }, _callee6, this, [[1, 14]]);
+        }, _callee9, this, [[1, 15]]);
       }));
-      function query(_x4) {
+      function query(_x5) {
         return _query.apply(this, arguments);
       }
       return query;
     }()
+    /**
+     * Loads one or multiple objects of a given type by their IDs.
+     *
+     * @param {string} type - The type of object to load.
+     * @param {Array<string>|string} ids - The ID(s) of the object(s) to load.
+     * 
+     * @returns {Promise<RbtObject|RbtObject[]>} - The loaded object(s) as RbtObject(s).
+     */
   }, {
     key: "load",
     value: function () {
-      var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(type, ids) {
-        var res;
-        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
+      var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(type, ids) {
+        var params,
+          mergedParams,
+          res,
+          _args10 = arguments;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
             case 0:
-              _context7.prev = 0;
-              debugger;
+              params = _args10.length > 2 && _args10[2] !== undefined ? _args10[2] : {};
+              _context10.prev = 1;
               if (!Array.isArray(ids)) {
-                _context7.next = 6;
+                _context10.next = 7;
                 break;
               }
-              return _context7.abrupt("return", this.query(type, {
+              mergedParams = _objectSpread(_objectSpread({}, params), {}, {
                 where: "id IN (" + ids.join(',') + ")"
-              }));
-            case 6:
-              _context7.next = 8;
-              return this.query(type, {
+              });
+              return _context10.abrupt("return", this.query(type, mergedParams));
+            case 7:
+              mergedParams = _objectSpread(_objectSpread({}, params), {}, {
                 where: "id=" + ids
               });
-            case 8:
-              res = _context7.sent;
-              return _context7.abrupt("return", res[0]);
+              _context10.next = 10;
+              return this.query(type, mergedParams);
             case 10:
-              _context7.next = 15;
-              break;
+              res = _context10.sent;
+              return _context10.abrupt("return", res[0]);
             case 12:
-              _context7.prev = 12;
-              _context7.t0 = _context7["catch"](0);
-              return _context7.abrupt("return", this._handleError(_context7.t0));
-            case 15:
+              _context10.next = 17;
+              break;
+            case 14:
+              _context10.prev = 14;
+              _context10.t0 = _context10["catch"](1);
+              return _context10.abrupt("return", this._handleError(_context10.t0));
+            case 17:
             case "end":
-              return _context7.stop();
+              return _context10.stop();
           }
-        }, _callee7, this, [[0, 12]]);
+        }, _callee10, this, [[1, 14]]);
       }));
-      function load(_x5, _x6) {
+      function load(_x6, _x7) {
         return _load.apply(this, arguments);
       }
       return load;
     }()
+    /**
+     * Makes a POST request to a specific endpoint to run a task and handle progress updates.
+     * 
+     * @param {Object} params - The parameters to be sent in the POST request.
+     * @param {Object} callbacks - An object containing callback functions for progress and error handling.
+     * 
+     * The function expects a response in the following format:
+     * {
+     *   ok: boolean, // Indicates if the request was successful or not
+     *   jobId: string, // The job identifier
+     *   status: string // Can be 'RUNNING', 'DONE', or 'ERROR'
+     * }
+     */
+  }, {
+    key: "runTask",
+    value: function () {
+      var _runTask = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
+        var params,
+          callbacks,
+          onProgress,
+          onError,
+          onFinish,
+          response,
+          ok,
+          jobId,
+          status,
+          message,
+          output,
+          _args11 = arguments;
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              params = _args11.length > 0 && _args11[0] !== undefined ? _args11[0] : {};
+              callbacks = _args11.length > 1 && _args11[1] !== undefined ? _args11[1] : {};
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onFinish = callbacks.onFinish;
+              _context11.prev = 3;
+              _context11.next = 6;
+              return this.post('http://localhost:3004/runChain', params);
+            case 6:
+              response = _context11.sent;
+              if (response) {
+                _context11.next = 9;
+                break;
+              }
+              throw new Error('Invalid server response');
+            case 9:
+              // Validate response structure
+              ok = response.ok, jobId = response.jobId, status = response.status, message = response.message, output = response.output;
+              if (!(!ok || typeof jobId !== 'string' || typeof status !== 'string')) {
+                _context11.next = 12;
+                break;
+              }
+              throw new Error('Invalid response structure');
+            case 12:
+              // If the task is still in progress, start polling for updates
+              if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED') {
+                this.pollTaskProgress(jobId, callbacks);
+              }
+              if (status === 'ERROR' && onError) {
+                // Provide the current progress to the callback function
+                onError(response);
+              }
+              if (status === 'DONE' && onFinish) {
+                // Provide the current progress to the callback function
+                console.log('Finish (request) ', response);
+                onFinish(response);
+              }
+              return _context11.abrupt("return", {
+                ok: ok,
+                jobId: jobId,
+                status: status,
+                message: message,
+                output: output
+              });
+            case 18:
+              _context11.prev = 18;
+              _context11.t0 = _context11["catch"](3);
+              if (typeof onError === 'function') {
+                onError(_context11.t0);
+              } else {
+                console.error('Error in runTask:', _context11.t0);
+              }
+              return _context11.abrupt("return", {
+                ok: false,
+                jobId: null,
+                status: 'ERROR',
+                error: _context11.t0.message
+              });
+            case 22:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this, [[3, 18]]);
+      }));
+      function runTask() {
+        return _runTask.apply(this, arguments);
+      }
+      return runTask;
+    }()
+    /**
+     * Polls the progress of a long-running task.
+     * 
+     * @param {string} jobId - The ID of the job to poll for progress.
+     * @param {function} onProgress - Callback function that receives progress updates.
+     * 
+     * The function periodically sends GET requests to check the task's progress
+     * and reports back via the provided callback function. The polling stops when
+     * the task is completed or an error occurs.
+     */
+  }, {
+    key: "pollTaskProgress",
+    value: function () {
+      var _pollTaskProgress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(jobId, callbacks) {
+        var _this2 = this;
+        var onProgress, onError, onFinish, checkProgress;
+        return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onFinish = callbacks.onFinish;
+              _context13.prev = 1;
+              checkProgress = /*#__PURE__*/function () {
+                var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
+                  var response;
+                  return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+                    while (1) switch (_context12.prev = _context12.next) {
+                      case 0:
+                        _context12.next = 2;
+                        return _this2.get("http://localhost:3004/pollChainProgress", {
+                          jobId: jobId
+                        });
+                      case 2:
+                        response = _context12.sent;
+                        // If the task is still in progress, start polling for updates
+                        if (response.status === 'DONE' && onFinish) {
+                          // Provide the current progress to the callback function
+                          console.log('Finish (progress) ', response);
+                          onFinish(response);
+                        }
+                        if (response.status === 'ERROR' && onError) {
+                          // Provide the current progress to the callback function
+                          onError(response);
+                        }
+
+                        // Provide the current progress to the callback function
+                        if (response.status == 'RUNNING') {
+                          onProgress(response);
+                        }
+
+                        // Continue polling if the status is 'RUNNING'
+                        if (['RUNNING'].includes(response.status)) {
+                          setTimeout(checkProgress, 1000); // Poll every 2 seconds
+                        }
+                      case 7:
+                      case "end":
+                        return _context12.stop();
+                    }
+                  }, _callee12);
+                }));
+                return function checkProgress() {
+                  return _ref2.apply(this, arguments);
+                };
+              }();
+              checkProgress();
+              _context13.next = 9;
+              break;
+            case 6:
+              _context13.prev = 6;
+              _context13.t0 = _context13["catch"](1);
+              return _context13.abrupt("return", this._handleError(_context13.t0));
+            case 9:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this, [[1, 6]]);
+      }));
+      function pollTaskProgress(_x8, _x9) {
+        return _pollTaskProgress.apply(this, arguments);
+      }
+      return pollTaskProgress;
+    }()
     /**
      * Performs a GET request to the specified endpoint.
      * 
@@ -340,45 +717,45 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
   }, {
     key: "get",
     value: function () {
-      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(endpoint) {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14(endpoint) {
         var params,
           headers,
           response,
-          _args8 = arguments;
-        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
+          _args14 = arguments;
+        return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
             case 0:
-              params = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : {};
-              _context8.prev = 1;
+              params = _args14.length > 1 && _args14[1] !== undefined ? _args14[1] : {};
+              _context14.prev = 1;
               // Add the authToken to the headers
               headers = {
                 authtoken: this.authtoken
               }; // Make the GET request using Axios
-              _context8.next = 5;
+              _context14.next = 5;
               return this.axios.get(endpoint, {
                 params: params,
                 headers: headers
               });
             case 5:
-              response = _context8.sent;
+              response = _context14.sent;
               if (!(response.data.ok === false)) {
-                _context8.next = 8;
+                _context14.next = 8;
                 break;
               }
-              return _context8.abrupt("return", this._handleError(response));
+              return _context14.abrupt("return", this._handleError(response));
             case 8:
-              return _context8.abrupt("return", response.data);
+              return _context14.abrupt("return", response.data);
             case 11:
-              _context8.prev = 11;
-              _context8.t0 = _context8["catch"](1);
-              return _context8.abrupt("return", this._handleError(_context8.t0));
+              _context14.prev = 11;
+              _context14.t0 = _context14["catch"](1);
+              return _context14.abrupt("return", this._handleError(_context14.t0));
             case 14:
             case "end":
-              return _context8.stop();
+              return _context14.stop();
           }
-        }, _callee8, this, [[1, 11]]);
+        }, _callee14, this, [[1, 11]]);
       }));
-      function get(_x7) {
+      function get(_x10) {
         return _get.apply(this, arguments);
       }
       return get;
@@ -398,59 +775,71 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
   }, {
     key: "post",
     value: function () {
-      var _post = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(endpoint) {
+      var _post = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(endpoint) {
         var data,
           headers,
           response,
-          _args9 = arguments;
-        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
+          _args15 = arguments;
+        return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
             case 0:
-              data = _args9.length > 1 && _args9[1] !== undefined ? _args9[1] : {};
-              _context9.prev = 1;
+              data = _args15.length > 1 && _args15[1] !== undefined ? _args15[1] : {};
+              _context15.prev = 1;
               // Add the authToken to the headers
               headers = {
                 authtoken: this.authtoken
               }; // Make the POST request using Axios
-              _context9.next = 5;
+              _context15.next = 5;
               return this.axios.post(endpoint, data, {
                 headers: headers
               });
             case 5:
-              response = _context9.sent;
+              response = _context15.sent;
               if (!(response.data.ok === false)) {
-                _context9.next = 8;
+                _context15.next = 8;
                 break;
               }
-              return _context9.abrupt("return", this._handleError(response));
+              return _context15.abrupt("return", this._handleError(response));
             case 8:
-              return _context9.abrupt("return", response.data);
+              return _context15.abrupt("return", response.data);
             case 11:
-              _context9.prev = 11;
-              _context9.t0 = _context9["catch"](1);
-              return _context9.abrupt("return", this._handleError(_context9.t0));
+              _context15.prev = 11;
+              _context15.t0 = _context15["catch"](1);
+              return _context15.abrupt("return", this._handleError(_context15.t0));
             case 14:
             case "end":
-              return _context9.stop();
+              return _context15.stop();
           }
-        }, _callee9, this, [[1, 11]]);
+        }, _callee15, this, [[1, 11]]);
       }));
-      function post(_x8) {
+      function post(_x11) {
         return _post.apply(this, arguments);
       }
       return post;
     }()
+  }, {
+    key: "setErrorHandler",
+    value: function setErrorHandler(customErrorHandler) {
+      this.customErrorHandler = customErrorHandler;
+    }
   }, {
     key: "_handleError",
     value: function _handleError(err) {
-      if (_lodash["default"].isObject(err)) {
-        // response object?
-        var msg = _lodash["default"].get(err, 'response.data.message');
-        msg = msg ? msg : err;
-        throw new Error(msg);
+      debugger;
+      // Invoke the custom error handler if provided
+      if (this.customErrorHandler) {
+        var res = this.customErrorHandler(err);
+        if (res) return;
+      }
+      if (_lodash["default"].isObject(err) && _lodash["default"].get(err, 'response')) {
+        var msg = _lodash["default"].get(err, 'response.data.message', 'Error in API response');
+        if (msg.key) {
+          throw new Error(msg.key);
+        } else {
+          throw new Error(msg);
+        }
       } else {
-        // all other errors
-        throw new Error(err);
+        throw new Error(err.message || 'Unknown error');
       }
     }
   }]);