roboto-js 1.4.37 → 1.4.39

package/dist/cjs/rbt_api.cjs

@@ -480,7 +480,7 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
     key: "refreshAuthToken",
     value: function () {
       var _refreshAuthToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(authtoken) {
-        var response;
+        var promise, response;
         return _regeneratorRuntime().wrap(function _callee11$(_context11) {
           while (1) switch (_context11.prev = _context11.next) {
             case 0:
@@ -488,31 +488,67 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
                 _context11.next = 3;
                 break;
               }
-              console.warn('appServiceHost not initialized');
+              console.warn('RBTTOK not initialized');
               return _context11.abrupt("return", false);
             case 3:
-              _context11.prev = 3;
-              _context11.next = 6;
-              return this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+              if (!this.requestCache[authtoken]) {
+                _context11.next = 6;
+                break;
+              }
+              // If there's already a pending promise to refresh this token, return it
+              console.log('RBTTOK Using cached promise for token refresh');
+              return _context11.abrupt("return", this.requestCache[authtoken]);
             case 6:
+              _context11.prev = 6;
+              console.log('RBTTOK Req', authtoken);
+              // Create a new promise for the token refresh and store it in the cache
+              promise = this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+              this.requestCache[authtoken] = promise;
+
+              // Await the promise to get the response
+              _context11.next = 12;
+              return promise;
+            case 12:
               response = _context11.sent;
-              debugger;
+              console.log('RBTTOK Response ', response);
+              // Once the promise resolves, delete it from the cache to allow future refreshes
+              delete this.requestCache[authtoken];
+
+              // Return the response data
               return _context11.abrupt("return", response.data);
-            case 11:
-              _context11.prev = 11;
-              _context11.t0 = _context11["catch"](3);
+            case 18:
+              _context11.prev = 18;
+              _context11.t0 = _context11["catch"](6);
+              // On error, remove the cached promise to allow retries
+              delete this.requestCache[authtoken];
               this._handleError(_context11.t0);
-            case 14:
+            case 22:
             case "end":
               return _context11.stop();
           }
-        }, _callee11, this, [[3, 11]]);
+        }, _callee11, this, [[6, 18]]);
       }));
       function refreshAuthToken(_x7) {
         return _refreshAuthToken.apply(this, arguments);
       }
       return refreshAuthToken;
-    }()
+    }() //  async refreshAuthToken(authtoken){
+    //
+    //    if(!this.appServiceHost){
+    //      console.warn('appServiceHost not initialized');
+    //      return false;
+    //    }
+    //
+    //    try {
+    //
+    //      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+    //      return response.data;
+    //
+    //    } catch (e) {
+    //
+    //      this._handleError(e);
+    //    }
+    //  }
     /**
      * Registers a new user.
      *
@@ -522,7 +558,7 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "registerUser",
-    value: (function () {
+    value: function () {
       var _registerUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
         var dataHash,
           response,
@@ -542,9 +578,8 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
             case 9:
               _context12.prev = 9;
               _context12.t0 = _context12["catch"](1);
-              debugger;
               return _context12.abrupt("return", this._handleError(_context12.t0));
-            case 13:
+            case 12:
             case "end":
               return _context12.stop();
           }
@@ -562,7 +597,6 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
      * @returns {Promise<RbtFile>} - The newly created file as an RbtFile.
      * 
      */
