json-fs-query 2.2.1 → 2.3.0

package/dist/data/queries/joinEntity.d.ts

@@ -1,2 +1,2 @@
-export declare const joinEntity: (entity: any, joinEntity: any, dataSets?: {}, joinClauses?: any[], entityAlreadyResolved?: boolean) => Promise<{}>;
+export declare const joinEntity: (entity: any, joinEntity: any, dataSets?: {}, joinClauses?: any[], entityAlreadyResolved?: boolean, joinAlreadyResolved?: boolean) => Promise<{}>;
 //# sourceMappingURL=joinEntity.d.ts.map

package/dist/data/queries/joinEntity.js

@@ -8,7 +8,7 @@ var _siFunciona = _interopRequireDefault(require("si-funciona"));
 var _readEntity = require("./readEntity");
 var _useJoinClause = require("../utilities/useJoinClause");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], entityAlreadyResolved = false) => {
+const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], entityAlreadyResolved = false, joinAlreadyResolved = false) => {
   // Same ambiguity readEntity() always has (can't tell "never loaded" from "loaded, zero rows
   // matched") - runQuery already resolved entity's rows via an indexed condition in that second
   // case, so entityAlreadyResolved tells this call not to reload and silently discard that result.
@@ -18,7 +18,10 @@ const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], e
   if (!joinClauses.length) {
     return dataSets;
   }
