cozy-pouch-link 57.4.0 → 57.6.0

package/dist/db/sqlite/sql.spec.js

@@ -0,0 +1,363 @@
+import {
+  mangoSelectorToSQL,
+  makeWhereClause,
+  makeSortClause,
+  makeSQLQueryFromMango,
+  keepDocWitHighestRev,
+  makeSQLQueryAll,
+  parseResults
+} from './sql'
+
+describe('mangoSelectorToSQL', () => {
+  it('should return empty string for empty selector', () => {
+    const selector = {}
+    expect(mangoSelectorToSQL(selector)).toBe('')
+  })
+
+  it('should handle implicit equality selector', () => {
+    const selector = { status: 'active' }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "json_extract(data, '$.status') = 'active'"
+    )
+  })
+
+  it('should handle explicit $eq operator', () => {
+    const selector = { status: { $eq: 'active' } }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "json_extract(data, '$.status') = 'active'"
+    )
+  })
+
+  it('should handle $neq operator', () => {
+    const selector = { status: { $ne: 'active' } }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "json_extract(data, '$.status') != 'active'"
+    )
+  })
+
+  it('should handle $in and $nin operator', () => {
+    const selector = {
+      status: { $in: ['active', 'pending'] },
+      other_status: { $nin: ['maintenance', 'failing'] }
+    }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "json_extract(data, '$.status') IN ('active', 'pending') AND json_extract(data, '$.other_status') NOT IN ('maintenance', 'failing')"
+    )
+  })
+
+  it('should handle $exists operator', () => {
+    const selector1 = { status: { $exists: true } }
+    expect(mangoSelectorToSQL(selector1)).toBe(
+      "json_extract(data, '$.status') IS NOT NULL"
+    )
+
+    const selector2 = { status: { $exists: false } }
+    expect(mangoSelectorToSQL(selector2)).toBe(
+      "json_extract(data, '$.status') IS NULL"
+    )
+  })
+
+  it('should handle implicit $and operator', () => {
+    const selector = {
+      age: 18,
+      status: 'active',
+      date: '2025-01-01'
+    }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "json_extract(data, '$.age') = 18 AND json_extract(data, '$.status') = 'active' AND json_extract(data, '$.date') = '2025-01-01'"
+    )
+  })
+
+  it('should handle range operators', () => {
+    const selector1 = { date: { $gt: '2025-01-01', $lt: '2026-01-01' } }
+    expect(mangoSelectorToSQL(selector1)).toBe(
+      "json_extract(data, '$.date') > '2025-01-01' AND json_extract(data, '$.date') < '2026-01-01'"
+    )
+
+    const selector2 = {
+      startDate: { $gte: '2025-01-01' },
+      endDate: { $lte: '2026-01-01' }
+    }
+    expect(mangoSelectorToSQL(selector2)).toBe(
+      "json_extract(data, '$.startDate') >= '2025-01-01' AND json_extract(data, '$.endDate') <= '2026-01-01'"
+    )
+  })
+
+  it('should handle $gt: null cases', () => {
+    const selector = { date: { $gt: null } }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "json_extract(data, '$.date') IS NOT NULL"
+    )
+  })
+
+  it('should handle explicit $and operator', () => {
+    const selector = { $and: [{ age: { $gte: 18 } }, { status: 'active' }] }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "(json_extract(data, '$.age') >= 18) AND (json_extract(data, '$.status') = 'active')"
+    )
+  })
+
+  it('should handle explicit $or operator', () => {
+    const selector = { $or: [{ status: 'active' }, { status: 'pending' }] }
+    expect(mangoSelectorToSQL(selector)).toBe(
+      "(json_extract(data, '$.status') = 'active') OR (json_extract(data, '$.status') = 'pending')"
+    )
+  })
+})
+
+describe('makeWhereClause', () => {
+  it('should return only deleted clause when no mango selector', () => {
+    expect(makeWhereClause(undefined)).toEqual('DELETED = 0')
+  })
+
+  it('should return deleted and mango clauses when there is a mango selector', () => {
+    const selector = { status: 'active' }
+    expect(makeWhereClause(selector)).toEqual(
+      "DELETED = 0 AND json_extract(data, '$.status') = 'active'"
+    )
+  })
+})
+
+describe('makeSortClause', () => {
+  it('should return null when no mango sort', () => {
+    const sortBy = undefined
+    expect(makeSortClause(sortBy)).toBe(null)
+  })
+
+  it('should return correct order by, with one sorting attribute', () => {
+    const sortBy = [{ date: 'asc' }]
+    expect(makeSortClause(sortBy)).toEqual("json_extract(data, '$.date') ASC")
+  })
+
+  it('should return correct order by, with multiple sorting attribute', () => {
+    const sortBy = [{ date: 'asc' }, { name: 'asc' }, { type: 'asc' }]
+    expect(makeSortClause(sortBy)).toEqual(
+      "json_extract(data, '$.date'), json_extract(data, '$.name'), json_extract(data, '$.type') ASC"
+    )
+  })
+
+  it('should deal with ascending and descending order', () => {
+    const sortBy1 = [{ date: 'asc' }]
+    expect(makeSortClause(sortBy1)).toEqual("json_extract(data, '$.date') ASC")
+    const sortBy2 = [{ date: 'desc' }]
+    expect(makeSortClause(sortBy2)).toEqual("json_extract(data, '$.date') DESC")
+  })
+})
+
+describe('makeSQLQueryFromMango', () => {
+  it('should return a correct SQL query with no sort', () => {
+    const selector = { date: { $gt: '2025-01-01' } }
+    const indexName = 'by_name'
+    const limit = 100
+    const sql = makeSQLQueryFromMango({ selector, indexName, limit })
+
+    const expectedSql = [
+      `SELECT json AS data, doc_id, rev`,
+      `FROM 'by-sequence' INDEXED BY by_name`,
+      `WHERE DELETED = 0 AND json_extract(data, '$.date') > '2025-01-01'`,
+      `LIMIT 100;`
+    ].join(' ')
+    expect(sql).toEqual(expectedSql)
+  })
+
+  it('should return a correct SQL query with sort', () => {
+    const selector = { date: { $gt: '2025-01-01' } }
+    const sort = [{ date: 'asc' }]
+    const indexName = 'by_name'
+    const limit = 100
+    const sql = makeSQLQueryFromMango({ selector, sort, indexName, limit })
+
+    const expectedSql = [
+      `SELECT json AS data, doc_id, rev`,
+      `FROM 'by-sequence' INDEXED BY by_name`,
+      `WHERE DELETED = 0 AND json_extract(data, '$.date') > '2025-01-01'`,
+      `LIMIT 100`,
+      `ORDER BY json_extract(data, '$.date') ASC;`
+    ].join(' ')
+    expect(sql).toEqual(expectedSql)
+  })
+
+  it('should handle the skip and limit', () => {
+    const selector = { date: { $gt: '2025-01-01' } }
+    const indexName = 'by_name'
+    const limit = 200
+    const skip = 100
+    const sql = makeSQLQueryFromMango({
+      selector,
+      indexName,
+      limit,
+      skip
+    })
+
+    const expectedSql = [
+      `SELECT json AS data, doc_id, rev`,
+      `FROM 'by-sequence' INDEXED BY by_name`,
+      `WHERE DELETED = 0 AND json_extract(data, '$.date') > '2025-01-01'`,
+      `LIMIT 200`,
+      `OFFSET 100;`
+    ].join(' ')
+    expect(sql).toEqual(expectedSql)
+  })
+})
+
+describe('makeSQLQueryAll', () => {
+  it('should return a correct sql query to get all docs', () => {
+    const sql = makeSQLQueryAll()
+    const expectedSql = [
+      `SELECT json AS data, doc_id, rev`,
+      `FROM 'by-sequence'`,
+      `WHERE deleted=0`,
+      `LIMIT -1;`
+    ].join(' ')
+    expect(sql).toEqual(expectedSql)
+  })
+
+  it('should handle limit and skip', () => {
+    const sql = makeSQLQueryAll({ limit: 10, skip: 100 })
+    const expectedSql = [
+      `SELECT json AS data, doc_id, rev`,
+      `FROM 'by-sequence'`,
+      `WHERE deleted=0`,
+      `LIMIT 10`,
+      `OFFSET 100;`
+    ].join(' ')
+    expect(sql).toEqual(expectedSql)
+  })
+})
+
+describe('keepDocWitHighestRev', () => {
+  it('should return null if no docs', () => {
+    expect(keepDocWitHighestRev([])).toBeNull()
+    expect(keepDocWitHighestRev(undefined)).toBeNull()
+  })
+
+  it('should return the single document when only one is provided', () => {
+    const doc = { _rev: '1-a', name: 'Single Doc' }
+    const docs = [doc]
+    expect(keepDocWitHighestRev(docs)).toBe(doc)
+  })
+
+  it('should return the document with the highest revision prefix', () => {
+    const docs = [
+      { _rev: '1-a', name: 'Doc 1' },
+      { _rev: '3-c', name: 'Doc 3' },
+      { _rev: '2-b', name: 'Doc 2' }
+    ]
+    expect(keepDocWitHighestRev(docs)).toEqual(docs[1])
+  })
+
+  it('should work correctly even if the documents are unsorted', () => {
+    const docs = [
+      { _rev: '5-zzz', name: 'Doc 5' },
+      { _rev: '2-aaa', name: 'Doc 2' },
+      { _rev: '10-xxx', name: 'Doc 10' },
+      { _rev: '7-bbb', name: 'Doc 7' }
+    ]
+    expect(keepDocWitHighestRev(docs)).toEqual(docs[2])
+  })
+})
+
+describe('parseResults', () => {
+  const client = {}
+  const doctype = 'testdoctype'
+
+  it('should parse results correctly for multiple documents', () => {
+    const result = {
+      rows: {
+        length: 2,
+        item: jest.fn().mockImplementation(i => ({
+          data: JSON.stringify({ name: `doc${i}` }),
+          doc_id: `id${i}`,
+          rev: `rev${i}`
+        }))
+      }
+    }
+
+    const parsed = parseResults(client, result, doctype)
+
+    expect(parsed.data.length).toBe(2)
+    expect(parsed.meta.count).toBe(2)
+    expect(parsed.skip).toBe(0)
+    expect(parsed.next).toBe(false)
+
+    expect(parsed.data[0]).toEqual({
+      _id: 'id0',
+      id: 'id0',
+      _rev: 'rev0',
+      _type: doctype,
+      name: 'doc0'
+    })
+  })
+
+  it('should handle isSingleDoc correctly with multiple docs', () => {
+    const result = {
+      rows: {
+        length: 2,
+        item: jest.fn().mockImplementation(i => ({
+          data: JSON.stringify({ name: `doc${i}` }),
+          doc_id: `id${i}`,
+          rev: `rev${i}`
+        }))
+      }
+    }
+
+    const parsed = parseResults(client, result, doctype, { isSingleDoc: true })
+
+    expect(parsed.data).toEqual({
+      _id: 'id0',
+      id: 'id0',
+      _rev: 'rev0',
+      _type: doctype,
+      name: 'doc0'
+    })
+  })
+
+  it('should return empty data array when no rows are present', () => {
+    const result = { rows: { length: 0, item: jest.fn() } }
+
+    const parsed = parseResults(client, result, doctype)
+
+    expect(parsed).toEqual({ data: [] })
+  })
+
+  it('should set next=true when limit matches parsed length', () => {
+    const result = {
+      rows: {
+        length: 3,
+        item: jest.fn().mockImplementation(i => ({
+          data: JSON.stringify({ name: `doc${i}` }),
+          doc_id: `id${i}`,
+          rev: `rev${i}`
+        }))
+      }
+    }
+
+    const parsed = parseResults(client, result, doctype, { limit: 3 })
+
+    expect(parsed.next).toBe(true)
+    expect(parsed.data.length).toBe(3)
+  })
+
+  it('should handle single document correctly', () => {
+    const result = {
+      rows: {
+        length: 1,
+        item: jest.fn().mockReturnValue({
+          data: JSON.stringify({ name: 'single_doc' }),
+          doc_id: 'single_id',
+          rev: 'single_rev'
+        })
+      }
+    }
+
+    const parsed = parseResults(client, result, doctype, { isSingleDoc: true })
+
+    expect(parsed.data).toEqual({
+      _id: 'single_id',
+      id: 'single_id',
+      _rev: 'single_rev',
+      _type: doctype,
+      name: 'single_doc'
+    })
+  })
+})

