cozy-client 60.1.1 → 60.3.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.3.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/dist/models/file.js

@@ -377,6 +377,8 @@ var isSharingShorcutNew = function isSharingShorcutNew(file) {
  * @param {CozyClient} client - The CozyClient instance
  * @param {import("../types").IOCozyFile} file - The file to qualify
  * @param {object} qualification - The file qualification
+ * @param {object} [params] - Parameters
+ * @param {string} [params.driveId] - ID of the shared drive in which the file should be saved
  * @returns {Promise<import("../types").IOCozyFile>} The saved file
  */
 
@@ -385,15 +387,22 @@ exports.isSharingShorcutNew = isSharingShorcutNew;
 
 var saveFileQualification = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client, file, qualification) {
-    var qualifiedFile;
+    var _ref2,
+        driveId,
+        qualifiedFile,
+        _args = arguments;
+
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
+            _ref2 = _args.length > 3 && _args[3] !== undefined ? _args[3] : {}, driveId = _ref2.driveId;
             qualifiedFile = (0, _qualification.setQualification)(file, qualification);
-            return _context.abrupt("return", client.collection(_const.DOCTYPE_FILES).updateMetadataAttribute(file._id, qualifiedFile.metadata));
+            return _context.abrupt("return", client.collection(_const.DOCTYPE_FILES, {
+              driveId: driveId
+            }).updateMetadataAttribute(file._id, qualifiedFile.metadata));
 
-          case 2:
+          case 3:
           case "end":
             return _context.stop();
         }
