cozy-pouch-link 57.5.0 → 57.6.1

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()
+  })
+})

package/dist/db/sqlite/sql.js

@@ -0,0 +1,422 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.executeSQL = exports.deleteIndex = exports.createMangoIndex = exports.makeSQLCreateDeletedIndex = exports.makeSQLCreateDocIDIndex = exports.makeSQLCreateMangoIndex = exports.makeSQLDropIndex = exports.makeSQLQueryAll = exports.makeSQLQueryForIds = exports.makeSQLQueryForId = exports.makeSQLQueryFromMango = exports.makeSortClause = exports.makeWhereClause = exports.mangoSelectorToSQL = exports.parseResults = exports.keepDocWitHighestRev = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _jsonapi = require("../../jsonapi");
+
+var _helpers = require("../helpers");
+
+var MANGO_TO_SQL_OP = {
+  $eq: '=',
+  $ne: '!=',
+  $gt: '>',
+  $gte: '>=',
+  $lt: '<',
+  $lte: '<=',
+  $in: 'IN',
+  $nin: 'NOT IN',
+  $exists: 'IS'
+};
+
+var extractRevPrefix = function extractRevPrefix(rev) {
+  if (!rev) {
+    return 0;
+  }
+
+  var prefixStr = rev.split('-')[0];
+  return prefixStr ? parseInt(prefixStr) : 0;
+};
+
+var keepDocWitHighestRev = function keepDocWitHighestRev(docs) {
+  if (!docs || docs.length < 1) {
+    return null;
+  }
+
+  var highestDocRev = {
+    doc: docs[0],
+    revPrefix: extractRevPrefix(docs[0]._rev)
+  };
+
+  for (var i = 0; i < docs.length; i++) {
+    var revPrefix = extractRevPrefix(docs[i]._rev);
+
+    if (revPrefix > highestDocRev.revPrefix) {
+      highestDocRev = {
+        doc: docs[i],
+        revPrefix: revPrefix
+      };
+    }
+  }
+
+  return highestDocRev.doc;
+};
+
+exports.keepDocWitHighestRev = keepDocWitHighestRev;
+
+var parseResults = function parseResults(client, result, doctype) {
+  var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+      _ref$isSingleDoc = _ref.isSingleDoc,
+      isSingleDoc = _ref$isSingleDoc === void 0 ? false : _ref$isSingleDoc,
+      _ref$skip = _ref.skip,
+      skip = _ref$skip === void 0 ? 0 : _ref$skip,
+      _ref$limit = _ref.limit,
+      limit = _ref$limit === void 0 ? -1 : _ref$limit;
+
+  var parsedResults = [];
+
+  for (var i = 0; i < result.rows.length; i++) {
+    var item = result.rows.item(i);
+    var doc = JSON.parse(item['data']); // Handle special case for docs with `cozyPouchData`
+
+    var cozyPouchData = (0, _helpers.getCozyPouchData)(doc);
+
+    if (cozyPouchData) {
+      return {
+        data: cozyPouchData
+      };
+    }
+
+    doc._id = item.doc_id;
+    doc._rev = item.rev;
+    doc._type = doctype;
+    (0, _jsonapi.normalizeDoc)(client, doctype, doc);
+    parsedResults.push(doc);
+  }
+
+  if (parsedResults.length === 0) {
+    return {
+      data: []
+    };
+  }
+
+  if (isSingleDoc) {
+    if (parsedResults.length > 1) {
+      var _doc = keepDocWitHighestRev(parsedResults);
+
+      return {
+        data: _doc
+      };
+    }
+
+    return {
+      data: parsedResults[0]
+    };
+  } // XXX - Ideally we should have the total number of rows in the database to have a reliable
+  // next parameter, but we prefer to avoid this computation for performances.
+  // So let's rely on the total number of returned rows - if next is true, the last paginated
+  // query should have less results than the limit, thanks to the offset
+
+
+  var next = false;
+
+  if (limit !== -1 && parsedResults.length >= limit) {
+    next = true;
+  }
+
+  return {
+    data: parsedResults,
+    meta: {
+      count: parsedResults.length
+    },
+    skip: skip,
+    next: next
+  };
+};
+
+exports.parseResults = parseResults;
+
+var parseCondition = function parseCondition(field, condition) {
+  var conditions = [];
+  var sqlField = transformMangoFieldInJSONSQL(field);
+
+  if (typeof condition === 'object' && !Array.isArray(condition)) {
+    for (var operator in condition) {
+      var sqlOp = MANGO_TO_SQL_OP[operator];
+
+      if (operator === '$in' || operator === '$nin') {
+        var values = condition[operator].map(function (v) {
+          return typeof v === 'string' ? "'".concat(v, "'") : v;
+        }).join(', ');
+        conditions.push("".concat(sqlField, " ").concat(sqlOp, " (").concat(values, ")"));
+      } else if (operator === '$exists') {
+        var value = condition[operator];
+
+        if (value) {
+          sqlOp += ' NOT NULL';
+        } else {
+          sqlOp += ' NULL';
+        }
+
+        conditions.push("".concat(sqlField, " ").concat(sqlOp));
+      } else {
+        var _value = typeof condition[operator] === 'string' ? "'".concat(condition[operator], "'") : condition[operator];
+
+        if (operator === '$gt' && _value === null) {
+          // Special case for $gt: null conditions
+          conditions.push("".concat(sqlField, " IS NOT NULL"));
+        } else {
+          conditions.push("".concat(sqlField, " ").concat(sqlOp, " ").concat(_value));
+        }
+      }
+    }
+  } else {
+    var _value2 = typeof condition === 'string' ? "'".concat(condition, "'") : condition;
+
+    conditions.push("".concat(sqlField, " = ").concat(_value2));
+  }
+
+  return conditions.join(' AND ');
+};
+
+var parseLogicalOperator = function parseLogicalOperator(operator, conditionsArray) {
+  var sqlOperator = operator === '$and' ? 'AND' : 'OR';
+  var parsedConditions = conditionsArray.map(function (cond) {
+    return "(".concat(mangoSelectorToSQL(cond).replace(/^WHERE /, ''), ")");
+  });
+  return parsedConditions.join(" ".concat(sqlOperator, " "));
+};
+
+var transformMangoFieldInJSONSQL = function transformMangoFieldInJSONSQL(field) {
+  var columnName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'data';
+  return "json_extract(".concat(columnName, ", '$.").concat(field, "')");
+};
+
+var mangoSelectorToSQL = function mangoSelectorToSQL(selector) {
+  var conditions = [];
+
+  for (var key in selector) {
+    if (key === '$and' || key === '$or') {
+      conditions.push(parseLogicalOperator(key, selector[key]));
+    } else {
+      conditions.push(parseCondition(key, selector[key]));
+    }
+  }
+
+  return conditions.length > 0 ? "".concat(conditions.join(' AND ')) : '';
+};
+
+exports.mangoSelectorToSQL = mangoSelectorToSQL;
+
+var makeWhereClause = function makeWhereClause(selector) {
+  var baseWhere = 'DELETED = 0';
+
+  if (!selector) {
+    return baseWhere;
+  }
+
+  var mangoWhere = mangoSelectorToSQL(selector);
+  baseWhere += " AND ".concat(mangoWhere);
+  return baseWhere;
+};
+
+exports.makeWhereClause = makeWhereClause;
+
+var makeSortClause = function makeSortClause(mangoSortBy) {
+  if (!mangoSortBy || !Array.isArray(mangoSortBy) || mangoSortBy.length < 1) {
+    return null;
+  }
+
+  var firstSortEntry = mangoSortBy[0];
+  var sortOrder = Object.values(firstSortEntry)[0].toUpperCase();
+  var sortFields = mangoSortBy.map(function (sort) {
+    var attribute = Object.keys(sort)[0];
+    return "json_extract(data, '$.".concat(attribute, "')");
+  }).join(', ');
+  var sortClause = "".concat(sortFields, " ").concat(sortOrder);
+  return sortClause;
+};
+
+exports.makeSortClause = makeSortClause;
+
+var makeSQLQueryFromMango = function makeSQLQueryFromMango(_ref2) {
+  var selector = _ref2.selector,
+      sort = _ref2.sort,
+      indexName = _ref2.indexName,
+      _ref2$limit = _ref2.limit,
+      limit = _ref2$limit === void 0 ? -1 : _ref2$limit,
+      _ref2$skip = _ref2.skip,
+      skip = _ref2$skip === void 0 ? 0 : _ref2$skip;
+  var whereClause = makeWhereClause(selector);
+  var sortClause = makeSortClause(sort);
+  var sql = ["SELECT json AS data, doc_id, rev", "FROM 'by-sequence' INDEXED BY ".concat(indexName), "WHERE ".concat(whereClause)].join(' ');
+
+  if (skip > 0) {
+    sql += " OFFSET ".concat(skip);
+  }
+
+  if (sortClause) {
+    sql += " ORDER BY ".concat(sortClause);
+  }
+
+  sql += " LIMIT ".concat(limit);
+  sql += ';';
+  return sql;
+};
+
+exports.makeSQLQueryFromMango = makeSQLQueryFromMango;
+
+var makeSQLQueryForId = function makeSQLQueryForId(id) {
+  var sql = ["SELECT json AS data, doc_id, rev", "FROM 'by-sequence'", "WHERE doc_id=\"".concat(id, "\" AND deleted=0"), ";"].join(' ');
+  return sql;
+};
+
+exports.makeSQLQueryForId = makeSQLQueryForId;
+
+var makeSQLQueryForIds = function makeSQLQueryForIds(ids) {
+  var doc_ids = ids.join(',');
+  var sql = "\n    SELECT json AS data, doc_id, rev\n    FROM 'by-sequence'\n    WHERE doc_id IN (\"".concat(doc_ids, "\") AND deleted = 0;\n  ");
+  return sql;
+};
+
+exports.makeSQLQueryForIds = makeSQLQueryForIds;
+
+var makeSQLQueryAll = function makeSQLQueryAll() {
+  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref3$limit = _ref3.limit,
+      limit = _ref3$limit === void 0 ? -1 : _ref3$limit,
+      _ref3$skip = _ref3.skip,
+      skip = _ref3$skip === void 0 ? 0 : _ref3$skip;
+
+  var sql = ["SELECT json AS data, doc_id, rev", "FROM 'by-sequence'", "WHERE deleted=0", "LIMIT ".concat(limit)].join(' ');
+
+  if (skip > 0) {
+    sql += " OFFSET ".concat(skip);
+  }
+
+  sql += ';';
+  return sql;
+};
+
+exports.makeSQLQueryAll = makeSQLQueryAll;
+
+var makeSQLDropIndex = function makeSQLDropIndex(indexName) {
+  return "DROP INDEX IF EXISTS '".concat(indexName, "';");
+};
+
+exports.makeSQLDropIndex = makeSQLDropIndex;
+
+var makeSQLCreateMangoIndex = function makeSQLCreateMangoIndex(indexName, fieldsToIndex, _ref4) {
+  var partialFilter = _ref4.partialFilter;
+  var jsonAttributes = fieldsToIndex.map(function (field) {
+    return "json_extract(json, '$.".concat(field, "')");
+  });
+  var jsonIndex = jsonAttributes.join(',');
+  var sql = "\n    CREATE INDEX IF NOT EXISTS '".concat(indexName, "'\n    ON 'by-sequence'\n    (").concat(jsonIndex, ")\n  ");
+
+  if (partialFilter) {
+    var whereClause = makeWhereClause(partialFilter);
+    sql += " WHERE ".concat(whereClause);
+  }
+
+  sql += ';';
+  return sql;
+};
+
+exports.makeSQLCreateMangoIndex = makeSQLCreateMangoIndex;
+
+var makeSQLCreateDocIDIndex = function makeSQLCreateDocIDIndex() {
+  // This index is useful for docid queries
+  var sql = "\n    CREATE UNIQUE INDEX IF NOT EXISTS 'by_docid_and_deleted'\n    ON 'by-sequence'\n    (doc_id, deleted);\n  ";
+  return sql;
+};
+
+exports.makeSQLCreateDocIDIndex = makeSQLCreateDocIDIndex;
+
+var makeSQLCreateDeletedIndex = function makeSQLCreateDeletedIndex() {
+  // This index is useful for allDocs queries
+  var sql = "\n    CREATE INDEX IF NOT EXISTS 'by_deleted'\n    ON 'by-sequence'\n    (deleted);\n  ";
+  return sql;
+};
+
+exports.makeSQLCreateDeletedIndex = makeSQLCreateDeletedIndex;
+
+var createMangoIndex = /*#__PURE__*/function () {
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(db, indexName, fieldsToIndex, _ref5) {
+    var partialFilter, sql, result;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            partialFilter = _ref5.partialFilter;
+            sql = makeSQLCreateMangoIndex(indexName, fieldsToIndex, {
+              partialFilter: partialFilter
+            });
+            _context.next = 4;
+            return executeSQL(db, sql);
+
+          case 4:
+            result = _context.sent;
+            return _context.abrupt("return", result);
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function createMangoIndex(_x, _x2, _x3, _x4) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
+exports.createMangoIndex = createMangoIndex;
+
+var deleteIndex = /*#__PURE__*/function () {
+  var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(db, indexName) {
+    var sql;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            sql = makeSQLDropIndex(indexName);
+            _context2.next = 3;
+            return executeSQL(db, sql);
+
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function deleteIndex(_x5, _x6) {
+    return _ref7.apply(this, arguments);
+  };
+}();
+
+exports.deleteIndex = deleteIndex;
+
+var executeSQL = /*#__PURE__*/function () {
+  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(db, sql) {
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            return _context3.abrupt("return", db.executeAsync(sql));
+
+          case 1:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function executeSQL(_x7, _x8) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+
+exports.executeSQL = executeSQL;