cozy-pouch-link 48.25.0 → 49.0.0

package/dist/replicateOnce.js

@@ -0,0 +1,337 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replicateOnce = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _fromPairs = _interopRequireDefault(require("lodash/fromPairs"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _map = _interopRequireDefault(require("lodash/map"));
+
+var _startsWith = _interopRequireDefault(require("lodash/startsWith"));
+
+var _zip = _interopRequireDefault(require("lodash/zip"));
+
+var _logger = _interopRequireDefault(require("./logger"));
+
+var _remote = require("./remote");
+
+var _startReplication = require("./startReplication");
+
+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; }
+
+/**
+ * Process replication once for given PouchManager
+ *
+ * @param {import('./PouchManager').default} pouchManager - PouchManager that handle the replication
+ * @returns {Promise<any>} res
+ */
+var replicateOnce = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(pouchManager) {
+    var doctypes, promises, res, zippedDoctypes, successZippedDoctypes, failedZippedDoctypes, blockingErrors, unblockingErrors, _iterator, _step, unblockingError, doctype, errors, reasons, doctypeUpdated, doctypeFailed;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return pouchManager.isOnline();
+
+          case 2:
+            if (_context2.sent) {
+              _context2.next = 5;
+              break;
+            }
+
+            _logger.default.info('PouchManager: The device is offline so the replication has been skipped');
+
+            return _context2.abrupt("return", Promise.resolve());
+
+          case 5:
+            _logger.default.info('PouchManager: Starting replication iteration'); // Creating each replication
+
+
+            pouchManager.replications = (0, _map.default)(pouchManager.pouches, /*#__PURE__*/function () {
+              var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(pouch, doctype) {
+                var getReplicationURL, initialReplication, replicationFilter, seq, lastSeq, replicationOptions, res;
+                return _regenerator.default.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        _logger.default.info('PouchManager: Starting replication for ' + doctype);
+
+                        getReplicationURL = function getReplicationURL() {
+                          return pouchManager.getReplicationURL(doctype);
+                        };
+
+                        initialReplication = pouchManager.getSyncStatus(doctype) !== 'synced';
+
+                        replicationFilter = function replicationFilter(doc) {
+                          return !(0, _startsWith.default)(doc._id, '_design');
+                        };
+
+                        seq = '';
+
+                        if (!initialReplication) {
+                          _context.next = 13;
+                          break;
+                        }
+
+                        _context.next = 8;
+                        return (0, _remote.fetchRemoteLastSequence)(getReplicationURL());
+
+                      case 8:
+                        lastSeq = _context.sent;
+                        _context.next = 11;
+                        return pouchManager.storage.persistDoctypeLastSequence(doctype, lastSeq);
+
+                      case 11:
+                        _context.next = 16;
+                        break;
+
+                      case 13:
+                        _context.next = 15;
+                        return pouchManager.storage.getDoctypeLastSequence(doctype);
+
+                      case 15:
+                        seq = _context.sent;
+
+                      case 16:
+                        replicationOptions = (0, _get.default)(pouchManager.doctypesReplicationOptions, doctype, {});
+                        replicationOptions.initialReplication = initialReplication;
+                        replicationOptions.filter = replicationFilter;
+                        replicationOptions.since = seq;
+                        replicationOptions.doctype = doctype;
+
+                        if (pouchManager.options.onDoctypeSyncStart) {
+                          pouchManager.options.onDoctypeSyncStart(doctype);
+                        }
+
+                        _context.next = 24;
+                        return (0, _startReplication.startReplication)(pouch, replicationOptions, getReplicationURL, pouchManager.storage);
+
+                      case 24:
+                        res = _context.sent;
+
+                        if (!seq) {
+                          _context.next = 28;
+                          break;
+                        }
+
+                        _context.next = 28;
+                        return pouchManager.storage.destroyDoctypeLastSequence(doctype);
+
+                      case 28:
+                        _context.next = 30;
+                        return pouchManager.updateSyncInfo(doctype);
+
+                      case 30:
+                        pouchManager.checkToWarmupDoctype(doctype, replicationOptions);
+
+                        if (pouchManager.options.onDoctypeSyncEnd) {
+                          pouchManager.options.onDoctypeSyncEnd(doctype);
+                        }
+
+                        return _context.abrupt("return", res);
+
+                      case 33:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x2, _x3) {
+                return _ref2.apply(this, arguments);
+              };
+            }()); // Waiting on each replication
+
+            doctypes = Object.keys(pouchManager.pouches);
+            promises = Object.values(pouchManager.replications);
+            _context2.prev = 9;
+            _context2.next = 12;
+            return allSettled(promises);
+
+          case 12:
+            res = _context2.sent;
+
+            if (process.env.NODE_ENV !== 'production') {
+              _logger.default.info('PouchManager: Replication ended');
+            }
+
+            if (!pouchManager.options.onSync) {
+              _context2.next = 51;
+              break;
+            }
+
+            zippedDoctypes = (0, _zip.default)(doctypes, res);
+            successZippedDoctypes = zippedDoctypes.filter(function (d) {
+              return d[1].status === 'fulfilled';
+            }).map(function (d) {
+              return [d[0], d[1].value];
+            });
+            failedZippedDoctypes = zippedDoctypes.filter(function (d) {
+              return d[1].status === 'rejected';
+            }).map(function (d) {
+              return [d[0], d[1].reason];
+            });
+            blockingErrors = res.filter(function (r) {
+              return r.status === 'rejected' && !(0, _remote.isDatabaseNotFoundError)(r.reason) && !(0, _remote.isDatabaseUnradableError)(r.reason);
+            });
+            unblockingErrors = failedZippedDoctypes.filter(function (r) {
+              return (0, _remote.isDatabaseNotFoundError)(r[1]) || (0, _remote.isDatabaseUnradableError)(r[1]);
+            });
+            _iterator = _createForOfIteratorHelper(unblockingErrors);
+            _context2.prev = 21;
+
+            _iterator.s();
+
+          case 23:
+            if ((_step = _iterator.n()).done) {
+              _context2.next = 30;
+              break;
+            }
+
+            unblockingError = _step.value;
+            doctype = unblockingError[0]; // @ts-ignore
+
+            _context2.next = 28;
+            return pouchManager.updateSyncInfo(doctype, 'not_complete');
+
+          case 28:
+            _context2.next = 23;
+            break;
+
+          case 30:
+            _context2.next = 35;
+            break;
+
+          case 32:
+            _context2.prev = 32;
+            _context2.t0 = _context2["catch"](21);
+
+            _iterator.e(_context2.t0);
+
+          case 35:
+            _context2.prev = 35;
+
+            _iterator.f();
+
+            return _context2.finish(35);
+
+          case 38:
+            if (!(blockingErrors.length > 0)) {
+              _context2.next = 45;
+              break;
+            }
+
+            errors = blockingErrors.map(function (err) {
+              return err.reason;
+            });
+            reasons = errors.join('\n');
+
+            _logger.default.debug("ReplicateOnce's promises failed with the following errors", reasons); // @ts-ignore
+            // eslint-disable-next-line no-undef
+
+
+            throw new AggregateError(errors, 'Failed with blocking errors');
+
+          case 45:
+            _logger.default.debug("ReplicateOnce's promises succeed with no blocking errors");
+
+          case 46:
+            doctypeUpdated = (0, _fromPairs.default)(successZippedDoctypes);
+            doctypeFailed = (0, _fromPairs.default)(failedZippedDoctypes);
+
+            _logger.default.debug('Doctypes replications in error: ', Object.keys(doctypeFailed));
+
+            _logger.default.debug('Doctypes replications in success: ', Object.keys(doctypeUpdated));
+
+            pouchManager.options.onSync(doctypeUpdated);
+
+          case 51:
+            // @ts-ignore
+            res.cancel = pouchManager.cancelCurrentReplications;
+            return _context2.abrupt("return", res);
+
+          case 55:
+            _context2.prev = 55;
+            _context2.t1 = _context2["catch"](9);
+            pouchManager.handleReplicationError(_context2.t1);
+
+          case 58:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[9, 55], [21, 32, 35, 38]]);
+  }));
+
+  return function replicateOnce(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * @typedef {object} FulfilledPromise
+ * @property {'fulfilled'} status - The status of the promise
+ * @property {undefined} reason - The Error rejected by the promise (undefined when fulfilled)
+ * @property {any} value - The resolved value of the promise
+ */
+
+/**
+ * @typedef {object} RejectedPromise
+ * @property {'rejected'} status - The status of the promise
+ * @property {Error} reason - The Error rejected by the promise
+ * @property {undefined} value - The resolved value of the promise (undefined when rejected)
+ */
+
+/**
+ * Takes an iterable of promises as input and returns a single Promise.
+ * This returned promise fulfills when all of the input's promises settle (including
+ * when an empty iterable is passed), with an array of objects that describe the
+ * outcome of each promise.
+ *
+ * @param {Promise[]} promises - Promise to be awaited
+ * @returns {Promise<(FulfilledPromise|RejectedPromise)[]>}
+ */
+
+
+exports.replicateOnce = replicateOnce;
+
+var allSettled = function allSettled(promises) {
+  return Promise.all(promises.map(function (promise) {
+    return promise.then(function (value) {
+      return (
+        /** @type {FulfilledPromise} */
+        {
+          status: 'fulfilled',
+          value: value
+        }
+      );
+    }).catch(function (
+    /** @type {Error} */
+    reason) {
+      return (
+        /** @type {RejectedPromise} */
+        {
+          status: 'rejected',
+          reason: reason
+        }
+      );
+    });
+  }));
+};

package/dist/startReplication.js

@@ -23,8 +23,6 @@ var _logger = _interopRequireDefault(require("./logger"));
 
 var _remote = require("./remote");
 
-var _localStorage = require("./localStorage");
-
 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; }
