cozy-pouch-link 60.15.2 → 60.16.0

package/dist/startReplication.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.replicateAllDocs = exports.startReplication = void 0;
+exports.sharedDriveReplicateAllDocs = exports.replicateAllDocs = exports.startReplication = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -23,6 +23,14 @@ var _logger = _interopRequireDefault(require("./logger"));
 
 var _remote = require("./remote");
 
+var _cozyClient = _interopRequireDefault(require("cozy-client"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -61,15 +69,17 @@ var TIME_UNITS = [['ms', 1000], ['s', 60], ['m', 60], ['h', 24]];
  * @param {object} replicationOptions Any option supported by the Pouch replication API (https://pouchdb.com/api.html#replication)
  * @param {string} replicationOptions.strategy The direction of the replication. Can be "fromRemote",  "toRemote" or "sync"
  * @param {boolean} replicationOptions.initialReplication Whether or not this is an initial replication
+ * @param {string} [replicationOptions.driveId] - ID of the shared drive to replicate (enables shared drive mode)
  * @param {string} replicationOptions.doctype The doctype to replicate
  * @param {import('cozy-client/types/types').Query[]} replicationOptions.warmupQueries The queries to warmup
  * @param {Function} getReplicationURL A function that should return the remote replication URL
  * @param {import('./localStorage').PouchLocalStorage} storage Methods to access local storage
+ * @param {CozyClient} client - Cozy client instance (required for shared drive replication)
  *
  * @returns {import('./types').CancelablePromise} A cancelable promise that resolves at the end of the replication
  */
 
-var startReplication = function startReplication(pouch, replicationOptions, getReplicationURL, storage) {
+var startReplication = function startReplication(pouch, replicationOptions, getReplicationURL, storage, client) {
   var replication;
   var docs = {};
   var start = new Date();
@@ -93,83 +103,131 @@ var startReplication = function startReplication(pouch, replicationOptions, getR
       }
     });
 
-    if (initialReplication && strategy !== 'toRemote') {
+    if (replicationOptions.driveId) {
       ;
       (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var end;
+        var _docs;
+
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
-                // For the first remote->local replication, we manually replicate all docs
-                // as it avoids to replicate all revs history, which can lead to
-                // performances issues
-                _logger.default.info("PouchManager: Start first replication for ".concat(doctype));
-
+                _context.prev = 0;
                 _context.next = 3;
-                return replicateAllDocs({
-                  db: pouch,
-                  baseUrl: url,
+                return sharedDriveReplicateAllDocs({
+                  pouch: pouch,
+                  storage: storage,
                   doctype: doctype,
-                  storage: storage
+                  client: client,
+                  initialReplication: initialReplication,
+                  driveId: replicationOptions.driveId
                 });
 
               case 3:
-                docs = _context.sent;
-
-                _logger.default.info("PouchManager: End first replication for ".concat(doctype));
-
-                end = new Date();
-
-                if (process.env.NODE_ENV !== 'production') {
-                  _logger.default.info("PouchManager: initial replication with all_docs for ".concat(url, " took ").concat(humanTimeDelta(end.getTime() - start.getTime())));
-                }
+                _docs = _context.sent;
+                resolve(_docs);
+                _context.next = 10;
+                break;
 
-                return _context.abrupt("return", resolve(docs));
+              case 7:
+                _context.prev = 7;
+                _context.t0 = _context["catch"](0);
+                reject(_context.t0);
 
-              case 8:
+              case 10:
               case "end":
                 return _context.stop();
             }
           }
-        }, _callee);
+        }, _callee, null, [[0, 7]]);
       }))();
       return;
