cozy-pouch-link 48.25.0 → 49.0.0

package/dist/CozyPouchLink.js

@@ -51,13 +51,15 @@ var jsonapi = _interopRequireWildcard(require("./jsonapi"));
 
 var _PouchManager = _interopRequireDefault(require("./PouchManager"));
 
+var _localStorage = require("./localStorage");
+
 var _logger = _interopRequireDefault(require("./logger"));
 
 var _adapter = require("./migrations/adapter");
 
-var _utils = require("./utils");
+var _platformWeb = require("./platformWeb");
 
-var _localStorage = require("./localStorage");
+var _utils = require("./utils");
 
 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; } } }; }
 
@@ -107,7 +109,9 @@ var _getReplicationURL = function getReplicationURL(uri, token, doctype) {
 
 exports.getReplicationURL = _getReplicationURL;
 
-var doNothing = function doNothing() {};
+var doNothing = function doNothing(operation) {
+  var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+};
 
 var expiredTokenError = /Expired token/;
 
@@ -117,13 +121,25 @@ var isExpiredTokenError = function isExpiredTokenError(pouchError) {
 
 exports.isExpiredTokenError = isExpiredTokenError;
 
-var normalizeAll = function normalizeAll(docs, doctype) {
-  return docs.map(function (doc) {
-    return jsonapi.normalizeDoc(doc, doctype);
-  });
+var normalizeAll = function normalizeAll(client) {
+  return function (docs, doctype) {
+    return docs.map(function (doc) {
+      return jsonapi.normalizeDoc(doc, doctype, client);
+    });
+  };
 };
 /**
- * @typedef {"idle"|"replicating"} SyncStatus
+ * @typedef {import('cozy-client/src/types').CozyClientDocument} CozyClientDocument
+ *
+ * @typedef {"idle"|"replicating"} ReplicationStatus
+ */
+
+/**
+ * @typedef {object} PouchLinkOptions
+ * @property {number} [replicationInterval] Milliseconds between replications
+ * @property {string[]} doctypes Doctypes to replicate
+ * @property {Record<string, object>} doctypesReplicationOptions A mapping from doctypes to replication options. All pouch replication options can be used, as well as the "strategy" option that determines which way the replication is done (can be "sync", "fromRemote" or "toRemote")
+ * @property {import('./types').LinkPlatform} platform Platform specific adapters and methods
  */
 
 /**
@@ -141,16 +157,13 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   /**
    * constructor - Initializes a new PouchLink
    *
-   * @param {object} [opts={}]
-   * @param {number} [opts.replicationInterval] Milliseconds between replications
-   * @param {string[]} opts.doctypes Doctypes to replicate
-   * @param {object[]} opts.doctypesReplicationOptions A mapping from doctypes to replication options. All pouch replication options can be used, as well as the "strategy" option that determines which way the replication is done (can be "sync", "fromRemote" or "toRemote")
-   * @returns {object} The PouchLink instance
+   * @param {PouchLinkOptions} [opts={}]
    */
-  function PouchLink() {
+  function PouchLink(opts) {
+    var _options$platform;
+
     var _this;
 
-    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     (0, _classCallCheck2.default)(this, PouchLink);
     var options = (0, _defaults.default)({}, opts, DEFAULT_OPTIONS);
     _this = _super.call(this, options);
@@ -165,7 +178,8 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
     _this.doctypes = doctypes;
     _this.doctypesReplicationOptions = doctypesReplicationOptions;
     _this.indexes = {};
-    /** @type {Record<string, SyncStatus>} - Stores replication states per doctype */
+    _this.storage = new _localStorage.PouchLocalStorage(((_options$platform = options.platform) === null || _options$platform === void 0 ? void 0 : _options$platform.storage) || _platformWeb.platformWeb.storage);
+    /** @type {Record<string, ReplicationStatus>} - Stores replication states per doctype */
 
     _this.replicationStatus = _this.replicationStatus || {};
     return _this;
@@ -174,7 +188,8 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
    * Return the PouchDB adapter name.
    * Should be IndexedDB for newest adapters.
    *
-   * @returns {string} The adapter name
+   * @param {import('./types').LocalStorage} localStorage Methods to access local storage
+   * @returns {Promise<string>} The adapter name
    */
 
 
@@ -256,49 +271,57 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
                   _iterator.f();
                 }
 
-                doctypes = (0, _localStorage.getPersistedSyncedDoctypes)();
-                _i = 0, _Object$keys = Object.keys(doctypes);
+                _context2.next = 6;
+                return this.storage.getPersistedSyncedDoctypes();
 
               case 6:
+                doctypes = _context2.sent;
+                _i = 0, _Object$keys = Object.keys(doctypes);
+
+              case 8:
                 if (!(_i < _Object$keys.length)) {
-                  _context2.next = 16;
+                  _context2.next = 19;
                   break;
                 }
 
                 doctype = _Object$keys[_i];
                 prefix = (0, _utils.getPrefix)(url);
                 dbName = (0, _utils.getDatabaseName)(prefix, doctype);
-                _context2.next = 12;
+                _context2.next = 14;
                 return (0, _adapter.migratePouch)({
                   dbName: dbName,
                   fromAdapter: fromAdapter,
                   toAdapter: toAdapter
                 });
 
-              case 12:
-                (0, _localStorage.destroyWarmedUpQueries)(); // force recomputing indexes
+              case 14:
+                _context2.next = 16;
+                return this.storage.destroyWarmedUpQueries();
 
-              case 13:
+              case 16:
                 _i++;
-                _context2.next = 6;
+                _context2.next = 8;
                 break;
 
-              case 16:
-                (0, _localStorage.persistAdapterName)('indexeddb');
-                _context2.next = 22;
+              case 19:
+                _context2.next = 21;
+                return this.storage.persistAdapterName('indexeddb');
+
+              case 21:
+                _context2.next = 26;
                 break;
 
-              case 19:
-                _context2.prev = 19;
+              case 23:
+                _context2.prev = 23;
                 _context2.t0 = _context2["catch"](1);
                 console.error('PouchLink: PouchDB migration failed. ', _context2.t0);
 
-              case 22:
+              case 26:
               case "end":
                 return _context2.stop();
             }
           }
-        }, _callee2, null, [[1, 19]]);
+        }, _callee2, this, [[1, 23]]);
       }));
 
       function migrateAdapter(_x2) {
@@ -367,11 +390,20 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
                   _logger.default.log('Create pouches with ' + prefix + ' prefix');
                 }
 
