cozy-pouch-link 57.5.0 → 57.6.0

package/dist/CozyPouchLink.spec.js

@@ -6,7 +6,8 @@ jest.mock('./helpers', () => ({
   allDocs: jest.fn(),
   normalizeFindSelector: jest.requireActual('./helpers').default
     .normalizeFindSelector,
-  withoutDesignDocuments: jest.fn()
+  withoutDesignDocuments: jest.fn(),
+  isAdapterBugged: jest.fn()
 }))
 
 import CozyPouchLink from '.'
@@ -309,12 +310,9 @@ describe('CozyPouchLink', () => {
         .indexFields(['done', 'label'])
         .sortBy([{ done: 'asc' }, { label: 'asc' }])
         .select(['label', 'done'])
-      await link.request(query)
-      expect(find).toHaveBeenLastCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          fields: ['label', 'done', '_id', '_rev']
-        })
+      const res = await link.request(query)
+      expect(Object.keys(res.data[0])).toEqual(
+        expect.arrayContaining(['label', 'done', '_id', '_rev'])
       )
     })
   })
@@ -455,10 +453,7 @@ describe('CozyPouchLink', () => {
             _type: 'io.cozy.todos',
             done: false,
             id: '1',
-            label: 'Buy bread',
-            relationships: {
-              referenced_by: undefined
-            }
+            label: 'Buy bread'
           }
         ]
       })
@@ -552,142 +547,6 @@ describe('CozyPouchLink', () => {
     })
   })
 