-    }
-
-    if (strategy === 'fromRemote') {
-      replication = pouch.replicate.from(url, options);
-    } else if (strategy === 'toRemote') {
-      replication = pouch.replicate.to(url, options);
     } else {
-      replication = pouch.sync(url, options);
-    }
-
-    replication.on('change', function (infos) {
-      //! Since we introduced the concept of strategy we can use
-      // PouchDB.replicate or PouchDB.sync. But both don't share the
-      // same API for the change's event.
-      // See https://pouchdb.com/api.html#replication
-      // and https://pouchdb.com/api.html#sync (see example response)
-      var change = infos.change ? infos.change : infos;
-
-      if (change.docs) {
-        change.docs.filter(function (doc) {
-          return !isDesignDocument(doc) && !isDeletedDocument(doc);
-        }).forEach(function (doc) {
-          docs[doc._id] = doc;
-        });
+      if (initialReplication && strategy !== 'toRemote') {
+        ;
+        (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+          var end;
+          return _regenerator.default.wrap(function _callee2$(_context2) {
+            while (1) {
+              switch (_context2.prev = _context2.next) {
+                case 0:
+                  _context2.prev = 0;
+
+                  // For the first remote->local replication, we manually replicate all docs
+                  // as it avoids to replicate all revs history, which can lead to
+                  // performances issues
+                  _logger.default.info("PouchManager: Start first replication for ".concat(doctype));
+
+                  _context2.next = 4;
+                  return replicateAllDocs({
+                    db: pouch,
+                    baseUrl: url,
+                    doctype: doctype,
+                    storage: storage
+                  });
+
+                case 4:
+                  docs = _context2.sent;
+
+                  _logger.default.info("PouchManager: End first replication for ".concat(doctype));
+
+                  end = new Date();
+
+                  if (process.env.NODE_ENV !== 'production') {
+                    _logger.default.info("PouchManager: initial replication with all_docs for ".concat(url, " took ").concat(humanTimeDelta(end.getTime() - start.getTime())));
+                  }
+
+                  return _context2.abrupt("return", resolve(docs));
+
+                case 11:
+                  _context2.prev = 11;
+                  _context2.t0 = _context2["catch"](0);
+                  return _context2.abrupt("return", reject(_context2.t0));
+
+                case 14:
+                case "end":
+                  return _context2.stop();
+              }
+            }
+          }, _callee2, null, [[0, 11]]);
+        }))();
+        return;
       }
-    });
-    replication.on('error', reject).on('complete', function () {
-      var end = new Date();
 
-      if (process.env.NODE_ENV !== 'production') {
-        _logger.default.info("PouchManager: replication for ".concat(url, " took ").concat(humanTimeDelta(end.getTime() - start.getTime())));
+      if (strategy === 'fromRemote') {
+        replication = pouch.replicate.from(url, options);
+      } else if (strategy === 'toRemote') {
+        replication = pouch.replicate.to(url, options);
+      } else {
+        replication = pouch.sync(url, options);
       }
 
-      resolve(Object.values(docs));
-    });
+      replication.on('change', function (infos) {
+        //! Since we introduced the concept of strategy we can use
+        // PouchDB.replicate or PouchDB.sync. But both don't share the
+        // same API for the change's event.
+        // See https://pouchdb.com/api.html#replication
+        // and https://pouchdb.com/api.html#sync (see example response)
+        var change = infos.change ? infos.change : infos;
+
+        if (change.docs) {
+          change.docs.forEach(function (doc) {
+            if (!isDesignDocument(doc) && !isDeletedDocument(doc)) {
+              docs[doc._id] = doc;
+            }
+          });
+        }
+      });
+      replication.on('error', reject).on('complete', function () {
+        var end = new Date();
+
+        if (process.env.NODE_ENV !== 'production') {
+          _logger.default.info("PouchManager: replication for ".concat(url, " took ").concat(humanTimeDelta(end.getTime() - start.getTime())));
+        }
+
+        resolve(Object.values(docs));
+      });
+    }
   });
 
   var cancel = function cancel() {
@@ -208,53 +266,53 @@ var filterDocs = function filterDocs(docs) {
 
 
 var replicateAllDocs = /*#__PURE__*/function () {
-  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(_ref2) {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(_ref3) {
     var db, baseUrl, doctype, storage, remoteUrlAllDocs, batchSize, hasMore, startDocId, docs, res, _res, filteredDocs;
 
-    return _regenerator.default.wrap(function _callee2$(_context2) {
+    return _regenerator.default.wrap(function _callee3$(_context3) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context3.prev = _context3.next) {
           case 0:
-            db = _ref2.db, baseUrl = _ref2.baseUrl, doctype = _ref2.doctype, storage = _ref2.storage;
+            db = _ref3.db, baseUrl = _ref3.baseUrl, doctype = _ref3.doctype, storage = _ref3.storage;
             remoteUrlAllDocs = new URL("".concat(baseUrl, "/_all_docs"));
             batchSize = BATCH_SIZE;
             hasMore = true;
-            _context2.next = 6;
+            _context3.next = 6;
             return storage.getLastReplicatedDocID(doctype);
 
           case 6:
-            startDocId = _context2.sent;
+            startDocId = _context3.sent;
             // Get last replicated _id in localStorage
             docs = [];
 
           case 8:
             if (!hasMore) {
-              _context2.next = 42;
+              _context3.next = 42;
               break;
             }
 
             if (startDocId) {
-              _context2.next = 26;
+              _context3.next = 26;
               break;
             }
 
-            _context2.next = 12;
+            _context3.next = 12;
             return (0, _remote.fetchRemoteInstance)(remoteUrlAllDocs, {
               limit: batchSize,
               include_docs: true
             });
 
           case 12:
-            res = _context2.sent;
+            res = _context3.sent;
             docs = filterDocs(res.rows);
 
             if (!(docs.length === 0)) {
-              _context2.next = 18;
+              _context3.next = 18;
               break;
             }
 
             hasMore = false;
-            _context2.next = 24;
+            _context3.next = 24;
             break;
 
           case 18:
@@ -264,19 +322,19 @@ var replicateAllDocs = /*#__PURE__*/function () {
               hasMore = false;
             }
 
-            _context2.next = 22;
+            _context3.next = 22;
             return _helpers.default.insertBulkDocs(db, docs);
 
           case 22:
-            _context2.next = 24;
+            _context3.next = 24;
             return storage.persistLastReplicatedDocID(doctype, startDocId);
 
           case 24:
-            _context2.next = 40;
+            _context3.next = 40;
             break;
 
           case 26:
-            _context2.next = 28;
+            _context3.next = 28;
             return (0, _remote.fetchRemoteInstance)(remoteUrlAllDocs, {
               include_docs: true,
               limit: batchSize,
@@ -284,25 +342,25 @@ var replicateAllDocs = /*#__PURE__*/function () {
             });
 
           case 28:
-            _res = _context2.sent;
+            _res = _context3.sent;
             filteredDocs = filterDocs(_res.rows);
 
             if (!(filteredDocs.length < 2)) {
-              _context2.next = 32;
+              _context3.next = 32;
               break;
             }
 
-            return _context2.abrupt("return", docs);
+            return _context3.abrupt("return", docs);
 
           case 32:
             filteredDocs.shift(); // Remove first element, already included in previous request
 
             startDocId = filteredDocs[filteredDocs.length - 1]._id;
-            _context2.next = 36;
+            _context3.next = 36;
             return _helpers.default.insertBulkDocs(db, filteredDocs);
 
           case 36:
-            _context2.next = 38;
+            _context3.next = 38;
             return storage.persistLastReplicatedDocID(doctype, startDocId);
 
           case 38:
@@ -313,23 +371,201 @@ var replicateAllDocs = /*#__PURE__*/function () {
             }
 
           case 40:
-            _context2.next = 8;
+            _context3.next = 8;
             break;
 
           case 42:
-            return _context2.abrupt("return", docs);
+            return _context3.abrupt("return", docs);
 
           case 43:
           case "end":
-            return _context2.stop();
+            return _context3.stop();
         }
       }
-    }, _callee2);
+    }, _callee3);
   }));
 
   return function replicateAllDocs(_x) {
-    return _ref3.apply(this, arguments);
+    return _ref4.apply(this, arguments);
+  };
+}();
+/**
+ * Replicates all documents from a shared drive to a local PouchDB instance.
+ * This function fetches documents in batches from a twake drive shared drive
+ * and replicates them to the local database, maintaining replication state
+ * to allow for incremental updates.
+ * We do not have an _all_docs view for shared drives, so we use the fetchChanges method.
+ *
+ * @param {Object} params - The parameters object
+ * @param {string} params.driveId - The unique identifier of the shared drive to replicate from
+ * @param {Object} params.pouch - The local PouchDB instance to replicate documents to
+ * @param {Object} params.storage - Storage interface for persisting replication state
+ * @param {string} params.doctype - The document type being replicated (e.g., 'io.cozy.files')
+ * @param {boolean} params.initialReplication - Whether this is an initial replication
+ * @param {CozyClient} params.client - CozyClient instance for fetching remote documents
+ * @returns {Promise<Array>} A promise that resolves to an array of all replicated documents
+ * @throws {Error} Throws an error if driveId is not provided
+ */
+
+
+exports.replicateAllDocs = replicateAllDocs;
+
+var sharedDriveReplicateAllDocs = /*#__PURE__*/function () {
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(_ref5) {
+    var driveId, pouch, storage, _ref5$initialReplicat, initialReplication, doctype, client, docs, hasMore, doctypeLastSequence, _yield$client$collect, newLastSeq, results, pending, toDelete, toInsert, allDocsWithDriveId, _iterator, _step, doc, docWithDriveId, updatedToDeleteDocs, toBulkDelete;
+
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            driveId = _ref5.driveId, pouch = _ref5.pouch, storage = _ref5.storage, _ref5$initialReplicat = _ref5.initialReplication, initialReplication = _ref5$initialReplicat === void 0 ? false : _ref5$initialReplicat, doctype = _ref5.doctype, client = _ref5.client;
+
+            if (driveId) {
+              _context4.next = 3;
+              break;
+            }
+
+            throw new Error('sharedDriveReplicateAllDocs: driveId is required');
+
+          case 3:
+            docs = [];
+            hasMore = true;
+            _context4.next = 7;
+            return storage.getDoctypeLastSequence(doctype);
+
+          case 7:
+            doctypeLastSequence = _context4.sent;
+
+          case 8:
+            if (!hasMore) {
+              _context4.next = 38;
+              break;
+            }
+
+            _context4.next = 11;
+            return client.collection('io.cozy.files', {
+              driveId: driveId
+            }).fetchChanges(_objectSpread({
+              include_docs: true
+            }, doctypeLastSequence ? {
+              since: doctypeLastSequence
+            } : {}), _objectSpread(_objectSpread({
+              includeFilePath: false
+            }, initialReplication ? {
+              skipDeleted: true,
+              skipTrashed: true
+            } : {
+              skipDeleted: false,
+              skipTrashed: false
+            }), {}, {
+              limit: BATCH_SIZE
+            }));
+
+          case 11:
+            _yield$client$collect = _context4.sent;
+            newLastSeq = _yield$client$collect.newLastSeq;
+            results = _yield$client$collect.results;
+            pending = _yield$client$collect.pending;
+            toDelete = [];
+            toInsert = [];
+            allDocsWithDriveId = [];
+            _iterator = _createForOfIteratorHelper(results);
+
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                doc = _step.value;
+                docWithDriveId = doc.doc;
+                docWithDriveId.driveId = driveId;
+                allDocsWithDriveId.push(docWithDriveId);
+
+                if (doc.doc._deleted) {
+                  toDelete.push(doc.doc);
+                } else {
+                  toInsert.push(docWithDriveId);
+                }
+              } // FIXME this is a workaround to allow to delete documents from the shared drive
+              // changes
+              // PouchDB.bulkDocs ignores _deleted documents with revision newer than the existing
+              // document
+              // The workaround is to get documents from PouchDB with correct revision and delete them
+              // see https://github.com/pouchdb/pouchdb/issues/7841
+
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+
+            if (!(toDelete.length > 0)) {
+              _context4.next = 29;
+              break;
+            }
+
+            _context4.next = 23;
+            return pouch.bulkGet({
+              docs: toDelete.map(function (d) {
+                return {
+                  id: d._id
+                };
+              })
+            });
+
+          case 23:
+            updatedToDeleteDocs = _context4.sent;
+            toBulkDelete = updatedToDeleteDocs.results.map(function (doc) {
+              var _doc$docs, _doc$docs$;
+
+              return _objectSpread(_objectSpread({}, doc === null || doc === void 0 ? void 0 : (_doc$docs = doc.docs) === null || _doc$docs === void 0 ? void 0 : (_doc$docs$ = _doc$docs[0]) === null || _doc$docs$ === void 0 ? void 0 : _doc$docs$.ok), {}, {
+                _deleted: true
+              });
+            }).filter(function (doc) {
+              return doc._id;
+            });
+
+            if (!(toBulkDelete.length > 0)) {
+              _context4.next = 29;
+              break;
+            }
+
+            _context4.next = 28;
+            return pouch.bulkDocs(toBulkDelete);
+
+          case 28:
+            if (toBulkDelete.length !== toDelete.length) {
+              _logger.default.error("sharedDriveReplicateAllDocs: Error deleting documents ".concat(toDelete.map(function (d) {
+                return d._id;
+              }).join(', ')));
+            }
+
+          case 29:
+            doctypeLastSequence = newLastSeq;
+            _context4.next = 32;
+            return _helpers.default.insertBulkDocs(pouch, toInsert);
+
+          case 32:
+            _context4.next = 34;
+            return storage.persistDoctypeLastSequence(doctype, doctypeLastSequence);
+
+          case 34:
+            docs = docs.concat(allDocsWithDriveId);
+            hasMore = !!pending;
+            _context4.next = 8;
+            break;
+
+          case 38:
+            return _context4.abrupt("return", docs);
+
+          case 39:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function sharedDriveReplicateAllDocs(_x2) {
+    return _ref6.apply(this, arguments);
   };
 }();
 
-exports.replicateAllDocs = replicateAllDocs;
+exports.sharedDriveReplicateAllDocs = sharedDriveReplicateAllDocs;