@@ -51,6 +49,8 @@ var humanTimeDelta = function humanTimeDelta(timeMs) {
   str = "".concat(cur).concat(lastUnit[0]) + str;
   return str;
 };
+/** @type {[string, number][]} */
+
 
 var TIME_UNITS = [['ms', 1000], ['s', 60], ['m', 60], ['h', 24]];
 /**
@@ -62,15 +62,19 @@ var TIME_UNITS = [['ms', 1000], ['s', 60], ['m', 60], ['h', 24]];
  * @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.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
  *
- * @returns {Promise} A cancelable promise that resolves at the end of the replication
+ * @returns {import('./types').CancelablePromise} A cancelable promise that resolves at the end of the replication
  */
 
-var startReplication = function startReplication(pouch, replicationOptions, getReplicationURL) {
+var startReplication = function startReplication(pouch, replicationOptions, getReplicationURL, storage) {
   var replication;
   var docs = {};
   var start = new Date();
+  /** @type {import('./types').CancelablePromise} */
+
   var promise = new Promise(function (resolve, reject) {
     var url = getReplicationURL();
     var strategy = replicationOptions.strategy,
@@ -79,11 +83,15 @@ var startReplication = function startReplication(pouch, replicationOptions, getR
         doctype = replicationOptions.doctype,
         customReplicationOptions = (0, _objectWithoutProperties2.default)(replicationOptions, ["strategy", "initialReplication", "warmupQueries", "doctype"]);
 
-    var options = _objectSpread({
+    var options = _objectSpread(_objectSpread({
       batch_size: BATCH_SIZE
-    }, customReplicationOptions);
-
-    var replication;
+    }, customReplicationOptions), {}, {
+      selector: {
+        cozyLocalOnly: {
+          $exists: false
+        }
+      }
+    });
 
     if (initialReplication && strategy !== 'toRemote') {
       ;
@@ -94,14 +102,19 @@ var startReplication = function startReplication(pouch, replicationOptions, getR
             switch (_context.prev = _context.next) {
               case 0:
                 _context.next = 2;
-                return replicateAllDocs(pouch, url, doctype);
+                return replicateAllDocs({
+                  db: pouch,
+                  baseUrl: url,
+                  doctype: doctype,
+                  storage: storage
+                });
 
               case 2:
                 docs = _context.sent;
                 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 - start)));
+                  _logger.default.info("PouchManager: initial replication with all_docs for ".concat(url, " took ").concat(humanTimeDelta(end.getTime() - start.getTime())));
                 }
 
                 return _context.abrupt("return", resolve(docs));
@@ -113,6 +126,7 @@ var startReplication = function startReplication(pouch, replicationOptions, getR
           }
         }, _callee);
       }))();
