cozy-pouch-link 57.4.0 → 57.6.0

package/dist/db/pouchdb/getDocs.js

@@ -0,0 +1,157 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDocs = exports.getDocsAndNormalize = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _helpers = _interopRequireDefault(require("../../helpers"));
+
+var _jsonapi = require("../../jsonapi");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var isAdapterBugged = _helpers.default.isAdapterBugged,
+    LIMIT_BUG = _helpers.default.LIMIT_BUG;
+
+var getDocsAndNormalize = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref) {
+    var client, doctype, db, queryFunc, _ref$queryParams, queryParams, _ref$withRows, withRows, results, jsonResult;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            client = _ref.client, doctype = _ref.doctype, db = _ref.db, queryFunc = _ref.queryFunc, _ref$queryParams = _ref.queryParams, queryParams = _ref$queryParams === void 0 ? {} : _ref$queryParams, _ref$withRows = _ref.withRows, withRows = _ref$withRows === void 0 ? true : _ref$withRows;
+            _context.next = 3;
+            return getDocs(db, queryFunc, queryParams);
+
+          case 3:
+            results = _context.sent;
+            jsonResult = (0, _jsonapi.fromPouchResult)({
+              res: results,
+              withRows: withRows,
+              doctype: doctype,
+              client: client
+            });
+            return _context.abrupt("return", jsonResult);
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getDocsAndNormalize(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+exports.getDocsAndNormalize = getDocsAndNormalize;
+
+var getDocs = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(db, fct) {
+    var queryParams,
+        limit,
+        field,
+        data,
+        next,
+        _args2 = arguments;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            queryParams = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
+            // allDocs return an error when limit is null
+            if (queryParams.limit === null) delete queryParams.limit;
+            limit = queryParams.limit;
+            field = fct === 'allDocs' ? 'rows' : 'docs';
+
+            if (isAdapterBugged(db.adapter)) {
+              // FIXME: to remove? This was used to deal with an old adapter that is probably no longer used
+              // But it might be worth checking the issue does not exist anymore
+              if (limit === undefined || limit > LIMIT_BUG) {
+                queryParams.limit = LIMIT_BUG;
+                queryParams.skip = queryParams.skip || 0;
+              }
+            }
+
+            if (!(fct === 'get')) {
+              _context2.next = 9;
+              break;
+            }
+
+            if (queryParams.id) {
+              _context2.next = 8;
+              break;
+            }
+
+            return _context2.abrupt("return", null);
+
+          case 8:
+            return _context2.abrupt("return", db.get(queryParams.id));
+
+          case 9:
+            _context2.next = 11;
+            return db[fct](queryParams);
+
+          case 11:
+            data = _context2.sent;
+
+            if (!(data[field].length === queryParams.limit)) {
+              _context2.next = 20;
+              break;
+            }
+
+            queryParams.skip = (queryParams.skip ? queryParams.skip : 0) + queryParams.limit;
+            queryParams.limit = limit ? limit - queryParams.limit : undefined;
+
+            if (!(queryParams.limit > 0 || queryParams.limit === undefined)) {
+              _context2.next = 20;
+              break;
+            }
+
+            _context2.next = 18;
+            return getDocs(db, fct, queryParams);
+
+          case 18:
+            next = _context2.sent;
+            return _context2.abrupt("return", _objectSpread(_objectSpread({}, data), {}, (0, _defineProperty2.default)({}, field, [].concat((0, _toConsumableArray2.default)(data[field]), (0, _toConsumableArray2.default)(next[field])))));
+
+          case 20:
+            if (queryParams.keys) {
+              // Special case for getByIds queries: Pouch returns the total number of rows in the database,
+              // which will make cozy-client believes there are more results to fetch
+              data.total_rows = data.rows.length;
+            }
+
+            return _context2.abrupt("return", data);
+
+          case 22:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function getDocs(_x2, _x3) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+exports.getDocs = getDocs;

package/dist/db/pouchdb/getDocs.spec.js

@@ -0,0 +1,63 @@
+import { getDocs } from './getDocs'
+
+import PouchDB from 'pouchdb-browser'
+import PouchDBFind from 'pouchdb-find'
+import adapter from 'pouchdb-adapter-memory'
+PouchDB.plugin(PouchDBFind)
+PouchDB.plugin(adapter)
+
+const insertData = async (db, number) => {
+  const docs = []
+  for (let i = 0; i < number; i++) {
+    docs.push({ _id: `doc${i}`, status: true })
+  }
+  await db.bulkDocs(docs)
+}
+
+describe('getDocs', () => {
+  let db, options
+
+  beforeEach(async () => {
+    db = new PouchDB('test', { adapter: 'memory' })
+    options = { selector: { status: { $eq: true } } }
+    await db.createIndex({ index: { fields: ['status'] } })
+    await insertData(db, 105)
+  })
+
+  afterEach(async () => {
+    await db.destroy()
+  })
+
+  it('should get all docs', async () => {
+    const resp = await getDocs(db, 'allDocs', options)
+    expect(resp.rows).toHaveLength(106) // include design doc
+  })
+
+  it('should get 20 docs with allDocs', async () => {
+    const resp = await getDocs(db, 'allDocs', { limit: 20 })
+    expect(resp.rows).toHaveLength(20)
+  })
+
+  it('should find docs with default limit', async () => {
+    const resp = await getDocs(db, 'find', options)
+    expect(resp.docs).toHaveLength(105) // does not include design doc
+  })
+
+  it('should get 20 docs with find', async () => {
+    const resp = await getDocs(db, 'find', { ...options, limit: 20 })
+    expect(resp.docs).toHaveLength(20)
+  })
+
+  it('should get a single doc by id', async () => {
+    const resp = await getDocs(db, 'get', { ...options, id: 'doc0' })
+    expect(resp._id).toEqual('doc0')
+  })
+
+  it('should get a multiple docs by ids', async () => {
+    const resp = await getDocs(db, 'allDocs', {
+      ...options,
+      keys: ['doc0', 'doc1', 'doc2']
+    })
+    expect(resp.rows).toHaveLength(3)
+  })
+})

package/dist/db/pouchdb/pouchdb.js

@@ -0,0 +1,264 @@
+"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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _mango = require("../../mango");
+
+var _dbInterface = _interopRequireDefault(require("../dbInterface"));
+
+var _errors = require("../../errors");
+
+var _getDocs = require("./getDocs");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+var PouchDBQueryEngine = /*#__PURE__*/function (_DatabaseQueryEngine) {
+  (0, _inherits2.default)(PouchDBQueryEngine, _DatabaseQueryEngine);
+
+  var _super = _createSuper(PouchDBQueryEngine);
+
+  function PouchDBQueryEngine(pouchManager, doctype) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, PouchDBQueryEngine);
+    _this = _super.call(this);
+    _this.pouchManager = pouchManager;
+    _this.client = pouchManager === null || pouchManager === void 0 ? void 0 : pouchManager.client;
+    _this.doctype = doctype;
+    _this.db = null;
+    return _this;
+  }
+
+  (0, _createClass2.default)(PouchDBQueryEngine, [{
+    key: "openDB",
+    value: function openDB(dbName) {
+      this.db = this.pouchManager.getPouch(dbName);
+      return this.db;
+    }
+  }, {
+    key: "allDocs",
+    value: function () {
+      var _allDocs = (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:
+                return _context.abrupt("return", (0, _getDocs.getDocsAndNormalize)({
+                  client: this.client,
+                  db: this.db,
+                  doctype: this.doctype,
+                  queryFunc: 'allDocs',
+                  queryParams: _objectSpread({
+                    include_docs: true
+                  }, options)
+                }));
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function allDocs(_x) {
+        return _allDocs.apply(this, arguments);
+      }
+
+      return allDocs;
+    }()
+  }, {
+    key: "getById",
+    value: function () {
+      var _getById = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(id) {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", (0, _getDocs.getDocsAndNormalize)({
+                  client: this.client,
+                  db: this.db,
+                  doctype: this.doctype,
+                  queryFunc: 'get',
+                  queryParams: {
+                    id: id
+                  },
+                  withRows: false
+                }));
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getById(_x2) {
+        return _getById.apply(this, arguments);
+      }
+
+      return getById;
+    }()
+  }, {
+    key: "getByIds",
+    value: function () {
+      var _getByIds = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(ids) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                return _context3.abrupt("return", (0, _getDocs.getDocsAndNormalize)({
+                  client: this.client,
+                  db: this.db,
+                  doctype: this.doctype,
+                  queryFunc: 'allDocs',
+                  queryParams: {
+                    include_docs: true,
+                    keys: ids
+                  }
+                }));
+
+              case 1:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function getByIds(_x3) {
+        return _getByIds.apply(this, arguments);
+      }
+
+      return getByIds;
+    }()
+  }, {
+    key: "find",
+    value: function () {
+      var _find = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(options) {
+        var selector, sort, partialFilter, doctype, indexedFields, indexName, findOpts, res;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                selector = options.selector, sort = options.sort, partialFilter = options.partialFilter, doctype = options.doctype;
+                indexedFields = options.indexedFields;
+                indexedFields = (0, _mango.getIndexFields)({
+                  indexedFields: indexedFields,
+                  selector: selector,
+                  sort: sort,
+                  partialFilter: partialFilter
+                });
+                indexName = (0, _mango.getIndexName)({
+                  selector: selector,
+                  sort: sort,
+                  partialFilter: partialFilter,
+                  indexedFields: indexedFields
+                });
+                findOpts = _objectSpread({
+                  selector: selector,
+                  sort: sort,
+                  partialFilter: partialFilter,
+                  doctype: doctype,
+                  use_index: indexName
+                }, options);
+                findOpts.indexedFields = indexedFields;
+                _context4.prev = 6;
+                _context4.next = 9;
+                return (0, _getDocs.getDocsAndNormalize)({
+                  client: this.client,
+                  db: this.db,
+                  doctype: this.doctype,
+                  queryFunc: 'find',
+                  queryParams: findOpts
+                });
+
+              case 9:
+                res = _context4.sent;
+                _context4.next = 23;
+                break;
+
+              case 12:
+                _context4.prev = 12;
+                _context4.t0 = _context4["catch"](6);
+
+                if (!(0, _errors.isMissingPouchDBIndexError)(_context4.t0)) {
+                  _context4.next = 22;
+                  break;
+                }
+
+                _context4.next = 17;
+                return (0, _mango.createIndex)(this.db, indexedFields, {
+                  indexName: indexName,
+                  doctype: doctype,
+                  partialFilter: partialFilter
+                });
+
+              case 17:
+                _context4.next = 19;
+                return (0, _getDocs.getDocsAndNormalize)({
+                  client: this.client,
+                  db: this.db,
+                  doctype: this.doctype,
+                  queryFunc: 'find',
+                  queryParams: findOpts
+                });
+
+              case 19:
+                res = _context4.sent;
+                _context4.next = 23;
+                break;
+
+              case 22:
+                throw _context4.t0;
+
+              case 23:
+                return _context4.abrupt("return", res);
+
+              case 24:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this, [[6, 12]]);
+      }));
+
+      function find(_x4) {
+        return _find.apply(this, arguments);
+      }
+
+      return find;
+    }()
+  }]);
+  return PouchDBQueryEngine;
+}(_dbInterface.default);
+
+exports.default = PouchDBQueryEngine;