package/dist/db/sqlite/sqliteDb.js

@@ -0,0 +1,319 @@
+"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"));
+
+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 _dbInterface = _interopRequireDefault(require("../dbInterface"));
+
+var _opSqlite = require("@op-engineering/op-sqlite");
+
+var _sql = require("./sql");
+
+var _mango = require("../../mango");
+
+var _errors = require("../../errors");
+
+var _logger = _interopRequireDefault(require("../../logger"));
+
+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 SQLiteQueryEngine = /*#__PURE__*/function (_DatabaseQueryEngine) {
+  (0, _inherits2.default)(SQLiteQueryEngine, _DatabaseQueryEngine);
+
+  var _super = _createSuper(SQLiteQueryEngine);
+
+  function SQLiteQueryEngine(pouchManager, doctype) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, SQLiteQueryEngine);
+    _this = _super.call(this);
+    _this.db = null;
+    _this.client = pouchManager === null || pouchManager === void 0 ? void 0 : pouchManager.client;
+    _this.doctype = doctype;
+    return _this;
+  }
+
+  (0, _createClass2.default)(SQLiteQueryEngine, [{
+    key: "openDB",
+    value: function openDB(dbName) {
+      var fileDbName = "".concat(dbName, ".sqlite");
+
+      try {
+        this.db = (0, _opSqlite.open)({
+          name: fileDbName
+        }); // Create index at db opening if needed
+
+        var docIdIndexSql = (0, _sql.makeSQLCreateDocIDIndex)();
+        var deletedIndexSql = (0, _sql.makeSQLCreateDeletedIndex)();
+        (0, _sql.executeSQL)(this.db, docIdIndexSql);
+        (0, _sql.executeSQL)(this.db, deletedIndexSql);
+      } catch (err) {
+        _logger.default.error(err);
+      }
+
+      return this.db;
+    }
+  }, {
+    key: "allDocs",
+    value: function () {
+      var _allDocs = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var _ref,
+            _ref$limit,
+            limit,
+            _ref$skip,
+            skip,
+            sql,
+            result,
+            docs,
+            _args = arguments;
+
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _ref = _args.length > 0 && _args[0] !== undefined ? _args[0] : {}, _ref$limit = _ref.limit, limit = _ref$limit === void 0 ? null : _ref$limit, _ref$skip = _ref.skip, skip = _ref$skip === void 0 ? 0 : _ref$skip;
+                _context.prev = 1;
+                sql = (0, _sql.makeSQLQueryAll)({
+                  limit: limit,
+                  skip: skip
+                });
+                _context.next = 5;
+                return (0, _sql.executeSQL)(this.db, sql);
+
+              case 5:
+                result = _context.sent;
+                docs = (0, _sql.parseResults)(this.client, result, this.doctype, {
+                  limit: limit,
+                  skip: skip
+                });
+                return _context.abrupt("return", docs);
+
+              case 10:
+                _context.prev = 10;
+                _context.t0 = _context["catch"](1);
+
+                _logger.default.error(_context.t0);
+
+                return _context.abrupt("return", null);
+
+              case 14:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[1, 10]]);
+      }));
+
+      function allDocs() {
+        return _allDocs.apply(this, arguments);
+      }
+
+      return allDocs;
+    }()
+  }, {
+    key: "getById",
+    value: function () {
+      var _getById = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(id) {
+        var sql, result, doc;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.prev = 0;
+                sql = (0, _sql.makeSQLQueryForId)(id);
+                _context2.next = 4;
+                return (0, _sql.executeSQL)(this.db, sql);
+
+              case 4:
+                result = _context2.sent;
+                doc = (0, _sql.parseResults)(this.client, result, this.doctype, {
+                  isSingleDoc: true
+                });
+                return _context2.abrupt("return", doc);
+
+              case 9:
+                _context2.prev = 9;
+                _context2.t0 = _context2["catch"](0);
+
+                _logger.default.error(_context2.t0);
+
+                return _context2.abrupt("return", null);
+
+              case 13:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[0, 9]]);
+      }));
+
+      function getById(_x) {
+        return _getById.apply(this, arguments);
+      }
+
+      return getById;
+    }()
+  }, {
+    key: "getByIds",
+    value: function () {
+      var _getByIds = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(ids) {
+        var sql, result, docs;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.prev = 0;
+                sql = (0, _sql.makeSQLQueryForIds)(ids);
+                _context3.next = 4;
+                return (0, _sql.executeSQL)(this.db, sql);
+
+              case 4:
+                result = _context3.sent;
+                docs = (0, _sql.parseResults)(this.client, result, this.doctype);
+                return _context3.abrupt("return", docs);
+
+              case 9:
+                _context3.prev = 9;
+                _context3.t0 = _context3["catch"](0);
+
+                _logger.default.error(_context3.t0);
+
+                return _context3.abrupt("return", null);
+
+              case 13:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this, [[0, 9]]);
+      }));
+
+      function getByIds(_x2) {
+        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, limit, recreateIndex, skip, indexedFields, indexName, sql, result, docs;
+        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, limit = options.limit, recreateIndex = options.recreateIndex, skip = options.skip;
+                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
+                });
+                sql = (0, _sql.makeSQLQueryFromMango)({
+                  selector: selector,
+                  sort: sort,
+                  indexName: indexName,
+                  limit: limit,
+                  skip: skip
+                });
+
+                if (!recreateIndex) {
+                  _context4.next = 8;
+                  break;
+                }
+
+                _context4.next = 8;
+                return (0, _sql.deleteIndex)(this.db, indexName);
+
+              case 8:
+                _context4.prev = 8;
+                _context4.next = 11;
+                return (0, _sql.executeSQL)(this.db, sql);
+
+              case 11:
+                result = _context4.sent;
+                _context4.next = 26;
+                break;
+
+              case 14:
+                _context4.prev = 14;
+                _context4.t0 = _context4["catch"](8);
+
+                if (!(0, _errors.isMissingSQLiteIndexError)(_context4.t0)) {
+                  _context4.next = 24;
+                  break;
+                }
+
+                _context4.next = 19;
+                return (0, _sql.createMangoIndex)(this.db, indexName, indexedFields, {
+                  partialFilter: partialFilter
+                });
+
+              case 19:
+                _context4.next = 21;
+                return (0, _sql.executeSQL)(this.db, sql);
+
+              case 21:
+                result = _context4.sent;
+                _context4.next = 26;
+                break;
+
+              case 24:
+                _logger.default.error(_context4.t0);
+
+                return _context4.abrupt("return", null);
+
+              case 26:
+                docs = (0, _sql.parseResults)(this.client, result, this.doctype, {
+                  skip: skip,
+                  limit: limit
+                });
+                return _context4.abrupt("return", docs);
+
+              case 28:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this, [[8, 14]]);
+      }));
+
+      function find(_x3) {
+        return _find.apply(this, arguments);
+      }
+
+      return find;
+    }()
+  }]);
+  return SQLiteQueryEngine;
+}(_dbInterface.default);
+
+exports.default = SQLiteQueryEngine;