@@ -417,7 +426,7 @@ var saveFileQualification = /*#__PURE__*/function () {
 exports.saveFileQualification = saveFileQualification;
 
 var fetchFilesByQualificationRules = /*#__PURE__*/function () {
-  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client, docRules) {
+  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client, docRules) {
     var rules, count, query, result;
     return _regenerator.default.wrap(function _callee2$(_context2) {
       while (1) {
@@ -445,7 +454,7 @@ var fetchFilesByQualificationRules = /*#__PURE__*/function () {
   }));
 
   return function fetchFilesByQualificationRules(_x4, _x5) {
-    return _ref2.apply(this, arguments);
+    return _ref3.apply(this, arguments);
   };
 }();
 /**
@@ -460,9 +469,9 @@ var fetchFilesByQualificationRules = /*#__PURE__*/function () {
 
 exports.fetchFilesByQualificationRules = fetchFilesByQualificationRules;
 
-var hasMetadataAttribute = function hasMetadataAttribute(_ref3) {
-  var file = _ref3.file,
-      attribute = _ref3.attribute;
+var hasMetadataAttribute = function hasMetadataAttribute(_ref4) {
+  var file = _ref4.file,
+      attribute = _ref4.attribute;
   return (0, _has.default)(file, "metadata.".concat(attribute));
 };
 /**
@@ -478,7 +487,7 @@ var hasMetadataAttribute = function hasMetadataAttribute(_ref3) {
 exports.hasMetadataAttribute = hasMetadataAttribute;
 
 var getFullpath = /*#__PURE__*/function () {
-  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, dirId, name) {
+  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, dirId, name) {
     var _yield$client$query, parentDir, parentDirectoryPath;
 
     return _regenerator.default.wrap(function _callee3$(_context3) {
@@ -511,7 +520,7 @@ var getFullpath = /*#__PURE__*/function () {
   }));
 
   return function getFullpath(_x6, _x7, _x8) {
-    return _ref4.apply(this, arguments);
+    return _ref5.apply(this, arguments);
   };
 }();
 /**
@@ -525,8 +534,9 @@ var getFullpath = /*#__PURE__*/function () {
  * @param {CozyClient} client                                                                    - The CozyClient instance
  * @param {import('../types').IOCozyFile | import('../types').NextcloudFile} file                - The file to move (required)
  * @param {import('../types').IOCozyFolder | import('../types').NextcloudFile} destination       - The destination folder (required)
- * @param {object} options                                                                       - The options
- * @param {boolean} options.force                                                                - Whether we should overwrite,
+ * @param {object} [options]                                                                     - The options
+ * @param {boolean} [options.force]                                                              - Whether we should overwrite,
+ * @param {string} [options.driveId]                                                             - The ID of the shared drive in which the file should be moved
  * i.e. put to trash, the destination in case of conflict (defaults to false).
  * @returns {Promise<{moved: undefined|import('../types').IOCozyFile, deleted: null|string[] }>} - A promise that returns the move action response (if any)
  * and the deleted file id (if any) if resolved or an Error if rejected
@@ -536,9 +546,12 @@ var getFullpath = /*#__PURE__*/function () {
 exports.getFullpath = getFullpath;
 
 var move = /*#__PURE__*/function () {
-  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(client, file, destination) {
-    var _ref6,
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(client, file, destination) {
+    var _ref7,
+        _ref7$force,
         force,
+        driveId,
+        filesCollection,
         resp,
         destinationPath,
         conflictResp,
@@ -549,9 +562,7 @@ var move = /*#__PURE__*/function () {
       while (1) {
         switch (_context4.prev = _context4.next) {
           case 0:
-            _ref6 = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {
-              force: false
-            }, force = _ref6.force;
+            _ref7 = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {}, _ref7$force = _ref7.force, force = _ref7$force === void 0 ? false : _ref7$force, driveId = _ref7.driveId;
             _context4.prev = 1;
 
             if (!(file._type === 'io.cozy.remote.nextcloud.files')) {
@@ -608,77 +619,83 @@ var move = /*#__PURE__*/function () {
             throw _context4.t0;
 
           case 19:
-            _context4.prev = 19;
-            _context4.next = 22;
-            return client.collection(_const.DOCTYPE_FILES).updateFileMetadata(file._id, {
+            // Move inside a Cozy server
+            filesCollection = client.collection(_const.DOCTYPE_FILES, {
+              driveId: driveId
+            });
+            _context4.prev = 20;
+            _context4.next = 23;
+            return filesCollection.updateFileMetadata(file._id, {
               dir_id: destination._id
             });
 
-          case 22:
+          case 23:
             resp = _context4.sent;
             return _context4.abrupt("return", {
               moved: resp.data,
               deleted: null
             });
 
-          case 26:
-            _context4.prev = 26;
-            _context4.t1 = _context4["catch"](19);
+          case 27:
+            _context4.prev = 27;
+            _context4.t1 = _context4["catch"](20);
 
             if (!(_context4.t1.status === 409 && force)) {
-              _context4.next = 43;
+              _context4.next = 44;
               break;
             }
 
-            _context4.next = 31;
+            _context4.next = 32;
             return getFullpath(client, destination._id, file.name);
 
-          case 31:
+          case 32:
             destinationPath = _context4.sent;
-            _context4.next = 34;
-            return client.collection(_const.DOCTYPE_FILES).statByPath(destinationPath);
+            _context4.next = 35;
+            return filesCollection.statByPath(destinationPath);
 
-          case 34:
+          case 35:
             conflictResp = _context4.sent;
-            _context4.next = 37;
-            return client.collection(_const.DOCTYPE_FILES).destroy(conflictResp.data);
+            _context4.next = 38;
+            return filesCollection.destroy(conflictResp.data);
 
-          case 37:
-            _context4.next = 39;
-            return client.collection(_const.DOCTYPE_FILES).updateFileMetadata(file._id, {
+          case 38:
+            _context4.next = 40;
+            return filesCollection.updateFileMetadata(file._id, {
               dir_id: destination._id
             });
 
-          case 39:
+          case 40:
             _resp = _context4.sent;
             return _context4.abrupt("return", {
               moved: _resp.data,
               deleted: conflictResp.data.id
             });
 
-          case 43:
+          case 44:
             throw _context4.t1;
 
-          case 44:
+          case 45:
           case "end":
             return _context4.stop();
         }
       }
-    }, _callee4, null, [[1, 16], [19, 26]]);
+    }, _callee4, null, [[1, 16], [20, 27]]);
   }));
 
   return function move(_x9, _x10, _x11) {
-    return _ref5.apply(this, arguments);
+    return _ref6.apply(this, arguments);
   };
 }();
 /**
  *
  * Method to upload a file even if a file with the same name already exists.
  *
- * @param {CozyClient} client   - The CozyClient instance
- * @param {string} dirPath      - Fullpath of directory to upload to ex: path/to/
- * @param {object} file         - HTML Object file
- * @param {object} metadata     - An object containing the wanted metadata to attach
+ * @param {CozyClient} client       - The CozyClient instance
+ * @param {string} dirPath          - Fullpath of directory to upload to ex: path/to/
+ * @param {object} file             - HTML Object file
+ * @param {object} metadata         - An object containing the wanted metadata to attach
+ * @param {object} [params]         - Parameters
+ * @param {string} [params.driveId] - ID of the shared drive in which the file should be saved
  * @returns {Promise<import("../types").IOCozyFile>} The overrided file
  */
 
@@ -686,71 +703,85 @@ var move = /*#__PURE__*/function () {
 exports.move = move;
 
 var overrideFileForPath = /*#__PURE__*/function () {
-  var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(client, dirPath, file, metadata) {
-    var path, filesCollection, existingFile, _existingFile$data, fileId, dirId, resp, _dirId, createdFile;
+  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(client, dirPath, file, metadata) {
+    var _ref9,
+        driveId,
+        path,
+        filesCollection,
+        existingFile,
+        _existingFile$data,
+        fileId,
+        dirId,
+        resp,
+        _dirId,
+        createdFile,
+        _args5 = arguments;
 
     return _regenerator.default.wrap(function _callee5$(_context5) {
       while (1) {
         switch (_context5.prev = _context5.next) {
           case 0:
+            _ref9 = _args5.length > 4 && _args5[4] !== undefined ? _args5[4] : {}, driveId = _ref9.driveId;
             path = dirPath;
             if (!path.endsWith('/')) path = path + '/';
-            filesCollection = client.collection(_const.DOCTYPE_FILES);
-            _context5.prev = 3;
-            _context5.next = 6;
+            filesCollection = client.collection(_const.DOCTYPE_FILES, {
+              driveId: driveId
+            });
+            _context5.prev = 4;
+            _context5.next = 7;
             return filesCollection.statByPath(path + file.name);
 
-          case 6:
+          case 7:
             existingFile = _context5.sent;
             _existingFile$data = existingFile.data, fileId = _existingFile$data.id, dirId = _existingFile$data.dir_id;
-            _context5.next = 10;
+            _context5.next = 11;
             return filesCollection.updateFile(file, {
               dirId: dirId,
               fileId: fileId,
               metadata: metadata
             });
 
-          case 10:
+          case 11:
             resp = _context5.sent;
             return _context5.abrupt("return", resp);
 
-          case 14:
-            _context5.prev = 14;
-            _context5.t0 = _context5["catch"](3);
+          case 15:
+            _context5.prev = 15;
+            _context5.t0 = _context5["catch"](4);
 
             if (!/Not Found/.test(_context5.t0)) {
-              _context5.next = 24;
+              _context5.next = 25;
               break;
             }
 
-            _context5.next = 19;
+            _context5.next = 20;
             return filesCollection.ensureDirectoryExists(path);
 
-          case 19:
+          case 20:
             _dirId = _context5.sent;
-            _context5.next = 22;
+            _context5.next = 23;
             return filesCollection.createFile(file, {
               dirId: _dirId,
               metadata: metadata
             });
 
-          case 22:
+          case 23:
             createdFile = _context5.sent;
             return _context5.abrupt("return", createdFile);
 
-          case 24:
+          case 25:
             throw _context5.t0;
 
-          case 25:
+          case 26:
           case "end":
             return _context5.stop();
         }
       }
-    }, _callee5, null, [[3, 14]]);
+    }, _callee5, null, [[4, 15]]);
   }));
 
   return function overrideFileForPath(_x12, _x13, _x14, _x15) {
-    return _ref7.apply(this, arguments);
+    return _ref8.apply(this, arguments);
   };
 }();
 /**
@@ -806,6 +837,7 @@ var generateFileNameForRevision = function generateFileNameForRevision(file, rev
  * @property {string} [contentType]       - The file Content-Type
  * @property {string} [conflictStrategy]  - Erase / rename
  * @property {import('../types').ConflictOptions} [conflictOptions] - Conflict options
+ * @property {string} [driveId]           - ID of the shared drive in which the file should be saved
  */
 
 /**
@@ -828,42 +860,45 @@ var generateFileNameForRevision = function generateFileNameForRevision(file, rev
 exports.generateFileNameForRevision = generateFileNameForRevision;
 
 var uploadFileWithConflictStrategy = /*#__PURE__*/function () {
-  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(client, file, options) {
-    var name, dirId, conflictStrategy, conflictOptions, path, existingFile, fileId, resp, _splitFilename2, filename, extension, newFileName;
+  var _ref10 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(client, file, options) {
+    var name, dirId, conflictStrategy, conflictOptions, driveId, filesCollection, path, existingFile, fileId, resp, _splitFilename2, filename, extension, newFileName;
 
     return _regenerator.default.wrap(function _callee6$(_context6) {
       while (1) {
         switch (_context6.prev = _context6.next) {
           case 0:
-            name = options.name, dirId = options.dirId, conflictStrategy = options.conflictStrategy, conflictOptions = options.conflictOptions;
-            _context6.prev = 1;
-            _context6.next = 4;
+            name = options.name, dirId = options.dirId, conflictStrategy = options.conflictStrategy, conflictOptions = options.conflictOptions, driveId = options.driveId;
+            filesCollection = client.collection(_const.DOCTYPE_FILES, {
+              driveId: driveId
+            });
+            _context6.prev = 2;
+            _context6.next = 5;
             return getFullpath(client, dirId, name);
 
-          case 4:
+          case 5:
             path = _context6.sent;
-            _context6.next = 7;
-            return client.collection(_const.DOCTYPE_FILES).statByPath(path);
+            _context6.next = 8;
+            return filesCollection.statByPath(path);
 
-          case 7:
+          case 8:
             existingFile = _context6.sent;
             fileId = existingFile.data.id;
 
             if (!(conflictStrategy === 'erase')) {
-              _context6.next = 16;
+              _context6.next = 17;
               break;
             }
 
-            _context6.next = 12;
-            return client.collection(_const.DOCTYPE_FILES).updateFile(file, _objectSpread(_objectSpread({}, options), {}, {
+            _context6.next = 13;
+            return filesCollection.updateFile(file, _objectSpread(_objectSpread({}, options), {}, {
               fileId: fileId
             }));
 
-          case 12:
+          case 13:
             resp = _context6.sent;
             return _context6.abrupt("return", resp);
 
-          case 16:
+          case 17:
             // @ts-ignore
             _splitFilename2 = splitFilename({
               name: name,
@@ -875,34 +910,34 @@ var uploadFileWithConflictStrategy = /*#__PURE__*/function () {
               name: newFileName
             })));
 
-          case 19:
-            _context6.next = 26;
+          case 20:
+            _context6.next = 27;
             break;
 
-          case 21:
-            _context6.prev = 21;
-            _context6.t0 = _context6["catch"](1);
+          case 22:
+            _context6.prev = 22;
+            _context6.t0 = _context6["catch"](2);
 
             if (!/Not Found/.test(_context6.t0.message)) {
-              _context6.next = 25;
+              _context6.next = 26;
               break;
             }
 
-            return _context6.abrupt("return", client.collection(_const.DOCTYPE_FILES).createFile(file, options));
+            return _context6.abrupt("return", filesCollection.createFile(file, options));
 
-          case 25:
+          case 26:
             throw _context6.t0;
 
-          case 26:
+          case 27:
           case "end":
             return _context6.stop();
         }
       }
-    }, _callee6, null, [[1, 21]]);
+    }, _callee6, null, [[2, 22]]);
   }));
 
   return function uploadFileWithConflictStrategy(_x16, _x17, _x18) {
-    return _ref8.apply(this, arguments);
+    return _ref10.apply(this, arguments);
   };
 }();
 /**
@@ -955,6 +990,8 @@ var isFromKonnector = function isFromKonnector(file) {
 /**
  * @param {CozyClient} client - Instance of CozyClient
  * @param {string} fileId - Id of io.cozy.files document
+ * @param {object} [params] - Parameters
+ * @param {string} [params.driveId] - ID of the shared drive in which the file should be saved
  * @returns {Promise<Blob>}
  */
 
@@ -962,26 +999,35 @@ var isFromKonnector = function isFromKonnector(file) {
 exports.isFromKonnector = isFromKonnector;
 
 var fetchBlobFileById = /*#__PURE__*/function () {
-  var _ref9 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(client, fileId) {
-    var fileColl, fileBin, fileBlob;
+  var _ref11 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(client, fileId) {
+    var _ref12,
+        driveId,
+        fileColl,
+        fileBin,
+        fileBlob,
+        _args7 = arguments;
+
     return _regenerator.default.wrap(function _callee7$(_context7) {
       while (1) {
         switch (_context7.prev = _context7.next) {
           case 0:
-            fileColl = client.collection(_const.DOCTYPE_FILES);
-            _context7.next = 3;
+            _ref12 = _args7.length > 2 && _args7[2] !== undefined ? _args7[2] : {}, driveId = _ref12.driveId;
+            fileColl = client.collection(_const.DOCTYPE_FILES, {
+              driveId: driveId
+            });
+            _context7.next = 4;
             return fileColl.fetchFileContentById(fileId);
 
-          case 3:
+          case 4:
             fileBin = _context7.sent;
-            _context7.next = 6;
+            _context7.next = 7;
             return fileBin.blob();
 
-          case 6:
+          case 7:
             fileBlob = _context7.sent;
             return _context7.abrupt("return", fileBlob);
 
-          case 8:
+          case 9:
           case "end":
             return _context7.stop();
         }
@@ -990,7 +1036,7 @@ var fetchBlobFileById = /*#__PURE__*/function () {
   }));
 
   return function fetchBlobFileById(_x19, _x20) {
-    return _ref9.apply(this, arguments);
+    return _ref11.apply(this, arguments);
   };
 }();
 /**
@@ -999,6 +1045,8 @@ var fetchBlobFileById = /*#__PURE__*/function () {
  * @param {object} client - The client object used for making API requests.
  * @param {object} file - The file object to be copied.
  * @param {object} destination - The destination object where the file will be copied to.
+ * @param {object} [params] - Parameters
+ * @param {string} [params.driveId] - ID of the shared drive in which the file should be saved
  * @returns {Promise} - A promise that resolves with the response from the API.
  * @throws {Error} - If an error occurs during the API request.
  */
@@ -1007,80 +1055,89 @@ var fetchBlobFileById = /*#__PURE__*/function () {
 exports.fetchBlobFileById = fetchBlobFileById;
 
 var copy = /*#__PURE__*/function () {
-  var _ref10 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(client, file, destination) {
-    var _resp2, _resp3, _resp4, resp;
+  var _ref13 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(client, file, destination) {
+    var _ref14,
+        driveId,
+        _resp2,
+        _resp3,
+        _resp4,
+        resp,
+        _args8 = arguments;
 
     return _regenerator.default.wrap(function _callee8$(_context8) {
       while (1) {
         switch (_context8.prev = _context8.next) {
           case 0:
-            _context8.prev = 0;
+            _ref14 = _args8.length > 3 && _args8[3] !== undefined ? _args8[3] : {}, driveId = _ref14.driveId;
+            _context8.prev = 1;
 
             if (!(file._type === 'io.cozy.remote.nextcloud.files' && destination._type === 'io.cozy.remote.nextcloud.files')) {
-              _context8.next = 6;
+              _context8.next = 7;
               break;
             }
 
-            _context8.next = 4;
+            _context8.next = 5;
             return client.collection('io.cozy.remote.nextcloud.files').copy(file, destination);
 
-          case 4:
+          case 5:
             _resp2 = _context8.sent;
             return _context8.abrupt("return", _resp2);
 
-          case 6:
+          case 7:
             if (!(file._type === 'io.cozy.remote.nextcloud.files' && destination._type === 'io.cozy.files')) {
-              _context8.next = 11;
+              _context8.next = 12;
               break;
             }
 
-            _context8.next = 9;
+            _context8.next = 10;
             return client.collection('io.cozy.remote.nextcloud.files').moveToCozy(file, destination, {
               copy: true
             });
 
-          case 9:
+          case 10:
             _resp3 = _context8.sent;
             return _context8.abrupt("return", _resp3);
 
-          case 11:
+          case 12:
             if (!(destination._type === 'io.cozy.remote.nextcloud.files')) {
-              _context8.next = 16;
+              _context8.next = 17;
               break;
             }
 
-            _context8.next = 14;
+            _context8.next = 15;
             return client.collection('io.cozy.remote.nextcloud.files').moveFromCozy(destination, file, {
               copy: true
             });
 
-          case 14:
+          case 15:
             _resp4 = _context8.sent;
             return _context8.abrupt("return", _resp4);
 
-          case 16:
-            _context8.next = 18;
-            return client.collection(_const.DOCTYPE_FILES).copy(file._id, undefined, destination._id);
+          case 17:
+            _context8.next = 19;
+            return client.collection(_const.DOCTYPE_FILES, {
+              driveId: driveId
+            }).copy(file._id, undefined, destination._id);
 
-          case 18:
+          case 19:
             resp = _context8.sent;
             return _context8.abrupt("return", resp);
 
-          case 22:
-            _context8.prev = 22;
-            _context8.t0 = _context8["catch"](0);
+          case 23:
+            _context8.prev = 23;
+            _context8.t0 = _context8["catch"](1);
             throw _context8.t0;
 
-          case 25:
+          case 26:
           case "end":
             return _context8.stop();
         }
       }
-    }, _callee8, null, [[0, 22]]);
+    }, _callee8, null, [[1, 23]]);
   }));
 
   return function copy(_x21, _x22, _x23) {
-    return _ref10.apply(this, arguments);
+    return _ref13.apply(this, arguments);
   };
 }();
 /**
@@ -1095,6 +1152,7 @@ var copy = /*#__PURE__*/function () {
  * @param {CozyClient} params.client - Instance of CozyClient
  * @param {import("../types").IOCozyFile} params.file - io.cozy.files metadata of the document to downloaded
  * @param {string} [params.url] - Blob url that should be used to download encrypted files
+ * @param {string} [params.driveId] - ID of the shared drive in which the file can be found
  * @param {import('cozy-intent').WebviewService} [params.webviewIntent] - webviewIntent that can be used to redirect the download to host Flagship app
  *
  * @returns {Promise<any>}
@@ -1104,15 +1162,17 @@ var copy = /*#__PURE__*/function () {
 exports.copy = copy;
 
 var downloadFile = /*#__PURE__*/function () {
-  var _ref12 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(_ref11) {
-    var client, file, url, webviewIntent, filesCollection, _yield$webviewIntent$, isFlagshipDownloadAvailable;
+  var _ref16 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(_ref15) {
+    var client, file, url, webviewIntent, driveId, filesCollection, _yield$webviewIntent$, isFlagshipDownloadAvailable;
 
     return _regenerator.default.wrap(function _callee9$(_context9) {
       while (1) {
         switch (_context9.prev = _context9.next) {
           case 0:
-            client = _ref11.client, file = _ref11.file, url = _ref11.url, webviewIntent = _ref11.webviewIntent;
-            filesCollection = client.collection(_const.DOCTYPE_FILES);
+            client = _ref15.client, file = _ref15.file, url = _ref15.url, webviewIntent = _ref15.webviewIntent, driveId = _ref15.driveId;
+            filesCollection = client.collection(_const.DOCTYPE_FILES, {
+              driveId: driveId
+            });
 
             if (!((0, _cozyDeviceHelper.isFlagshipApp)() && webviewIntent && !isEncrypted(file))) {
               _context9.next = 19;
@@ -1180,7 +1240,7 @@ var downloadFile = /*#__PURE__*/function () {
   }));
 
   return function downloadFile(_x24) {
-    return _ref12.apply(this, arguments);
+    return _ref16.apply(this, arguments);
   };
 }();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "60.1.1",
+  "version": "60.3.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": "708cec590442076e46405082403975018fa8bb31"
 }

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

package/types/models/file.d.ts

@@ -47,20 +47,25 @@ export function isSharingShortcut(file: import("../types").IOCozyFile): boolean;
 export function isSharingShorcut(file: import("../types").IOCozyFile): boolean;
 export function isSharingShortcutNew(file: import("../types").IOCozyFile): boolean;
 export function isSharingShorcutNew(file: object): boolean;
-export function saveFileQualification(client: CozyClient, file: import("../types").IOCozyFile, qualification: object): Promise<import("../types").IOCozyFile>;
+export function saveFileQualification(client: CozyClient, file: import("../types").IOCozyFile, qualification: object, { driveId }?: {
+    driveId: string;
+}): Promise<import("../types").IOCozyFile>;
 export function fetchFilesByQualificationRules(client: object, docRules: object): Promise<import("../types").QueryResult>;
 export function hasMetadataAttribute({ file, attribute }: {
     file: import("../types").IOCozyFile;
     attribute: string;
 }): boolean;
 export function getFullpath(client: CozyClient, dirId: string, name: string): Promise<string>;
-export function move(client: CozyClient, file: import('../types').IOCozyFile | import('../types').NextcloudFile, destination: import('../types').IOCozyFolder | import('../types').NextcloudFile, { force }?: {
+export function move(client: CozyClient, file: import('../types').IOCozyFile | import('../types').NextcloudFile, destination: import('../types').IOCozyFolder | import('../types').NextcloudFile, { force, driveId }?: {
     force: boolean;
+    driveId: string;
 }): Promise<{
     moved: undefined | import('../types').IOCozyFile;
     deleted: null | string[];
 }>;
-export function overrideFileForPath(client: CozyClient, dirPath: string, file: object, metadata: object): Promise<import("../types").IOCozyFile>;
+export function overrideFileForPath(client: CozyClient, dirPath: string, file: object, metadata: object, { driveId }?: {
+    driveId: string;
+}): Promise<import("../types").IOCozyFile>;
 export function generateNewFileNameOnConflict(filenameWithoutExtension: string, conflictOptions?: import('../types').ConflictOptions): string;
 export function generateFileNameForRevision(file: import("../types").IOCozyFile, revision: object, f: Function): string;
 export function uploadFileWithConflictStrategy(client: CozyClient, file: string | ArrayBuffer, options: FileUploadOptions): any;
@@ -68,12 +73,17 @@ export function isPlainText(mimeType?: string, fileName?: string): boolean;
 export function hasQualifications(file: import("../types").IOCozyFile): boolean;
 export function hasCertifications(file: import("../types").IOCozyFile): boolean;
 export function isFromKonnector(file: import("../types").IOCozyFile): boolean;
-export function fetchBlobFileById(client: CozyClient, fileId: string): Promise<Blob>;
-export function copy(client: object, file: object, destination: object): Promise<any>;
-export function downloadFile({ client, file, url, webviewIntent }: {
+export function fetchBlobFileById(client: CozyClient, fileId: string, { driveId }?: {
+    driveId: string;
+}): Promise<Blob>;
+export function copy(client: object, file: object, destination: object, { driveId }?: {
+    driveId: string;
+}): Promise<any>;
+export function downloadFile({ client, file, url, webviewIntent, driveId }: {
     client: CozyClient;
     file: import("../types").IOCozyFile;
     url: string;
+    driveId: string;
     webviewIntent: import('cozy-intent').WebviewService;
 }): Promise<any>;
 export type FileUploadOptions = {
@@ -101,5 +111,9 @@ export type FileUploadOptions = {
      * - Conflict options
      */
     conflictOptions?: import('../types').ConflictOptions;
+    /**
+     * - ID of the shared drive in which the file should be saved
+     */
+    driveId?: string;
 };
 import CozyClient from "../CozyClient";