-  dataSets = await (0, _readEntity.readEntity)(joinEntity, dataSets);
+  // The same for joinEntity: an indexed condition on its field may have resolved its rows to none
+  if (!joinAlreadyResolved) {
+    dataSets = await (0, _readEntity.readEntity)(joinEntity, dataSets);
+  }
   for (const anEntity in dataSets[entity]) {
     let filterJoins = _siFunciona.default.cloneObject(dataSets);
     filterJoins[entity] = [dataSets[entity][anEntity]];

package/dist/data/queries/joinEntity.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinEntity=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_readEntity=require("./readEntity"),_useJoinClause=require("../utilities/useJoinClause");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const joinEntity=async(e,t,i={},n=[],r=!1)=>{if(r||(i=await(0,_readEntity.readEntity)(e,i)),!n.length)return i;i=await(0,_readEntity.readEntity)(t,i);for(const r in i[e]){let u=_siFunciona.default.cloneObject(i);u[e]=[i[e][r]];for(const e of n)u=await(0,_useJoinClause.useJoinClause)(e,i,u);i[e][r][t]=u[t]}return i};exports.joinEntity=joinEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinEntity=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_readEntity=require("./readEntity"),_useJoinClause=require("../utilities/useJoinClause");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const joinEntity=async(e,t,i={},n=[],r=!1,u=!1)=>{if(r||(i=await(0,_readEntity.readEntity)(e,i)),!n.length)return i;u||(i=await(0,_readEntity.readEntity)(t,i));for(const r in i[e]){let u=_siFunciona.default.cloneObject(i);u[e]=[i[e][r]];for(const e of n)u=await(0,_useJoinClause.useJoinClause)(e,i,u);i[e][r][t]=u[t]}return i};exports.joinEntity=joinEntity;

package/dist/data/queries/where.d.ts

@@ -1,8 +1,39 @@
-export declare const where: (dataSet?: any[], { property, joinEntity, comparator, value, type }?: {
-    property?: string;
-    joinEntity?: any;
-    comparator?: string;
-    value?: any;
-    type?: any;
-}) => any[];
+import { ConditionNode } from '../utilities/conditionTree';
+/**
+ * SQL's three-valued logic: a condition is true, false, or unknown (null here), see makeCondition.
+ */
+export type Truth = boolean | null;
+/**
+ * The rows for which one condition is true (unknown, from a null or missing field, isn't).
+ * @param dataSet
+ * @param condition
+ */
+export declare const where: (dataSet?: any[], condition?: {}) => any[];
+/**
+ * A where-clause tree on one row, with SQL's three-valued logic: unknown (null) stays unknown through `not`, and
+ * `and` / `or` decide on it only when another child settles the result.
+ *
+ * | | result |
+ * |---|---|
+ * | `not unknown` | unknown |
+ * | `false and unknown` | false |
+ * | `true and unknown` | unknown |
+ * | `true or unknown` | true |
+ * | `false or unknown` | unknown |
+ * @param data
+ * @param node
+ */
+export declare const treeTruth: (data: any, node: ConditionNode) => Truth;
+/**
+ * The rows that match a where-clause tree (see ConditionNode): only those for which the whole tree is true, so
+ * `not (n = 5)` returns the same rows as `n != 5` (neither returns a row where n is null or missing). Every row when
+ * there is no where clause.
+ *
+ * With a joinEntity (the tree uses its fields, see conditionEntities), it's SQL's inner join, evaluated per pair: each
+ * row keeps the joined rows for which the tree is true with that pair, and a row left with none is dropped.
+ * @param dataSet
+ * @param node
+ * @param joinEntity
+ */
+export declare const whereTree: (dataSet?: any[], node?: ConditionNode | undefined, joinEntity?: string | undefined) => any[];
 //# sourceMappingURL=where.d.ts.map

package/dist/data/queries/where.js

@@ -3,12 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.where = void 0;
+exports.whereTree = exports.where = exports.treeTruth = void 0;
 require("core-js/modules/es.array.includes.js");
 require("core-js/modules/esnext.iterator.constructor.js");
 require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.flat-map.js");
 require("core-js/modules/esnext.iterator.some.js");
 var _compareAs = require("../utilities/compareAs");
+var _conditionTree = require("../utilities/conditionTree");
 const likeMatch = (dataValue, pattern) => {
   if (typeof dataValue !== 'string' || typeof pattern !== 'string') {
     return false;
@@ -21,8 +23,9 @@ const likeMatch = (dataValue, pattern) => {
  * '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:
+ * Null and missing are their own cases, as in SQL: a comparison on a field that is null or missing is unknown (null),
+ * neither true nor false, so it matches nothing (not even `!=`) and `not` doesn't turn it into a match. A null never
+ * equals anything, not even another null. Only these test for them, and they are never unknown:
  * - `is null`: the field is there and holds null
  * - `is not null`: the field is there and holds a value (so a missing field doesn't match either)
  * - `exists` / `does not exist`: the field is there (null counts) / is missing
@@ -45,7 +48,7 @@ const makeCondition = (data, property, comparator, value, type = undefined) => {
       return exists && data[property] !== null;
   }
   if (!exists || data[property] === null || value === null) {
-    return false;
+    return null;
   }
   const dataValue = data[property];
   const typedValue = (0, _compareAs.compareAs)(type, dataValue);
@@ -64,25 +67,128 @@ const makeCondition = (data, property, comparator, value, type = undefined) => {
     case '<=':
       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));
+      {
+        if (!Array.isArray(value)) {
+          return false;
+        }
+        if (type ? value.some(item => item !== null && (0, _compareAs.sameValue)(type, dataValue, item)) : value.includes(dataValue)) {
+          return true;
+        }
+        // SQL: `x in [1, null]` is x = 1 or x = null, so with no match it's unknown (not false), and not (...) keeps nothing
+        return value.includes(null) ? null : false;
+      }
     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) && typedValue >= (0, _compareAs.compareAs)(type, value[0]) && typedValue <= (0, _compareAs.compareAs)(type, value[1]);
+      if (!Array.isArray(value) || value.length !== 2) {
+        return false;
+      }
+      // A null bound would act as 0 in >= / <=: it bounds nothing, so the result is unknown (the parser refuses it)
+      if (value.includes(null)) {
+        return null;
+      }
+      return typedValue >= (0, _compareAs.compareAs)(type, value[0]) && typedValue <= (0, _compareAs.compareAs)(type, value[1]);
     case 'like':
       return likeMatch(dataValue, value);
   }
   return false;
 };
-const where = (dataSet = [], {
+/**
+ * One condition on one row: true, false or unknown (shared by where and whereTree).
+ * @param data
+ * @param condition
+ */
+const conditionTruth = (data, {
   property = '',
   joinEntity = undefined,
   comparator = '=',
   value = null,
   type = undefined
-} = {}) => {
-  return dataSet.filter(data => {
-    const testProperty = joinEntity ? `${joinEntity}.${property}` : property;
-    return makeCondition(data, testProperty, comparator, value, type);
+} = {}) => makeCondition(data, joinEntity ? `${joinEntity}.${property}` : property, comparator, value, type);
+/**
+ * The rows for which one condition is true (unknown, from a null or missing field, isn't).
+ * @param dataSet
+ * @param condition
+ */
+const where = (dataSet = [], condition = {}) => dataSet.filter(data => conditionTruth(data, condition) === true);
+/**
+ * A where-clause tree on one row, with SQL's three-valued logic: unknown (null) stays unknown through `not`, and
+ * `and` / `or` decide on it only when another child settles the result.
+ *
+ * | | result |
+ * |---|---|
+ * | `not unknown` | unknown |
+ * | `false and unknown` | false |
+ * | `true and unknown` | unknown |
+ * | `true or unknown` | true |
+ * | `false or unknown` | unknown |
+ * @param data
+ * @param node
+ */
+exports.where = where;
+const treeTruth = (data, node) => {
+  if ((0, _conditionTree.isCondition)(node)) {
+    return conditionTruth(data, node);
+  }
+  if ('not' in node) {
+    const truth = treeTruth(data, node.not);
+    return truth === null ? null : !truth;
+  }
+  // and: false wins, then unknown; or: true wins, then unknown
+  const settles = !('and' in node);
+  let result = !settles;
+  for (const child of 'and' in node ? node.and : node.or) {
+    const truth = treeTruth(data, child);
+    if (truth === settles) {
+      return settles;
+    }
+    if (truth === null) {
+      result = null;
+    }
+  }
+  return result;
+};
+/**
+ * One row seen together with one of its joined rows, for evaluating a where clause on the pair: the row's own fields,
+ * plus the joined row's as `joinEntity.field` (a field already on the row, such as a merged one, is kept).
+ * @param row
+ * @param joinEntity
+ * @param joinedRow
+ */
+exports.treeTruth = treeTruth;
+const pairView = (row, joinEntity, joinedRow) => {
+  const view = Object.assign({}, row);
+  for (const field of Object.keys(joinedRow)) {
+    // A merged field on the joined row is already named `entity.field`
+    const name = field.includes('.') ? field : `${joinEntity}.${field}`;
+    if (!Object.prototype.hasOwnProperty.call(view, name)) {
+      view[name] = joinedRow[field];
+    }
+  }
+  return view;
+};
+/**
+ * The rows that match a where-clause tree (see ConditionNode): only those for which the whole tree is true, so
+ * `not (n = 5)` returns the same rows as `n != 5` (neither returns a row where n is null or missing). Every row when
+ * there is no where clause.
+ *
+ * With a joinEntity (the tree uses its fields, see conditionEntities), it's SQL's inner join, evaluated per pair: each
+ * row keeps the joined rows for which the tree is true with that pair, and a row left with none is dropped.
+ * @param dataSet
+ * @param node
+ * @param joinEntity
+ */
+const whereTree = (dataSet = [], node = undefined, joinEntity = undefined) => {
+  if (typeof node === 'undefined') {
+    return dataSet;
+  }
+  if (typeof joinEntity === 'undefined') {
+    return dataSet.filter(data => treeTruth(data, node) === true);
+  }
+  return dataSet.flatMap(data => {
+    const joined = Array.isArray(data[joinEntity]) ? data[joinEntity] : [];
+    const kept = joined.filter(joinedRow => treeTruth(pairView(data, joinEntity, joinedRow), node) === true);
+    return kept.length ? [Object.assign({}, data, {
+      [joinEntity]: kept
+    })] : [];
   });
 };
-exports.where = where;
+exports.whereTree = whereTree;

package/dist/data/queries/where.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.where=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.some.js");var _compareAs=require("../utilities/compareAs");const likeMatch=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const s=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${s}$`,"i").test(e)},makeCondition=(e,r,s,t,a=void 0)=>{const o=Object.prototype.hasOwnProperty.call(e,r);switch(s){case"exists":return o;case"does not exist":return!o;case"is null":return o&&null===e[r];case"is not null":return o&&null!==e[r]}if(!o||null===e[r]||null===t)return!1;const c=e[r],n=(0,_compareAs.compareAs)(a,c);switch(s){case"=":return(0,_compareAs.sameValue)(a,c,t);case"!=":case"<>":return!(0,_compareAs.sameValue)(a,c,t);case">":return n>(0,_compareAs.compareAs)(a,t);case">=":return n>=(0,_compareAs.compareAs)(a,t);case"<":return n<(0,_compareAs.compareAs)(a,t);case"<=":return n<=(0,_compareAs.compareAs)(a,t);case"in":return Array.isArray(t)&&(a?t.some((e=>(0,_compareAs.sameValue)(a,c,e))):t.includes(c));case"between":return Array.isArray(t)&&2===t.length&&!t.includes(null)&&n>=(0,_compareAs.compareAs)(a,t[0])&&n<=(0,_compareAs.compareAs)(a,t[1]);case"like":return likeMatch(c,t)}return!1},where=(e=[],{property:r="",joinEntity:s,comparator:t="=",value:a=null,type:o}={})=>e.filter((e=>makeCondition(e,s?`${s}.${r}`:r,t,a,o)));exports.where=where;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.whereTree=exports.where=exports.treeTruth=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.flat-map.js"),require("core-js/modules/esnext.iterator.some.js");var _compareAs=require("../utilities/compareAs"),_conditionTree=require("../utilities/conditionTree");const likeMatch=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const t=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${t}$`,"i").test(e)},makeCondition=(e,r,t,s,n=void 0)=>{const o=Object.prototype.hasOwnProperty.call(e,r);switch(t){case"exists":return o;case"does not exist":return!o;case"is null":return o&&null===e[r];case"is not null":return o&&null!==e[r]}if(!o||null===e[r]||null===s)return null;const i=e[r],c=(0,_compareAs.compareAs)(n,i);switch(t){case"=":return(0,_compareAs.sameValue)(n,i,s);case"!=":case"<>":return!(0,_compareAs.sameValue)(n,i,s);case">":return c>(0,_compareAs.compareAs)(n,s);case">=":return c>=(0,_compareAs.compareAs)(n,s);case"<":return c<(0,_compareAs.compareAs)(n,s);case"<=":return c<=(0,_compareAs.compareAs)(n,s);case"in":return!!Array.isArray(s)&&(!!(n?s.some((e=>null!==e&&(0,_compareAs.sameValue)(n,i,e))):s.includes(i))||!!s.includes(null)&&null);case"between":return!(!Array.isArray(s)||2!==s.length)&&(s.includes(null)?null:c>=(0,_compareAs.compareAs)(n,s[0])&&c<=(0,_compareAs.compareAs)(n,s[1]));case"like":return likeMatch(i,s)}return!1},conditionTruth=(e,{property:r="",joinEntity:t,comparator:s="=",value:n=null,type:o}={})=>makeCondition(e,t?`${t}.${r}`:r,s,n,o),where=(e=[],r={})=>e.filter((e=>!0===conditionTruth(e,r)));exports.where=where;const treeTruth=(e,r)=>{if((0,_conditionTree.isCondition)(r))return conditionTruth(e,r);if("not"in r){const t=treeTruth(e,r.not);return null===t?null:!t}const t=!("and"in r);let s=!t;for(const n of"and"in r?r.and:r.or){const r=treeTruth(e,n);if(r===t)return t;null===r&&(s=null)}return s};exports.treeTruth=treeTruth;const pairView=(e,r,t)=>{const s=Object.assign({},e);for(const e of Object.keys(t)){const n=e.includes(".")?e:`${r}.${e}`;Object.prototype.hasOwnProperty.call(s,n)||(s[n]=t[e])}return s},whereTree=(e=[],r=void 0,t=void 0)=>void 0===r?e:void 0===t?e.filter((e=>!0===treeTruth(e,r))):e.flatMap((e=>{const s=(Array.isArray(e[t])?e[t]:[]).filter((s=>!0===treeTruth(pairView(e,t,s),r)));return s.length?[Object.assign({},e,{[t]:s})]:[]}));exports.whereTree=whereTree;

package/dist/data/utilities/conditionEntities.d.ts

@@ -0,0 +1,20 @@
+import { ParsedQuery } from './parsers/parseQuery';
+/**
+ * Check which entity each condition's field is on, before anything is read, and say whether the where clause has to be
+ * evaluated per pair of a row and one of its joined rows:
+ * - the queried entity (`workouts.date`): written as the plain field (`date`), which is where the row holds it
+ * - the joined entity (`read workouts.exercises on ...`, `exercises.name`): per pair (see whereTree), so returns true
+ * - an entity merged into the rows or the joined rows (`merge workouts.exercise_id with exercises._id`): read from the
+ *   merged fields (`exercises.name` on the row), as before
+ * - anything else is an error: an entity that only links the join (`exercise_muscle` in `workouts.muscles`), or one
+ *   that isn't in the query at all (these used to match nothing, or fail to read the entity)
+ *
+ * update and delete apply their conditions before any join or merge runs, so they only take the entity's own fields.
+ * (An indexed joined-field condition used to be dropped once its index had narrowed the joined rows, so the command hit
+ * every row the other conditions allowed: `delete workouts.exercises on ... where exercises._id = 1` deleted every
+ * workout. Refused since #79.)
+ * @param parsed - its conditions on the queried entity lose their `entity.` prefix
+ * @throws {Error} For a condition on a field the query can't check
+ */
+export declare const conditionEntities: (parsed: ParsedQuery) => boolean;
+//# sourceMappingURL=conditionEntities.d.ts.map

package/dist/data/utilities/conditionEntities.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conditionEntities = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.flat-map.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.js");
+var _isEntityProperty = require("./parsers/isEntityProperty");
+var _splitEntityProperty = require("./parsers/splitEntityProperty");
+var _conditionTree = require("./conditionTree");
+/**
+ * Check which entity each condition's field is on, before anything is read, and say whether the where clause has to be
+ * evaluated per pair of a row and one of its joined rows:
+ * - the queried entity (`workouts.date`): written as the plain field (`date`), which is where the row holds it
+ * - the joined entity (`read workouts.exercises on ...`, `exercises.name`): per pair (see whereTree), so returns true
+ * - an entity merged into the rows or the joined rows (`merge workouts.exercise_id with exercises._id`): read from the
+ *   merged fields (`exercises.name` on the row), as before
+ * - anything else is an error: an entity that only links the join (`exercise_muscle` in `workouts.muscles`), or one
+ *   that isn't in the query at all (these used to match nothing, or fail to read the entity)
+ *
+ * update and delete apply their conditions before any join or merge runs, so they only take the entity's own fields.
+ * (An indexed joined-field condition used to be dropped once its index had narrowed the joined rows, so the command hit
+ * every row the other conditions allowed: `delete workouts.exercises on ... where exercises._id = 1` deleted every
+ * workout. Refused since #79.)
+ * @param parsed - its conditions on the queried entity lose their `entity.` prefix
+ * @throws {Error} For a condition on a field the query can't check
+ */
+const conditionEntities = parsed => {
+  const entity = parsed.entity;
+  const joinEntity = parsed.joinClauses.length ? parsed.joinEntity : undefined;
+  const joined = new Set([entity, joinEntity]);
+  const merged = new Set(parsed.mergeJoins.filter(merge => joined.has((0, _splitEntityProperty.splitEntityProperty)(merge.propertyA).entity)).map(merge => (0, _splitEntityProperty.splitEntityProperty)(merge.propertyB).entity));
+  const linking = new Set(parsed.joinClauses.flatMap(clause => [clause.propertyA, clause.propertyB].map(property => (0, _splitEntityProperty.splitEntityProperty)(property).entity)).filter(name => !joined.has(name) && !merged.has(name)));
+  const changes = parsed.command === 'update' || parsed.command === 'delete';
+  let perPair = false;
+  for (const condition of (0, _conditionTree.conditionsOf)(parsed.where)) {
+    if (!(0, _isEntityProperty.isEntityProperty)(condition.property)) {
+      continue;
+    }
+    const {
+      entity: fieldEntity,
+      property
+    } = (0, _splitEntityProperty.splitEntityProperty)(condition.property);
+    if (fieldEntity === entity) {
+      condition.property = property;
+      continue;
+    }
+    if (changes) {
+      throw new Error(`${parsed.command} can only use conditions on ${entity}'s own fields, not ${condition.property}`);
+    }
+    if (fieldEntity === joinEntity) {
+      perPair = true;
+      continue;
+    }
+    if (merged.has(fieldEntity)) {
+      continue;
+    }
+    if (linking.has(fieldEntity)) {
+      throw new Error(`${fieldEntity} only links ${entity} to ${joinEntity}: a condition can't use its fields (${condition.property})`);
+    }
+    const usable = [entity, joinEntity, ...merged].filter(name => typeof name !== 'undefined').join(', ');
+    throw new Error(`${fieldEntity} is not part of this query (${condition.property}): conditions can use the fields of ${usable}`);
+  }
+  return perPair;
+};
+exports.conditionEntities = conditionEntities;