+      return;
     }
 
     if (strategy === 'fromRemote') {
@@ -143,7 +157,7 @@ var startReplication = function startReplication(pouch, replicationOptions, getR
       var end = new Date();
 
       if (process.env.NODE_ENV !== 'production') {
-        _logger.default.info("PouchManager: replication for ".concat(url, " took ").concat(humanTimeDelta(end - start)));
+        _logger.default.info("PouchManager: replication for ".concat(url, " took ").concat(humanTimeDelta(end.getTime() - start.getTime())));
       }
 
       resolve(Object.values(docs));
@@ -176,117 +190,128 @@ var filterDocs = function filterDocs(docs) {
  * Note it saves the last replicated _id for each run and
  * starts from there in case the process stops before the end.
  *
- * @param {object} db - Pouch instance
- * @param {string} baseUrl - The remote instance
- * @param {string} doctype - The doctype to replicate
- * @returns {Array} The retrieved documents
+ * @param {object} params - The replications parameters
+ * @param {object} params.db - Pouch instance
+ * @param {string} params.baseUrl - The remote instance
+ * @param {string} params.doctype - The doctype to replicate
+ * @param {import('./localStorage').PouchLocalStorage} params.storage - Methods to access local storage
+ * @returns {Promise<Array>} The retrieved documents
  */
 
 
 var replicateAllDocs = /*#__PURE__*/function () {
-  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(db, baseUrl, doctype) {
-    var remoteUrlAllDocs, batchSize, hasMore, startDocId, docs, res, _res, filteredDocs;
+  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(_ref2) {
+    var db, baseUrl, doctype, storage, remoteUrlAllDocs, batchSize, hasMore, startDocId, docs, res, _res, filteredDocs;
 
     return _regenerator.default.wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
+            db = _ref2.db, baseUrl = _ref2.baseUrl, doctype = _ref2.doctype, storage = _ref2.storage;
             remoteUrlAllDocs = new URL("".concat(baseUrl, "/_all_docs"));
             batchSize = BATCH_SIZE;
             hasMore = true;
-            startDocId = (0, _localStorage.getLastReplicatedDocID)(doctype); // Get last replicated _id in localStorage
+            _context2.next = 6;
+            return storage.getLastReplicatedDocID(doctype);
 
+          case 6:
+            startDocId = _context2.sent;
+            // Get last replicated _id in localStorage
             docs = [];
 
-          case 5:
+          case 8:
             if (!hasMore) {
-              _context2.next = 37;
+              _context2.next = 42;
               break;
             }
 
             if (startDocId) {
-              _context2.next = 22;
+              _context2.next = 26;
               break;
             }
 
-            _context2.next = 9;
+            _context2.next = 12;
             return (0, _remote.fetchRemoteInstance)(remoteUrlAllDocs, {
               limit: batchSize,
               include_docs: true
             });
 
-          case 9:
+          case 12:
             res = _context2.sent;
             docs = filterDocs(res.rows);
 
             if (!(docs.length === 0)) {
-              _context2.next = 15;
+              _context2.next = 18;
               break;
             }
 
             hasMore = false;
-            _context2.next = 20;
+            _context2.next = 24;
             break;
 
-          case 15:
+          case 18:
             startDocId = docs[docs.length - 1]._id;
 
             if (docs.length < batchSize) {
               hasMore = false;
             }
 
-            _context2.next = 19;
+            _context2.next = 22;
             return _helpers.default.insertBulkDocs(db, docs);
 
-          case 19:
-            (0, _localStorage.persistLastReplicatedDocID)(doctype, startDocId);
+          case 22:
+            _context2.next = 24;
+            return storage.persistLastReplicatedDocID(doctype, startDocId);
 
-          case 20:
-            _context2.next = 35;
+          case 24:
+            _context2.next = 40;
             break;
 
-          case 22:
-            _context2.next = 24;
+          case 26:
+            _context2.next = 28;
             return (0, _remote.fetchRemoteInstance)(remoteUrlAllDocs, {
               include_docs: true,
               limit: batchSize,
               startkey_docid: startDocId
             });
 
-          case 24:
+          case 28:
             _res = _context2.sent;
             filteredDocs = filterDocs(_res.rows);
 
             if (!(filteredDocs.length < 2)) {
-              _context2.next = 28;
+              _context2.next = 32;
               break;
             }
 
             return _context2.abrupt("return", docs);
 
-          case 28:
+          case 32:
             filteredDocs.shift(); // Remove first element, already included in previous request
 
             startDocId = filteredDocs[filteredDocs.length - 1]._id;
-            _context2.next = 32;
+            _context2.next = 36;
             return _helpers.default.insertBulkDocs(db, filteredDocs);
 
-          case 32:
-            (0, _localStorage.persistLastReplicatedDocID)(doctype, startDocId);
+          case 36:
+            _context2.next = 38;
+            return storage.persistLastReplicatedDocID(doctype, startDocId);
+
+          case 38:
             docs = docs.concat(filteredDocs);
 
             if (_res.rows.length < batchSize) {
               hasMore = false;
             }
 
-          case 35:
-            _context2.next = 5;
+          case 40:
+            _context2.next = 8;
             break;
 
-          case 37:
+          case 42:
             return _context2.abrupt("return", docs);
 
-          case 38:
+          case 43:
           case "end":
             return _context2.stop();
         }
@@ -294,8 +319,8 @@ var replicateAllDocs = /*#__PURE__*/function () {
     }, _callee2);
   }));
 
-  return function replicateAllDocs(_x, _x2, _x3) {
-    return _ref2.apply(this, arguments);
+  return function replicateAllDocs(_x) {
+    return _ref3.apply(this, arguments);
   };
 }();