cozy-pouch-link 48.25.0 → 49.1.0

package/dist/PouchManager.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
 Object.defineProperty(exports, "__esModule", {
@@ -17,39 +15,32 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _pouchdbBrowser = _interopRequireDefault(require("pouchdb-browser"));
-
 var _fromPairs = _interopRequireDefault(require("lodash/fromPairs"));
 
 var _forEach = _interopRequireDefault(require("lodash/forEach"));
 
 var _get = _interopRequireDefault(require("lodash/get"));
 
-var _map = _interopRequireDefault(require("lodash/map"));
-
-var _zip = _interopRequireDefault(require("lodash/zip"));
-
-var _startsWith = _interopRequireDefault(require("lodash/startsWith"));
-
 var _cozyDeviceHelper = require("cozy-device-helper");
 
-var _cozyClient = require("cozy-client");
+var _localStorage = require("./localStorage");
 
 var _loop = _interopRequireDefault(require("./loop"));
 
 var _logger = _interopRequireDefault(require("./logger"));
 
-var _remote = require("./remote");
-
-var _startReplication = require("./startReplication");
+var _platformWeb = require("./platformWeb");
 
-var localStorage = _interopRequireWildcard(require("./localStorage"));
+var _replicateOnce3 = require("./replicateOnce");
 
 var _utils = require("./utils");
 
-var DEFAULT_DELAY = 30 * 1000;
+var DEFAULT_DELAY = 30 * 1000; // See view_update_changes_batch_size in https://pouchdb.com/api.html#create_database
+// PouchDB default is 50, which badly hurt performances for large databases
+
+var DEFAULT_VIEW_UPDATE_BATCH = 1000;
 /**
- * @param {QueryDefinition} query The query definition whose name we're getting
+ * @param {import('cozy-client/types/types').Query} query The query definition whose name we're getting
  *
  * @returns {string} alias
  */
@@ -67,41 +58,92 @@ var getQueryAlias = function getQueryAlias(query) {
 
 var PouchManager = /*#__PURE__*/function () {
   function PouchManager(doctypes, options) {
+    var _options$platform, _options$platform2, _options$platform3, _options$platform4;
+
     (0, _classCallCheck2.default)(this, PouchManager);
     this.options = options;
-    var pouchPlugins = (0, _get.default)(options, 'pouch.plugins', []);
-    var pouchOptions = (0, _get.default)(options, 'pouch.options', {});
-    (0, _forEach.default)(pouchPlugins, function (plugin) {
-      return _pouchdbBrowser.default.plugin(plugin);
-    });
-    this.pouches = (0, _fromPairs.default)(doctypes.map(function (doctype) {
-      return [doctype, new _pouchdbBrowser.default((0, _utils.getDatabaseName)(options.prefix, doctype), pouchOptions)];
-    }));
-    this.syncedDoctypes = localStorage.getPersistedSyncedDoctypes();
-    this.warmedUpQueries = localStorage.getPersistedWarmedUpQueries();
-    this.getReplicationURL = options.getReplicationURL;
-    this.doctypesReplicationOptions = options.doctypesReplicationOptions || {};
-    this.listenerLaunched = false; // We must ensure databases exist on the remote before
-    // starting replications
-
-    this.ensureDatabasesExistDone = false;
-    this.startReplicationLoop = this.startReplicationLoop.bind(this);
-    this.stopReplicationLoop = this.stopReplicationLoop.bind(this);
-    this.replicateOnce = this.replicateOnce.bind(this);
-    this.executeQuery = this.options.executeQuery;
+    this.doctypes = doctypes;
+    this.storage = new _localStorage.PouchLocalStorage(((_options$platform = options.platform) === null || _options$platform === void 0 ? void 0 : _options$platform.storage) || _platformWeb.platformWeb.storage);
+    this.PouchDB = ((_options$platform2 = options.platform) === null || _options$platform2 === void 0 ? void 0 : _options$platform2.pouchAdapter) || _platformWeb.platformWeb.pouchAdapter;
+    this.isOnline = ((_options$platform3 = options.platform) === null || _options$platform3 === void 0 ? void 0 : _options$platform3.isOnline) || _platformWeb.platformWeb.isOnline;
+    this.events = ((_options$platform4 = options.platform) === null || _options$platform4 === void 0 ? void 0 : _options$platform4.events) || _platformWeb.platformWeb.events;
   }
 
   (0, _createClass2.default)(PouchManager, [{
+    key: "init",
+    value: function () {
+      var _init = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var _this = this;
+
+        var pouchPlugins, pouchOptions;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                pouchPlugins = (0, _get.default)(this.options, 'pouch.plugins', []);
+                pouchOptions = (0, _get.default)(this.options, 'pouch.options', {});
+
+                if (!pouchOptions.view_update_changes_batch_size) {
+                  pouchOptions.view_update_changes_batch_size = DEFAULT_VIEW_UPDATE_BATCH;
+                }
+
+                (0, _forEach.default)(pouchPlugins, function (plugin) {
+                  return _this.PouchDB.plugin(plugin);
+                });
+                this.pouches = (0, _fromPairs.default)(this.doctypes.map(function (doctype) {
+                  return [doctype, new _this.PouchDB((0, _utils.getDatabaseName)(_this.options.prefix, doctype), pouchOptions)];
+                }));
+                /** @type {Record<string, import('./types').SyncInfo>} - Stores synchronization info per doctype */
+
+                _context.next = 7;
+                return this.storage.getPersistedSyncedDoctypes();
+
+              case 7:
+                this.syncedDoctypes = _context.sent;
+                _context.next = 10;
+                return this.storage.getPersistedWarmedUpQueries();
+
+              case 10:
+                this.warmedUpQueries = _context.sent;
+                this.getReplicationURL = this.options.getReplicationURL;
+                this.doctypesReplicationOptions = this.options.doctypesReplicationOptions || {};
+                this.listenerLaunched = false; // We must ensure databases exist on the remote before
+                // starting replications
+
+                this.ensureDatabasesExistDone = false;
+                this.startReplicationLoop = this.startReplicationLoop.bind(this);
+                this.stopReplicationLoop = this.stopReplicationLoop.bind(this);
+                this.replicateOnce = this.replicateOnce.bind(this);
+                this.executeQuery = this.options.executeQuery;
+                /** @type {import('./types').CancelablePromise[]} - Stores replication promises */
+
+                this.replications = undefined;
+
+              case 20:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function init() {
+        return _init.apply(this, arguments);
+      }
+
+      return init;
+    }()
+  }, {
     key: "addListeners",
     value: function addListeners() {
       if (!this.listenerLaunched) {
         if ((0, _cozyDeviceHelper.isMobileApp)()) {
-          document.addEventListener('pause', this.stopReplicationLoop);
-          document.addEventListener('resume', this.startReplicationLoop);
+          this.events.addEventListener('pause', this.stopReplicationLoop);
+          this.events.addEventListener('resume', this.startReplicationLoop);
         }
 
-        document.addEventListener('online', this.startReplicationLoop);
-        document.addEventListener('offline', this.stopReplicationLoop);
+        this.events.addEventListener('online', this.startReplicationLoop);
+        this.events.addEventListener('offline', this.stopReplicationLoop);
         this.listenerLaunched = true;
       }
     }
@@ -110,28 +152,59 @@ var PouchManager = /*#__PURE__*/function () {
     value: function removeListeners() {
       if (this.listenerLaunched) {
         if ((0, _cozyDeviceHelper.isMobileApp)()) {
-          document.removeEventListener('pause', this.stopReplicationLoop);
-          document.removeEventListener('resume', this.startReplicationLoop);
+          this.events.removeEventListener('pause', this.stopReplicationLoop);
+          this.events.removeEventListener('resume', this.startReplicationLoop);
         }
 
-        document.removeEventListener('online', this.startReplicationLoop);
-        document.removeEventListener('offline', this.stopReplicationLoop);
+        this.events.removeEventListener('online', this.startReplicationLoop);
+        this.events.removeEventListener('offline', this.stopReplicationLoop);
         this.listenerLaunched = false;
       }
     }
   }, {
     key: "destroy",
-    value: function destroy() {
-      this.stopReplicationLoop();
-      this.removeListeners();
-      this.clearSyncedDoctypes();
-      this.clearWarmedUpQueries();
-      localStorage.destroyAllDoctypeLastSequence();
-      localStorage.destroyAllLastReplicatedDocID();
-      return Promise.all(Object.values(this.pouches).map(function (pouch) {
-        return pouch.destroy();
+    value: function () {
+      var _destroy = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                this.stopReplicationLoop();
+                this.removeListeners();
+                _context2.next = 4;
+                return this.clearSyncedDoctypes();
+
+              case 4:
+                _context2.next = 6;
+                return this.clearWarmedUpQueries();
+
+              case 6:
+                _context2.next = 8;
+                return this.storage.destroyAllDoctypeLastSequence();
+
+              case 8:
+                _context2.next = 10;
+                return this.storage.destroyAllLastReplicatedDocID();
+
+              case 10:
+                return _context2.abrupt("return", Promise.all(Object.values(this.pouches).map(function (pouch) {
+                  return pouch.destroy();
+                })));
+
+              case 11:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
       }));
-    }
+
+      function destroy() {
+        return _destroy.apply(this, arguments);
+      }
+
+      return destroy;
+    }()
     /**
      * Via a call to info() we ensure the database exist on the
      * remote side. This is done only once since after the first
@@ -141,35 +214,35 @@ var PouchManager = /*#__PURE__*/function () {
   }, {
     key: "ensureDatabasesExist",
     value: function () {
-      var _ensureDatabasesExist = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var _this = this;
+      var _ensureDatabasesExist = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        var _this2 = this;
 
-        return _regenerator.default.wrap(function _callee$(_context) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
           while (1) {
-            switch (_context.prev = _context.next) {
+            switch (_context3.prev = _context3.next) {
               case 0:
                 if (!this.ensureDatabasesExistDone) {
-                  _context.next = 2;
+                  _context3.next = 2;
                   break;
                 }
 
-                return _context.abrupt("return", Promise.resolve());
+                return _context3.abrupt("return", Promise.resolve());
 
               case 2:
-                return _context.abrupt("return", Promise.all(Object.values(this.pouches).map(function (pouch) {
+                return _context3.abrupt("return", Promise.all(Object.values(this.pouches).map(function (pouch) {
                   return pouch.info();
                 })).then(function () {
                   _logger.default.info('PouchManager: ensure databases exist done');
 
-                  _this.ensureDatabasesExistDone = true;
+                  _this2.ensureDatabasesExistDone = true;
                 }));
 
               case 3:
               case "end":
-                return _context.stop();
+                return _context3.stop();
             }
           }
-        }, _callee, this);
+        }, _callee3, this);
       }));
 
       function ensureDatabasesExist() {
@@ -178,29 +251,33 @@ var PouchManager = /*#__PURE__*/function () {
 
       return ensureDatabasesExist;
     }()
-    /** Starts periodic syncing of the pouches */
+    /**
+     * Starts periodic syncing of the pouches
+     *
+     * @returns {Promise<Loop | void>}
+     */
 
   }, {
     key: "startReplicationLoop",
     value: function () {
-      var _startReplicationLoop = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var _startReplicationLoop = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
         var delay;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
           while (1) {
-            switch (_context2.prev = _context2.next) {
+            switch (_context4.prev = _context4.next) {
               case 0:
-                _context2.next = 2;
+                _context4.next = 2;
                 return this.ensureDatabasesExist();
 
               case 2:
                 if (!this.replicationLoop) {
-                  _context2.next = 5;
+                  _context4.next = 5;
                   break;
                 }
 
                 _logger.default.warn('Replication loop already started');
 
-                return _context2.abrupt("return");
+                return _context4.abrupt("return");
 
               case 5:
                 if (process.env.NODE_ENV !== 'production') {
@@ -211,14 +288,14 @@ var PouchManager = /*#__PURE__*/function () {
                 this.replicationLoop = new _loop.default(this.replicateOnce, delay);
                 this.replicationLoop.start();
                 this.addListeners();
-                return _context2.abrupt("return", this.replicationLoop);
+                return _context4.abrupt("return", this.replicationLoop);
 
               case 11:
               case "end":
-                return _context2.stop();
+                return _context4.stop();
             }
           }
-        }, _callee2, this);
+        }, _callee4, this);
       }));
 
       function startReplicationLoop() {
@@ -261,147 +338,23 @@ var PouchManager = /*#__PURE__*/function () {
   }, {
     key: "replicateOnce",
     value: function () {
-      var _replicateOnce = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
-        var _this2 = this;
-
-        var doctypes, promises, res, doctypeUpdates;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
+      var _replicateOnce2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+        return _regenerator.default.wrap(function _callee5$(_context5) {
           while (1) {
-            switch (_context4.prev = _context4.next) {
+            switch (_context5.prev = _context5.next) {
               case 0:
-                if (window.navigator.onLine) {
-                  _context4.next = 3;
-                  break;
-                }
-
-                _logger.default.info('PouchManager: The device is offline so the replication has been skipped');
-
-                return _context4.abrupt("return", Promise.resolve());
-
-              case 3:
-                _logger.default.info('PouchManager: Starting replication iteration'); // Creating each replication
-
-
-                this.replications = (0, _map.default)(this.pouches, /*#__PURE__*/function () {
-                  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(pouch, doctype) {
-                    var getReplicationURL, initialReplication, replicationFilter, seq, lastSeq, replicationOptions, res;
-                    return _regenerator.default.wrap(function _callee3$(_context3) {
-                      while (1) {
-                        switch (_context3.prev = _context3.next) {
-                          case 0:
-                            _logger.default.info('PouchManager: Starting replication for ' + doctype);
-
-                            getReplicationURL = function getReplicationURL() {
-                              return _this2.getReplicationURL(doctype);
-                            };
-
-                            initialReplication = !_this2.isSynced(doctype);
-
-                            replicationFilter = function replicationFilter(doc) {
-                              return !(0, _startsWith.default)(doc._id, '_design');
-                            };
-
-                            seq = '';
-
-                            if (!initialReplication) {
-                              _context3.next = 12;
-                              break;
-                            }
-
-                            _context3.next = 8;
-                            return (0, _remote.fetchRemoteLastSequence)(getReplicationURL());
-
-                          case 8:
-                            lastSeq = _context3.sent;
-                            localStorage.persistDoctypeLastSequence(doctype, lastSeq);
-                            _context3.next = 13;
-                            break;
-
-                          case 12:
-                            seq = localStorage.getDoctypeLastSequence(doctype);
-
-                          case 13:
-                            replicationOptions = (0, _get.default)(_this2.doctypesReplicationOptions, doctype, {});
-                            replicationOptions.initialReplication = initialReplication;
-                            replicationOptions.filter = replicationFilter;
-                            replicationOptions.since = seq;
-                            replicationOptions.doctype = doctype;
-
-                            if (_this2.options.onDoctypeSyncStart) {
-                              _this2.options.onDoctypeSyncStart(doctype);
-                            }
-
-                            _context3.next = 21;
-                            return (0, _startReplication.startReplication)(pouch, replicationOptions, getReplicationURL);
-
-                          case 21:
-                            res = _context3.sent;
-
-                            if (seq) {
-                              // We only need the sequence for the second replication, as PouchDB
-                              // will use a local checkpoint for the next runs.
-                              localStorage.destroyDoctypeLastSequence(doctype);
-                            }
-
-                            _this2.updateSyncInfo(doctype);
-
-                            _this2.checkToWarmupDoctype(doctype, replicationOptions);
-
-                            if (_this2.options.onDoctypeSyncEnd) {
-                              _this2.options.onDoctypeSyncEnd(doctype);
-                            }
-
-                            return _context3.abrupt("return", res);
-
-                          case 27:
-                          case "end":
-                            return _context3.stop();
-                        }
-                      }
-                    }, _callee3);
-                  }));
-
-                  return function (_x, _x2) {
-                    return _ref.apply(this, arguments);
-                  };
-                }()); // Waiting on each replication
+                return _context5.abrupt("return", (0, _replicateOnce3.replicateOnce)(this));
 
-                doctypes = Object.keys(this.pouches);
-                promises = Object.values(this.replications);
-                _context4.prev = 7;
-                _context4.next = 10;
-                return Promise.all(promises);
-
-              case 10:
-                res = _context4.sent;
-
-                if (process.env.NODE_ENV !== 'production') {
-                  _logger.default.info('PouchManager: Replication ended');
-                }
-
-                if (this.options.onSync) {
-                  doctypeUpdates = (0, _fromPairs.default)((0, _zip.default)(doctypes, res));
-                  this.options.onSync(doctypeUpdates);
-                }
-
-                res.cancel = this.cancelCurrentReplications;
-                return _context4.abrupt("return", res);
-
-              case 17:
-                _context4.prev = 17;
-                _context4.t0 = _context4["catch"](7);
-                this.handleReplicationError(_context4.t0);
-
-              case 20:
+              case 1:
               case "end":
-                return _context4.stop();
+                return _context5.stop();
             }
           }
-        }, _callee4, this, [[7, 17]]);
+        }, _callee5, this);
       }));
 
       function replicateOnce() {
-        return _replicateOnce.apply(this, arguments);
+        return _replicateOnce2.apply(this, arguments);
       }
 
       return replicateOnce;
@@ -409,7 +362,14 @@ var PouchManager = /*#__PURE__*/function () {
   }, {
     key: "handleReplicationError",
     value: function handleReplicationError(err) {
-      _logger.default.warn('PouchManager: Error during replication', err); // On error, replication stops, it needs to be started
+      var aggregatedMessage = ''; // @ts-ignore
+      // eslint-disable-next-line no-undef
+
+      if (err instanceof AggregateError) {
+        aggregatedMessage = (0, _utils.formatAggregatedError)(err);
+      }
+
+      _logger.default.warn("PouchManager: Error during replication - ".concat(err.message).concat(aggregatedMessage)); // On error, replication stops, it needs to be started
       // again manually by the owner of PouchManager
 
 
@@ -446,59 +406,124 @@ var PouchManager = /*#__PURE__*/function () {
     value: function getPouch(doctype) {
       return this.pouches[doctype];
     }
+    /**
+     * Update the Sync info for the specifed doctype
+     *
+     * @param {string} doctype - The doctype to update
+     * @param {import('./types').SyncStatus} status - The new Sync status for the doctype
+     */
+
   }, {
     key: "updateSyncInfo",
-    value: function updateSyncInfo(doctype) {
-      this.syncedDoctypes[doctype] = {
-        date: new Date().toISOString()
-      };
-      localStorage.persistSyncedDoctypes(this.syncedDoctypes);
-    }
+    value: function () {
+      var _updateSyncInfo = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(doctype) {
+        var status,
+            _args6 = arguments;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                status = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : 'synced';
+                this.syncedDoctypes[doctype] = {
+                  date: new Date().toISOString(),
+                  status: status
+                };
+                _context6.next = 4;
+                return this.storage.persistSyncedDoctypes(this.syncedDoctypes);
+
+              case 4:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function updateSyncInfo(_x) {
+        return _updateSyncInfo.apply(this, arguments);
+      }
+
+      return updateSyncInfo;
+    }()
+    /**
+     * Get the Sync info for the specified doctype
+     *
+     * @param {string} doctype - The doctype to check
+     * @returns {import('./types').SyncInfo}
+     */
+
   }, {
     key: "getSyncInfo",
     value: function getSyncInfo(doctype) {
       return this.syncedDoctypes && this.syncedDoctypes[doctype];
     }
+    /**
+     * Get the Sync status for the specified doctype
+     *
+     * @param {string} doctype - The doctype to check
+     * @returns {import('./types').SyncStatus}
+     */
+
   }, {
-    key: "isSynced",
-    value: function isSynced(doctype) {
+    key: "getSyncStatus",
+    value: function getSyncStatus(doctype) {
       var info = this.getSyncInfo(doctype);
-      return info ? !!info.date : false;
+      return (info === null || info === void 0 ? void 0 : info.status) || 'not_synced';
     }
   }, {
     key: "clearSyncedDoctypes",
-    value: function clearSyncedDoctypes() {
-      this.syncedDoctypes = {};
-      localStorage.destroySyncedDoctypes();
-    }
+    value: function () {
+      var _clearSyncedDoctypes = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                this.syncedDoctypes = {};
+                _context7.next = 3;
+                return this.storage.destroySyncedDoctypes();
+
+              case 3:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function clearSyncedDoctypes() {
+        return _clearSyncedDoctypes.apply(this, arguments);
+      }
+
+      return clearSyncedDoctypes;
+    }()
   }, {
     key: "warmupQueries",
     value: function () {
-      var _warmupQueries = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(doctype, queries) {
+      var _warmupQueries = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(doctype, queries) {
         var _this3 = this;
 
-        return _regenerator.default.wrap(function _callee6$(_context6) {
+        return _regenerator.default.wrap(function _callee9$(_context9) {
           while (1) {
-            switch (_context6.prev = _context6.next) {
+            switch (_context9.prev = _context9.next) {
               case 0:
                 if (!this.warmedUpQueries[doctype]) this.warmedUpQueries[doctype] = [];
-                _context6.prev = 1;
-                _context6.next = 4;
+                _context9.prev = 1;
+                _context9.next = 4;
                 return Promise.all(queries.map( /*#__PURE__*/function () {
-                  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(query) {
+                  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(query) {
                     var def;
-                    return _regenerator.default.wrap(function _callee5$(_context5) {
+                    return _regenerator.default.wrap(function _callee8$(_context8) {
                       while (1) {
-                        switch (_context5.prev = _context5.next) {
+                        switch (_context8.prev = _context8.next) {
                           case 0:
                             def = getQueryAlias(query);
 
                             if (_this3.warmedUpQueries[doctype].includes(def)) {
-                              _context5.next = 5;
+                              _context8.next = 5;
                               break;
                             }
 
-                            _context5.next = 4;
+                            _context8.next = 4;
                             return _this3.executeQuery(query.definition().toDefinition());
 
                           case 4:
@@ -506,42 +531,44 @@ var PouchManager = /*#__PURE__*/function () {
 
                           case 5:
                           case "end":
-                            return _context5.stop();
+                            return _context8.stop();
                         }
                       }
-                    }, _callee5);
+                    }, _callee8);
                   }));
 
-                  return function (_x5) {
-                    return _ref2.apply(this, arguments);
+                  return function (_x4) {
+                    return _ref.apply(this, arguments);
                   };
                 }()));
 
               case 4:
-                localStorage.persistWarmedUpQueries(this.warmedUpQueries);
+                _context9.next = 6;
+                return this.storage.persistWarmedUpQueries(this.warmedUpQueries);
 
+              case 6:
                 _logger.default.log('PouchManager: warmupQueries for ' + doctype + ' are done');
 
-                _context6.next = 12;
+                _context9.next = 13;
                 break;
 
-              case 8:
-                _context6.prev = 8;
-                _context6.t0 = _context6["catch"](1);
+              case 9:
+                _context9.prev = 9;
+                _context9.t0 = _context9["catch"](1);
 
-                _logger.default.error('PouchManager: Could not warm up queries for ' + doctype, _context6.t0);
+                _logger.default.error('PouchManager: Could not warm up queries for ' + doctype, _context9.t0);
 
                 delete this.warmedUpQueries[doctype];
 
-              case 12:
+              case 13:
               case "end":
-                return _context6.stop();
+                return _context9.stop();
             }
           }
-        }, _callee6, this, [[1, 8]]);
+        }, _callee9, this, [[1, 9]]);
       }));
 
-      function warmupQueries(_x3, _x4) {
+      function warmupQueries(_x2, _x3) {
         return _warmupQueries.apply(this, arguments);
       }
 
@@ -559,18 +586,62 @@ var PouchManager = /*#__PURE__*/function () {
     }
   }, {
     key: "areQueriesWarmedUp",
-    value: function areQueriesWarmedUp(doctype, queries) {
-      var persistWarmedUpQueries = localStorage.getPersistedWarmedUpQueries();
-      return queries.every(function (query) {
-        return persistWarmedUpQueries[doctype] && persistWarmedUpQueries[doctype].includes(getQueryAlias(query));
-      });
-    }
+    value: function () {
+      var _areQueriesWarmedUp = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(doctype, queries) {
+        var persistWarmedUpQueries;
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                _context10.next = 2;
+                return this.storage.getPersistedWarmedUpQueries();
+
+              case 2:
+                persistWarmedUpQueries = _context10.sent;
+                return _context10.abrupt("return", queries.every(function (query) {
+                  return persistWarmedUpQueries[doctype] && persistWarmedUpQueries[doctype].includes(getQueryAlias(query));
+                }));
+
+              case 4:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this);
+      }));
+
+      function areQueriesWarmedUp(_x5, _x6) {
+        return _areQueriesWarmedUp.apply(this, arguments);
+      }
+
+      return areQueriesWarmedUp;
+    }()
   }, {
     key: "clearWarmedUpQueries",
-    value: function clearWarmedUpQueries() {
-      this.warmedUpQueries = {};
-      localStorage.destroyWarmedUpQueries();
-    }
+    value: function () {
+      var _clearWarmedUpQueries = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
+        return _regenerator.default.wrap(function _callee11$(_context11) {
+          while (1) {
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                this.warmedUpQueries = {};
+                _context11.next = 3;
+                return this.storage.destroyWarmedUpQueries();
+
+              case 3:
+              case "end":
+                return _context11.stop();
+            }
+          }
+        }, _callee11, this);
+      }));
+
+      function clearWarmedUpQueries() {
+        return _clearWarmedUpQueries.apply(this, arguments);
+      }
+
+      return clearWarmedUpQueries;
+    }()
   }]);
   return PouchManager;
 }();