-  describe('index creation', () => {
-    let spy
-    beforeEach(() => {
-      allDocs.mockReturnValue({ docs: [] })
-      withoutDesignDocuments.mockReturnValue({ docs: [] })
-      find.mockReturnValue({ docs: [] })
-    })
-    afterEach(() => {
-      spy.mockRestore()
-    })
-
-    it('uses the default index, the one from the sort', async () => {
-      spy = jest.spyOn(PouchDB.prototype, 'createIndex')
-      await setup()
-      link.pouches.getSyncStatus = jest.fn().mockReturnValue('synced')
-      const query = Q(TODO_DOCTYPE)
-        .where({})
-        .sortBy([{ name: 'asc' }])
-      await link.request(query)
-      expect(spy).toHaveBeenCalledWith({
-        index: {
-          ddoc: 'by_name',
-          fields: ['name'],
-          indexName: 'by_name',
-          partial_filter_selector: undefined
-        }
-      })
-    })
-
-    it('uses indexFields if provided', async () => {
-      spy = jest.spyOn(PouchDB.prototype, 'createIndex').mockReturnValue({})
-      await setup()
-      await link.ensureIndex(TODO_DOCTYPE, {
-        indexedFields: ['myIndex']
-      })
-      expect(spy).toHaveBeenCalled()
-      expect(spy).toHaveBeenCalledWith({
-        index: {
-          ddoc: 'by_myIndex',
-          fields: ['myIndex'],
-          indexName: 'by_myIndex',
-          partial_filter_selector: undefined
-        }
-      })
-    })
-
-    it('should handle partial filters', async () => {
-      spy = jest.spyOn(PouchDB.prototype, 'createIndex').mockReturnValue({})
-      await setup()
-      await link.ensureIndex(TODO_DOCTYPE, {
-        indexedFields: ['myIndex'],
-        partialFilter: { SOME_FIELD: { $exists: true } }
-      })
-      expect(spy).toHaveBeenCalled()
-      expect(spy).toHaveBeenCalledWith({
-        index: {
-          ddoc: 'by_myIndex_and_SOME_FIELD_filter_(SOME_FIELD_$exists_true)',
-          fields: ['myIndex', 'SOME_FIELD'],
-          indexName:
-            'by_myIndex_and_SOME_FIELD_filter_(SOME_FIELD_$exists_true)',
-          partial_filter_selector: {
-            SOME_FIELD: {
-              $exists: true
-            }
-          }
-        }
-      })
-    })
-
-    it('should exclude $and and $or operators from fields with partialIndex', async () => {
-      spy = jest.spyOn(PouchDB.prototype, 'createIndex').mockReturnValue({})
-      await setup()
-      await link.ensureIndex(TODO_DOCTYPE, {
-        indexedFields: ['myIndex'],
-        partialFilter: {
-          $and: [
-            { SOME_FIELD: { $exists: true } },
-            { SOME_FIELD: { $gt: null } }
-          ],
-          $or: [{ SOME_FIELD: { $eq: '1' } }, { SOME_FIELD: { $eq: '2' } }]
-        }
-      })
-      expect(spy).toHaveBeenCalled()
-      expect(spy).toHaveBeenCalledWith({
-        index: {
-          ddoc:
-            'by_myIndex_filter_((SOME_FIELD_$exists_true)_$and_(SOME_FIELD_$gt_null))_and_((SOME_FIELD_$eq_1)_$or_(SOME_FIELD_$eq_2))',
-          fields: ['myIndex'],
-          indexName:
-            'by_myIndex_filter_((SOME_FIELD_$exists_true)_$and_(SOME_FIELD_$gt_null))_and_((SOME_FIELD_$eq_1)_$or_(SOME_FIELD_$eq_2))',
-          partial_filter_selector: {
-            $and: [
-              { SOME_FIELD: { $exists: true } },
-              { SOME_FIELD: { $gt: null } }
-            ],
-            $or: [{ SOME_FIELD: { $eq: '1' } }, { SOME_FIELD: { $eq: '2' } }]
-          }
-        }
-      })
-    })
-
-    it('uses the specified index', async () => {
-      let spyIndex = jest
-        .spyOn(CozyPouchLink.prototype, 'ensureIndex')
-        .mockReturnValue({ id: 'design/myIndex2' })
-
-      await setup()
-      const db = link.getPouch(TODO_DOCTYPE)
-      await link.executeQuery({
-        doctype: TODO_DOCTYPE,
-        indexedFields: ['myIndex2'],
-        selector: {}
-      })
-      const params = {
-        sort: undefined,
-        selector: {
-          myIndex2: {
-            $gt: null
-          }
-        },
-        fields: undefined,
-        limit: undefined,
-        partialFilter: undefined,
-        skip: undefined
-      }
-
-      expect(spyIndex).toHaveBeenCalledWith('io.cozy.todos', {
-        ...params,
-        indexedFields: ['myIndex2']
-      })
-      params.use_index = 'design/myIndex2'
-      expect(find).toHaveBeenCalledWith(db, params)
-      spyIndex.mockRestore()
-    })
-  })
-
   describe('deleteDocument', () => {
     it('should add _rev and _deleted prop to a deleted document', async () => {
       await setup()

package/dist/PouchManager.js

@@ -35,6 +35,10 @@ var _replicateOnce3 = require("./replicateOnce");
 
 var _utils = require("./utils");
 
+var _pouchdb = require("./migrations/pouchdb");
+
+var _pouchdb2 = _interopRequireDefault(require("./db/pouchdb/pouchdb"));
+
 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
 
@@ -64,9 +68,12 @@ var PouchManager = /*#__PURE__*/function () {
     this.options = options;
     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.queryEngine = options.queryEngine || _pouchdb2.default;
+    this.client = options.client;
     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;
+    this.dbQueryEngines = new Map();
   }
 
   (0, _createClass2.default)(PouchManager, [{
@@ -91,19 +98,27 @@ var PouchManager = /*#__PURE__*/function () {
                   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)];
+                  var dbName = (0, _utils.getDatabaseName)(_this.options.prefix, doctype);
+                  var pouch = new _this.PouchDB((0, _utils.getDatabaseName)(_this.options.prefix, doctype), pouchOptions);
+                  return [dbName, pouch];
                 }));
+                Object.keys(this.pouches).forEach(function (dbName) {
+                  // Set query engine for all databases
+                  var doctype = (0, _utils.getDoctypeFromDatabaseName)(dbName);
+
+                  _this.setQueryEngine(dbName, doctype);
+                });
                 /** @type {Record<string, import('./types').SyncInfo>} - Stores synchronization info per doctype */
 
-                _context.next = 7;
+                _context.next = 8;
                 return this.storage.getPersistedSyncedDoctypes();
 
-              case 7:
+              case 8:
                 this.syncedDoctypes = _context.sent;
-                _context.next = 10;
+                _context.next = 11;
                 return this.storage.getPersistedWarmedUpQueries();
 
-              case 10:
+              case 11:
                 this.warmedUpQueries = _context.sent;
                 this.getReplicationURL = this.options.getReplicationURL;
                 this.doctypesReplicationOptions = this.options.doctypesReplicationOptions || {};
@@ -118,8 +133,9 @@ var PouchManager = /*#__PURE__*/function () {
                 /** @type {import('./types').CancelablePromise[]} - Stores replication promises */
 
                 this.replications = undefined;
+                (0, _pouchdb.destroyOldDatabases)();
 
-              case 20:
+              case 22:
               case "end":
                 return _context.stop();
             }
@@ -421,8 +437,27 @@ var PouchManager = /*#__PURE__*/function () {
     }
   }, {
     key: "getPouch",
-    value: function getPouch(doctype) {
-      return this.pouches[doctype];
+    value: function getPouch(dbName) {
+      return this.pouches[dbName];
+    }
+  }, {
+    key: "setQueryEngine",
+    value: function setQueryEngine(name, doctype) {
+      var engine = new this.queryEngine(this, doctype);
+      engine.openDB(name);
+      this.dbQueryEngines.set(name, engine);
+      return engine;
+    }
+  }, {
+    key: "getQueryEngine",
+    value: function getQueryEngine(name, doctype) {
+      var engine = this.dbQueryEngines.get(name);
+
+      if (!engine) {
+        engine = this.setQueryEngine(name, doctype);
+      }
+
+      return engine;
     }
     /**
      * Update the Sync info for the specifed doctype

package/dist/PouchManager.spec.js

@@ -60,6 +60,9 @@ const query2 = () => ({
     as: 'query2'
   }
 })
+
+const dbName = 'cozy.tools__doctype__io.cozy.todos'
+
 describe('PouchManager', () => {
   let manager,
     managerOptions,
@@ -76,7 +79,7 @@ describe('PouchManager', () => {
     }
     manager = new PouchManager(['io.cozy.todos'], managerOptions)
     await manager.init()
-    const pouch = manager.getPouch('io.cozy.todos')
+    const pouch = manager.getPouch(dbName)
     const replication = mocks.pouchReplication({
       direction: 'pull',
       change: {
@@ -106,7 +109,7 @@ describe('PouchManager', () => {
     manager.startReplicationLoop()
     await sleep(1000)
     expect(fetchRemoteInstance).toHaveBeenCalledTimes(1)
-    const pouch = manager.getPouch('io.cozy.todos')
+    const pouch = manager.getPouch(dbName)
     expect(pouch.info).toHaveBeenCalledTimes(1)
     expect(pouch.sync).toHaveBeenCalled()
   })
@@ -114,19 +117,19 @@ describe('PouchManager', () => {
   it('should call info() on all pouches before starting replication', async () => {
     manager.startReplicationLoop()
     await sleep(1)
-    expect(manager.getPouch('io.cozy.todos').info).toHaveBeenCalled()
+    expect(manager.getPouch(dbName).info).toHaveBeenCalled()
     manager.stopReplicationLoop()
     manager.startReplicationLoop()
     await sleep(1)
 
     // Database existence check should only occur once
-    expect(manager.getPouch('io.cozy.todos').info).toHaveBeenCalledTimes(1)
+    expect(manager.getPouch(dbName).info).toHaveBeenCalledTimes(1)
   })
 
   it('should periodically call sync', async () => {
     manager.startReplicationLoop()
     await sleep(1000)
-    const pouch = manager.getPouch('io.cozy.todos')
+    const pouch = manager.getPouch(dbName)
     expect(pouch.sync.mock.calls.length).toBeGreaterThan(5)
   })
 
@@ -138,8 +141,10 @@ describe('PouchManager', () => {
       }
     })
     await manager.init()
-    const normalPouch = manager.getPouch('io.cozy.todos')
-    const readOnlyPouch = manager.getPouch('io.cozy.readonly')
+    const normalPouch = manager.getPouch(dbName)
+    const readOnlyPouch = manager.getPouch(
+      'cozy.tools__doctype__io.cozy.readonly'
+    )
     readOnlyPouch.replicate = {}
     readOnlyPouch.replicate.from = jest.fn()
     manager.startReplicationLoop()
@@ -161,11 +166,15 @@ describe('PouchManager', () => {
       }
     )
     await manager.init()
-    const normalPouch = manager.getPouch('io.cozy.todos')
-    const readOnlyPouch = manager.getPouch('io.cozy.readonly')
+    const normalPouch = manager.getPouch(dbName)
+    const readOnlyPouch = manager.getPouch(
+      'cozy.tools__doctype__io.cozy.readonly'
+    )
     readOnlyPouch.replicate = {}
     readOnlyPouch.replicate.from = jest.fn()
-    const writeOnlyPouch = manager.getPouch('io.cozy.writeonly')
+    const writeOnlyPouch = manager.getPouch(
+      'cozy.tools__doctype__io.cozy.writeonly'
+    )
     writeOnlyPouch.replicate = {}
     writeOnlyPouch.replicate.to = jest.fn()
     manager.updateSyncInfo('io.cozy.todos')
@@ -226,7 +235,7 @@ describe('PouchManager', () => {
     manager.updateSyncInfo('io.cozy.todos')
     await manager.replicateOnce()
     expect(onSync).toHaveBeenCalledWith({
-      'io.cozy.todos': [
+      'cozy.tools__doctype__io.cozy.todos': [
         {
           _id: '1',
           name: 'Make replication work'
@@ -252,7 +261,7 @@ describe('PouchManager', () => {
     const manager = new PouchManager(['io.cozy.todos'], options)
     await manager.init()
     expect(PouchDB).toHaveBeenCalledWith(
-      'cozy.tools_io.cozy.todos',
+      'cozy.tools__doctype__io.cozy.todos',
       pouchOptions
     )
   })

package/dist/__mocks__/@op-engineering/op-sqlite.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.open = void 0;
+
+var open = function open() {// DO STUFF
+};
+
+exports.open = open;

package/dist/db/dbInterface.js

@@ -0,0 +1,190 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+/**
+ * @typedef {object} FindParams
+ * @property {object} selector - The mango selector
+ * @property {object} partialFilter - Following the mango selector syntax, used to filter out documents at indexing time
+ * @property {Array} sort - The mango sort
+ * @property {string} doctype - The doctype
+ * @property {Array<string>} indexedFields - Array of indexed field name
+ * @property {number} limit - Maximum number of documents to return
+ * @property {number} skip - Number of documents to skip
+ * @property {boolean} recreateIndex - Whether or not an existing index should be recreated
+ */
+
+/**
+ * @typedef {object} AllDocsParams
+ * @property {number} limit - Maximum number of documents to return
+ * @property {number} skip - Number of documents to skip
+ */
+
+/**
+ * @typedef {object} QueryResponse
+ * @property {Array<object>} data - The documents retrieved by the query
+ */
+
+/**
+ * @typedef {object} QueryResponseSingleDoc
+ * @property {object} data - The document retrieved by the query
+ */
+var DatabaseQueryEngine = /*#__PURE__*/function () {
+  function DatabaseQueryEngine() {
+    (0, _classCallCheck2.default)(this, DatabaseQueryEngine);
+  }
+
+  (0, _createClass2.default)(DatabaseQueryEngine, [{
+    key: "openDB",
+
+    /**
+     * Open the database
+     *
+     * @param {string} dbName - The database name
+     */
+    value: function openDB(dbName) {
+      throw new Error('method non implemented');
+    }
+    /**
+     * Find docs with filtered query
+     *
+     * @param {FindParams} options - The find options
+     * @returns {Promise<QueryResponse>} The found docs
+     */
+
+  }, {
+    key: "find",
+    value: function () {
+      var _find = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(options) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                throw new Error('method not implemented');
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function find(_x) {
+        return _find.apply(this, arguments);
+      }
+
+      return find;
+    }()
+    /**
+     * Get all docs
+     *
+     * @param {AllDocsParams} options - The all docs options
+     * @returns {Promise<QueryResponse>} The found docs
+     */
+
+  }, {
+    key: "allDocs",
+    value: function () {
+      var _allDocs = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(options) {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                throw new Error('method not implemented');
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function allDocs(_x2) {
+        return _allDocs.apply(this, arguments);
+      }
+
+      return allDocs;
+    }()
+    /**
+     * Get a single doc by its id
+     *
+     * @param {string} id - id of the document to get
+     * @returns {Promise<QueryResponseSingleDoc>} The found docs
+     */
+
+  }, {
+    key: "getById",
+    value: function () {
+      var _getById = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(id) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                throw new Error('method not implemented');
+
+              case 1:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }));
+
+      function getById(_x3) {
+        return _getById.apply(this, arguments);
+      }
+
+      return getById;
+    }()
+    /**
+     * Get several docs by their ids
+     *
+     * @param {Array<string>} ids - ids of the documents to get
+     * @returns {Promise<QueryResponse>} The found docs
+     */
+
+  }, {
+    key: "getByIds",
+    value: function () {
+      var _getByIds = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(ids) {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                throw new Error('method not implemented');
+
+              case 1:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4);
+      }));
+
+      function getByIds(_x4) {
+        return _getByIds.apply(this, arguments);
+      }
+
+      return getByIds;
+    }()
+  }]);
+  return DatabaseQueryEngine;
+}();
+
+var _default = DatabaseQueryEngine;
+exports.default = _default;