-    )
   }, {
     key: "createFile",
     value: (function () {
@@ -706,6 +740,48 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
      *
      * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
      */
+    //  async query(type, params = {}) {
+    //    try {
+    //      console.log('RBTAPI.query INIT', type, params);
+    //      params.type = type;
+    //      // Default ordering and pagination
+    //      const defaultOrderBy = { orderBy: { column: 'timeCreated', direction: 'DESC' } };
+    //      const defaultLimit = { limit: { offset: 0, results: 50 } };
+    //      
+    //      // Merge defaults with provided params
+    //      const mergedParams = { ...defaultOrderBy, ...defaultLimit, ...params };
+    //      // Check cache for an existing request
+    //      const currentTime = Date.now();
+    //      const paramsKey = JSON.stringify(mergedParams);
+    //      const cacheEntry = this.requestCache[paramsKey];
+    //      if (cacheEntry && (currentTime - cacheEntry.time) < 10000) {  // 10000 ms = 10 seconds
+    //        console.log('RBTAPI.query CACHED', type, paramsKey);
+    //        return cacheEntry.val;
+    //      }
+    //      // Create the response promise and store it in the cache
+    //      const responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]);
+    //      // Store the promise along with the current time in the cache
+    //      this.requestCache[paramsKey] = { val: responsePromise, time: currentTime };
+    //      // Await the response from the API
+    //      const response = await responsePromise;
+    //      if (response.data.ok === false) {
+    //        return this._handleError(response);
+    //      }
+    //      // Process items into RbtObject instances
+    //      if (Array.isArray(response.data.items)) {
+    //        response.data.items = response.data.items.map(record => {
+    //          return new RbtObject(record, this.axios, { isNew: true });
+    //        });
+    //      }
+    //      console.log('RBTAPI.query RESPONSE', type, paramsKey, response.data.items);
+    //      return response.data.items;
+    //    } catch (e) {
+    //      delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+    //      console.log('RBTAPI.query ERROR', paramsKey, e);
+    //      return this._handleError(e);
+    //    
+    //    }
+    //  }
     )
   }, {
     key: "query",
@@ -717,15 +793,17 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
           defaultLimit,
           mergedParams,
           currentTime,
+          _paramsKey,
           cacheEntry,
           responsePromise,
-          response,
+          processingPromise,
           _args16 = arguments;
         return _regeneratorRuntime().wrap(function _callee16$(_context16) {
           while (1) switch (_context16.prev = _context16.next) {
             case 0:
               params = _args16.length > 1 && _args16[1] !== undefined ? _args16[1] : {};
               _context16.prev = 1;
+              //console.log('RBTAPI.query INIT', type, params);
               params.type = type;
 
               // Default ordering and pagination
@@ -743,58 +821,70 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
               }; // Merge defaults with provided params
               mergedParams = _objectSpread(_objectSpread(_objectSpread({}, defaultOrderBy), defaultLimit), params); // Check cache for an existing request
               currentTime = Date.now();
-              cacheEntry = this.requestCache[paramsKey];
+              _paramsKey = JSON.stringify(mergedParams);
+              cacheEntry = this.requestCache[_paramsKey];
               if (!(cacheEntry && currentTime - cacheEntry.time < 10000)) {
                 _context16.next = 11;
                 break;
               }
-              // 10000 ms = 10 seconds
-              console.log("Using cached request for params:", paramsKey);
               return _context16.abrupt("return", cacheEntry.val);
             case 11:
-              // Create the response promise and store it in the cache
-              responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]); // Store the promise along with the current time in the cache
-              this.requestCache[paramsKey] = {
-                val: responsePromise,
+              // Create the response promise
+              responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]); // Cache the promise of processing data, not just the raw response
+              processingPromise = responsePromise.then(function (response) {
+                return _this._processResponseData(response);
+              })["catch"](function (e) {
+                delete _this.requestCache[_paramsKey]; // Ensure cache cleanup on failure
+                //console.log('RBTAPI.query ERROR (Processing)', paramsKey, e);
+                return _this._handleError(e);
+              }); // Store the promise of the processed data in the cache
+              this.requestCache[_paramsKey] = {
+                val: processingPromise,
                 time: currentTime
               };
 
-              // Await the response from the API
-              _context16.next = 15;
-              return responsePromise;
-            case 15:
-              response = _context16.sent;
-              if (!(response.data.ok === false)) {
-                _context16.next = 18;
-                break;
-              }
-              return _context16.abrupt("return", this._handleError(response));
-            case 18:
-              // 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, {
-                    isNew: true
-                  });
-                });
-              }
-              return _context16.abrupt("return", response.data.items);
-            case 22:
-              _context16.prev = 22;
+              // Await the processing promise for this call to get processed data
+              _context16.next = 16;
+              return processingPromise;
+            case 16:
+              return _context16.abrupt("return", _context16.sent);
+            case 19:
+              _context16.prev = 19;
               _context16.t0 = _context16["catch"](1);
               delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+              //console.log('RBTAPI.query ERROR', paramsKey, e);
               return _context16.abrupt("return", this._handleError(_context16.t0));
-            case 26:
+            case 23:
             case "end":
               return _context16.stop();
           }
