cozy-client 60.1.1 → 60.2.0

package/dist/CozyClient.js

@@ -3126,7 +3126,7 @@ var CozyClient = /*#__PURE__*/function () {
 CozyClient.hooks = CozyClient.hooks || {};
 CozyClient.fetchPolicies = _policies.default; //COZY_CLIENT_VERSION_PACKAGE in replaced by babel. See babel config
 
-CozyClient.version = "60.1.1";
+CozyClient.version = "60.2.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/links/DataProxyLink.js

@@ -15,14 +15,20 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _CozyLink2 = _interopRequireDefault(require("./CozyLink"));
 
+var _cozyLogger = _interopRequireDefault(require("cozy-logger"));
+
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
@@ -44,7 +50,30 @@ var DataProxyLink = /*#__PURE__*/function (_CozyLink) {
 
     (0, _classCallCheck2.default)(this, DataProxyLink);
     _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_onReceiveMessage", function (event) {
+      // See https://github.com/cozy/cozy-web-data-proxy/blob/1fc3deef767536aa264074c8a377f422b588409d/src/dataproxy/parent/ParentWindowProvider.tsx#L27
+      if (!event.origin.includes('dataproxy')) {
+        return;
+      }
+
+      var eventData = event === null || event === void 0 ? void 0 : event.data;
+
+      if (eventData && typeof eventData === 'object') {
+        if (eventData.type === 'DATAPROXYMESSAGE' && eventData.payload === 'READY') {
+          _cozyLogger.default.info("Received message: DataProxy is ready");
+
+          _this._flushQueue();
+        }
+      }
+    });
     _this.dataproxy = dataproxy || null;
+    _this._queue = [];
+    _this._drainingRequests = false;
+
+    if (window) {
+      window.addEventListener('message', _this._onReceiveMessage);
+    }
+
     return _this;
   }
 
@@ -64,6 +93,8 @@ var DataProxyLink = /*#__PURE__*/function (_CozyLink) {
     key: "registerDataProxy",
     value: function registerDataProxy(dataproxy) {
       this.dataproxy = dataproxy;
+
+      this._flushQueue();
     }
   }, {
     key: "reset",
@@ -90,24 +121,31 @@ var DataProxyLink = /*#__PURE__*/function (_CozyLink) {
     key: "request",
     value: function () {
       var _request = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(operation, options, result, forward) {
-        var opts;
+        var _this$dataproxy,
+            _this2 = this;
+
         return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) {
             switch (_context2.prev = _context2.next) {
               case 0:
-                if (!this.dataproxy) {
-                  _context2.next = 5;
+                if (!((_this$dataproxy = this.dataproxy) !== null && _this$dataproxy !== void 0 && _this$dataproxy.requestLink)) {
+                  _context2.next = 2;
                   break;
                 }
 
-                // Send the request to the DataProxy, that will handle both web and mobile environments
-                opts = options || {};
-                return _context2.abrupt("return", this.dataproxy.requestLink(operation, opts));
+                return _context2.abrupt("return", this.doRequest(operation, options));
 
-              case 5:
-                return _context2.abrupt("return", forward(operation, options));
+              case 2:
+                return _context2.abrupt("return", new Promise(function (resolve, reject) {
+                  _this2._queue.push({
+                    operation: operation,
+                    options: options,
+                    resolve: resolve,
+                    reject: reject
+                  });
+                }));
 
-              case 6:
+              case 3:
               case "end":
                 return _context2.stop();
             }
@@ -122,29 +160,141 @@ var DataProxyLink = /*#__PURE__*/function (_CozyLink) {
       return request;
     }()
   }, {
-    key: "persistCozyData",
+    key: "doRequest",
     value: function () {
-      var _persistCozyData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(data, forward) {
+      var _doRequest = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(operation, options) {
+        var opts, startQuery, resp, endQuery;
         return _regenerator.default.wrap(function _callee3$(_context3) {
           while (1) {
             switch (_context3.prev = _context3.next) {
               case 0:
-                return _context3.abrupt("return");
+                opts = options || {};
+                startQuery = performance.now(); // Send the request to the DataProxy, that will handle both web and mobile environments
 
-              case 1:
+                _context3.next = 4;
+                return this.dataproxy.requestLink(operation, opts);
+
+              case 4:
+                resp = _context3.sent;
+                endQuery = performance.now();
+
+                _cozyLogger.default.info("Request query took ".concat(endQuery - startQuery, " ms"));
+
+                return _context3.abrupt("return", resp);
+
+              case 8:
               case "end":
                 return _context3.stop();
             }
           }
-        }, _callee3);
+        }, _callee3, this);
       }));
 
-      function persistCozyData(_x5, _x6) {
+      function doRequest(_x5, _x6) {
+        return _doRequest.apply(this, arguments);
+      }
+
+      return doRequest;
+    }()
+  }, {
+    key: "persistCozyData",
+    value: function () {
+      var _persistCozyData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(data, forward) {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                return _context4.abrupt("return");
+
+              case 1:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4);
+      }));
+
+      function persistCozyData(_x7, _x8) {
         return _persistCozyData.apply(this, arguments);
       }
 
       return persistCozyData;
     }()