package/dist/data/utilities/conditionEntities.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.conditionEntities=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.flat-map.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.set.add-all.js"),require("core-js/modules/esnext.set.delete-all.js"),require("core-js/modules/esnext.set.difference.js"),require("core-js/modules/esnext.set.every.js"),require("core-js/modules/esnext.set.filter.js"),require("core-js/modules/esnext.set.find.js"),require("core-js/modules/esnext.set.intersection.js"),require("core-js/modules/esnext.set.is-disjoint-from.js"),require("core-js/modules/esnext.set.is-subset-of.js"),require("core-js/modules/esnext.set.is-superset-of.js"),require("core-js/modules/esnext.set.join.js"),require("core-js/modules/esnext.set.map.js"),require("core-js/modules/esnext.set.reduce.js"),require("core-js/modules/esnext.set.some.js"),require("core-js/modules/esnext.set.symmetric-difference.js"),require("core-js/modules/esnext.set.union.js");var _isEntityProperty=require("./parsers/isEntityProperty"),_splitEntityProperty=require("./parsers/splitEntityProperty"),_conditionTree=require("./conditionTree");const conditionEntities=e=>{const t=e.entity,r=e.joinClauses.length?e.joinEntity:void 0,s=new Set([t,r]),o=new Set(e.mergeJoins.filter((e=>s.has((0,_splitEntityProperty.splitEntityProperty)(e.propertyA).entity))).map((e=>(0,_splitEntityProperty.splitEntityProperty)(e.propertyB).entity))),i=new Set(e.joinClauses.flatMap((e=>[e.propertyA,e.propertyB].map((e=>(0,_splitEntityProperty.splitEntityProperty)(e).entity)))).filter((e=>!s.has(e)&&!o.has(e)))),n="update"===e.command||"delete"===e.command;let u=!1;for(const s of(0,_conditionTree.conditionsOf)(e.where)){if(!(0,_isEntityProperty.isEntityProperty)(s.property))continue;const{entity:p,property:c}=(0,_splitEntityProperty.splitEntityProperty)(s.property);if(p===t){s.property=c;continue}if(n)throw new Error(`${e.command} can only use conditions on ${t}'s own fields, not ${s.property}`);if(p===r){u=!0;continue}if(o.has(p))continue;if(i.has(p))throw new Error(`${p} only links ${t} to ${r}: a condition can't use its fields (${s.property})`);const l=[t,r,...o].filter((e=>void 0!==e)).join(", ");throw new Error(`${p} is not part of this query (${s.property}): conditions can use the fields of ${l}`)}return u};exports.conditionEntities=conditionEntities;