-        }, _callee16, this, [[1, 22]]);
+        }, _callee16, this, [[1, 19]]);
       }));
       function query(_x11) {
         return _query.apply(this, arguments);
       }
       return query;
-    }()
+    }())
+  }, {
+    key: "_processResponseData",
+    value: function _processResponseData(response) {
+      var _this2 = this;
+      if (response.data.ok === false) {
+        return this._handleError(response);
+      }
+      if (Array.isArray(response.data.items)) {
+        //console.log('RBTAPI.query RESPONSE PRE', response.data.items);
+        response.data.items = response.data.items.map(function (record) {
+          return new _rbt_object["default"](record, _this2.axios, {
+            isNew: true
+          });
+        });
+      }
+
+      //console.log('RBTAPI.query RESPONSE POST', response.data.items);
+      return response.data.items;
+    }
+
     /**
      * Loads one or multiple objects of a given type by their IDs.
      *
@@ -803,7 +893,6 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
      * 
      * @returns {Promise<RbtObject|RbtObject[]>} - The loaded object(s) as RbtObject(s).
      */
-    )
   }, {
     key: "load",
     value: (function () {
@@ -1016,7 +1105,7 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
     key: "pollTaskProgress",
     value: (function () {
       var _pollTaskProgress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(jobId, callbacks) {
-        var _this2 = this;
+        var _this3 = this;
         var onProgress, onError, onStopped, onDone, checkProgress;
         return _regeneratorRuntime().wrap(function _callee21$(_context21) {
           while (1) switch (_context21.prev = _context21.next) {
@@ -1030,7 +1119,7 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
                     while (1) switch (_context20.prev = _context20.next) {
                       case 0:
                         _context20.next = 2;
-                        return _this2.get("/task_service/pollChainProgress", {
+                        return _this3.get("/task_service/pollChainProgress", {
                           jobId: jobId
                         });
                       case 2:
@@ -1111,35 +1200,34 @@ var RbtApi = exports["default"] = /*#__PURE__*/function () {
           while (1) switch (_context22.prev = _context22.next) {
             case 0:
               params = _args22.length > 1 && _args22[1] !== undefined ? _args22[1] : {};
-              debugger;
-              _context22.prev = 2;
+              _context22.prev = 1;
               // Add the authToken to the headers
               headers = {
                 authtoken: this.authtoken
               }; // Make the GET request using Axios
-              _context22.next = 6;
+              _context22.next = 5;
               return this.axios.get(endpoint, {
                 params: params,
                 headers: headers
               });
-            case 6:
+            case 5:
               response = _context22.sent;
               if (!(response.data.ok === false)) {
-                _context22.next = 9;
+                _context22.next = 8;
                 break;
               }
               return _context22.abrupt("return", this._handleError(response));
-            case 9:
+            case 8:
               return _context22.abrupt("return", response.data);
-            case 12:
-              _context22.prev = 12;
-              _context22.t0 = _context22["catch"](2);
+            case 11:
+              _context22.prev = 11;
+              _context22.t0 = _context22["catch"](1);
               return _context22.abrupt("return", this._handleError(_context22.t0));
-            case 15:
+            case 14:
             case "end":
               return _context22.stop();
           }
-        }, _callee22, this, [[2, 12]]);
+        }, _callee22, this, [[1, 11]]);
       }));
       function get(_x16) {
         return _get.apply(this, arguments);

package/dist/esm/rbt_api.js

@@ -217,18 +217,53 @@ export default class RbtApi {
   }
   async refreshAuthToken(authtoken) {
     if (!this.appServiceHost) {
-      console.warn('appServiceHost not initialized');
+      console.warn('RBTTOK not initialized');
       return false;
     }
+    if (this.requestCache[authtoken]) {
+      // If there's already a pending promise to refresh this token, return it
+      console.log('RBTTOK Using cached promise for token refresh');
+      return this.requestCache[authtoken];
+    }
     try {
-      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
-      debugger;
+      console.log('RBTTOK Req', authtoken);
+      // Create a new promise for the token refresh and store it in the cache
+      const promise = this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+      this.requestCache[authtoken] = promise;
+
+      // Await the promise to get the response
+      const response = await promise;
+      console.log('RBTTOK Response ', response);
+      // Once the promise resolves, delete it from the cache to allow future refreshes
+      delete this.requestCache[authtoken];
+
+      // Return the response data
       return response.data;
     } catch (e) {
+      // On error, remove the cached promise to allow retries
+      delete this.requestCache[authtoken];
       this._handleError(e);
     }
   }
 
+  //  async refreshAuthToken(authtoken){
+  //
+  //    if(!this.appServiceHost){
+  //      console.warn('appServiceHost not initialized');
+  //      return false;
+  //    }
+  //
+  //    try {
+  //
+  //      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+  //      return response.data;
+  //
+  //    } catch (e) {
+  //
+  //      this._handleError(e);
+  //    }
+  //  }
+
   /**
    * Registers a new user.
    *
@@ -242,7 +277,6 @@ export default class RbtApi {
       const record = response.data;
       return new RbtUser(record, this.axios);
     } catch (e) {
-      debugger;
       return this._handleError(e);
     }
   }
@@ -331,8 +365,65 @@ export default class RbtApi {
    *
    * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
    */
+  //  async query(type, params = {}) {
+
+  //    try {
+
+  //      console.log('RBTAPI.query INIT', type, params);
+  //      params.type = type;
+
+  //      // Default ordering and pagination
+  //      const defaultOrderBy = { orderBy: { column: 'timeCreated', direction: 'DESC' } };
+  //      const defaultLimit = { limit: { offset: 0, results: 50 } };
+  //      
+  //      // Merge defaults with provided params
+  //      const mergedParams = { ...defaultOrderBy, ...defaultLimit, ...params };
+
+  //      // Check cache for an existing request
+  //      const currentTime = Date.now();
+  //      const paramsKey = JSON.stringify(mergedParams);
+  //      const cacheEntry = this.requestCache[paramsKey];
+  //      if (cacheEntry && (currentTime - cacheEntry.time) < 10000) {  // 10000 ms = 10 seconds
+  //        console.log('RBTAPI.query CACHED', type, paramsKey);
+  //        return cacheEntry.val;
+  //      }
+
+  //      // Create the response promise and store it in the cache
+  //      const responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]);
+
+  //      // Store the promise along with the current time in the cache
+  //      this.requestCache[paramsKey] = { val: responsePromise, time: currentTime };
+
+  //      // Await the response from the API
+  //      const response = await responsePromise;
+
+  //      if (response.data.ok === false) {
+  //        return this._handleError(response);
+  //      }
+
+  //      // Process items into RbtObject instances
+  //      if (Array.isArray(response.data.items)) {
+  //        response.data.items = response.data.items.map(record => {
+  //          return new RbtObject(record, this.axios, { isNew: true });
+  //        });
+  //      }
+
+  //      console.log('RBTAPI.query RESPONSE', type, paramsKey, response.data.items);
+  //      return response.data.items;
+
+  //    } catch (e) {
+
+  //      delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+  //      console.log('RBTAPI.query ERROR', paramsKey, e);
+  //      return this._handleError(e);
+  //    
+  //    }
+
+  //  }
+
   async query(type, params = {}) {
     try {
+      //console.log('RBTAPI.query INIT', type, params);
       params.type = type;
 
       // Default ordering and pagination
@@ -358,42 +449,54 @@ export default class RbtApi {
 
       // Check cache for an existing request
       const currentTime = Date.now();
+      const paramsKey = JSON.stringify(mergedParams);
       const cacheEntry = this.requestCache[paramsKey];
       if (cacheEntry && currentTime - cacheEntry.time < 10000) {
         // 10000 ms = 10 seconds
-        console.log("Using cached request for params:", paramsKey);
+        //console.log('RBTAPI.query CACHED', type, paramsKey);
         return cacheEntry.val;
       }
 
-      // Create the response promise and store it in the cache
+      // Create the response promise
       const responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]);
 
-      // Store the promise along with the current time in the cache
+      // Cache the promise of processing data, not just the raw response
+      const processingPromise = responsePromise.then(response => this._processResponseData(response)).catch(e => {
+        delete this.requestCache[paramsKey]; // Ensure cache cleanup on failure
+        //console.log('RBTAPI.query ERROR (Processing)', paramsKey, e);
+        return this._handleError(e);
+      });
+
+      // Store the promise of the processed data in the cache
       this.requestCache[paramsKey] = {
-        val: responsePromise,
+        val: processingPromise,
         time: currentTime
       };
 
-      // Await the response from the API
-      const response = await responsePromise;
-      if (response.data.ok === false) {
-        return this._handleError(response);
-      }
-
-      // Process items into RbtObject instances
-      if (Array.isArray(response.data.items)) {
-        response.data.items = response.data.items.map(record => {
-          return new RbtObject(record, this.axios, {
-            isNew: true
-          });
-        });
-      }
-      return response.data.items;
+      // Await the processing promise for this call to get processed data
+      return await processingPromise;
     } catch (e) {
       delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+      //console.log('RBTAPI.query ERROR', paramsKey, e);
       return this._handleError(e);
     }
   }
+  _processResponseData(response) {
+    if (response.data.ok === false) {
+      return this._handleError(response);
+    }
+    if (Array.isArray(response.data.items)) {
+      //console.log('RBTAPI.query RESPONSE PRE', response.data.items);
+      response.data.items = response.data.items.map(record => {
+        return new RbtObject(record, this.axios, {
+          isNew: true
+        });
+      });
+    }
+
+    //console.log('RBTAPI.query RESPONSE POST', response.data.items);
+    return response.data.items;
+  }
 
   /**
    * Loads one or multiple objects of a given type by their IDs.
@@ -587,7 +690,6 @@ export default class RbtApi {
    * @returns {Promise<Object>} - The response data from the API.
    */
   async get(endpoint, params = {}) {
-    debugger;
     try {
       // Add the authToken to the headers
       const headers = {

package/package.json

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

package/src/rbt_api.js

@@ -274,27 +274,63 @@ export default class RbtApi {
   }
 
 
-  async refreshAuthToken(authtoken){
 
-    if(!this.appServiceHost){
-      console.warn('appServiceHost not initialized');
+  async refreshAuthToken(authtoken) {
+
+    if (!this.appServiceHost) {
+      console.warn('RBTTOK not initialized');
       return false;
     }
 
+    if (this.requestCache[authtoken]) {
+      // If there's already a pending promise to refresh this token, return it
+      console.log('RBTTOK Using cached promise for token refresh');
+      return this.requestCache[authtoken];
+    }
+
     try {
+      console.log('RBTTOK Req', authtoken);
+      // Create a new promise for the token refresh and store it in the cache
+      const promise = this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+      this.requestCache[authtoken] = promise;
 
-      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+      // Await the promise to get the response
+      const response = await promise;
 
-      debugger;
+      console.log('RBTTOK Response ',response);
+      // Once the promise resolves, delete it from the cache to allow future refreshes
+      delete this.requestCache[authtoken];
+
+      // Return the response data
       return response.data;
 
     } catch (e) {
-
+      // On error, remove the cached promise to allow retries
+      delete this.requestCache[authtoken];
       this._handleError(e);
     }
   }
 
 
+//  async refreshAuthToken(authtoken){
+//
+//    if(!this.appServiceHost){
+//      console.warn('appServiceHost not initialized');
+//      return false;
+//    }
+//
+//    try {
+//
+//      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+//      return response.data;
+//
+//    } catch (e) {
+//
+//      this._handleError(e);
+//    }
+//  }
+
+
   /**
    * Registers a new user.
    *
@@ -309,7 +345,7 @@ export default class RbtApi {
       const record = response.data;
       return new RbtUser(record, this.axios);
     } catch (e) {
-      debugger;
+      
       return this._handleError(e);
     }
   }
@@ -405,10 +441,66 @@ export default class RbtApi {
    *
    * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
    */
-  async query(type, params = {}) {
+//  async query(type, params = {}) {
 
-    try {
+//    try {
+
+//      console.log('RBTAPI.query INIT', type, params);
+//      params.type = type;
+
+//      // Default ordering and pagination
+//      const defaultOrderBy = { orderBy: { column: 'timeCreated', direction: 'DESC' } };
+//      const defaultLimit = { limit: { offset: 0, results: 50 } };
+//      
+//      // Merge defaults with provided params
+//      const mergedParams = { ...defaultOrderBy, ...defaultLimit, ...params };
+
+//      // Check cache for an existing request
+//      const currentTime = Date.now();
+//      const paramsKey = JSON.stringify(mergedParams);
+//      const cacheEntry = this.requestCache[paramsKey];
+//      if (cacheEntry && (currentTime - cacheEntry.time) < 10000) {  // 10000 ms = 10 seconds
+//        console.log('RBTAPI.query CACHED', type, paramsKey);
+//        return cacheEntry.val;
+//      }
+
+//      // Create the response promise and store it in the cache
+//      const responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]);
+
+//      // Store the promise along with the current time in the cache
+//      this.requestCache[paramsKey] = { val: responsePromise, time: currentTime };
+
+//      // Await the response from the API
+//      const response = await responsePromise;
+
+//      if (response.data.ok === false) {
+//        return this._handleError(response);
+//      }
+
+//      // Process items into RbtObject instances
+//      if (Array.isArray(response.data.items)) {
+//        response.data.items = response.data.items.map(record => {
+//          return new RbtObject(record, this.axios, { isNew: true });
+//        });
+//      }
+
+//      console.log('RBTAPI.query RESPONSE', type, paramsKey, response.data.items);
+//      return response.data.items;
+
+//    } catch (e) {
 
+//      delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+//      console.log('RBTAPI.query ERROR', paramsKey, e);
+//      return this._handleError(e);
+//    
+//    }
+
+//  }
+
+
+  async query(type, params = {}) {
+    try {
+      //console.log('RBTAPI.query INIT', type, params);
       params.type = type;
 
       // Default ordering and pagination
@@ -420,43 +512,53 @@ export default class RbtApi {
 
       // Check cache for an existing request
       const currentTime = Date.now();
+      const paramsKey = JSON.stringify(mergedParams);
       const cacheEntry = this.requestCache[paramsKey];
       if (cacheEntry && (currentTime - cacheEntry.time) < 10000) {  // 10000 ms = 10 seconds
-        console.log("Using cached request for params:", paramsKey);
+        //console.log('RBTAPI.query CACHED', type, paramsKey);
         return cacheEntry.val;
       }
 
-      // Create the response promise and store it in the cache
+      // Create the response promise
       const responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]);
 
-      // Store the promise along with the current time in the cache
-      this.requestCache[paramsKey] = { val: responsePromise, time: currentTime };
-
-      // Await the response from the API
-      const response = await responsePromise;
-
-      if (response.data.ok === false) {
-        return this._handleError(response);
-      }
+      // Cache the promise of processing data, not just the raw response
+      const processingPromise = responsePromise.then(response => this._processResponseData(response)).catch(e => {
+        delete this.requestCache[paramsKey];  // Ensure cache cleanup on failure
+        //console.log('RBTAPI.query ERROR (Processing)', paramsKey, e);
+        return this._handleError(e);
+      });
 
-      // Process items into RbtObject instances
-      if (Array.isArray(response.data.items)) {
-        response.data.items = response.data.items.map(record => {
-          return new RbtObject(record, this.axios, { isNew: true });
-        });
-      }
+      // Store the promise of the processed data in the cache
+      this.requestCache[paramsKey] = { val: processingPromise, time: currentTime };
 
-      return response.data.items;
+      // Await the processing promise for this call to get processed data
+      return await processingPromise;
 
     } catch (e) {
-
       delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+      //console.log('RBTAPI.query ERROR', paramsKey, e);
       return this._handleError(e);
-    
+    }
+  }
+
+  _processResponseData(response) {
+    if (response.data.ok === false) {
+      return this._handleError(response);
+    }
+
+    if (Array.isArray(response.data.items)) {
+      //console.log('RBTAPI.query RESPONSE PRE', response.data.items);
+      response.data.items = response.data.items.map(record => {
+        return new RbtObject(record, this.axios, { isNew: true });
+      });
     }
 
+    //console.log('RBTAPI.query RESPONSE POST', response.data.items);
+    return response.data.items;
   }
 
+
   /**
    * Loads one or multiple objects of a given type by their IDs.
    *
@@ -634,7 +736,7 @@ export default class RbtApi {
    * @returns {Promise<Object>} - The response data from the API.
    */
   async get(endpoint, params = {}) {
-    debugger;
+    
     try {
 
       // Add the authToken to the headers