cozy-pouch-link 60.30.1 → 60.30.2

package/dist/db/sqlite/sql.js

@@ -144,9 +144,9 @@ var quoteSQLValue = function quoteSQLValue(value) {
   return value;
 };
 
-var parseCondition = function parseCondition(field, condition) {
+var parseCondition = function parseCondition(field, condition, columnName) {
   var conditions = [];
-  var sqlField = transformMangoFieldInJSONSQL(field);
+  var sqlField = transformMangoFieldInJSONSQL(field, columnName);
 
   if (typeof condition === 'object' && !Array.isArray(condition)) {
     for (var operator in condition) {
@@ -189,27 +189,45 @@ var parseCondition = function parseCondition(field, condition) {
   return conditions.join(' AND ');
 };
 
-var parseLogicalOperator = function parseLogicalOperator(operator, conditionsArray) {
+var parseLogicalOperator = function parseLogicalOperator(operator, conditionsArray, columnName) {
   var sqlOperator = operator === '$and' ? 'AND' : 'OR';
   var parsedConditions = conditionsArray.map(function (cond) {
-    return "(".concat(mangoSelectorToSQL(cond).replace(/^WHERE /, ''), ")");
+    return "(".concat(mangoSelectorToSQL(cond, columnName).replace(/^WHERE /, ''), ")");
   });
   return parsedConditions.join(" ".concat(sqlOperator, " "));
+}; // PouchDB keeps a document's id and rev in by-sequence COLUMNS and strips them
+// from the stored JSON, so json_extract(json, '$._id') is NULL on every row. A
+// selector on `_id` would therefore match nothing it is meant to match, and a
+// `$nin` on it would filter nothing at all.
+
+
+var PHYSICAL_COLUMNS = {
+  _id: 'doc_id',
+  _rev: 'rev'
 };
 
 var transformMangoFieldInJSONSQL = function transformMangoFieldInJSONSQL(field) {
   var columnName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'data';
+  var physicalColumn = PHYSICAL_COLUMNS[field];
+
+  if (physicalColumn) {
+    // `data` is the query alias, where by-sequence is joined with document-store
+    // and the column needs qualifying; `json` is the CREATE INDEX context, which
+    // is scoped to by-sequence alone and must stay unqualified.
+    return columnName === 'json' ? physicalColumn : "'by-sequence'.".concat(physicalColumn);
+  }
+
   return "json_extract(".concat(columnName, ", '$.").concat(field, "')");
 };
 
-var mangoSelectorToSQL = function mangoSelectorToSQL(selector) {
+var mangoSelectorToSQL = function mangoSelectorToSQL(selector, columnName) {
   var conditions = [];
 
   for (var key in selector) {
     if (key === '$and' || key === '$or') {
-      conditions.push(parseLogicalOperator(key, selector[key]));
+      conditions.push(parseLogicalOperator(key, selector[key], columnName));
     } else {
-      conditions.push(parseCondition(key, selector[key]));
+      conditions.push(parseCondition(key, selector[key], columnName));
     }
   }
 
@@ -218,14 +236,14 @@ var mangoSelectorToSQL = function mangoSelectorToSQL(selector) {
 
 exports.mangoSelectorToSQL = mangoSelectorToSQL;
 
-var makeWhereClause = function makeWhereClause(selector) {
+var makeWhereClause = function makeWhereClause(selector, columnName) {
   var baseWhere = 'DELETED = 0';
 
   if (!selector) {
     return baseWhere;
   }
 
-  var mangoWhere = mangoSelectorToSQL(selector);
+  var mangoWhere = mangoSelectorToSQL(selector, columnName);
 
   if (!mangoWhere) {
     return baseWhere;
@@ -260,11 +278,24 @@ var makeSQLQueryFromMango = function makeSQLQueryFromMango(_ref2) {
   var selector = _ref2.selector,
       sort = _ref2.sort,
       indexName = _ref2.indexName,
+      partialFilter = _ref2.partialFilter,
       _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 whereClause = makeWhereClause(selector); // Restate the partial filter in the query itself. Relying on the partial index
+  // alone is unsafe: CREATE INDEX IF NOT EXISTS never rewrites an index built
+  // under an older definition, so a stale unfiltered index would silently return
+  // the rows the filter is meant to hide.
+
+  if (partialFilter) {
+    var partialWhere = mangoSelectorToSQL(partialFilter);
+
+    if (partialWhere) {
+      whereClause += " AND (".concat(partialWhere, ")");
+    }
+  }
+
   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
@@ -342,7 +373,10 @@ var makeSQLCreateMangoIndex = function makeSQLCreateMangoIndex(indexName, fields
   var sql = "\n    CREATE INDEX IF NOT EXISTS '".concat(indexName, "'\n    ON 'by-sequence'\n    (").concat(jsonIndex, ")\n  ");
 
   if (partialFilter) {
-    var whereClause = makeWhereClause(partialFilter);
+    // `data` only exists as a SELECT alias of 'by-sequence'.json; inside CREATE
+    // INDEX the column is `json`. Emitting the alias made every partial index
+    // fail with "no such column: data", so the filter was never enforced.
+    var whereClause = makeWhereClause(partialFilter, 'json');
     sql += " WHERE ".concat(whereClause);
   }
 

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

@@ -7,7 +7,8 @@ import {
   makeSQLQueryForIds,
   keepDocWitHighestRev,
   makeSQLQueryAll,
-  parseResults
+  parseResults,
+  makeSQLCreateMangoIndex
 } from './sql'
 
 describe('mangoSelectorToSQL', () => {
@@ -435,3 +436,52 @@ describe('parseResults', () => {
     })
   })
 })
+
+describe('partialFilter', () => {
+  it('should build the index filter against the json column', () => {
+    const sql = makeSQLCreateMangoIndex('by_name', ['name'], {
+      partialFilter: { trashed: false }
+    })
+
+    // `data` is only a SELECT alias, CREATE INDEX would reject it.
+    expect(sql).toContain(`json_extract(json, '$.trashed') = false`)
+    expect(sql).not.toContain(`json_extract(data`)
+  })
+
+  it('should restate the partial filter in the query', () => {
+    const sql = makeSQLQueryFromMango({
+      selector: { dir_id: 'root' },
+      indexName: 'by_dir_id',
+      partialFilter: { trashed: false }
+    })
+
+    expect(sql).toContain(`json_extract(data, '$.trashed') = false`)
+  })
+})
+
+describe('_id and _rev selectors', () => {
+  it('should resolve _id to the by-sequence column in a query', () => {
+    // PouchDB strips _id from the stored JSON, so json_extract would be NULL.
+    expect(mangoSelectorToSQL({ _id: 'abc' })).toEqual(
+      `'by-sequence'.doc_id = 'abc'`
+    )
+  })
+
+  it('should resolve _rev to the by-sequence column in a query', () => {
+    expect(mangoSelectorToSQL({ _rev: '1-abc' })).toEqual(
+      `'by-sequence'.rev = '1-abc'`
+    )
+  })
+
+  it('should leave the column unqualified in an index context', () => {
+    expect(mangoSelectorToSQL({ _id: 'abc' }, 'json')).toEqual(`doc_id = 'abc'`)
+  })
+
+  it('should keep filtering hidden ids out of a partial index', () => {
+    const sql = makeSQLCreateMangoIndex('by_name', ['name'], {
+      partialFilter: { _id: { $nin: ['io.cozy.files.trash-dir'] } }
+    })
+
+    expect(sql).toContain(`doc_id NOT IN ('io.cozy.files.trash-dir')`)
+  })
+})

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

@@ -256,6 +256,7 @@ var SQLiteQueryEngine = /*#__PURE__*/function (_DatabaseQueryEngine) {
                   selector: selector,
                   sort: sort,
                   indexName: indexName,
+                  partialFilter: partialFilter,
                   limit: limit,
                   skip: skip
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-pouch-link",
-  "version": "60.30.1",
+  "version": "60.30.2",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -41,5 +41,5 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "f209689b3951ddbedc83db50a2dcd976082777b3"
+  "gitHead": "65d4da4479058f57d0e77f15eb40b9cc89cb7aec"
 }

package/types/db/sqlite/sql.d.ts

@@ -16,13 +16,14 @@ export function parseResults(client: any, result: any, doctype: any, { isSingleD
     skip: number;
     next: boolean;
 };
-export function mangoSelectorToSQL(selector: any): string;
-export function makeWhereClause(selector: any): string;
+export function mangoSelectorToSQL(selector: any, columnName: any): string;
+export function makeWhereClause(selector: any, columnName: any): string;
 export function makeSortClause(mangoSortBy: any): string;
-export function makeSQLQueryFromMango({ selector, sort, indexName, limit, skip }: {
+export function makeSQLQueryFromMango({ selector, sort, indexName, partialFilter, limit, skip }: {
     selector: any;
     sort: any;
     indexName: any;
+    partialFilter: any;
     limit?: number;
     skip?: number;
 }): string;