-                if (!(0, _localStorage.getAdapterName)()) {
-                  adapter = (0, _get.default)(this.options, 'pouch.options.adapter');
-                  (0, _localStorage.persistAdapterName)(adapter);
+                _context3.next = 20;
+                return this.storage.getAdapterName();
+
+              case 20:
+                if (_context3.sent) {
+                  _context3.next = 24;
+                  break;
                 }
 
+                adapter = (0, _get.default)(this.options, 'pouch.options.adapter');
+                _context3.next = 24;
+                return this.storage.persistAdapterName(adapter);
+
+              case 24:
                 this.pouches = new _PouchManager.default(this.doctypes, {
                   pouch: this.options.pouch,
                   getReplicationURL: this.getReplicationURL.bind(this),
@@ -383,14 +415,18 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
                   onDoctypeSyncStart: this.handleDoctypeSyncStart.bind(this),
                   onDoctypeSyncEnd: this.handleDoctypeSyncEnd.bind(this),
                   prefix: prefix,
-                  executeQuery: this.executeQuery.bind(this)
+                  executeQuery: this.executeQuery.bind(this),
+                  platform: this.options.platform
                 });
+                _context3.next = 27;
+                return this.pouches.init();
 
+              case 27:
                 if (this.client && this.options.initialSync) {
                   this.startReplication();
                 }
 
-              case 21:
+              case 28:
               case "end":
                 return _context3.stop();
             }
