cozy-pouch-link 60.29.0 → 60.30.1

package/dist/db/sqlite/sql.js

@@ -130,10 +130,20 @@ var parseResults = function parseResults(client, result, doctype) {
     skip: skip,
     next: next
   };
-};
+}; // Quote a value for inline SQL. String single quotes are doubled ('' ) so a
+// value like "l'ete.txt" cannot break out of the literal (SQL error) or inject.
+
 
 exports.parseResults = parseResults;
 
+var quoteSQLValue = function quoteSQLValue(value) {
+  if (typeof value === 'string') {
+    return "'".concat(value.replace(/'/g, "''"), "'");
+  }
+
+  return value;
+};
+
 var parseCondition = function parseCondition(field, condition) {
   var conditions = [];
   var sqlField = transformMangoFieldInJSONSQL(field);
@@ -143,10 +153,16 @@ var parseCondition = function parseCondition(field, 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, ")"));
+        var list = condition[operator] || [];
+
+        if (list.length === 0) {
+          // "IN ()" is a syntax error. $in [] matches nothing (0 = false),
+          // $nin [] matches everything (1 = true).
+          conditions.push(operator === '$in' ? '0' : '1');
+        } else {
+          var values = list.map(quoteSQLValue).join(', ');
+          conditions.push("".concat(sqlField, " ").concat(sqlOp, " (").concat(values, ")"));
+        }
       } else if (operator === '$exists') {
         var value = condition[operator];
 
@@ -158,20 +174,16 @@ var parseCondition = function parseCondition(field, condition) {
 
         conditions.push("".concat(sqlField, " ").concat(sqlOp));
       } else {
-        var _value = typeof condition[operator] === 'string' ? "'".concat(condition[operator], "'") : condition[operator];
-
-        if (operator === '$gt' && _value === null) {
+        if (operator === '$gt' && condition[operator] === null) {
           // Special case for $gt: null conditions
           conditions.push("".concat(sqlField, " IS NOT NULL"));
         } else {
-          conditions.push("".concat(sqlField, " ").concat(sqlOp, " ").concat(_value));
+          conditions.push("".concat(sqlField, " ").concat(sqlOp, " ").concat(quoteSQLValue(condition[operator])));
         }
       }
     }
   } else {
-    var _value2 = typeof condition === 'string' ? "'".concat(condition, "'") : condition;
-
-    conditions.push("".concat(sqlField, " = ").concat(_value2));
+    conditions.push("".concat(sqlField, " = ").concat(quoteSQLValue(condition)));
   }
 
   return conditions.join(' AND ');
@@ -214,7 +226,15 @@ var makeWhereClause = function makeWhereClause(selector) {
   }
 
   var mangoWhere = mangoSelectorToSQL(selector);
-  baseWhere += " AND ".concat(mangoWhere);
+
+  if (!mangoWhere) {
+    return baseWhere;
+  } // Parenthesise the mango expression: SQL binds AND tighter than OR, so a
+  // top-level $or would otherwise read as "(DELETED = 0 AND a) OR b" and leak
+  // deleted docs matching b.
+
+
+  baseWhere += " AND (".concat(mangoWhere, ")");
   return baseWhere;
 };
 
@@ -223,16 +243,15 @@ exports.makeWhereClause = makeWhereClause;
 var makeSortClause = function makeSortClause(mangoSortBy) {
   if (!mangoSortBy || !Array.isArray(mangoSortBy) || mangoSortBy.length < 1) {
     return null;
-  }
+  } // Each field carries its own direction; a shared trailing ASC/DESC would sort
+  // every field the first entry's way and silently ignore mixed asc/desc sorts.
+
 