package/dist/db/helpers.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.areDocsEqual = exports.getExistingDocument = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _fastDeepEqual = _interopRequireDefault(require("fast-deep-equal"));
+
+var _dbInterface = _interopRequireDefault(require("./dbInterface"));
+
+/**
+ * Retrieve the existing document from Pouch
+ *
+ * @param {DatabaseQueryEngine} queryEngine - The query engine
+ * @param {string} id - ID of the document to retrieve
+ * @param {boolean} throwIfNotFound - If true the method will throw when the document is not found. Otherwise it will return null
+ * @returns {Promise<import('./dbInterface').QueryResponseSingleDoc>}
+ */
+var getExistingDocument = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(queryEngine, id) {
+    var throwIfNotFound,
+        existingDoc,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            throwIfNotFound = _args.length > 2 && _args[2] !== undefined ? _args[2] : false;
+            _context.prev = 1;
+            _context.next = 4;
+            return queryEngine.getById(id);
+
+          case 4:
+            existingDoc = _context.sent;
+            return _context.abrupt("return", existingDoc);
+
+          case 8:
+            _context.prev = 8;
+            _context.t0 = _context["catch"](1);
+
+            if (!(_context.t0.name === 'not_found' && !throwIfNotFound)) {
+              _context.next = 14;
+              break;
+            }
+
+            return _context.abrupt("return", null);
+
+          case 14:
+            throw _context.t0;
+
+          case 15:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[1, 8]]);
+  }));
+
+  return function getExistingDocument(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.getExistingDocument = getExistingDocument;
+
+var areDocsEqual = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(oldDoc, newDoc) {
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            // Do not rely on revisions as they can be missing or wrong
+            newDoc._rev = undefined;
+            oldDoc._rev = undefined;
+
+            if (!(0, _fastDeepEqual.default)(oldDoc, newDoc)) {
+              _context2.next = 4;
+              break;
+            }
+
+            return _context2.abrupt("return", true);
+
+          case 4:
+            return _context2.abrupt("return", false);
+
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function areDocsEqual(_x3, _x4) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+exports.areDocsEqual = areDocsEqual;