+  }, {
+    key: "_flushQueue",
+    value: function () {
+      var _flushQueue2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+        var _this$dataproxy2;
+
+        var _this$_queue$shift, operation, options, resolve, reject, resp;
+
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                if (!(!((_this$dataproxy2 = this.dataproxy) !== null && _this$dataproxy2 !== void 0 && _this$dataproxy2.requestLink) || this._queue.length < 1)) {
+                  _context5.next = 2;
+                  break;
+                }
+
+                return _context5.abrupt("return");
+
+              case 2:
+                _cozyLogger.default.info("Execute ".concat(this._queue.length, " delayed requests"));
+
+                this._drainingRequests = true;
+                _context5.prev = 4;
+
+              case 5:
+                if (!(this._queue.length > 0)) {
+                  _context5.next = 19;
+                  break;
+                }
+
+                _this$_queue$shift = this._queue.shift(), operation = _this$_queue$shift.operation, options = _this$_queue$shift.options, resolve = _this$_queue$shift.resolve, reject = _this$_queue$shift.reject;
+                _context5.prev = 7;
+                _context5.next = 10;
+                return this.doRequest(operation, options);
+
+              case 10:
+                resp = _context5.sent;
+                resolve(resp);
+                _context5.next = 17;
+                break;
+
+              case 14:
+                _context5.prev = 14;
+                _context5.t0 = _context5["catch"](7);
+                reject(_context5.t0);
+
+              case 17:
+                _context5.next = 5;
+                break;
+
+              case 19:
+                _context5.prev = 19;
+                this._drainingRequests = false; // Run it again in case queue has filled again during the flush
+
+                if (this._queue.length > 0) {
+                  this._flushQueue();
+                }
+
+                return _context5.finish(19);
+
+              case 23:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this, [[4,, 19, 23], [7, 14]]);
+      }));
+
+      function _flushQueue() {
+        return _flushQueue2.apply(this, arguments);
+      }
+
+      return _flushQueue;
+    }()
   }]);
   return DataProxyLink;
 }(_CozyLink2.default);

package/dist/links/DataProxyLink.spec.js