package/dist/db/pouchdb/pouchdb.spec.js

@@ -0,0 +1,151 @@
+import PouchDBQuery from './pouchdb'
+import { createIndex } from '../../mango'
+import { getDocsAndNormalize } from './getDocs'
+import { Q } from 'cozy-client'
+
+jest.mock('../../mango', () => ({
+  ...jest.requireActual('../../mango'),
+  createIndex: jest.fn()
+}))
+
+jest.mock('./getDocs', () => ({
+  getDocsAndNormalize: jest.fn()
+}))
+
+describe('PouchDBQuery find()', () => {
+  let pouchQE
+
+  beforeEach(() => {
+    pouchQE = new PouchDBQuery()
+    pouchQE.client = {}
+    pouchQE.db = {}
+    pouchQE.doctype = 'io.cozy.test'
+
+    jest.clearAllMocks()
+  })
+
+  it('should use provided indexedFields', async () => {
+    const options = {
+      selector: { name: 'John' },
+      sort: [{ name: 'asc' }],
+      indexedFields: ['name'],
+      doctype: 'io.cozy.test'
+    }
+
+    getDocsAndNormalize.mockResolvedValue([{ _id: '1', name: 'John' }])
+
+    const result = await pouchQE.find(options)
+
+    expect(getDocsAndNormalize).toHaveBeenCalledWith({
+      client: pouchQE.client,
+      db: pouchQE.db,
+      doctype: pouchQE.doctype,
+      queryFunc: 'find',
+      queryParams: expect.objectContaining({
+        selector: options.selector,
+        sort: options.sort,
+        partialFilter: options.partialFilter,
+        indexedFields: ['name'],
+        use_index: 'by_name'
+      })
+    })
+    expect(result).toEqual([{ _id: '1', name: 'John' }])
+  })
+
+  it('should use the index attribute from the sort', async () => {
+    const query = Q('io.cozy.todos')
+      .where({})
+      .sortBy([{ name: 'asc' }])
+    await pouchQE.find(query)
+    expect(getDocsAndNormalize).toHaveBeenCalledWith({
+      client: pouchQE.client,
+      db: pouchQE.db,
+      doctype: pouchQE.doctype,
+      queryFunc: 'find',
+      queryParams: expect.objectContaining({
+        sort: query.sort,
+        indexedFields: ['name'],
+        use_index: 'by_name'
+      })
+    })
+  })
+
+  it('should handle partialIndex', async () => {
+    const query = Q('io.cozy.todos')
+      .indexFields(['name'])
+      .partialIndex({ name: { $exists: true } })
+    await pouchQE.find(query)
+    expect(getDocsAndNormalize).toHaveBeenCalledWith({
+      client: pouchQE.client,
+      db: pouchQE.db,
+      doctype: pouchQE.doctype,
+      queryFunc: 'find',
+      queryParams: expect.objectContaining({
+        partialFilter: { name: { $exists: true } },
+        indexedFields: ['name'],
+        use_index: 'by_name_filter_(name_$exists_true)'
+      })
+    })
+  })
+
+  it('should handle complex index name for partial filters ', async () => {
+    const query = Q('io.cozy.todos')
+      .indexFields(['name'])
+      .partialIndex({
+        $and: [{ name: { $exists: true } }, { date: { $gt: null } }],
+        $or: [{ count: { $eq: '1' } }, { count: { $eq: '2' } }]
+      })
+    await pouchQE.find(query)
+    expect(getDocsAndNormalize).toHaveBeenCalledWith({
+      client: pouchQE.client,
+      db: pouchQE.db,
+      doctype: pouchQE.doctype,
+      queryFunc: 'find',
+      queryParams: expect.objectContaining({
+        partialFilter: {
+          $and: [{ name: { $exists: true } }, { date: { $gt: null } }],
+          $or: [{ count: { $eq: '1' } }, { count: { $eq: '2' } }]
+        },
+        indexedFields: ['name'],
+        use_index:
+          'by_name_filter_((name_$exists_true)_$and_(date_$gt_null))_and_((count_$eq_1)_$or_(count_$eq_2))'
+      })
+    })
+  })
+
+  it('should create index and retry query if missing index error occurs', async () => {
+    const options = {
+      selector: { age: { $gt: 18 } },
+      sort: [{ age: 'desc' }],
+      indexedFields: ['age'],
+      doctype: 'io.cozy.test'
+    }
+
+    const mockError = new Error('no index')
+
+    getDocsAndNormalize
+      .mockRejectedValueOnce(mockError)
+      .mockResolvedValueOnce([{ _id: '2', age: 20 }])
+
+    const result = await pouchQE.find(options)
+
+    expect(createIndex).toHaveBeenCalledWith(pouchQE.db, ['age'], {
+      indexName: 'by_age',
+      doctype: 'io.cozy.test'
+    })
+
+    expect(getDocsAndNormalize).toHaveBeenCalledTimes(2)
+    expect(result).toEqual([{ _id: '2', age: 20 }])
+  })
+
+  it('should throw error if non-index related error occurs', async () => {
+    const options = { selector: { status: 'active' } }
+    const mockError = new Error('generic error')
+
+    getDocsAndNormalize.mockRejectedValue(mockError)
+
+    await expect(pouchQE.find(options)).rejects.toThrow('generic error')
+
+    expect(createIndex).not.toHaveBeenCalled()
+  })
+})