@@ -449,7 +485,7 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "handleOnSync",
     value: function handleOnSync(doctypeUpdates) {
-      var normalizedData = (0, _mapValues.default)(doctypeUpdates, normalizeAll);
+      var normalizedData = (0, _mapValues.default)(doctypeUpdates, normalizeAll(this.client));
 
       if (this.client) {
         this.client.setData(normalizedData);
@@ -596,128 +632,408 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
     }
   }, {
     key: "request",
-    value: function request(operation) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var forward = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : doNothing;
-      var doctype = (0, _cozyClient.getDoctypeFromOperation)(operation);
+    value: function () {
+      var _request = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(operation) {
+        var result,
+            forward,
+            doctype,
+            _args6 = arguments;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                result = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : null;
+                forward = _args6.length > 2 && _args6[2] !== undefined ? _args6[2] : doNothing;
+                doctype = (0, _cozyClient.getDoctypeFromOperation)(operation);
 
-      if (!this.pouches) {
-        if (process.env.NODE_ENV !== 'production') {
-          _logger.default.info("Tried to access local ".concat(doctype, " but Cozy Pouch is not initialized yet. Forwarding the operation to next link"));
-        }
+                if (this.pouches) {
+                  _context6.next = 6;
+                  break;
+                }
 
-        return forward(operation);
-      }
+                if (process.env.NODE_ENV !== 'production') {
+                  _logger.default.info("Tried to access local ".concat(doctype, " but Cozy Pouch is not initialized yet. Forwarding the operation to next link"));
+                }
+
+                return _context6.abrupt("return", forward(operation));
+
+              case 6:
+                if (!(this.pouches.getSyncStatus(doctype) === 'not_synced')) {
+                  _context6.next = 9;
+                  break;
+                }
+
+                if (process.env.NODE_ENV !== 'production') {
+                  _logger.default.info("Tried to access local ".concat(doctype, " but Cozy Pouch is not synced yet. Forwarding the operation to next link"));
+                }
+
+                return _context6.abrupt("return", forward(operation));
+
+              case 9:
+                _context6.next = 11;
+                return this.needsToWaitWarmup(doctype);
+
+              case 11:
+                if (!_context6.sent) {
+                  _context6.next = 14;
+                  break;
+                }
+
+                if (process.env.NODE_ENV !== 'production') {
+                  _logger.default.info("Tried to access local ".concat(doctype, " but not warmuped yet. Forwarding the operation to next link"));
+                }
+
+                return _context6.abrupt("return", forward(operation));
+
+              case 14:
+                if (this.supportsOperation(operation)) {
+                  _context6.next = 17;
+                  break;
+                }
+
+                if (process.env.NODE_ENV !== 'production') {
+                  _logger.default.info("The doctype '".concat(doctype, "' is not supported. Forwarding the operation to next link"));
+                }
+
+                return _context6.abrupt("return", forward(operation));
+
+              case 17:
+                if (!operation.mutationType) {
+                  _context6.next = 21;
+                  break;
+                }
 
-      if (!this.pouches.isSynced(doctype)) {
-        if (process.env.NODE_ENV !== 'production') {
-          _logger.default.info("Tried to access local ".concat(doctype, " but Cozy Pouch is not synced yet. Forwarding the operation to next link"));
-        }
+                return _context6.abrupt("return", this.executeMutation(operation, result, forward));
 
-        return forward(operation);
+              case 21:
+                return _context6.abrupt("return", this.executeQuery(operation));
+
+              case 22:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function request(_x4) {
+        return _request.apply(this, arguments);
       }
 
-      if (this.needsToWaitWarmup(doctype)) {
-        if (process.env.NODE_ENV !== 'production') {
-          _logger.default.info("Tried to access local ".concat(doctype, " but not warmuped yet. Forwarding the operation to next link"));
-        }
+      return request;
+    }()
+  }, {
+    key: "sanitizeJsonApi",
+    value: function sanitizeJsonApi(data) {
+      var docWithoutType = sanitized(data);
+      /*
+      We persist in the local Pouch database all the documents that do not
+      exist on the remote Couch database
+       Those documents are computed by the cozy-stack then are sent to the
+      client using JSON-API format containing `attributes` and `meta`
+      attributes
+       Then the cozy-stack-client would normalize those documents by spreading
+      `attributes` and `meta` content into the document's root
+       So we don't need to store `attributes` and `meta` data into the Pouch
+      database as their data already exists in the document's root
+       Note that this is also the case for `links` and `relationships`
+      attributes, but we don't remove them for now. They are also part of the
+      JSON-API, but the normalization do not spread them in the document's
+      root, so we have to check their usefulnes first
+      */
+
+      var sanitizedDoc = (0, _omit.default)(docWithoutType, ['attributes', 'meta']);
+      return sanitizedDoc;
+    }
+  }, {
+    key: "persistCozyData",
+    value: function () {
+      var _persistCozyData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(data) {
+        var forward,
+            sanitizedDoc,
+            oldDoc,
+            db,
+            _args7 = arguments;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                forward = _args7.length > 1 && _args7[1] !== undefined ? _args7[1] : doNothing;
+                sanitizedDoc = this.sanitizeJsonApi(data);
+                sanitizedDoc.cozyLocalOnly = true;
+                _context7.next = 5;
+                return this.getExistingDocument(data._id, data._type);
+
+              case 5:
+                oldDoc = _context7.sent;
 
-        return forward(operation);
-      } // Forwards if doctype not supported
+                if (oldDoc) {
+                  sanitizedDoc._rev = oldDoc._rev;
+                }
 
+                db = this.pouches.getPouch(data._type);
+                _context7.next = 10;
+                return db.put(sanitizedDoc);
 
-      if (!this.supportsOperation(operation)) {
-        if (process.env.NODE_ENV !== 'production') {
-          _logger.default.info("The doctype '".concat(doctype, "' is not supported. Forwarding the operation to next link"));
-        }
+              case 10:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
 
-        return forward(operation);
+      function persistCozyData(_x5) {
+        return _persistCozyData.apply(this, arguments);
       }
 
-      if (operation.mutationType) {
-        return this.executeMutation(operation, result, forward);
-      } else {
-        return this.executeQuery(operation);
+      return persistCozyData;
+    }()
+    /**
+     * Retrieve the existing document from Pouch
+     *
+     * @private
+     * @param {*} id - ID of the document to retrieve
+     * @param {*} type - Doctype of the document to retrieve
+     * @param {*} throwIfNotFound - If true the method will throw when the document is not found. Otherwise it will return null
+     * @returns {Promise<CozyClientDocument | null>}
+     */
+
+  }, {
+    key: "getExistingDocument",
+    value: function () {
+      var _getExistingDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(id, type) {
+        var throwIfNotFound,
+            db,
+            existingDoc,
+            _args8 = arguments;
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                throwIfNotFound = _args8.length > 2 && _args8[2] !== undefined ? _args8[2] : false;
+                _context8.prev = 1;
+                db = this.pouches.getPouch(type);
+                _context8.next = 5;
+                return db.get(id);
+
+              case 5:
+                existingDoc = _context8.sent;
+                return _context8.abrupt("return", existingDoc);
+
+              case 9:
+                _context8.prev = 9;
+                _context8.t0 = _context8["catch"](1);
+
+                if (!(_context8.t0.name === 'not_found' && !throwIfNotFound)) {
+                  _context8.next = 15;
+                  break;
+                }
+
+                return _context8.abrupt("return", null);
+
+              case 15:
+                throw _context8.t0;
+
+              case 16:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this, [[1, 9]]);
+      }));
+
+      function getExistingDocument(_x6, _x7) {
+        return _getExistingDocument.apply(this, arguments);
       }
-    }
+
+      return getExistingDocument;
+    }()
     /**
      *
      * Check if there is warmup queries for this doctype
      * and return if those queries are already warmed up or not
      *
      * @param {string} doctype - Doctype to check
-     * @returns {boolean} the need to wait for the warmup
+     * @returns {Promise<boolean>} the need to wait for the warmup
      */
 
   }, {
     key: "needsToWaitWarmup",
-    value: function needsToWaitWarmup(doctype) {
-      if (this.doctypesReplicationOptions && this.doctypesReplicationOptions[doctype] && this.doctypesReplicationOptions[doctype].warmupQueries) {
-        return !this.pouches.areQueriesWarmedUp(doctype, this.doctypesReplicationOptions[doctype].warmupQueries);
+    value: function () {
+      var _needsToWaitWarmup = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(doctype) {
+        return _regenerator.default.wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                if (!(this.doctypesReplicationOptions && this.doctypesReplicationOptions[doctype] && this.doctypesReplicationOptions[doctype].warmupQueries)) {
+                  _context9.next = 4;
+                  break;
+                }
+
+                _context9.next = 3;
+                return this.pouches.areQueriesWarmedUp(doctype, this.doctypesReplicationOptions[doctype].warmupQueries);
+
+              case 3:
+                return _context9.abrupt("return", !_context9.sent);
+
+              case 4:
+                return _context9.abrupt("return", false);
+
+              case 5:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+
+      function needsToWaitWarmup(_x8) {
+        return _needsToWaitWarmup.apply(this, arguments);
       }
 
-      return false;
-    }
+      return needsToWaitWarmup;
+    }()
   }, {
     key: "hasIndex",
     value: function hasIndex(name) {
       return Boolean(this.indexes[name]);
-    } // This merge is necessary because PouchDB does not support partial indexes
+    }
+    /**
+     * Create the PouchDB index if not existing
+     *
+     * @param {Array} fields - Fields to index
+     * @param {object} indexOption - Options for the index
+     * @param {object} [indexOption.partialFilter] - partialFilter
+     * @param {string} [indexOption.indexName] - indexName
+     * @param {string} [indexOption.doctype] - doctype
+     * @returns {Promise<import('./types').PouchDbIndex>}
+     */
 
   }, {
-    key: "mergePartialIndexInSelector",
-    value: function mergePartialIndexInSelector(selector, partialFilter) {
-      if (partialFilter) {
-        _logger.default.info("PouchLink: The query contains a partial index but PouchDB does not support it. " + "Hence, the partial index definition is used in the selector for in-memory evaluation, " + "which might impact expected performances. If this support is important in your use-case, " + "please let us know or help us contribute to PouchDB!");
+    key: "createIndex",
+    value: function () {
+      var _createIndex = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(fields) {
+        var _ref2,
+            partialFilter,
+            indexName,
+            doctype,
+            absName,
+            db,
+            index,
+            _args10 = arguments;
+
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                _ref2 = _args10.length > 1 && _args10[1] !== undefined ? _args10[1] : {}, partialFilter = _ref2.partialFilter, indexName = _ref2.indexName, doctype = _ref2.doctype;
+                absName = "".concat(doctype, "/").concat(indexName);
+                db = this.pouches.getPouch(doctype);
+                _context10.next = 5;
+                return db.createIndex({
+                  index: {
+                    fields: fields,
+                    ddoc: indexName,
+                    indexName: indexName,
+                    partial_filter_selector: partialFilter
+                  }
+                });
 
-        return _objectSpread(_objectSpread({}, selector), partialFilter);
+              case 5:
+                index = _context10.sent;
+                this.indexes[absName] = index;
+                return _context10.abrupt("return", index);
+
+              case 8:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this);
+      }));
+
+      function createIndex(_x9) {
+        return _createIndex.apply(this, arguments);
       }
 
-      return selector;
+      return createIndex;
+    }()
+    /**
+     * Retrieve the PouchDB index if exist, undefined otherwise
+     *
+     * @param {string} doctype - The query's doctype
+     * @param {import('./types').MangoQueryOptions} options - The find options
+     * @param {string} indexName - The index name
+     * @returns {import('./types').PouchDbIndex | undefined}
+     */
+
+  }, {
+    key: "findExistingIndex",
+    value: function findExistingIndex(doctype, options, indexName) {
+      var absName = "".concat(doctype, "/").concat(indexName);
+      return this.indexes[absName];
     }
+    /**
+     * Handle index creation if it is missing.
+     *
+     * When an index is missing, we first check if there is one with a different
+     * name but the same definition. If there is none, we create the new index.
+     *
+     * /!\ Warning: this method is similar to DocumentCollection.handleMissingIndex()
+     * If you edit this method, please check if the change is also needed in DocumentCollection
+     *
+     * @param {string} doctype The mango selector
+     * @param {import('./types').MangoQueryOptions} options The find options
+     * @returns {Promise<import('./types').PouchDbIndex>} index
+     * @private
+     */
+
   }, {
     key: "ensureIndex",
     value: function () {
-      var _ensureIndex = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(doctype, query) {
-        var fields, name, absName, db, index;
-        return _regenerator.default.wrap(function _callee6$(_context6) {
+      var _ensureIndex = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(doctype, options) {
+        var indexedFields, partialFilter, indexName, existingIndex;
+        return _regenerator.default.wrap(function _callee11$(_context11) {
           while (1) {
-            switch (_context6.prev = _context6.next) {
+            switch (_context11.prev = _context11.next) {
               case 0:
-                fields = query.indexedFields || (0, _mango.getIndexFields)(query);
-                name = (0, _mango.getIndexNameFromFields)(fields);
-                absName = "".concat(doctype, "/").concat(name);
-                db = this.pouches.getPouch(doctype);
+                indexedFields = options.indexedFields, partialFilter = options.partialFilter;
 
-                if (!this.indexes[absName]) {
-                  _context6.next = 8;
-                  break;
+                if (!indexedFields) {
+                  indexedFields = (0, _mango.getIndexFields)(options);
                 }
 
-                return _context6.abrupt("return", this.indexes[absName]);
+                indexName = (0, _mango.getIndexNameFromFields)(indexedFields, partialFilter);
+                existingIndex = this.findExistingIndex(doctype, options, indexName);
 
-              case 8:
-                _context6.next = 10;
-                return db.createIndex({
-                  index: {
-                    fields: fields
-                  }
+                if (existingIndex) {
+                  _context11.next = 10;
+                  break;
+                }
+
+                _context11.next = 7;
+                return this.createIndex(indexedFields, {
+                  partialFilter: partialFilter,
+                  indexName: indexName,
+                  doctype: doctype
                 });
 
+              case 7:
+                return _context11.abrupt("return", _context11.sent);
+
               case 10:
-                index = _context6.sent;
-                this.indexes[absName] = index;
-                return _context6.abrupt("return", index);
+                return _context11.abrupt("return", existingIndex);
 
-              case 13:
+              case 11:
               case "end":
-                return _context6.stop();
+                return _context11.stop();
             }
           }
-        }, _callee6, this);
+        }, _callee11, this);
       }));
 
-      function ensureIndex(_x4, _x5) {
+      function ensureIndex(_x10, _x11) {
         return _ensureIndex.apply(this, arguments);
       }
 
@@ -726,110 +1042,120 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "executeQuery",
     value: function () {
-      var _executeQuery = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(_ref2) {
-        var doctype, selector, sort, fields, limit, id, ids, skip, indexedFields, partialFilter, db, mergedSelector, res, withRows, findOpts, index;
-        return _regenerator.default.wrap(function _callee7$(_context7) {
+      var _executeQuery = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(_ref3) {
+        var doctype, selector, sort, fields, limit, id, ids, skip, indexedFields, partialFilter, db, res, withRows, findSelector, findOpts, index;
+        return _regenerator.default.wrap(function _callee12$(_context12) {
           while (1) {
-            switch (_context7.prev = _context7.next) {
+            switch (_context12.prev = _context12.next) {
               case 0:
-                doctype = _ref2.doctype, selector = _ref2.selector, sort = _ref2.sort, fields = _ref2.fields, limit = _ref2.limit, id = _ref2.id, ids = _ref2.ids, skip = _ref2.skip, indexedFields = _ref2.indexedFields, partialFilter = _ref2.partialFilter;
-                db = this.getPouch(doctype); // The partial index is not supported by PouchDB, so we ensure the selector includes it
-
-                mergedSelector = this.mergePartialIndexInSelector(selector, partialFilter);
+                doctype = _ref3.doctype, selector = _ref3.selector, sort = _ref3.sort, fields = _ref3.fields, limit = _ref3.limit, id = _ref3.id, ids = _ref3.ids, skip = _ref3.skip, indexedFields = _ref3.indexedFields, partialFilter = _ref3.partialFilter;
+                db = this.getPouch(doctype);
 
                 if (!id) {
-                  _context7.next = 10;
+                  _context12.next = 9;
                   break;
                 }
 
-                _context7.next = 6;
+                _context12.next = 5;
                 return db.get(id);
 
-              case 6:
-                res = _context7.sent;
+              case 5:
+                res = _context12.sent;
                 withRows = false;
-                _context7.next = 38;
+                _context12.next = 38;
                 break;
 
-              case 10:
+              case 9:
                 if (!ids) {
-                  _context7.next = 19;
+                  _context12.next = 18;
                   break;
                 }
 
-                _context7.next = 13;
+                _context12.next = 12;
                 return allDocs(db, {
                   include_docs: true,
                   keys: ids
                 });
 
-              case 13:
-                res = _context7.sent;
+              case 12:
+                res = _context12.sent;
                 res = withoutDesignDocuments(res);
                 res.total_rows = null; // pouch indicates the total number of docs in res.total_rows, even though we use "keys". Setting it to null avoids cozy-client thinking there are more docs to fetch.
 
                 withRows = true;
-                _context7.next = 38;
+                _context12.next = 38;
                 break;
 
-              case 19:
-                if (!(!mergedSelector && !fields && !sort)) {
-                  _context7.next = 27;
+              case 18:
+                if (!(!selector && !partialFilter && !fields && !sort)) {
+                  _context12.next = 26;
                   break;
                 }
 
-                _context7.next = 22;
+                _context12.next = 21;
                 return allDocs(db, {
                   include_docs: true,
                   limit: limit
                 });
 
-              case 22:
-                res = _context7.sent;
+              case 21:
+                res = _context12.sent;
                 res = withoutDesignDocuments(res);
                 withRows = true;
-                _context7.next = 38;
+                _context12.next = 38;
                 break;
 
-              case 27:
+              case 26:
+                findSelector = _helpers.default.normalizeFindSelector({
+                  selector: selector,
+                  sort: sort,
+                  indexedFields: indexedFields,
+                  partialFilter: partialFilter
+                });
                 findOpts = {
                   sort: sort,
-                  selector: mergedSelector,
-                  // same selector as Document Collection. We force _id.
-                  // Fix https://github.com/cozy/cozy-client/issues/985
-                  fields: fields ? [].concat((0, _toConsumableArray2.default)(fields), ['_id', '_type', 'class']) : undefined,
+                  selector: findSelector,
+                  // same selector as Document Collection.
+                  // _id is necessary for the store, and _rev is required for offline. See https://github.com/cozy/cozy-client/blob/95978d39546023920b0c01d689fed5dd41577a02/packages/cozy-client/src/CozyClient.js#L1153
+                  fields: fields ? [].concat((0, _toConsumableArray2.default)(fields), ['_id', '_rev']) : undefined,
                   limit: limit,
                   skip: skip
                 };
-                _context7.next = 30;
+                _context12.next = 30;
                 return this.ensureIndex(doctype, _objectSpread(_objectSpread({}, findOpts), {}, {
-                  indexedFields: indexedFields
+                  indexedFields: indexedFields,
+                  partialFilter: partialFilter
                 }));
 
               case 30:
-                index = _context7.sent;
+                index = _context12.sent;
                 findOpts.use_index = index.id;
-                _context7.next = 34;
+                _context12.next = 34;
                 return find(db, findOpts);
 
               case 34:
-                res = _context7.sent;
+                res = _context12.sent;
                 res.offset = skip;
                 res.limit = limit;
                 withRows = true;
 
               case 38:
-                return _context7.abrupt("return", jsonapi.fromPouchResult(res, withRows, doctype));
+                return _context12.abrupt("return", jsonapi.fromPouchResult({
+                  res: res,
+                  withRows: withRows,
+                  doctype: doctype,
+                  client: this.client
+                }));
 
               case 39:
               case "end":
-                return _context7.stop();
+                return _context12.stop();
             }
           }
-        }, _callee7, this);
+        }, _callee12, this);
       }));
 
-      function executeQuery(_x6) {
+      function executeQuery(_x12) {
         return _executeQuery.apply(this, arguments);
       }
 
@@ -838,71 +1164,76 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "executeMutation",
     value: function () {
-      var _executeMutation = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(mutation, result, forward) {
+      var _executeMutation = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(mutation, result, forward) {
         var pouchRes;
-        return _regenerator.default.wrap(function _callee8$(_context8) {
+        return _regenerator.default.wrap(function _callee13$(_context13) {
           while (1) {
-            switch (_context8.prev = _context8.next) {
+            switch (_context13.prev = _context13.next) {
               case 0:
-                _context8.t0 = mutation.mutationType;
-                _context8.next = _context8.t0 === _cozyClient.MutationTypes.CREATE_DOCUMENT ? 3 : _context8.t0 === _cozyClient.MutationTypes.UPDATE_DOCUMENT ? 7 : _context8.t0 === _cozyClient.MutationTypes.UPDATE_DOCUMENTS ? 11 : _context8.t0 === _cozyClient.MutationTypes.DELETE_DOCUMENT ? 15 : _context8.t0 === _cozyClient.MutationTypes.ADD_REFERENCES_TO ? 19 : 23;
+                _context13.t0 = mutation.mutationType;
+                _context13.next = _context13.t0 === _cozyClient.MutationTypes.CREATE_DOCUMENT ? 3 : _context13.t0 === _cozyClient.MutationTypes.UPDATE_DOCUMENT ? 7 : _context13.t0 === _cozyClient.MutationTypes.UPDATE_DOCUMENTS ? 11 : _context13.t0 === _cozyClient.MutationTypes.DELETE_DOCUMENT ? 15 : _context13.t0 === _cozyClient.MutationTypes.ADD_REFERENCES_TO ? 19 : 23;
                 break;
 
               case 3:
-                _context8.next = 5;
+                _context13.next = 5;
                 return this.createDocument(mutation);
 
               case 5:
-                pouchRes = _context8.sent;
-                return _context8.abrupt("break", 24);
+                pouchRes = _context13.sent;
+                return _context13.abrupt("break", 24);
 
               case 7:
-                _context8.next = 9;
+                _context13.next = 9;
                 return this.updateDocument(mutation);
 
               case 9:
-                pouchRes = _context8.sent;
-                return _context8.abrupt("break", 24);
+                pouchRes = _context13.sent;
+                return _context13.abrupt("break", 24);
 
               case 11:
-                _context8.next = 13;
+                _context13.next = 13;
                 return this.updateDocuments(mutation);
 
               case 13:
-                pouchRes = _context8.sent;
-                return _context8.abrupt("break", 24);
+                pouchRes = _context13.sent;
+                return _context13.abrupt("break", 24);
 
               case 15:
-                _context8.next = 17;
+                _context13.next = 17;
                 return this.deleteDocument(mutation);
 
               case 17:
-                pouchRes = _context8.sent;
-                return _context8.abrupt("break", 24);
+                pouchRes = _context13.sent;
+                return _context13.abrupt("break", 24);
 
               case 19:
-                _context8.next = 21;
+                _context13.next = 21;
                 return this.addReferencesTo(mutation);
 
               case 21:
-                pouchRes = _context8.sent;
-                return _context8.abrupt("break", 24);
+                pouchRes = _context13.sent;
+                return _context13.abrupt("break", 24);
 
               case 23:
-                return _context8.abrupt("return", forward(mutation, result));
+                return _context13.abrupt("return", forward(mutation, result));
 
               case 24:
-                return _context8.abrupt("return", jsonapi.fromPouchResult(pouchRes, false, (0, _cozyClient.getDoctypeFromOperation)(mutation)));
+                return _context13.abrupt("return", jsonapi.fromPouchResult({
+                  res: pouchRes,
+                  withRows: false,
+                  doctype: (0, _cozyClient.getDoctypeFromOperation)(mutation),
+                  client: this.client
+                }));
 
               case 25:
               case "end":
-                return _context8.stop();
+                return _context13.stop();
             }
           }
-        }, _callee8, this);
+        }, _callee13, this);
       }));
 
-      function executeMutation(_x7, _x8, _x9) {
+      function executeMutation(_x13, _x14, _x15) {
         return _executeMutation.apply(this, arguments);
       }
 
@@ -911,28 +1242,28 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "createDocument",
     value: function () {
-      var _createDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(mutation) {
+      var _createDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(mutation) {
         var res;
-        return _regenerator.default.wrap(function _callee9$(_context9) {
+        return _regenerator.default.wrap(function _callee14$(_context14) {
           while (1) {
-            switch (_context9.prev = _context9.next) {
+            switch (_context14.prev = _context14.next) {
               case 0:
-                _context9.next = 2;
+                _context14.next = 2;
                 return this.dbMethod('post', mutation);
 
               case 2:
-                res = _context9.sent;
-                return _context9.abrupt("return", parseMutationResult(mutation.document, res));
+                res = _context14.sent;
+                return _context14.abrupt("return", parseMutationResult(mutation.document, res));
 
               case 4:
               case "end":
-                return _context9.stop();
+                return _context14.stop();
             }
           }
-        }, _callee9, this);
+        }, _callee14, this);
       }));
 
-      function createDocument(_x10) {
+      function createDocument(_x16) {
         return _createDocument.apply(this, arguments);
       }
 
@@ -941,28 +1272,28 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "updateDocument",
     value: function () {
-      var _updateDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(mutation) {
+      var _updateDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15(mutation) {
         var res;
-        return _regenerator.default.wrap(function _callee10$(_context10) {
+        return _regenerator.default.wrap(function _callee15$(_context15) {
           while (1) {
-            switch (_context10.prev = _context10.next) {
+            switch (_context15.prev = _context15.next) {
               case 0:
-                _context10.next = 2;
+                _context15.next = 2;
                 return this.dbMethod('put', mutation);
 
               case 2:
-                res = _context10.sent;
-                return _context10.abrupt("return", parseMutationResult(mutation.document, res));
+                res = _context15.sent;
+                return _context15.abrupt("return", parseMutationResult(mutation.document, res));
 
               case 4:
               case "end":
-                return _context10.stop();
+                return _context15.stop();
             }
           }
-        }, _callee10, this);
+        }, _callee15, this);
       }));
 
-      function updateDocument(_x11) {
+      function updateDocument(_x17) {
         return _updateDocument.apply(this, arguments);
       }
 
@@ -971,18 +1302,18 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "updateDocuments",
     value: function () {
-      var _updateDocuments = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(mutation) {
+      var _updateDocuments = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(mutation) {
         var docs, bulkResponse, updatedDocs;
-        return _regenerator.default.wrap(function _callee11$(_context11) {
+        return _regenerator.default.wrap(function _callee16$(_context16) {
           while (1) {
-            switch (_context11.prev = _context11.next) {
+            switch (_context16.prev = _context16.next) {
               case 0:
                 docs = mutation.documents;
-                _context11.next = 3;
+                _context16.next = 3;
                 return this.dbMethod('bulkDocs', mutation);
 
               case 3:
-                bulkResponse = _context11.sent;
+                bulkResponse = _context16.sent;
                 updatedDocs = (0, _zipWith.default)(bulkResponse, docs, function (bulkResult, originalDoc) {
                   return _objectSpread(_objectSpread({}, originalDoc), {}, {
                     _id: bulkResult.id,
@@ -993,24 +1324,24 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
                 if (!bulkResponse.find(function (x) {
                   return !x.ok;
                 })) {
-                  _context11.next = 7;
+                  _context16.next = 7;
                   break;
                 }
 
                 throw new _cozyClient.BulkEditError(bulkResponse, updatedDocs);
 
               case 7:
-                return _context11.abrupt("return", updatedDocs);
+                return _context16.abrupt("return", updatedDocs);
 
               case 8:
               case "end":
-                return _context11.stop();
+                return _context16.stop();
             }
           }
-        }, _callee11, this);
+        }, _callee16, this);
       }));
 
-      function updateDocuments(_x12) {
+      function updateDocuments(_x18) {
         return _updateDocuments.apply(this, arguments);
       }
 
@@ -1019,101 +1350,125 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "deleteDocument",
     value: function () {
-      var _deleteDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(mutation) {
+      var _deleteDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17(mutation) {
         var res, document;
-        return _regenerator.default.wrap(function _callee12$(_context12) {
+        return _regenerator.default.wrap(function _callee17$(_context17) {
           while (1) {
-            switch (_context12.prev = _context12.next) {
+            switch (_context17.prev = _context17.next) {
               case 0:
-                _context12.next = 2;
+                _context17.next = 2;
                 return this.dbMethod('remove', mutation);
 
               case 2:
-                res = _context12.sent;
+                res = _context17.sent;
                 document = _objectSpread(_objectSpread({}, mutation.document), {}, {
                   _id: res.id,
                   _rev: res.rev,
                   _deleted: true
                 });
-                return _context12.abrupt("return", parseMutationResult(document, res));
+                return _context17.abrupt("return", parseMutationResult(document, res));
 
               case 5:
               case "end":
-                return _context12.stop();
+                return _context17.stop();
             }
           }
-        }, _callee12, this);
+        }, _callee17, this);
       }));
 
-      function deleteDocument(_x13) {
+      function deleteDocument(_x19) {
         return _deleteDocument.apply(this, arguments);
       }
 
       return deleteDocument;
     }()
+  }, {
+    key: "addReferencesTo",
+    value: function () {
+      var _addReferencesTo = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18(mutation) {
+        return _regenerator.default.wrap(function _callee18$(_context18) {
+          while (1) {
+            switch (_context18.prev = _context18.next) {
+              case 0:
+                throw new Error('addReferencesTo is not implemented in CozyPouchLink');
+
+              case 1:
+              case "end":
+                return _context18.stop();
+            }
+          }
+        }, _callee18);
+      }));
+
+      function addReferencesTo(_x20) {
+        return _addReferencesTo.apply(this, arguments);
+      }
+
+      return addReferencesTo;
+    }()
   }, {
     key: "dbMethod",
     value: function () {
-      var _dbMethod = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(method, mutation) {
+      var _dbMethod = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19(method, mutation) {
         var doctype, doc, docs, db, res;
-        return _regenerator.default.wrap(function _callee13$(_context13) {
+        return _regenerator.default.wrap(function _callee19$(_context19) {
           while (1) {
-            switch (_context13.prev = _context13.next) {
+            switch (_context19.prev = _context19.next) {
               case 0:
                 doctype = (0, _cozyClient.getDoctypeFromOperation)(mutation);
                 doc = mutation.document, docs = mutation.documents;
                 db = this.getPouch(doctype);
-                _context13.prev = 3;
+                _context19.prev = 3;
 
                 if (!docs) {
-                  _context13.next = 10;
+                  _context19.next = 10;
                   break;
                 }
 
-                _context13.next = 7;
+                _context19.next = 7;
                 return db[method](docs.map(function (doc) {
                   return sanitized(doc);
                 }));
 
               case 7:
-                res = _context13.sent;
-                _context13.next = 17;
+                res = _context19.sent;
+                _context19.next = 17;
                 break;
 
               case 10:
                 if (!doc) {
-                  _context13.next = 16;
+                  _context19.next = 16;
                   break;
                 }
 
-                _context13.next = 13;
+                _context19.next = 13;
                 return db[method](sanitized(doc));
 
               case 13:
-                res = _context13.sent;
-                _context13.next = 17;
+                res = _context19.sent;
+                _context19.next = 17;
                 break;
 
               case 16:
                 throw new Error('A mutation should either have document or documents member.');
 
               case 17:
-                return _context13.abrupt("return", res);
+                return _context19.abrupt("return", res);
 
               case 20:
-                _context13.prev = 20;
-                _context13.t0 = _context13["catch"](3);
-                throw new Error("Coud not apply mutation: ".concat(_context13.t0.message));
+                _context19.prev = 20;
+                _context19.t0 = _context19["catch"](3);
+                throw new Error("Coud not apply mutation: ".concat(_context19.t0.message));
 
               case 23:
               case "end":
-                return _context13.stop();
+                return _context19.stop();
             }
           }
-        }, _callee13, this, [[3, 20]]);
+        }, _callee19, this, [[3, 20]]);
       }));
 
-      function dbMethod(_x14, _x15) {
+      function dbMethod(_x21, _x22) {
         return _dbMethod.apply(this, arguments);
       }
 
@@ -1122,29 +1477,29 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "syncImmediately",
     value: function () {
-      var _syncImmediately = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
-        return _regenerator.default.wrap(function _callee14$(_context14) {
+      var _syncImmediately = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
+        return _regenerator.default.wrap(function _callee20$(_context20) {
           while (1) {
-            switch (_context14.prev = _context14.next) {
+            switch (_context20.prev = _context20.next) {
               case 0:
                 if (this.pouches) {
-                  _context14.next = 3;
+                  _context20.next = 3;
                   break;
                 }
 
                 _logger.default.warn('Cannot sync immediately, no PouchManager');
 
-                return _context14.abrupt("return");
+                return _context20.abrupt("return");
 
               case 3:
                 this.pouches.syncImmediately();
 
               case 4:
               case "end":
-                return _context14.stop();
+                return _context20.stop();
             }
           }
-        }, _callee14, this);
+        }, _callee20, this);
       }));
 
       function syncImmediately() {
@@ -1157,8 +1512,9 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   return PouchLink;
 }(_cozyClient.CozyLink);
 
-(0, _defineProperty2.default)(PouchLink, "getPouchAdapterName", function () {
-  return (0, _localStorage.getAdapterName)();
+(0, _defineProperty2.default)(PouchLink, "getPouchAdapterName", function (localStorage) {
+  var storage = new _localStorage.PouchLocalStorage(localStorage || _platformWeb.platformWeb.storage);
+  return storage.getAdapterName();
 });
 var _default = PouchLink;
 exports.default = _default;