cozy-pouch-link 60.30.2 → 60.30.3

package/dist/db/sqlite/sql.js

@@ -5,26 +5,42 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 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;
+exports.executeSQL = exports.toWebSQLResult = 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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _jsonapi = require("../../jsonapi");
 
 var _helpers = require("../helpers");
 
+var _errors = require("../../errors");
+
+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; }
+
+// Binary operators with a direct SQL equivalent. Everything else needs its own
+// SQL shape and is handled explicitly in parseCondition.
 var MANGO_TO_SQL_OP = {
   $eq: '=',
-  $ne: '!=',
   $gt: '>',
   $gte: '>=',
   $lt: '<',
-  $lte: '<=',
-  $in: 'IN',
-  $nin: 'NOT IN',
-  $exists: 'IS'
+  $lte: '<='
+}; // Mango and SQLite do not spell types the same way: json_type() reports integers
+// and reals separately, and booleans as 'true'/'false'.
+
+var MANGO_TYPE_TO_JSON_TYPES = {
+  null: ['null'],
+  boolean: ['true', 'false'],
+  number: ['integer', 'real'],
+  string: ['text'],
+  array: ['array'],
+  object: ['object']
 };
 
 var extractRevPrefix = function extractRevPrefix(rev) {
@@ -130,70 +146,249 @@ 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.
+}; // 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 escapeSQLString = function escapeSQLString(str) {
+  return str.replace(/'/g, "''");
+}; // Quote a value for inline SQL.
+// $in, $nin and $all are the operators whose operand is a list. A non-array
+// operand would reach .map / .length and either throw a TypeError or, worse,
+// silently iterate a string's characters.
+
+
+var requireArrayOperand = function requireArrayOperand(operator, field, value) {
+  if (!Array.isArray(value)) {
+    throw new _errors.UnsupportedMangoSelectorError("".concat(operator, " on \"").concat(field, "\" expects an array, got ").concat(JSON.stringify(value)));
+  }
+
+  return value;
+};
+
+var joinTests = function joinTests(tests, operator) {
+  return tests.length > 1 ? "(".concat(tests.join(" ".concat(operator, " ")), ")") : tests[0];
+};
+
 var quoteSQLValue = function quoteSQLValue(value) {
   if (typeof value === 'string') {
-    return "'".concat(value.replace(/'/g, "''"), "'");
+    return "'".concat(escapeSQLString(value), "'");
+  }
+
+  if (typeof value === 'number' && !Number.isFinite(value)) {
+    // NaN and +/-Infinity have no SQL literal: they would be interpolated as the
+    // bare words "NaN" / "Infinity", which SQLite reads as column names.
+    throw new _errors.UnsupportedMangoSelectorError("Cannot express ".concat(String(value), " as a SQL value"));
+  }
+
+  if (value === undefined || typeof value === 'object' && value !== null) {
+    // undefined, objects and arrays have no SQL literal form. A template
+    // literal would stringify undefined to the word "undefined" - the very
+    // failure this translator exists to make impossible - and an object to
+    // "[object Object]".
+    throw new _errors.UnsupportedMangoSelectorError("Cannot express ".concat(JSON.stringify(value), " as a SQL value"));
   }
 
   return value;
+}; // Mango forbids mixing operators and field names in the same object, so a single
+// $-prefixed key is enough to tell an operator object ({ $gt: 1 }) from a nested
+// document selector ({ b: 'x' }).
+
+
+var isOperatorObject = function isOperatorObject(obj) {
+  return Object.keys(obj).some(function (key) {
+    return key.startsWith('$');
+  });
 };
 
-var parseCondition = function parseCondition(field, condition, columnName) {
+var isPlainObject = function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}; // json_extract yields SQL NULL for a missing path, and NOT NULL is NULL rather
+// than true. CouchDB's $not / $nor match documents where the inner condition
+// merely fails to hold, missing field included, so resolve the unknown to false
+// before negating.
+
+
+var negate = function negate(sql) {
+  return "NOT IFNULL((".concat(sql, "), 0)");
+}; // json_each / json_type / json_array_length take (column, path) rather than a
+// pre-extracted value: json_extract unwraps a JSON string into bare SQL text,
+// which those functions then fail to re-parse as JSON.
+
+
+var makeJSONFunctionArgs = function makeJSONFunctionArgs(field, columnName) {
+  return field ? "".concat(columnName, ", '$.").concat(escapeSQLString(field), "'") : columnName;
+}; // "at least one element of the array satisfies elementWhere", where the element
+// is bound to `elem.value`.
+
+
+var makeArrayElementExists = function makeArrayElementExists(field, columnName, elementWhere) {
+  return "EXISTS (SELECT 1 FROM json_each(".concat(makeJSONFunctionArgs(field, columnName), ") AS elem WHERE ").concat(elementWhere, ")");
+}; // A sub-selector made of operators applies to the array element itself
+// ({ tags: { $elemMatch: { $eq: 'a' } } }); one made of field names applies to
+// the element's subfields ({ referenced_by: { $elemMatch: { type: 'album' } } }).
+
+
+var parseElemMatch = function parseElemMatch(field, subSelector, columnName) {
+  if (!isPlainObject(subSelector)) {
+    throw new _errors.UnsupportedMangoSelectorError("$elemMatch on \"".concat(field, "\" expects a selector"));
+  }
+
+  var elementColumn = 'elem.value';
+  var where = isOperatorObject(subSelector) ? parseCondition('', subSelector, elementColumn) : mangoSelectorToSQL(subSelector, elementColumn);
+  return makeArrayElementExists(field, columnName, where);
+};
+
+var parseCondition = function parseCondition(field, condition) {
+  var columnName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'data';
   var conditions = [];
   var sqlField = transformMangoFieldInJSONSQL(field, columnName);
 
-  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 list = condition[operator] || [];
+  if (!isPlainObject(condition)) {
+    // Implicit equality. Routed through $eq so `null` gets the same IS NULL
+    // treatment as its explicit form.
+    return parseCondition(field, {
+      $eq: condition
+    }, columnName);
+  }
 
-        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];
+  if (!isOperatorObject(condition)) {
+    // A nested document means subfield equality: { a: { b: 'x' } } selects the
+    // same documents as { 'a.b': 'x' }.
+    for (var subField in condition) {
+      conditions.push(parseCondition("".concat(field, ".").concat(subField), condition[subField], columnName));
+    }
 
-        if (value) {
-          sqlOp += ' NOT NULL';
-        } else {
-          sqlOp += ' NULL';
-        }
+    return conditions.join(' AND ');
+  }
 
-        conditions.push("".concat(sqlField, " ").concat(sqlOp));
+  for (var operator in condition) {
+    var value = condition[operator];
+    var sqlOp = MANGO_TO_SQL_OP[operator]; // json_extract returns SQL NULL both for a JSON null and for a missing path,
+    // so every null comparison needs an IS [NOT] NULL form: `= NULL` and
+    // `!= NULL` are NULL, never true.
+
+    if (operator === '$eq' && value === null) {
+      conditions.push("".concat(sqlField, " IS NULL"));
+    } else if ((operator === '$gt' || operator === '$ne') && value === null) {
+      conditions.push("".concat(sqlField, " IS NOT NULL"));
+    } else if (value === null && sqlOp) {
+      // The remaining range operators have no meaningful null form here: `x >=
+      // NULL` is NULL for every row, so the query would silently match nothing.
+      // CouchDB orders null against every other type, which SQL comparison does
+      // not, so hand these to pouch-find rather than approximate them.
+      throw new _errors.UnsupportedMangoSelectorError("Cannot compare \"".concat(field, "\" to null with \"").concat(operator, "\""));
+    } else if (operator === '$ne') {
+      // CouchDB matches a missing field: `x != v` is NULL, not true, when
+      // json_extract finds nothing, so the absent case needs its own branch.
+      conditions.push("(".concat(sqlField, " IS NULL OR ").concat(sqlField, " != ").concat(quoteSQLValue(value), ")"));
+    } else if (operator === '$in' || operator === '$nin') {
+      var list = requireArrayOperand(operator, field, value);
+
+      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 {
-        if (operator === '$gt' && condition[operator] === null) {
-          // Special case for $gt: null conditions
-          conditions.push("".concat(sqlField, " IS NOT NULL"));
+        // SQL never matches NULL through IN / NOT IN, so a null member has to
+        // become an explicit IS NULL test rather than sit in the list.
+        var hasNull = list.some(function (item) {
+          return item === null;
+        });
+        var values = list.filter(function (item) {
+          return item !== null;
+        }).map(quoteSQLValue);
+        var tests = [];
+
+        if (operator === '$in') {
+          if (values.length > 0) {
+            tests.push("".concat(sqlField, " IN (").concat(values.join(', '), ")"));
+          }
+
+          if (hasNull) {
+            tests.push("".concat(sqlField, " IS NULL"));
+          }
+
+          conditions.push(joinTests(tests, 'OR'));
         } else {
-          conditions.push("".concat(sqlField, " ").concat(sqlOp, " ").concat(quoteSQLValue(condition[operator])));
+          if (values.length > 0) {
+            tests.push("".concat(sqlField, " NOT IN (").concat(values.join(', '), ")"));
+          } // $nin keeps documents missing the field, matching CouchDB - unless
+          // null is itself excluded, which is exactly what those rows hold.
+
+
+          tests.push(hasNull ? "".concat(sqlField, " IS NOT NULL") : "".concat(sqlField, " IS NULL"));
+          conditions.push(hasNull ? joinTests(tests, 'AND') : joinTests(tests.reverse(), 'OR'));
         }
       }
+    } else if (operator === '$exists') {
+      conditions.push("".concat(sqlField, " IS ").concat(value ? 'NOT NULL' : 'NULL'));
+    } else if (operator === '$not') {
+      conditions.push(negate(parseCondition(field, value, columnName)));
+    } else if (operator === '$elemMatch') {
+      conditions.push(parseElemMatch(field, value, columnName));
+    } else if (operator === '$all') {
+      var _list = requireArrayOperand(operator, field, value); // One scan per value: SQLite has no "contains all of" primitive, and the
+      // values may sit at any positions in the array.
+
+
+      conditions.push(_list.length === 0 ? '1' : _list.map(function (item) {
+        return makeArrayElementExists(field, columnName, "elem.value = ".concat(quoteSQLValue(item)));
+      }).join(' AND '));
+    } else if (operator === '$size') {
+      conditions.push("json_array_length(".concat(makeJSONFunctionArgs(field, columnName), ") = ").concat(quoteSQLValue(value)));
+    } else if (operator === '$mod') {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new _errors.UnsupportedMangoSelectorError("$mod on \"".concat(field, "\" expects a [divisor, remainder] pair"));
+      } // The numeric guard is not decoration: SQLite coerces a non-numeric
+      // operand of % to 0, so a text field would match any {$mod: [d, 0]}.
+
+
+      conditions.push("(json_type(".concat(makeJSONFunctionArgs(field, columnName), ") IN (").concat(MANGO_TYPE_TO_JSON_TYPES.number.map(quoteSQLValue).join(', '), ") AND ").concat(sqlField, " % ").concat(quoteSQLValue(value[0]), " = ").concat(quoteSQLValue(value[1]), ")"));
+    } else if (operator === '$type') {
+      var jsonTypes = MANGO_TYPE_TO_JSON_TYPES[value];
+
+      if (!jsonTypes) {
+        throw new _errors.UnsupportedMangoSelectorError("Unsupported mango $type \"".concat(value, "\" on field \"").concat(field, "\""));
+      }
+
+      conditions.push("json_type(".concat(makeJSONFunctionArgs(field, columnName), ") IN (").concat(jsonTypes.map(quoteSQLValue).join(', '), ")"));
+    } else if (sqlOp) {
+      conditions.push("".concat(sqlField, " ").concat(sqlOp, " ").concat(quoteSQLValue(value)));
+    } else {
+      // The single point where an untranslatable selector is caught. $regex ends
+      // up here - op-sqlite exposes no way to register a REGEXP function - along
+      // with any operator this translator does not know. Throwing rather than
+      // interpolating an undefined operator is what guarantees the generated SQL
+      // never contains "undefined"; SQLiteQueryEngine turns it into a pouch-find
+      // fallback.
+      throw new _errors.UnsupportedMangoSelectorError("Unsupported mango operator \"".concat(operator, "\" on field \"").concat(field, "\""));
     }
-  } else {
-    conditions.push("".concat(sqlField, " = ").concat(quoteSQLValue(condition)));
   }
 
   return conditions.join(' AND ');
 };
 
 var parseLogicalOperator = function parseLogicalOperator(operator, conditionsArray, columnName) {
-  var sqlOperator = operator === '$and' ? 'AND' : 'OR';
+  if (!Array.isArray(conditionsArray) || conditionsArray.length === 0) {
+    throw new _errors.UnsupportedMangoSelectorError("".concat(operator, " expects a non-empty array of selectors"));
+  }
+
+  var sqlOperator = operator === '$and' ? 'AND' : 'OR'; // An empty sub-selector translates to an empty string; wrapping it would emit
+  // "()" and break the statement.
+
   var parsedConditions = conditionsArray.map(function (cond) {
-    return "(".concat(mangoSelectorToSQL(cond, columnName).replace(/^WHERE /, ''), ")");
+    return mangoSelectorToSQL(cond, columnName);
+  }).filter(Boolean).map(function (sql) {
+    return "(".concat(sql, ")");
   });
+
+  if (parsedConditions.length === 0) {
+    throw new _errors.UnsupportedMangoSelectorError("".concat(operator, " expects at least one translatable selector"));
+  }
+
   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
@@ -208,24 +403,53 @@ var PHYSICAL_COLUMNS = {
 
 var transformMangoFieldInJSONSQL = function transformMangoFieldInJSONSQL(field) {
   var columnName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'data';
-  var physicalColumn = PHYSICAL_COLUMNS[field];
+  var physicalColumn = PHYSICAL_COLUMNS[field]; // Only at document level: inside a json_each element (`elem.value`) the row
+  // is an array item, which has no doc_id / rev of its own.
 
-  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.
+  if (physicalColumn && (columnName === 'data' || columnName === 'json')) {
+    // `data` is the query alias, where by-sequence is joined with
+    // document-store and the column needs qualifying; `json` is the CREATE
+    // INDEX context, scoped to by-sequence alone, which must stay unqualified.
     return columnName === 'json' ? physicalColumn : "'by-sequence'.".concat(physicalColumn);
   }
 
-  return "json_extract(".concat(columnName, ", '$.").concat(field, "')");
+  if (!field) {
+    // No path: the value IS the column (a json_each element, for $elemMatch on
+    // an array of scalars). json_extract would re-parse it as JSON and fail on a
+    // bare string.
+    return columnName;
+  }
+
+  return "json_extract(".concat(columnName, ", '$.").concat(escapeSQLString(field), "')");
 };
+/**
+ * Translate a mango selector into a SQL boolean expression.
+ *
+ * @param {object} selector - The mango selector
+ * @param {string} [columnName] - The JSON column the paths are resolved against
+ * @returns {string} The SQL expression, never containing "undefined"
+ * @throws {UnsupportedMangoSelectorError} When the selector uses a mango feature
+ * this translator cannot express in SQL
+ */
+
+
+var mangoSelectorToSQL = function mangoSelectorToSQL(selector) {
+  var columnName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'data';
+
+  if (!isPlainObject(selector)) {
+    throw new _errors.UnsupportedMangoSelectorError("Expected a selector, got ".concat(JSON.stringify(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], columnName));
+    } else if (key === '$nor') {
+      // "none of these match" is the negation of the $or.
+      conditions.push(negate(parseLogicalOperator('$or', selector[key], columnName)));
+    } else if (key === '$not') {
+      conditions.push(negate(mangoSelectorToSQL(selector[key], columnName)));
     } else {
       conditions.push(parseCondition(key, selector[key], columnName));
     }
@@ -266,23 +490,33 @@ var makeSortClause = function makeSortClause(mangoSortBy) {
 
 
   return mangoSortBy.map(function (sort) {
-    var attribute = Object.keys(sort)[0];
-    var order = String(sort[attribute]).toUpperCase();
-    return "json_extract(data, '$.".concat(attribute, "') ").concat(order);
+    // A bare string is the shorthand for ascending on that field; Object.keys
+    // would otherwise read its first index and sort on the JSON path "$.0".
+    var entry = typeof sort === 'string' ? (0, _defineProperty2.default)({}, sort, 'asc') : sort;
+
+    if (!isPlainObject(entry)) {
+      throw new _errors.UnsupportedMangoSelectorError("Cannot sort on ".concat(JSON.stringify(sort)));
+    }
+
+    var attribute = Object.keys(entry)[0]; // ASC/DESC are bare SQL keywords, so the direction cannot be quoted the
+    // way a value would be - it has to be whitelisted instead.
+
+    var order = String(entry[attribute]).toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+    return "".concat(transformMangoFieldInJSONSQL(attribute), " ").concat(order);
   }).join(', ');
 };
 
 exports.makeSortClause = makeSortClause;
 
-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 makeSQLQueryFromMango = function makeSQLQueryFromMango(_ref3) {
+  var selector = _ref3.selector,
+      sort = _ref3.sort,
+      indexName = _ref3.indexName,
+      partialFilter = _ref3.partialFilter,
+      _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 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
@@ -303,15 +537,19 @@ var makeSQLQueryFromMango = function makeSQLQueryFromMango(_ref2) {
 
   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);
-  }
-
   if (sortClause) {
     sql += " ORDER BY ".concat(sortClause);
+  } // OFFSET is a modifier of LIMIT, not a clause of its own: SQL requires it last
+  // and rejects it without a LIMIT. `null` parses but fails at step time with a
+  // datatype mismatch, and the `limit = -1` default only catches `undefined`.
+
+
+  sql += " LIMIT ".concat(limit == null ? -1 : limit);
+
+  if (skip > 0) {
+    sql += " OFFSET ".concat(skip);
   }
 
-  sql += " LIMIT ".concat(limit);
   sql += ';';
   return sql;
 };
@@ -340,13 +578,13 @@ var makeSQLQueryForIds = function makeSQLQueryForIds(ids) {
 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 _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref4$limit = _ref4.limit,
+      limit = _ref4$limit === void 0 ? -1 : _ref4$limit,
+      _ref4$skip = _ref4.skip,
+      skip = _ref4$skip === void 0 ? 0 : _ref4$skip;
 
-  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(' ');
+  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 == null ? -1 : limit)].join(' ');
 
   if (skip > 0) {
     sql += " OFFSET ".concat(skip);
@@ -364,10 +602,16 @@ var makeSQLDropIndex = function makeSQLDropIndex(indexName) {
 
 exports.makeSQLDropIndex = makeSQLDropIndex;
 
-var makeSQLCreateMangoIndex = function makeSQLCreateMangoIndex(indexName, fieldsToIndex, _ref4) {
-  var partialFilter = _ref4.partialFilter;
+var makeSQLCreateMangoIndex = function makeSQLCreateMangoIndex(indexName, fieldsToIndex, _ref5) {
+  var partialFilter = _ref5.partialFilter;
+  // Escaped like the where clause's paths, so an index covers exactly the
+  // expression makeWhereClause emits for the same field.
+  // XXX - indexName itself is still interpolated raw here, in makeSQLDropIndex
+  // and in makeSQLQueryFromMango's INDEXED BY. The three must agree, so they are
+  // left alone together: a field name containing a quote would break index
+  // resolution rather than the where clause.
   var jsonAttributes = fieldsToIndex.map(function (field) {
-    return "json_extract(json, '$.".concat(field, "')");
+    return "json_extract(json, '$.".concat(escapeSQLString(field), "')");
   });
   var jsonIndex = jsonAttributes.join(',');
   var sql = "\n    CREATE INDEX IF NOT EXISTS '".concat(indexName, "'\n    ON 'by-sequence'\n    (").concat(jsonIndex, ")\n  ");
@@ -406,13 +650,13 @@ var makeSQLCreateDeletedIndex = function makeSQLCreateDeletedIndex() {
 exports.makeSQLCreateDeletedIndex = makeSQLCreateDeletedIndex;
 
 var createMangoIndex = /*#__PURE__*/function () {
-  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(db, indexName, fieldsToIndex, _ref5) {
+  var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(db, indexName, fieldsToIndex, _ref6) {
     var partialFilter, sql, result;
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            partialFilter = _ref5.partialFilter;
+            partialFilter = _ref6.partialFilter;
             sql = makeSQLCreateMangoIndex(indexName, fieldsToIndex, {
               partialFilter: partialFilter
             });
@@ -432,14 +676,14 @@ var createMangoIndex = /*#__PURE__*/function () {
   }));
 
   return function createMangoIndex(_x, _x2, _x3, _x4) {
-    return _ref6.apply(this, arguments);
+    return _ref7.apply(this, arguments);
   };
 }();
 
 exports.createMangoIndex = createMangoIndex;
 
 var deleteIndex = /*#__PURE__*/function () {
-  var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(db, indexName) {
+  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(db, indexName) {
     var sql;
     return _regenerator.default.wrap(function _callee2$(_context2) {
       while (1) {
@@ -458,19 +702,62 @@ var deleteIndex = /*#__PURE__*/function () {
   }));
 
   return function deleteIndex(_x5, _x6) {
-    return _ref7.apply(this, arguments);
+    return _ref8.apply(this, arguments);
   };
 }();
+/**
+ * op-sqlite answers with positional rows (`rawRows`) and the column names beside
+ * them, while older releases exposed a WebSQL-style `rows` accessor. parseResults
+ * reads `rows.length` and `rows.item(i)`, so every shape is brought back to that
+ * contract: otherwise `rows` is undefined and each query dies reading `length`.
+ *
+ * @param {object} result - A raw op-sqlite result
+ * @returns {object} The same result, with a WebSQL-style `rows` accessor
+ */
+
 
 exports.deleteIndex = deleteIndex;
 
+var toWebSQLResult = function toWebSQLResult(result) {
+  if (!result) {
+    return result;
+  }
+
+  var rows = result.rows;
+
+  if (rows && typeof rows.item === 'function') {
+    return result;
+  }
+
+  var list = Array.isArray(rows) ? rows : (result.rawRows || []).map(function (row) {
+    var columnNames = result.columnNames || [];
+    var record = {};
+
+    for (var i = 0; i < columnNames.length; i++) {
+      record[columnNames[i]] = row[i];
+    }
+
+    return record;
+  });
+  return _objectSpread(_objectSpread({}, result), {}, {
+    rows: {
+      length: list.length,
+      item: function item(i) {
+        return list[i];
+      }
+    }
+  });
+};
+
+exports.toWebSQLResult = toWebSQLResult;
+
 var executeSQL = /*#__PURE__*/function () {
-  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(db, sql) {
+  var _ref9 = (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).catch(function (err) {
+            return _context3.abrupt("return", db.executeAsync(sql).then(toWebSQLResult).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.
@@ -500,7 +787,7 @@ var executeSQL = /*#__PURE__*/function () {
   }));
 
   return function executeSQL(_x7, _x8) {
-    return _ref8.apply(this, arguments);
+    return _ref9.apply(this, arguments);
   };
 }();