-  var firstSortEntry = mangoSortBy[0];
-  var sortOrder = Object.values(firstSortEntry)[0].toUpperCase();
-  var sortFields = mangoSortBy.map(function (sort) {
+  return mangoSortBy.map(function (sort) {
     var attribute = Object.keys(sort)[0];
-    return "json_extract(data, '$.".concat(attribute, "')");
+    var order = String(sort[attribute]).toUpperCase();
+    return "json_extract(data, '$.".concat(attribute, "') ").concat(order);
   }).join(', ');
-  var sortClause = "".concat(sortFields, " ").concat(sortOrder);
-  return sortClause;
 };
 
 exports.makeSortClause = makeSortClause;
@@ -246,8 +265,12 @@ var makeSQLQueryFromMango = function makeSQLQueryFromMango(_ref2) {
       _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(' ');
+  var sortClause = makeSortClause(sort); // Scan by-sequence via the mango index, then join document-store on its
+  // winningseq so only WINNING revisions survive (matches CouchDB mango, which
+  // queries the winning rev). `data` aliases 'by-sequence'.json; `deleted` lives
+  // only on by-sequence, so the where clause stays unambiguous.
+
+  var sql = ["SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev", "FROM 'by-sequence' INDEXED BY ".concat(indexName, ", 'document-store'"), "WHERE 'by-sequence'.seq = 'document-store'.winningseq AND ".concat(whereClause)].join(' ');
 
   if (skip > 0) {
     sql += " OFFSET ".concat(skip);
@@ -265,15 +288,21 @@ var makeSQLQueryFromMango = function makeSQLQueryFromMango(_ref2) {
 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(' ');
+  // Join document-store on its winningseq so we return the WINNING revision
+  // (PouchDB keeps every rev in by-sequence; document-store.winningseq points at
+  // the winning one). Both sides are indexed: by-sequence.seq is the PK and the
+  // adapter indexes document-store.winningseq.
+  var sql = ["SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev", "FROM 'document-store', 'by-sequence'", "WHERE 'by-sequence'.seq = 'document-store'.winningseq", "AND 'document-store'.id = \"".concat(id, "\" AND 'by-sequence'.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  ");
+  var doc_ids = ids.map(function (id) {
+    return "\"".concat(id, "\"");
+  }).join(', ');
+  var sql = "\n    SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev\n    FROM 'document-store', 'by-sequence'\n    WHERE 'by-sequence'.seq = 'document-store'.winningseq\n    AND 'document-store'.id IN (".concat(doc_ids, ") AND 'by-sequence'.deleted = 0;\n  ");
   return sql;
 };
 
@@ -286,7 +315,7 @@ var makeSQLQueryAll = function makeSQLQueryAll() {
       _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(' ');
+  var sql = ["SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev", "FROM 'document-store', 'by-sequence'", "WHERE 'by-sequence'.seq = 'document-store'.winningseq AND 'by-sequence'.deleted=0", "LIMIT ".concat(limit)].join(' ');
 
   if (skip > 0) {
     sql += " OFFSET ".concat(skip);
@@ -324,8 +353,11 @@ var makeSQLCreateMangoIndex = function makeSQLCreateMangoIndex(indexName, fields
 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  ";
+  // This index is useful for docid queries. It is NOT unique: PouchDB's
+  // by-sequence keeps a doc's whole rev history, so several rows can share the
+  // same (doc_id, deleted) — the winning rev is picked in JS by
+  // keepDocWitHighestRev(). A UNIQUE index here throws on any multi-rev doc.
+  var sql = "\n    CREATE INDEX IF NOT EXISTS 'by_docid_and_deleted'\n    ON 'by-sequence'\n    (doc_id, deleted);\n  ";
   return sql;
 };
 
@@ -404,7 +436,26 @@ var executeSQL = /*#__PURE__*/function () {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            return _context3.abrupt("return", db.executeAsync(sql));
+            return _context3.abrupt("return", db.executeAsync(sql).catch(function (err) {
+              var message = err && err.message || String(err); // Before the adapter has created the by-sequence table, the earliest
+              // queries hit a missing table. That is transient (the table appears once
+              // replication first writes), so return empty instead of rejecting uncaught.
+              // Lock timeouts are NOT swallowed: WAL + busy_timeout handle contention, and
+              // a genuine lock error must surface rather than look like "no documents".
+
+              if (/no such table/i.test(message)) {
+                return {
+                  rows: {
+                    length: 0,
+                    item: function item() {
+                      return undefined;
+                    }
+                  }
+                };
+              }
+
+              throw err;
+            }));
 
           case 1:
           case "end":

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

@@ -0,0 +1,90 @@
+import { makeWhereClause, makeSortClause, makeSQLQueryForIds } from './sql'
+
+// Compatibility of the native SQLite engine with the mango selector language
+// (cozy-client / pouchdb-find).
+//
+// - "correctness fixes" lock the behaviour of selectors the engine DOES accept
+//   but used to mistranslate (quoting, $or precedence, empty $in, sort order).
+// - "gaps" document selectors mango accepts that the engine cannot translate
+//   yet; they are `.skip` and assert the SQL we want, so each unskips the day
+//   the gap is closed. See the tracking issue for the full matrix.
+
+describe('native SQLite mango — correctness fixes', () => {
+  it('escapes single quotes in string values (no SQL break / injection)', () => {
+    expect(makeWhereClause({ name: { $eq: "l'ete.txt" } })).toBe(
+      "DELETED = 0 AND (json_extract(data, '$.name') = 'l''ete.txt')"
+    )
+  })
+
+  it('parenthesises the mango expression so a top-level $or keeps the DELETED guard', () => {
+    expect(
+      makeWhereClause({ $or: [{ type: 'file' }, { type: 'directory' }] })
+    ).toBe(
+      "DELETED = 0 AND ((json_extract(data, '$.type') = 'file') OR (json_extract(data, '$.type') = 'directory'))"
+    )
+  })
+
+  it('turns an empty $in into a false constant instead of "IN ()"', () => {
+    expect(makeWhereClause({ type: { $in: [] } })).toBe('DELETED = 0 AND (0)')
+  })
+
+  it('turns an empty $nin into a true constant', () => {
+    expect(makeWhereClause({ type: { $nin: [] } })).toBe('DELETED = 0 AND (1)')
+  })
+
+  it('applies per-field sort direction for mixed asc/desc', () => {
+    expect(makeSortClause([{ name: 'asc' }, { size: 'desc' }])).toBe(
+      "json_extract(data, '$.name') ASC, json_extract(data, '$.size') DESC"
+    )
+  })
+
+  it('quotes each id separately in getByIds', () => {
+    expect(makeSQLQueryForIds(['a', 'b'])).toContain('IN ("a", "b")')
+  })
+})
+
+describe('native SQLite mango — gaps (mango accepts, engine does not yet)', () => {
+  // $not / $nor are currently read as field names -> "json_extract('$.$not') undefined"
+  it.skip('translates $not', () => {
+    expect(makeWhereClause({ $not: { type: 'file' } })).not.toContain(
+      'undefined'
+    )
+  })
+
+  // No mapping in MANGO_TO_SQL_OP -> literal "undefined" in the SQL
+  it.skip('translates $regex', () => {
+    expect(makeWhereClause({ name: { $regex: '^foo' } })).not.toContain(
+      'undefined'
+    )
+  })
+
+  // Array operators are entirely absent
+  it.skip('translates $elemMatch on an array field', () => {
+    expect(
+      makeWhereClause({ referenced_by: { $elemMatch: { type: 'album' } } })
+    ).not.toContain('undefined')
+  })
+  it.skip('translates $all', () => {
+    expect(makeWhereClause({ tags: { $all: ['a', 'b'] } })).not.toContain(
+      'undefined'
+    )
+  })
+  it.skip('translates $size', () => {
+    expect(makeWhereClause({ tags: { $size: 3 } })).not.toContain('undefined')
+  })
+
+  // A nested object means subfield equality; the sub-keys are currently iterated
+  // as operators -> "json_extract('$.cozyMetadata') undefined 'drive'"
+  it.skip('treats a nested object as subfield equality', () => {
+    expect(makeWhereClause({ cozyMetadata: { createdByApp: 'drive' } })).toBe(
+      "DELETED = 0 AND (json_extract(data, '$.cozyMetadata.createdByApp') = 'drive')"
+    )
+  })
+
+  // "= NULL" never matches; mango $eq null should match null / missing
+  it.skip('translates $eq null to an IS NULL check', () => {
+    expect(makeWhereClause({ trashed: { $eq: null } })).toBe(
+      "DELETED = 0 AND (json_extract(data, '$.trashed') IS NULL)"
+    )
+  })
+})

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

@@ -3,6 +3,8 @@ import {
   makeWhereClause,
   makeSortClause,
   makeSQLQueryFromMango,
+  makeSQLQueryForId,
+  makeSQLQueryForIds,
   keepDocWitHighestRev,
   makeSQLQueryAll,
   parseResults
@@ -113,7 +115,7 @@ describe('makeWhereClause', () => {
   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'"
+      "DELETED = 0 AND (json_extract(data, '$.status') = 'active')"
     )
   })
 })
@@ -132,7 +134,7 @@ describe('makeSortClause', () => {
   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"
+      "json_extract(data, '$.date') ASC, json_extract(data, '$.name') ASC, json_extract(data, '$.type') ASC"
     )
   })
 
@@ -152,9 +154,9 @@ describe('makeSQLQueryFromMango', () => {
     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'`,
+      `SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev`,
+      `FROM 'by-sequence' INDEXED BY by_name, 'document-store'`,
+      `WHERE 'by-sequence'.seq = 'document-store'.winningseq AND DELETED = 0 AND (json_extract(data, '$.date') > '2025-01-01')`,
       `LIMIT 100;`
     ].join(' ')
     expect(sql).toEqual(expectedSql)
@@ -168,9 +170,9 @@ describe('makeSQLQueryFromMango', () => {
     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'`,
+      `SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev`,
+      `FROM 'by-sequence' INDEXED BY by_name, 'document-store'`,
+      `WHERE 'by-sequence'.seq = 'document-store'.winningseq AND DELETED = 0 AND (json_extract(data, '$.date') > '2025-01-01')`,
       `ORDER BY json_extract(data, '$.date') ASC`,
       `LIMIT 100;`
     ].join(' ')
@@ -190,9 +192,9 @@ describe('makeSQLQueryFromMango', () => {
     })
 
     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'`,
+      `SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev`,
+      `FROM 'by-sequence' INDEXED BY by_name, 'document-store'`,
+      `WHERE 'by-sequence'.seq = 'document-store'.winningseq AND DELETED = 0 AND (json_extract(data, '$.date') > '2025-01-01')`,
       `OFFSET 100`,
       `LIMIT 200;`
     ].join(' ')
@@ -204,9 +206,9 @@ 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`,
+      `SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev`,
+      `FROM 'document-store', 'by-sequence'`,
+      `WHERE 'by-sequence'.seq = 'document-store'.winningseq AND 'by-sequence'.deleted=0`,
       `LIMIT -1;`
     ].join(' ')
     expect(sql).toEqual(expectedSql)
@@ -215,9 +217,9 @@ describe('makeSQLQueryAll', () => {
   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`,
+      `SELECT 'by-sequence'.json AS data, 'by-sequence'.doc_id, 'by-sequence'.rev`,
+      `FROM 'document-store', 'by-sequence'`,
+      `WHERE 'by-sequence'.seq = 'document-store'.winningseq AND 'by-sequence'.deleted=0`,
       `LIMIT 10`,
       `OFFSET 100;`
     ].join(' ')
@@ -225,6 +227,22 @@ describe('makeSQLQueryAll', () => {
   })
 })
 
+describe('makeSQLQueryForId', () => {
+  it('joins document-store on winningseq to return the winning revision', () => {
+    const sql = makeSQLQueryForId('abc')
+    expect(sql).toContain(`'by-sequence'.seq = 'document-store'.winningseq`)
+    expect(sql).toContain(`'document-store'.id = "abc"`)
+  })
+})
+
+describe('makeSQLQueryForIds', () => {
+  it('emits one quoted value per id in the IN clause', () => {
+    const sql = makeSQLQueryForIds(['a', 'b'])
+    expect(sql).toContain(`'document-store'.id IN ("a", "b")`)
+    expect(sql).toContain(`'by-sequence'.seq = 'document-store'.winningseq`)
+  })
+})
+
 describe('keepDocWitHighestRev', () => {
   it('should return null if no docs', () => {
     expect(keepDocWitHighestRev([])).toBeNull()

package/dist/db/sqlite/sqliteDb.native.js

@@ -56,20 +56,37 @@ var SQLiteQueryEngine = /*#__PURE__*/function (_DatabaseQueryEngine) {
   (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);
-      }
+      var fileDbName = "".concat(dbName, ".sqlite"); // Resolve the DB handle lazily on first use, opening our OWN op-sqlite
+      // connection on the same file the adapter uses. WAL mode + a busy timeout
+      // let this connection coexist with the adapter's writer without "database
+      // is locked" — the two-connection setup in rollback mode was what made this
+      // engine unusable. Lazy so the adapter has created the schema by the time
+      // the first query runs.
+
+      var resolved = null;
+      Object.defineProperty(this, 'db', {
+        configurable: true,
+        set: function set(value) {
+          resolved = value;
+        },
+        get: function get() {
+          if (resolved) return resolved;
+          resolved = (0, _opSqlite.open)({
+            name: fileDbName
+          });
+
+          try {
+            (0, _sql.executeSQL)(resolved, 'PRAGMA journal_mode=WAL');
+            (0, _sql.executeSQL)(resolved, 'PRAGMA busy_timeout=5000');
+            (0, _sql.executeSQL)(resolved, (0, _sql.makeSQLCreateDocIDIndex)());
+            (0, _sql.executeSQL)(resolved, (0, _sql.makeSQLCreateDeletedIndex)());
+          } catch (err) {
+            _logger.default.error(err);
+          }
+
+          return resolved;
+        }
+      });
     }
   }, {
     key: "allDocs",

package/dist/jsonapi.js

@@ -63,6 +63,18 @@ var resetAllPaths = function resetAllPaths() {
 exports.resetAllPaths = resetAllPaths;
 
 var normalizeDocs = function normalizeDocs(client, doctype, docs) {
+  if (doctype === 'io.cozy.files') {
+    // Seed the path cache with every directory's path first, so each file
+    // resolves its parent path from memory instead of a per-file getById.
+    for (var j = 0; j < docs.length; j++) {
+      var dir = docs[j];
+
+      if (dir && dir.type === _files.TYPE_DIRECTORY && dir.path) {
+        setFilePath(dir._id || dir.id, dir.path);
+      }
+    }
+  }
+
   for (var i = docs.length; i >= 0; i--) {
     var doc = docs[i];
 

package/dist/jsonapi.spec.js

@@ -4,6 +4,7 @@ import {
   computeFileFullpath,
   fromPouchResult,
   normalizeDoc,
+  normalizeDocs,
   resetAllPaths
 } from './jsonapi'
 import { queryFileById } from './files'
@@ -720,6 +721,18 @@ describe('computeFileFullpath', () => {
     expect(res2.path).toEqual('ROOT/MYDIR/file3.1')
   })
 
+  it('normalizeDocs seeds directory paths so sibling files resolve without querying', async () => {
+    // Clear the module-level path cache so the result depends on the seeding
+    // block, not on a directory a previous test may have cached.
+    resetAllPaths()
+    queryFileById.mockClear()
+    const dirDoc = { ...dir }
+    const fileDoc = { ...filewithNoPath }
+    normalizeDocs(client, 'io.cozy.files', [dirDoc, fileDoc])
+    expect(fileDoc.path).toEqual('ROOT/MYDIR/file3')
+    expect(queryFileById).not.toHaveBeenCalled()
+  })
+
   it('should return the file unchanged when queryFileById resolves to undefined', async () => {
     // This happens offline when the link chain returns nothing for the
     // parent dir lookup. Before the fix, destructuring `.data` from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-pouch-link",
-  "version": "60.29.0",
+  "version": "60.30.1",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -13,7 +13,7 @@
     "url": "git+https://github.com/linagora/cozy-client.git"
   },
   "dependencies": {
-    "cozy-client": "^60.29.0",
+    "cozy-client": "^60.30.1",
     "pouchdb-browser": "^7.2.2",
     "pouchdb-find": "^7.2.2"
   },
@@ -41,5 +41,5 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "0e624ae6b3ba93c2618ba9d26f4d4f48945bf5c8"
+  "gitHead": "f209689b3951ddbedc83db50a2dcd976082777b3"
 }

package/types/db/sqlite/sqliteDb.native.d.ts

@@ -1,6 +1,6 @@
 export default class SQLiteQueryEngine extends DatabaseQueryEngine {
     constructor(pouchManager: any, doctype: any);
-    db: import("@op-engineering/op-sqlite").DB;
+    db: any;
     client: any;
     doctype: any;
 }