cozy-pouch-link 57.5.0 → 57.6.1

package/dist/db/helpers.js

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCozyPouchData = 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);
+  };
+}();
+/**
+ * Get cozyPouchData from a document
+ *
+ * Sometimes, queries are transformed by Collections and they call a dedicated
+ * cozy-stack route. When this is the case, we want to be able to replicate the same
+ * query from cozy-pouch-link. It is not possible as-is because the received data
+ * is not the same as the one stored in the Couch database
+ * To handle this, we store the received data in the Pouch with a dedicated id and
+ * we store the query result in a `cozyPouchData` attribute
+ * So when `cozyPouchData` attribute exists, we know that we want to return its content
+ * as the result of the query
+ *
+ * @param {import('../CozyPouchLink').CozyPouchDocument} doc - The PouchDB doc
+ * @returns { Array<import('cozy-client/types/types').CozyClientDocument>} The formatted docs
+ */
+
+
+exports.areDocsEqual = areDocsEqual;
+
+var getCozyPouchData = function getCozyPouchData(doc) {
+  return doc.cozyPouchData;
+};
+
+exports.getCozyPouchData = getCozyPouchData;

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;