json-fs-query 2.1.1 → 2.2.1

package/README.md

@@ -148,6 +148,14 @@ read workouts where reps > 8 and where date = '2024-06-02'
 `or where` is not supported yet, and is an error (in 1.x it was silently read as `and where`). And/or with grouping
 and precedence is planned.
 
+### Comparing by the field's type
+
+Conditions compare by the field's declared type, whatever type the stored value or the literal has: in a `string`
+or `int` field, `'3'` and `3` are equal. Ordering (`>`, `>=`, `<`, `<=`, `between`) and `sort` follow it too: a
+`string` field orders as text, so `'10'` comes before `'9'` (even ids stored as numbers), and an `int` field as
+numbers. A field with no declared type, or an `object` or `array` one, compares the stored values as they are.
+`like` only matches values stored as text.
+
 ### Null and missing fields
 
 A field can be missing (left out) or hold `null`, and both are their own cases, as in SQL: they match no

package/browser/jsonFsQuery.js

@@ -1211,6 +1211,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.sortBy = void 0;
+var _compareAs = require("../utilities/compareAs");
 // Where a value sorts before any other, ascending: missing first, then null, then the values (MySQL's null placement,
 // with missing below null). Descending reverses it.
 const presence = (data, property) => {
@@ -1219,6 +1220,12 @@ const presence = (data, property) => {
   }
   return data[property] === null ? 1 : 2;
 };
