json-fs-query 2.1.1 → 2.2.0

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);
   }
@@ -3849,15 +3860,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 +3878,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 => {
@@ -3896,7 +3907,7 @@ const runQuery = async parsed => {
   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]: []
   };