package/dist/data/utilities/conditionTree.d.ts

@@ -0,0 +1,36 @@
+import type { ParsedCondition } from './parsers/findConditions';
+/**
+ * A where clause as a tree: a condition, or `and` / `or` over several nodes, or `not` over one. `a and b and c` is one
+ * `and` node with three children, not nested pairs.
+ */
+export type ConditionNode = ParsedCondition | {
+    and: ConditionNode[];
+} | {
+    or: ConditionNode[];
+} | {
+    not: ConditionNode;
+};
+/**
+ * Whether a node is a single condition rather than `and` / `or` / `not`.
+ * @param node
+ */
+export declare const isCondition: (node: ConditionNode) => node is ParsedCondition;
+/**
+ * The tree for conditions that must all match: none gives undefined (no where clause), one gives that condition itself,
+ * several give one `and` node.
+ * @param conditions
+ */
+export declare const allOf: (conditions: ConditionNode[]) => ConditionNode | undefined;
+/**
+ * Every condition in the tree, in order, whatever group it is in.
+ * @param node
+ */
+export declare const conditionsOf: (node: ConditionNode | undefined) => ParsedCondition[];
+/**
+ * The conditions every matching row must meet on their own: the tree itself when it is one condition, or the
+ * conditions directly under its top-level `and`. Only these may narrow the rows read through an index (an `or` or a
+ * `not` doesn't require any one of its conditions).
+ * @param node
+ */
+export declare const requiredConditions: (node: ConditionNode | undefined) => ParsedCondition[];
+//# sourceMappingURL=conditionTree.d.ts.map

package/dist/data/utilities/conditionTree.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requiredConditions = exports.isCondition = exports.conditionsOf = exports.allOf = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.flat-map.js");
+/**
+ * Whether a node is a single condition rather than `and` / `or` / `not`.
+ * @param node
+ */
+const isCondition = node => !('and' in node) && !('or' in node) && !('not' in node);
+/**
+ * The tree for conditions that must all match: none gives undefined (no where clause), one gives that condition itself,
+ * several give one `and` node.
+ * @param conditions
+ */
+exports.isCondition = isCondition;
+const allOf = conditions => {
+  if (!conditions.length) {
+    return undefined;
+  }
+  return conditions.length === 1 ? conditions[0] : {
+    and: conditions
+  };
+};
+/**
+ * Every condition in the tree, in order, whatever group it is in.
+ * @param node
+ */
+exports.allOf = allOf;
+const conditionsOf = node => {
+  if (typeof node === 'undefined') {
+    return [];
+  }
+  if (isCondition(node)) {
+    return [node];
+  }
+  if ('not' in node) {
+    return conditionsOf(node.not);
+  }
+  return ('and' in node ? node.and : node.or).flatMap(conditionsOf);
+};
+/**
+ * The conditions every matching row must meet on their own: the tree itself when it is one condition, or the
+ * conditions directly under its top-level `and`. Only these may narrow the rows read through an index (an `or` or a
+ * `not` doesn't require any one of its conditions).
+ * @param node
+ */
+exports.conditionsOf = conditionsOf;
+const requiredConditions = node => {
+  if (typeof node === 'undefined') {
+    return [];
+  }
+  if (isCondition(node)) {
+    return [node];
+  }
+  return 'and' in node ? node.and.filter(isCondition) : [];
+};
+exports.requiredConditions = requiredConditions;