+/**
+ * Sort by each clause in turn: missing, then null, then the values, compared by the field's declared type when the
+ * clause has one (see compareAs), so a string field sorts as text ('10' before '9') and an int field as numbers.
+ * @param dataSet
+ * @param sortClauses
+ */
 const sortBy = (dataSet = [], sortClauses = []) => {
   if (!sortClauses.length) {
     return dataSet;
@@ -1232,13 +1239,15 @@ const sortBy = (dataSet = [], sortClauses = []) => {
       if (rankA !== rankB) {
         return direction === 'asc' ? rankA - rankB : rankB - rankA;
       }
-      // Ordering compares the raw stored values, not by declared type (that's only for equality, see where), so
-      // numeric ids in a string field still sort numerically. Loose so '3' and 3 still tie, as do two nulls or two missing.
+      // Values compare by the declared type, so numeric ids in a string field sort as text ('10' before '9'). Loose so
+      // '3' and 3 still tie in an untyped field, as do two nulls or two missing.
+      const valueA = (0, _compareAs.compareAs)(sortClause.type, a[property]);
+      const valueB = (0, _compareAs.compareAs)(sortClause.type, b[property]);
       // eslint-disable-next-line eqeqeq
-      if (a[property] == b[property]) {
+      if (valueA == valueB) {
         continue;
       }
-      const result = a[property] < b[property] ? -1 : 1;
+      const result = valueA < valueB ? -1 : 1;
       return direction === 'asc' ? result : result * -1;
     }
     return 0;
@@ -1246,7 +1255,7 @@ const sortBy = (dataSet = [], sortClauses = []) => {
   return dataSet;
 };
 exports.sortBy = sortBy;
-},{}],32:[function(require,module,exports){
+},{"../utilities/compareAs":34}],32:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -1514,7 +1523,8 @@ const likeMatch = (dataValue, pattern) => {
 };
 /**
  * Equality (=, !=, <>, in) compares by the field's declared type when given one (see sameValue), so
- * '3' and 3 match in a string or int field. Ordering (>, <, between, like) compares the raw values.
+ * '3' and 3 match in a string or int field. Ordering (>, >=, <, <=, between) compares by it too (see compareAs): a
+ * string field orders as text ('10' < '9'), an int field as numbers. like compares the raw values.
  *
  * Null and missing are their own cases, as in SQL: a field that is null or missing matches no comparison (not even
  * `!=`), and a null never equals anything, not even another null. Only these test for them:
@@ -1543,6 +1553,7 @@ const makeCondition = (data, property, comparator, value, type = undefined) => {
     return false;
   }
   const dataValue = data[property];
+  const typedValue = (0, _compareAs.compareAs)(type, dataValue);
   switch (comparator) {
     case '=':
       return (0, _compareAs.sameValue)(type, dataValue, value);
@@ -1550,18 +1561,18 @@ const makeCondition = (data, property, comparator, value, type = undefined) => {
     case '<>':
       return !(0, _compareAs.sameValue)(type, dataValue, value);
     case '>':
-      return dataValue > value;
+      return typedValue > (0, _compareAs.compareAs)(type, value);
     case '>=':
-      return dataValue >= value;
+      return typedValue >= (0, _compareAs.compareAs)(type, value);
     case '<':
-      return dataValue < value;
+      return typedValue < (0, _compareAs.compareAs)(type, value);
     case '<=':
-      return dataValue <= value;
+      return typedValue <= (0, _compareAs.compareAs)(type, value);
     case 'in':
       return Array.isArray(value) && (type ? value.some(item => (0, _compareAs.sameValue)(type, dataValue, item)) : value.includes(dataValue));
     case 'between':
       // A null bound would act as 0 in >= / <=: it bounds nothing, so nothing matches (the parser refuses it)
-      return Array.isArray(value) && value.length === 2 && !value.includes(null) && dataValue >= value[0] && dataValue <= value[1];
+      return Array.isArray(value) && value.length === 2 && !value.includes(null) && typedValue >= (0, _compareAs.compareAs)(type, value[0]) && typedValue <= (0, _compareAs.compareAs)(type, value[1]);
     case 'like':
       return likeMatch(dataValue, value);
   }
@@ -3810,6 +3821,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.runQuery = void 0;
 require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
 require("core-js/modules/esnext.iterator.reduce.js");
 require("core-js/modules/esnext.set.add-all.js");
 require("core-js/modules/esnext.set.delete-all.js");
@@ -3849,15 +3861,15 @@ var _isEntityProperty = require("./parsers/isEntityProperty");
 var _splitEntityProperty = require("./parsers/splitEntityProperty");
 var _fieldType = require("./fieldType");
 /**
- * Give each condition its field's declared type, so where compares by it (a joined entity's field
- * is looked up on that entity's record).
+ * Give each condition and sort clause its field's declared type, so where and sortBy compare by it
+ * (a joined entity's field is looked up on that entity's record).
  * @param parsed
  * @param recordData
  */
-const typeConditions = async (parsed, recordData) => {
-  for (const condition of parsed.conditions) {
+const typeClauses = async (parsed, recordData) => {
+  for (const clause of [...parsed.conditions, ...parsed.sortClauses]) {
     let entity = parsed.entity;
-    let property = condition.property;
+    let property = clause.property;
     if ((0, _isEntityProperty.isEntityProperty)(property)) {
       ({
         entity,
@@ -3867,7 +3879,7 @@ const typeConditions = async (parsed, recordData) => {
     if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
       recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
     }
-    condition.type = (0, _fieldType.fieldType)(recordData[entity], property);
+    clause.type = (0, _fieldType.fieldType)(recordData[entity], property);
   }
 };
 const runQuery = async parsed => {
@@ -3890,13 +3902,23 @@ const runQuery = async parsed => {
         [parsed.entity]: await (0, _showRecords.showRecords)()
       };
   }
+  // update/delete apply their conditions before any join or merge runs, so a condition on another entity's field
+  // can't be checked there. An indexed one used to be dropped once its index had narrowed the joined rows, and the
+  // command then hit every row the other conditions allowed (`delete workouts.exercises on ... where
+  // exercises._id = 1` deleted every workout)
+  if (parsed.command === 'update' || parsed.command === 'delete') {
+    const other = parsed.conditions.find(condition => (0, _isEntityProperty.isEntityProperty)(condition.property) && (0, _splitEntityProperty.splitEntityProperty)(condition.property).entity !== parsed.entity);
+    if (other) {
+      throw new Error(`${parsed.command} can only use conditions on ${parsed.entity}'s own fields, not ${other.property}`);
+    }
+  }
   const recordData = {
     [parsed.entity]: await (0, _retrieveRecord.retrieveRecord)(parsed.entity)
   };
   if (typeof parsed.joinEntity !== 'undefined') {
     recordData[parsed.joinEntity] = await (0, _retrieveRecord.retrieveRecord)(parsed.joinEntity);
   }
-  await typeConditions(parsed, recordData);
+  await typeClauses(parsed, recordData);
   let dataSet = {
     [parsed.entity]: []
   };
@@ -3956,7 +3978,7 @@ const runQuery = async parsed => {
   return dataSet;
 };
 exports.runQuery = runQuery;
-},{"../queries/createRecord":15,"../queries/deleteEntity":16,"../queries/describeRecord":17,"../queries/dropRecord":18,"../queries/groupBy":19,"../queries/insertEntity":20,"../queries/joinEntity":21,"../queries/limitOffset":22,"../queries/mergeJoins":23,"../queries/readEntity":28,"../queries/selectFields":29,"../queries/showRecords":30,"../queries/sortBy":31,"../queries/updateEntity":32,"../queries/where":33,"./fieldType":39,"./getConditionIndexedList":40,"./getJoinIndexedList":41,"./parsers/isEntityProperty":58,"./parsers/splitEntityProperty":66,"./retrieveRecord":77,"core-js/modules/esnext.iterator.constructor.js":235,"core-js/modules/esnext.iterator.reduce.js":243,"core-js/modules/esnext.set.add-all.js":258,"core-js/modules/esnext.set.delete-all.js":259,"core-js/modules/esnext.set.difference.js":260,"core-js/modules/esnext.set.every.js":261,"core-js/modules/esnext.set.filter.js":262,"core-js/modules/esnext.set.find.js":263,"core-js/modules/esnext.set.intersection.js":264,"core-js/modules/esnext.set.is-disjoint-from.js":265,"core-js/modules/esnext.set.is-subset-of.js":266,"core-js/modules/esnext.set.is-superset-of.js":267,"core-js/modules/esnext.set.join.js":268,"core-js/modules/esnext.set.map.js":269,"core-js/modules/esnext.set.reduce.js":270,"core-js/modules/esnext.set.some.js":271,"core-js/modules/esnext.set.symmetric-difference.js":272,"core-js/modules/esnext.set.union.js":273}],80:[function(require,module,exports){
+},{"../queries/createRecord":15,"../queries/deleteEntity":16,"../queries/describeRecord":17,"../queries/dropRecord":18,"../queries/groupBy":19,"../queries/insertEntity":20,"../queries/joinEntity":21,"../queries/limitOffset":22,"../queries/mergeJoins":23,"../queries/readEntity":28,"../queries/selectFields":29,"../queries/showRecords":30,"../queries/sortBy":31,"../queries/updateEntity":32,"../queries/where":33,"./fieldType":39,"./getConditionIndexedList":40,"./getJoinIndexedList":41,"./parsers/isEntityProperty":58,"./parsers/splitEntityProperty":66,"./retrieveRecord":77,"core-js/modules/esnext.iterator.constructor.js":235,"core-js/modules/esnext.iterator.find.js":239,"core-js/modules/esnext.iterator.reduce.js":243,"core-js/modules/esnext.set.add-all.js":258,"core-js/modules/esnext.set.delete-all.js":259,"core-js/modules/esnext.set.difference.js":260,"core-js/modules/esnext.set.every.js":261,"core-js/modules/esnext.set.filter.js":262,"core-js/modules/esnext.set.find.js":263,"core-js/modules/esnext.set.intersection.js":264,"core-js/modules/esnext.set.is-disjoint-from.js":265,"core-js/modules/esnext.set.is-subset-of.js":266,"core-js/modules/esnext.set.is-superset-of.js":267,"core-js/modules/esnext.set.join.js":268,"core-js/modules/esnext.set.map.js":269,"core-js/modules/esnext.set.reduce.js":270,"core-js/modules/esnext.set.some.js":271,"core-js/modules/esnext.set.symmetric-difference.js":272,"core-js/modules/esnext.set.union.js":273}],80:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {