roboto-js 1.4.21 → 1.4.23

package/dist/cjs/rbt_api.cjs

@@ -483,22 +483,29 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
         return _regeneratorRuntime().wrap(function _callee11$(_context11) {
           while (1) switch (_context11.prev = _context11.next) {
             case 0:
-              _context11.prev = 0;
-              _context11.next = 3;
-              return this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+              if (this.appServiceHost) {
+                _context11.next = 3;
+                break;
+              }
+              console.warn('appServiceHost not initialized');
+              return _context11.abrupt("return", false);
             case 3:
+              _context11.prev = 3;
+              _context11.next = 6;
+              return this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+            case 6:
               response = _context11.sent;
               debugger;
               return _context11.abrupt("return", response.data);
-            case 8:
-              _context11.prev = 8;
-              _context11.t0 = _context11["catch"](0);
-              this._handleError(_context11.t0);
             case 11:
+              _context11.prev = 11;
+              _context11.t0 = _context11["catch"](3);
+              this._handleError(_context11.t0);
+            case 14:
             case "end":
               return _context11.stop();
           }
-        }, _callee11, this, [[0, 8]]);
+        }, _callee11, this, [[3, 11]]);
       }));
       function refreshAuthToken(_x7) {
         return _refreshAuthToken.apply(this, arguments);
@@ -824,7 +831,12 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
     }()
     /**
      * Makes a POST request to a specific endpoint to run a task and handle progress updates.
-     * 
+     *
+     * @param params.id (optional) IF the client is MONITORING the job with WS ClientMonitor, 
+     *                             the client should generate a jobId and connect to the ClientMonitor
+     *                             BEFORE starting the job, to make sure no messages are missed - 
+     *                             otherwise we'd have to delay the task start.
+     *                             
      * @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.
      * 
@@ -844,7 +856,8 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
           callbacks,
           onProgress,
           onError,
-          onFinish,
+          onStopped,
+          onDone,
           response,
           ok,
           jobId,
@@ -857,7 +870,7 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
             case 0:
               params = _args18.length > 0 && _args18[0] !== undefined ? _args18[0] : {};
               callbacks = _args18.length > 1 && _args18[1] !== undefined ? _args18[1] : {};
-              onProgress = callbacks.onProgress, onError = callbacks.onError, onFinish = callbacks.onFinish;
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onStopped = callbacks.onStopped, onDone = callbacks.onDone;
               _context18.prev = 3;
               _context18.next = 6;
               return this.post('/task_service/runChain', params);
@@ -878,17 +891,21 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
               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') {
+              if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED' || status === 'STOPPING') {
                 this.pollTaskProgress(jobId, callbacks);
               }
               if (status === 'ERROR' && onError) {
                 // Provide the current progress to the callback function
                 onError(response);
               }
-              if (status === 'DONE' && onFinish) {
+              if (status === 'STOPPED' && onError) {
+                // Provide the current progress to the callback function
+                onStopped(response);
+              }
+              if (status === 'DONE' && onDone) {
                 // Provide the current progress to the callback function
                 console.log('Finish (request) ', response);
-                onFinish(response);
+                onDone(response);
               }
               return _context18.abrupt("return", {
                 ok: ok,
@@ -897,8 +914,8 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
                 message: message,
                 output: output
               });
-            case 18:
-              _context18.prev = 18;
+            case 19:
+              _context18.prev = 19;
               _context18.t0 = _context18["catch"](3);
               if (typeof onError === 'function') {
                 onError(_context18.t0);
@@ -911,16 +928,56 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
                 status: 'ERROR',
                 error: _context18.t0.message
               });
-            case 22:
+            case 23:
             case "end":
               return _context18.stop();
           }
-        }, _callee18, this, [[3, 18]]);
+        }, _callee18, this, [[3, 19]]);
       }));
       function runTask() {
         return _runTask.apply(this, arguments);
       }
       return runTask;
+    }())
+  }, {
+    key: "stopJob",
+    value: function () {
+      var _stopJob = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
+        var params,
+          callbacks,
+          response,
+          _args19 = arguments;
+        return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              params = _args19.length > 0 && _args19[0] !== undefined ? _args19[0] : {};
+              callbacks = _args19.length > 1 && _args19[1] !== undefined ? _args19[1] : {};
+              _context19.prev = 2;
+              _context19.next = 5;
+              return this.post('/task_service/stopJob', params);
+            case 5:
+              response = _context19.sent;
+              if (response) {
+                _context19.next = 8;
+                break;
+              }
+              throw new Error('Invalid server response');
+            case 8:
+              return _context19.abrupt("return", true);
+            case 11:
+              _context19.prev = 11;
+              _context19.t0 = _context19["catch"](2);
+              throw 'Error in stopJob';
+            case 14:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this, [[2, 11]]);
+      }));
+      function stopJob() {
+        return _stopJob.apply(this, arguments);
+      }
+      return stopJob;
     }()
     /**
      * Polls the progress of a long-running task.
@@ -932,35 +989,34 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
      * 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 _callee20(jobId, callbacks) {
+      var _pollTaskProgress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(jobId, callbacks) {
         var _this2 = this;
-        var onProgress, onError, onFinish, checkProgress;
-        return _regeneratorRuntime().wrap(function _callee20$(_context20) {
-          while (1) switch (_context20.prev = _context20.next) {
+        var onProgress, onError, onDone, checkProgress;
+        return _regeneratorRuntime().wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
             case 0:
-              onProgress = callbacks.onProgress, onError = callbacks.onError, onFinish = callbacks.onFinish;
-              _context20.prev = 1;
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onDone = callbacks.onDone;
+              _context21.prev = 1;
               checkProgress = /*#__PURE__*/function () {
-                var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
+                var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20() {
                   var response;
-                  return _regeneratorRuntime().wrap(function _callee19$(_context19) {
-                    while (1) switch (_context19.prev = _context19.next) {
+                  return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+                    while (1) switch (_context20.prev = _context20.next) {
                       case 0:
-                        _context19.next = 2;
+                        _context20.next = 2;
                         return _this2.get("/task_service/pollChainProgress", {
                           jobId: jobId
                         });
                       case 2:
-                        response = _context19.sent;
+                        response = _context20.sent;
                         // If the task is still in progress, start polling for updates
-                        if (response.status === 'DONE' && onFinish) {
+                        if (response.status === 'DONE' && onDone) {
                           // Provide the current progress to the callback function
                           console.log('Finish (progress) ', response);
-                          onFinish(response);
+                          onDone(response);
                         }
                         if (response.status === 'ERROR' && onError) {
                           // Provide the current progress to the callback function
@@ -978,26 +1034,26 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
                         }
                       case 7:
                       case "end":
-                        return _context19.stop();
+                        return _context20.stop();
                     }
-                  }, _callee19);
+                  }, _callee20);
                 }));
                 return function checkProgress() {
                   return _ref2.apply(this, arguments);
                 };
               }();
               checkProgress();
-              _context20.next = 9;
+              _context21.next = 9;
               break;
             case 6:
-              _context20.prev = 6;
-              _context20.t0 = _context20["catch"](1);
-              return _context20.abrupt("return", this._handleError(_context20.t0));
+              _context21.prev = 6;
+              _context21.t0 = _context21["catch"](1);
+              return _context21.abrupt("return", this._handleError(_context21.t0));
             case 9:
             case "end":
-              return _context20.stop();
+              return _context21.stop();
           }
-        }, _callee20, this, [[1, 6]]);
+        }, _callee21, this, [[1, 6]]);
       }));
       function pollTaskProgress(_x14, _x15) {
         return _pollTaskProgress.apply(this, arguments);
@@ -1019,44 +1075,44 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
   }, {
     key: "get",
     value: (function () {
-      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(endpoint) {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(endpoint) {
         var params,
           headers,
           response,
-          _args21 = arguments;
-        return _regeneratorRuntime().wrap(function _callee21$(_context21) {
-          while (1) switch (_context21.prev = _context21.next) {
+          _args22 = arguments;
+        return _regeneratorRuntime().wrap(function _callee22$(_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
             case 0:
-              params = _args21.length > 1 && _args21[1] !== undefined ? _args21[1] : {};
+              params = _args22.length > 1 && _args22[1] !== undefined ? _args22[1] : {};
               debugger;
-              _context21.prev = 2;
+              _context22.prev = 2;
               // Add the authToken to the headers
               headers = {
                 authtoken: this.authtoken
               }; // Make the GET request using Axios
-              _context21.next = 6;
+              _context22.next = 6;
               return this.axios.get(endpoint, {
                 params: params,
                 headers: headers
               });
             case 6:
-              response = _context21.sent;
+              response = _context22.sent;
               if (!(response.data.ok === false)) {
-                _context21.next = 9;
+                _context22.next = 9;
                 break;
               }
-              return _context21.abrupt("return", this._handleError(response));
+              return _context22.abrupt("return", this._handleError(response));
             case 9:
-              return _context21.abrupt("return", response.data);
+              return _context22.abrupt("return", response.data);
             case 12:
-              _context21.prev = 12;
-              _context21.t0 = _context21["catch"](2);
-              return _context21.abrupt("return", this._handleError(_context21.t0));
+              _context22.prev = 12;
+              _context22.t0 = _context22["catch"](2);
+              return _context22.abrupt("return", this._handleError(_context22.t0));
             case 15:
             case "end":
-              return _context21.stop();
+              return _context22.stop();
           }
-        }, _callee21, this, [[2, 12]]);
+        }, _callee22, this, [[2, 12]]);
       }));
       function get(_x16) {
         return _get.apply(this, arguments);
@@ -1079,42 +1135,42 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
   }, {
     key: "post",
     value: (function () {
-      var _post = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(endpoint) {
+      var _post = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee23(endpoint) {
         var data,
           headers,
           response,
-          _args22 = arguments;
-        return _regeneratorRuntime().wrap(function _callee22$(_context22) {
-          while (1) switch (_context22.prev = _context22.next) {
+          _args23 = arguments;
+        return _regeneratorRuntime().wrap(function _callee23$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
             case 0:
-              data = _args22.length > 1 && _args22[1] !== undefined ? _args22[1] : {};
-              _context22.prev = 1;
+              data = _args23.length > 1 && _args23[1] !== undefined ? _args23[1] : {};
+              _context23.prev = 1;
               // Add the authToken to the headers
               headers = {
                 authtoken: this.authtoken
               }; // Make the POST request using Axios
-              _context22.next = 5;
+              _context23.next = 5;
               return this.axios.post(endpoint, data, {
                 headers: headers
               });
             case 5:
-              response = _context22.sent;
+              response = _context23.sent;
               if (!(response.data.ok === false)) {
-                _context22.next = 8;
+                _context23.next = 8;
                 break;
               }
-              return _context22.abrupt("return", this._handleError(response));
+              return _context23.abrupt("return", this._handleError(response));
             case 8:
-              return _context22.abrupt("return", response.data);
+              return _context23.abrupt("return", response.data);
             case 11:
-              _context22.prev = 11;
-              _context22.t0 = _context22["catch"](1);
-              return _context22.abrupt("return", this._handleError(_context22.t0));
+              _context23.prev = 11;
+              _context23.t0 = _context23["catch"](1);
+              return _context23.abrupt("return", this._handleError(_context23.t0));
             case 14:
             case "end":
-              return _context22.stop();
+              return _context23.stop();
           }
-        }, _callee22, this, [[1, 11]]);
+        }, _callee23, this, [[1, 11]]);
       }));
       function post(_x17) {
         return _post.apply(this, arguments);

package/dist/esm/rbt_api.js

@@ -215,6 +215,10 @@ export default class RbtApi {
     }
   }
   async refreshAuthToken(authtoken) {
+    if (!this.appServiceHost) {
+      console.warn('appServiceHost not initialized');
+      return false;
+    }
     try {
       const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
       debugger;
@@ -399,7 +403,12 @@ export default class RbtApi {
 
   /**
    * Makes a POST request to a specific endpoint to run a task and handle progress updates.
-   * 
+   *
+   * @param params.id (optional) IF the client is MONITORING the job with WS ClientMonitor, 
+   *                             the client should generate a jobId and connect to the ClientMonitor
+   *                             BEFORE starting the job, to make sure no messages are missed - 
+   *                             otherwise we'd have to delay the task start.
+   *                             
    * @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.
    * 
@@ -414,7 +423,8 @@ export default class RbtApi {
     const {
       onProgress,
       onError,
-      onFinish
+      onStopped,
+      onDone
     } = callbacks;
     try {
       const response = await this.post('/task_service/runChain', params);
@@ -436,17 +446,21 @@ export default class RbtApi {
       }
 
       // If the task is still in progress, start polling for updates
-      if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED') {
+      if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED' || status === 'STOPPING') {
         this.pollTaskProgress(jobId, callbacks);
       }
       if (status === 'ERROR' && onError) {
         // Provide the current progress to the callback function
         onError(response);
       }
-      if (status === 'DONE' && onFinish) {
+      if (status === 'STOPPED' && onError) {
+        // Provide the current progress to the callback function
+        onStopped(response);
+      }
+      if (status === 'DONE' && onDone) {
         // Provide the current progress to the callback function
         console.log('Finish (request) ', response);
-        onFinish(response);
+        onDone(response);
       }
       return {
         ok,
@@ -469,6 +483,18 @@ export default class RbtApi {
       };
     }
   }
+  async stopJob(params = {}, callbacks = {}) {
+    try {
+      const response = await this.post('/task_service/stopJob', params);
+      // Check if response and response.data are defined
+      if (!response) {
+        throw new Error('Invalid server response');
+      }
+      return true;
+    } catch (e) {
+      throw 'Error in stopJob';
+    }
+  }
 
   /**
    * Polls the progress of a long-running task.
@@ -484,7 +510,7 @@ export default class RbtApi {
     const {
       onProgress,
       onError,
-      onFinish
+      onDone
     } = callbacks;
     try {
       const checkProgress = async () => {
@@ -493,10 +519,10 @@ export default class RbtApi {
         });
 
         // If the task is still in progress, start polling for updates
-        if (response.status === 'DONE' && onFinish) {
+        if (response.status === 'DONE' && onDone) {
           // Provide the current progress to the callback function
           console.log('Finish (progress) ', response);
-          onFinish(response);
+          onDone(response);
         }
         if (response.status === 'ERROR' && onError) {
           // Provide the current progress to the callback function

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roboto-js",
-  "version": "1.4.21",
+  "version": "1.4.23",
   "type": "module",
   "description": "",
   "main": "dist/cjs/index.cjs",

package/src/rbt_api.js

@@ -275,6 +275,11 @@ export default class RbtApi {
 
   async refreshAuthToken(authtoken){
 
+    if(!this.appServiceHost){
+      console.warn('appServiceHost not initialized');
+      return false;
+    }
+
     try {
 
       const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
@@ -456,7 +461,12 @@ export default class RbtApi {
 
   /**
    * Makes a POST request to a specific endpoint to run a task and handle progress updates.
-   * 
+   *
+   * @param params.id (optional) IF the client is MONITORING the job with WS ClientMonitor, 
+   *                             the client should generate a jobId and connect to the ClientMonitor
+   *                             BEFORE starting the job, to make sure no messages are missed - 
+   *                             otherwise we'd have to delay the task start.
+   *                             
    * @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.
    * 
@@ -468,7 +478,7 @@ export default class RbtApi {
    * }
    */
   async runTask(params = {}, callbacks = {}) {
-    const { onProgress, onError, onFinish } = callbacks;
+    const { onProgress, onError, onStopped, onDone } = callbacks;
 
     try {
       const response = await this.post('/task_service/runChain', params);
@@ -484,17 +494,21 @@ export default class RbtApi {
       }
 
       // If the task is still in progress, start polling for updates
-      if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED') {
+      if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED' || status === 'STOPPING') {
         this.pollTaskProgress(jobId, callbacks);
       }
       if (status === 'ERROR' && onError){
         // Provide the current progress to the callback function
         onError(response);
       }
-      if (status === 'DONE' && onFinish){
+      if (status === 'STOPPED' && onError){
+        // Provide the current progress to the callback function
+        onStopped(response);
+      }
+      if (status === 'DONE' && onDone){
         // Provide the current progress to the callback function
-          console.log('Finish (request) ',response);
-        onFinish(response);
+        console.log('Finish (request) ',response);
+        onDone(response);
       }
 
       return { ok, jobId, status, message, output };
@@ -511,6 +525,23 @@ export default class RbtApi {
     }
   }
 
+  async stopJob(params = {}, callbacks = {}) {
+
+    try {
+      const response = await this.post('/task_service/stopJob', params);
+      // Check if response and response.data are defined
+      if (!response) {
+        throw new Error('Invalid server response');
+      }
+      return true;
+
+    } catch (e) {
+
+      throw 'Error in stopJob';
+
+    }
+  }
+
 
   /**
    * Polls the progress of a long-running task.
@@ -523,16 +554,16 @@ export default class RbtApi {
    * the task is completed or an error occurs.
    */
    async pollTaskProgress(jobId, callbacks) {
-    const { onProgress, onError, onFinish } = callbacks;
+    const { onProgress, onError, onDone } = callbacks;
     try {
       const checkProgress = async () => {
         const response = await this.get(`/task_service/pollChainProgress`, { jobId: jobId });
 
         // If the task is still in progress, start polling for updates
-        if (response.status === 'DONE' && onFinish){
+        if (response.status === 'DONE' && onDone){
           // Provide the current progress to the callback function
           console.log('Finish (progress) ',response);
-          onFinish(response);
+          onDone(response);
         }
         if (response.status === 'ERROR' && onError){
           // Provide the current progress to the callback function