cozy-client 60.1.0 → 60.2.0

package/dist/CozyClient.js

@@ -1207,7 +1207,11 @@ var CozyClient = /*#__PURE__*/function () {
       }
 
       return [saveMutation, function (response) {
-        var doc = _this3.hydrateDocument(response.data);
+        var schema = _this3.schema.getDoctypeSchema(response.data._type);
+
+        var doc = _this3.hydrateDocument(response.data, schema, {
+          forceHydratation: true
+        });
 
         return Object.entries(referencesByName).map(function (_ref3) {
           var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
@@ -1990,6 +1994,8 @@ var CozyClient = /*#__PURE__*/function () {
      *
      * @param  {string} doctype - Doctype of the documents being hydrated
      * @param  {Array<import("./types").CozyClientDocument>} documents - Documents to be hydrated
+     * @param  {object} [options] - Options
+     * @param  {boolean} [options.forceHydratation=false] - If set to true, all documents will be hydrated w.r.t. the provided schema's relationships, even if the relationship does not exist on the doc.
      * @returns {Array<import("./types").HydratedDocument>}
      */
 
@@ -1998,12 +2004,18 @@ var CozyClient = /*#__PURE__*/function () {
     value: function hydrateDocuments(doctype, documents) {
       var _this8 = this;
 
+      var _ref7 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+          _ref7$forceHydratatio = _ref7.forceHydratation,
+          forceHydratation = _ref7$forceHydratatio === void 0 ? false : _ref7$forceHydratatio;
+
       var schema = this.schema.getDoctypeSchema(doctype);
       var relationships = schema.relationships;
 
       if (relationships) {
         return documents.map(function (doc) {
-          return _this8.hydrateDocument(doc, schema);
+          return _this8.hydrateDocument(doc, schema, {
+            forceHydratation: forceHydratation
+          });
         });
       } else {
         return documents;
@@ -2016,31 +2028,42 @@ var CozyClient = /*#__PURE__*/function () {
      * the relationship
      *
      * @param  {import("./types").CozyClientDocument} document - for which relationships must be resolved
-     * @param  {Schema} [schemaArg] - Optional
+     * @param  {Schema} [schemaArg] - The schema describing the relationships
+     * @param  {object} [options] - Options
+     * @param  {boolean} [options.forceHydratation=false] - If set to true, the doc will be hydrated w.r.t. the provided schema's relationships, even if the relationship does not exist on the doc.
      * @returns {import("./types").HydratedDocument}
      */
 
   }, {
     key: "hydrateDocument",
     value: function hydrateDocument(document, schemaArg) {
+      var _ref8 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+          _ref8$forceHydratatio = _ref8.forceHydratation,
+          forceHydratation = _ref8$forceHydratatio === void 0 ? false : _ref8$forceHydratatio;
+
       if (!document) {
         return document;
       }
 
       var schema = schemaArg || this.schema.getDoctypeSchema(document._type);
-      var hydratedRelationships = this.hydrateRelationships(document, schema.relationships);
+      var shouldForceHydrate = this.options.autoHydrate || forceHydratation;
+      var hydratedRelationships = this.hydrateRelationships(document, schema.relationships, {
+        forceHydratation: shouldForceHydrate
+      });
       return _objectSpread(_objectSpread({}, document), hydratedRelationships);
     }
   }, {
     key: "hydrateRelationships",
     value: function hydrateRelationships(document, schemaRelationships) {
-      var _this9 = this;
+      var _ref9 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+          _ref9$forceHydratatio = _ref9.forceHydratation,
+          forceHydratation = _ref9$forceHydratatio === void 0 ? false : _ref9$forceHydratatio;
 
       var methods = this.getRelationshipStoreAccessors();
       return (0, _mapValues.default)(schemaRelationships, function (assoc, name) {
-        var _this9$options, _document$relationshi;
+        var _document$relationshi;
 
-        if ((_this9$options = _this9.options) !== null && _this9$options !== void 0 && _this9$options.autoHydrate || (_document$relationshi = document.relationships) !== null && _document$relationshi !== void 0 && _document$relationshi[name]) {
+        if (forceHydratation || (_document$relationshi = document.relationships) !== null && _document$relationshi !== void 0 && _document$relationshi[name]) {
           return (0, _associations.create)(document, assoc, methods);
         }
       });
@@ -2071,20 +2094,20 @@ var CozyClient = /*#__PURE__*/function () {
   }, {
     key: "getRelationshipStoreAccessors",
     value: function getRelationshipStoreAccessors() {
-      var _this10 = this;
+      var _this9 = this;
 
       if (!this.storeAccesors) {
         this.storeAccessors = {
           get: this.getDocumentFromState.bind(this),
           save: function save(document, opts) {
-            return _this10.save.call(_this10, document, opts);
+            return _this9.save.call(_this9, document, opts);
           },
           dispatch: this.dispatch.bind(this),
           query: function query(def, opts) {
-            return _this10.query.call(_this10, def, opts);
+            return _this9.query.call(_this9, def, opts);
           },
           mutate: function mutate(def, opts) {
-            return _this10.mutate.call(_this10, def, opts);
+            return _this9.mutate.call(_this9, def, opts);
           }
         };
       }
@@ -2311,12 +2334,12 @@ var CozyClient = /*#__PURE__*/function () {
     key: "authorize",
     value: function () {
       var _authorize = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19() {
-        var _ref7,
-            _ref7$openURLCallback,
+        var _ref10,
+            _ref10$openURLCallbac,
             openURLCallback,
-            _ref7$sessionCode,
+            _ref10$sessionCode,
             sessionCode,
-            _ref7$pkceCodes,
+            _ref10$pkceCodes,
             pkceCodes,
             codeVerifier,
             codeChallenge,
@@ -2333,7 +2356,7 @@ var CozyClient = /*#__PURE__*/function () {
           while (1) {
             switch (_context19.prev = _context19.next) {
               case 0:
-                _ref7 = _args19.length > 0 && _args19[0] !== undefined ? _args19[0] : {}, _ref7$openURLCallback = _ref7.openURLCallback, openURLCallback = _ref7$openURLCallback === void 0 ? _mobile.authFunction : _ref7$openURLCallback, _ref7$sessionCode = _ref7.sessionCode, sessionCode = _ref7$sessionCode === void 0 ? undefined : _ref7$sessionCode, _ref7$pkceCodes = _ref7.pkceCodes, pkceCodes = _ref7$pkceCodes === void 0 ? {} : _ref7$pkceCodes;
+                _ref10 = _args19.length > 0 && _args19[0] !== undefined ? _args19[0] : {}, _ref10$openURLCallbac = _ref10.openURLCallback, openURLCallback = _ref10$openURLCallbac === void 0 ? _mobile.authFunction : _ref10$openURLCallbac, _ref10$sessionCode = _ref10.sessionCode, sessionCode = _ref10$sessionCode === void 0 ? undefined : _ref10$sessionCode, _ref10$pkceCodes = _ref10.pkceCodes, pkceCodes = _ref10$pkceCodes === void 0 ? {} : _ref10$pkceCodes;
                 _context19.prev = 1;
                 codeVerifier = pkceCodes.codeVerifier, codeChallenge = pkceCodes.codeChallenge;
                 stackClient = this.getStackClient();
@@ -2430,9 +2453,9 @@ var CozyClient = /*#__PURE__*/function () {
   }, {
     key: "setStore",
     value: function setStore(store) {
-      var _ref8 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-          _ref8$force = _ref8.force,
-          force = _ref8$force === void 0 ? false : _ref8$force;
+      var _ref11 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          _ref11$force = _ref11.force,
+          force = _ref11$force === void 0 ? false : _ref11$force;
 
       if (store === undefined) {
         throw new Error('Store is undefined');
@@ -2677,15 +2700,15 @@ var CozyClient = /*#__PURE__*/function () {
   }, {
     key: "setData",
     value: function setData(data) {
-      var _this11 = this;
+      var _this10 = this;
 
       this.ensureStore();
-      Object.entries(data).forEach(function (_ref9) {
-        var _ref10 = (0, _slicedToArray2.default)(_ref9, 2),
-            doctype = _ref10[0],
-            data = _ref10[1];
+      Object.entries(data).forEach(function (_ref12) {
+        var _ref13 = (0, _slicedToArray2.default)(_ref12, 2),
+            doctype = _ref13[0],
+            data = _ref13[1];
 
-        _this11.dispatch((0, _store.receiveQueryResult)(null, {
+        _this10.dispatch((0, _store.receiveQueryResult)(null, {
           data: data
         }));
       });
@@ -3103,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.0";
+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.0",
+  "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": "78342f53c89c0c28a1559e6f0224249f4713c47b"
+  "gitHead": "48687a04cfb284dadd0d208451ca4f6a514519f2"
 }

package/types/CozyClient.d.ts

@@ -584,9 +584,13 @@ declare class CozyClient {
      *
      * @param  {string} doctype - Doctype of the documents being hydrated
      * @param  {Array<import("./types").CozyClientDocument>} documents - Documents to be hydrated
+     * @param  {object} [options] - Options
+     * @param  {boolean} [options.forceHydratation=false] - If set to true, all documents will be hydrated w.r.t. the provided schema's relationships, even if the relationship does not exist on the doc.
      * @returns {Array<import("./types").HydratedDocument>}
      */
-    hydrateDocuments(doctype: string, documents: Array<import("./types").CozyClientDocument>): Array<import("./types").HydratedDocument>;
+    hydrateDocuments(doctype: string, documents: Array<import("./types").CozyClientDocument>, { forceHydratation }?: {
+        forceHydratation?: boolean;
+    }): Array<import("./types").HydratedDocument>;
     /**
      * Resolves relationships on a document.
      *
@@ -594,11 +598,17 @@ declare class CozyClient {
      * the relationship
      *
      * @param  {import("./types").CozyClientDocument} document - for which relationships must be resolved
-     * @param  {Schema} [schemaArg] - Optional
+     * @param  {Schema} [schemaArg] - The schema describing the relationships
+     * @param  {object} [options] - Options
+     * @param  {boolean} [options.forceHydratation=false] - If set to true, the doc will be hydrated w.r.t. the provided schema's relationships, even if the relationship does not exist on the doc.
      * @returns {import("./types").HydratedDocument}
      */
-    hydrateDocument(document: import("./types").CozyClientDocument, schemaArg?: Schema): import("./types").HydratedDocument;
-    hydrateRelationships(document: any, schemaRelationships: any): {
+    hydrateDocument(document: import("./types").CozyClientDocument, schemaArg?: Schema, { forceHydratation }?: {
+        forceHydratation?: boolean;
+    }): import("./types").HydratedDocument;
+    hydrateRelationships(document: any, schemaRelationships: any, { forceHydratation }?: {
+        forceHydratation?: boolean;
+    }): {
         [x: string]: any;
     };
     generateRandomId(): string;

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";