package/dist/data/utilities/conditionTree.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.requiredConditions=exports.isCondition=exports.conditionsOf=exports.allOf=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.flat-map.js");const isCondition=o=>!("and"in o)&&!("or"in o)&&!("not"in o);exports.isCondition=isCondition;const allOf=o=>{if(o.length)return 1===o.length?o[0]:{and:o}};exports.allOf=allOf;const conditionsOf=o=>void 0===o?[]:isCondition(o)?[o]:"not"in o?conditionsOf(o.not):("and"in o?o.and:o.or).flatMap(conditionsOf);exports.conditionsOf=conditionsOf;const requiredConditions=o=>void 0===o?[]:isCondition(o)?[o]:"and"in o?o.and.filter(isCondition):[];exports.requiredConditions=requiredConditions;

package/dist/data/utilities/getConditionIndexedList.d.ts

@@ -1,15 +1,18 @@
 import { ParsedQuery } from './parsers/parseQuery';
 /**
- * Load only the rows the indexed conditions match, and leave the other conditions for where() to apply later.
- * Conditions are joined by `and`, so a row is loaded only when every indexed condition on its entity matched it: each
- * condition narrows the files the ones before it matched. (Each indexed condition used to replace the rows of the one
- * before, so `where date = 'x' and where exercise_id = 1` returned every row with exercise_id 1, whatever its date.)
+ * Load only the candidate rows the indexes allow for the where clause (see candidatesOf): an index only narrows which
+ * rows are read. Every condition, indexed or not, stays in parsed.where and is still applied to the candidates
+ * afterwards (runQuery), so an index can make a query faster but never changes its result (where-clauses decision 3;
+ * it used to remove the conditions it answered, and the 3 bugs fixed in #69 came from that split).
+ *
+ * An indexed condition on a joined entity's field (`exercises._id = 1`) narrows that entity's rows only when every
+ * row must meet it (directly under the top-level `and`, see requiredConditions). It stays in the tree too: the where
+ * clause is then evaluated per pair of a row and a joined row (see whereTree).
  * @param parsed
  * @param recordData
  * @param dataSet
- * @param resolved - Filled with each entity whose rows were loaded here: its rows in dataSet are final (possibly none)
- * and must not be reloaded, even when other conditions are left for where() (an empty list otherwise reads as "not
- * loaded yet", see readEntity).
+ * @param resolved - Filled with each entity whose candidate rows were loaded here: they must not be reloaded (an
+ * empty list otherwise reads as "not loaded yet", see readEntity).
  */
 export declare const getConditionIndexedList: (parsed: ParsedQuery, recordData: any, dataSet: any, resolved?: Set<string>) => Promise<ParsedQuery>;
 //# sourceMappingURL=getConditionIndexedList.d.ts.map