@@ -0,0 +1,86 @@
+/** @jest-environment jsdom */
+import DataProxyLink from './DataProxyLink'
+
+describe('DataProxyLink queueing', () => {
+  it('should directly call dataproxy requestLink if available', async () => {
+    const requestLink = jest.fn().mockResolvedValue('OK')
+    const dataproxy = { requestLink }
+    const link = new DataProxyLink({ dataproxy })
+
+    const res = await link.request({ op: 'op1' }, {}, undefined, undefined)
+
+    expect(res).toBe('OK')
+    expect(requestLink).toHaveBeenCalledTimes(1)
+    expect(requestLink).toHaveBeenCalledWith({ op: 'op1' }, {})
+  })
+
+  it('should fill the event queue as long as dataproxy is not ready and run all of them once it registers', async () => {
+    const link = new DataProxyLink() // no dataproxy
+
+    const p1 = link.request({ op: 'op1' }, {}, undefined, undefined)
+    const p2 = link.request({ op: 'op2' }, {}, undefined, undefined)
+
+    expect(link._queue.length).toEqual(2)
+
+    const requestLink = jest
+      .fn()
+      .mockResolvedValueOnce('Res1')
+      .mockResolvedValueOnce('Res2')
+
+    link.registerDataProxy({ requestLink })
+
+    await expect(p1).resolves.toBe('Res1')
+    await expect(p2).resolves.toBe('Res2')
+
+    expect(requestLink.mock.calls.map(c => c[0].op)).toEqual(['op1', 'op2'])
+    expect(link._queue.length).toEqual(0)
+  })
+
+  it('should correctly deal with rejected promises ', async () => {
+    const link = new DataProxyLink()
+
+    const pOk1 = link.request({ op: 'op1' }, {})
+    const pFail = link.request({ op: 'op2' }, {})
+    const pOk2 = link.request({ op: 'op3' }, {})
+
+    const requestLink = jest
+      .fn()
+      .mockResolvedValueOnce('Res1')
+      .mockRejectedValueOnce(new Error('boom'))
+      .mockResolvedValueOnce('Res3')
+
+    link.registerDataProxy({ requestLink })
+
+    await expect(pOk1).resolves.toBe('Res1')
+    await expect(pFail).rejects.toThrow('boom')
+    await expect(pOk2).resolves.toBe('Res3')
+
+    expect(requestLink.mock.calls.map(c => c[0].op)).toEqual([
+      'op1',
+      'op2',
+      'op3'
+    ])
+  })
+
+  it('should flush events when ready message is received', async () => {
+    const link = new DataProxyLink()
+
+    const p1 = link.request({ op: 'op1' }, {})
+    const p2 = link.request({ op: 'op2' }, {})
+
+    const requestLink = jest
+      .fn()
+      .mockResolvedValueOnce('Res1')
+      .mockResolvedValueOnce('Res2')
+    link.dataproxy = { requestLink }
+
+    const ev = new MessageEvent('message', {
+      data: { type: 'DATAPROXYMESSAGE', payload: 'READY' },
+      origin: 'http://dataproxy.cozy.localhost:8080'
+    })
+    window.dispatchEvent(ev)
+
+    await expect(p1).resolves.toBe('Res1')
+    await expect(p2).resolves.toBe('Res2')
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "60.1.1",
+  "version": "60.2.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -74,5 +74,5 @@
     "react-native-ios11-devicecheck": "^0.0.3"
   },
   "sideEffects": false,
-  "gitHead": "a944c176ad97aa07f7145d97642716a9dc231990"
+  "gitHead": "48687a04cfb284dadd0d208451ca4f6a514519f2"
 }

package/types/links/DataProxyLink.d.ts

@@ -7,6 +7,8 @@ export default class DataProxyLink extends CozyLink {
         dataproxy: object;
     });
     dataproxy: any;
+    _queue: any[];
+    _drainingRequests: boolean;
     registerClient(client: any): void;
     /**
      * When the link is given to a cozy-client instance, the dataproxy might not be ready yet.
@@ -16,5 +18,8 @@ export default class DataProxyLink extends CozyLink {
      * @param {object} dataproxy - The dataproxy instance
      */
     registerDataProxy(dataproxy: object): void;
+    doRequest(operation: any, options: any): Promise<any>;
+    _flushQueue(): Promise<void>;
+    _onReceiveMessage: (event: any) => void;
 }
 import CozyLink from "./CozyLink";