json-fs-query 2.2.1 → 2.3.0

package/dist/data/utilities/getConditionIndexedList.js

@@ -5,8 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getConditionIndexedList = 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.for-each.js");
+require("core-js/modules/esnext.iterator.some.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");
@@ -28,47 +29,123 @@ var _splitEntityProperty = require("./parsers/splitEntityProperty");
 var _retrieveRecord = require("./retrieveRecord");
 var _where = require("../queries/where");
 var _retrieveFile = require("./retrieveFile");
-var _getMatchingIndexes = require("./getMatchingIndexes");
+var _retrieveIndexes = require("./retrieveIndexes");
+var _isSingleFieldKey = require("./isSingleFieldKey");
+var _conditionTree = require("./conditionTree");
 /**
- * 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.)
+ * The entity and field a condition is on (`exercises.name` is on exercises, `name` on the queried entity).
+ * @param condition
+ * @param mainEntity
+ */
+const conditionField = (condition, mainEntity) => (0, _isEntityProperty.isEntityProperty)(condition.property) ? (0, _splitEntityProperty.splitEntityProperty)(condition.property) : {
+  entity: mainEntity,
+  property: condition.property
+};
+/**
+ * The files an index says can match one condition, or undefined when the field has no single-field index.
+ * @param entity
+ * @param property
+ * @param condition
+ * @param recordData
+ * @param indexed - index files already read, by entity and field (each is read once per query)
+ */
+const indexedFiles = async (entity, property, condition, recordData, indexed) => {
+  if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
+    recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
+  }
+  if (!recordData[entity].keys.some(key => (0, _isSingleFieldKey.isSingleFieldKey)(key, property))) {
+    return undefined;
+  }
+  indexed[entity] = indexed[entity] || {};
+  if (!Object.prototype.hasOwnProperty.call(indexed[entity], property)) {
+    indexed[entity][property] = (await (0, _retrieveIndexes.retrieveIndexes)(entity, [property], recordData))[property];
+  }
+  return new Set((0, _where.where)(indexed[entity][property], {
+    property: 'value',
+    comparator: condition.comparator,
+    value: condition.value,
+    type: condition.type
+  }).flatMap(matchedRecord => matchedRecord.record));
+};
+/**
+ * The candidate files for a node, on the queried entity:
+ * - a condition: the files its index matches; unindexed (or on another entity): every row
+ * - `and`: the intersection of the children that narrow anything
+ * - `or`: the union, only when every branch narrows; otherwise every row
+ * - `not`: every row (its complement would have to leave out the unknown rows)
+ * @param node
+ * @param mainEntity
+ * @param recordData
+ * @param indexed
+ */
+const candidatesOf = async (node, mainEntity, recordData, indexed) => {
+  if ((0, _conditionTree.isCondition)(node)) {
+    const {
+      entity,
+      property
+    } = conditionField(node, mainEntity);
+    return entity === mainEntity ? await indexedFiles(entity, property, node, recordData, indexed) : undefined;
+  }
+  if ('not' in node) {
+    return undefined;
+  }
+  if ('or' in node) {
+    const union = new Set();
+    for (const child of node.or) {
+      const files = await candidatesOf(child, mainEntity, recordData, indexed);
+      if (typeof files === 'undefined') {
+        return undefined;
+      }
+      files.forEach(file => union.add(file));
+    }
+    return union;
+  }
+  let intersection;
+  for (const child of node.and) {
+    const files = await candidatesOf(child, mainEntity, recordData, indexed);
+    if (typeof files !== 'undefined') {
+      intersection = typeof intersection === 'undefined' ? files : new Set([...intersection].filter(file => files.has(file)));
+    }
+  }
+  return intersection;
+};
+/**
+ * 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).
  */
 const getConditionIndexedList = async (parsed, recordData, dataSet, resolved = new Set()) => {
-  const reducedConditions = [];
   const matchedFiles = {};
   const indexed = {};
-  for (const condition of parsed.conditions) {
-    let entity = parsed.entity;
-    let property = condition.property;
-    if ((0, _isEntityProperty.isEntityProperty)(property)) {
-      const entityProperty = (0, _splitEntityProperty.splitEntityProperty)(property);
-      entity = entityProperty.entity;
-      property = entityProperty.property;
+  if (typeof parsed.where !== 'undefined') {
+    const candidates = await candidatesOf(parsed.where, parsed.entity, recordData, indexed);
+    if (typeof candidates !== 'undefined') {
+      matchedFiles[parsed.entity] = candidates;
     }
-    if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
-      recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
+  }
+  for (const condition of (0, _conditionTree.requiredConditions)(parsed.where)) {
+    const {
+      entity,
+      property
+    } = conditionField(condition, parsed.entity);
+    if (entity === parsed.entity) {
+      continue;
     }
-    const narrowMatchedFiles = async (entity, property, recordData, condition, dataSet, indexed) => {
-      const files = new Set((0, _where.where)(indexed[entity][property], {
-        property: 'value',
-        comparator: condition.comparator,
-        value: condition.value,
-        type: condition.type
-      }).flatMap(matchedRecord => matchedRecord.record));
-      matchedFiles[entity] = Object.prototype.hasOwnProperty.call(matchedFiles, entity) ? matchedFiles[entity].filter(file => files.has(file)) : [...files];
-    };
-    const isIndexed = await (0, _getMatchingIndexes.getMatchingIndexes)(entity, property, recordData, condition, dataSet, indexed, narrowMatchedFiles);
-    if (!isIndexed) {
-      reducedConditions.push(condition);
+    const files = await indexedFiles(entity, property, condition, recordData, indexed);
+    if (typeof files === 'undefined') {
+      continue;
     }
+    matchedFiles[entity] = Object.prototype.hasOwnProperty.call(matchedFiles, entity) ? new Set([...matchedFiles[entity]].filter(file => files.has(file))) : files;
   }
   for (const entity of Object.keys(matchedFiles)) {
     resolved.add(entity);
@@ -77,7 +154,6 @@ const getConditionIndexedList = async (parsed, recordData, dataSet, resolved = n
       dataSet[entity].push(await (0, _retrieveFile.retrieveFile)(`${entity}/${file}`));
     }
   }
-  parsed.conditions = reducedConditions;
   return parsed;
 };
 exports.getConditionIndexedList = getConditionIndexedList;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getConditionIndexedList=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.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"),_retrieveRecord=require("./retrieveRecord"),_where=require("../queries/where"),_retrieveFile=require("./retrieveFile"),_getMatchingIndexes=require("./getMatchingIndexes");const getConditionIndexedList=async(e,r,t,s=new Set)=>{const o=[],i={},n={};for(const s of e.conditions){let u=e.entity,c=s.property;if((0,_isEntityProperty.isEntityProperty)(c)){const e=(0,_splitEntityProperty.splitEntityProperty)(c);u=e.entity,c=e.property}Object.prototype.hasOwnProperty.call(r,u)||(r[u]=await(0,_retrieveRecord.retrieveRecord)(u));const d=async(e,r,t,s,o,n)=>{const u=new Set((0,_where.where)(n[e][r],{property:"value",comparator:s.comparator,value:s.value,type:s.type}).flatMap((e=>e.record)));i[e]=Object.prototype.hasOwnProperty.call(i,e)?i[e].filter((e=>u.has(e))):[...u]};await(0,_getMatchingIndexes.getMatchingIndexes)(u,c,r,s,t,n,d)||o.push(s)}for(const e of Object.keys(i)){s.add(e),t[e]=[];for(const r of i[e])t[e].push(await(0,_retrieveFile.retrieveFile)(`${e}/${r}`))}return e.conditions=o,e};exports.getConditionIndexedList=getConditionIndexedList;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getConditionIndexedList=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.flat-map.js"),require("core-js/modules/esnext.iterator.for-each.js"),require("core-js/modules/esnext.iterator.some.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"),_retrieveRecord=require("./retrieveRecord"),_where=require("../queries/where"),_retrieveFile=require("./retrieveFile"),_retrieveIndexes=require("./retrieveIndexes"),_isSingleFieldKey=require("./isSingleFieldKey"),_conditionTree=require("./conditionTree");const conditionField=(e,r)=>(0,_isEntityProperty.isEntityProperty)(e.property)?(0,_splitEntityProperty.splitEntityProperty)(e.property):{entity:r,property:e.property},indexedFiles=async(e,r,t,s,i)=>{if(Object.prototype.hasOwnProperty.call(s,e)||(s[e]=await(0,_retrieveRecord.retrieveRecord)(e)),s[e].keys.some((e=>(0,_isSingleFieldKey.isSingleFieldKey)(e,r))))return i[e]=i[e]||{},Object.prototype.hasOwnProperty.call(i[e],r)||(i[e][r]=(await(0,_retrieveIndexes.retrieveIndexes)(e,[r],s))[r]),new Set((0,_where.where)(i[e][r],{property:"value",comparator:t.comparator,value:t.value,type:t.type}).flatMap((e=>e.record)))},candidatesOf=async(e,r,t,s)=>{if((0,_conditionTree.isCondition)(e)){const{entity:i,property:o}=conditionField(e,r);return i===r?await indexedFiles(i,o,e,t,s):void 0}if("not"in e)return;if("or"in e){const i=new Set;for(const o of e.or){const e=await candidatesOf(o,r,t,s);if(void 0===e)return;e.forEach((e=>i.add(e)))}return i}let i;for(const o of e.and){const e=await candidatesOf(o,r,t,s);void 0!==e&&(i=void 0===i?e:new Set([...i].filter((r=>e.has(r)))))}return i},getConditionIndexedList=async(e,r,t,s=new Set)=>{const i={},o={};if(void 0!==e.where){const t=await candidatesOf(e.where,e.entity,r,o);void 0!==t&&(i[e.entity]=t)}for(const t of(0,_conditionTree.requiredConditions)(e.where)){const{entity:s,property:n}=conditionField(t,e.entity);if(s===e.entity)continue;const d=await indexedFiles(s,n,t,r,o);void 0!==d&&(i[s]=Object.prototype.hasOwnProperty.call(i,s)?new Set([...i[s]].filter((e=>d.has(e)))):d)}for(const e of Object.keys(i)){s.add(e),t[e]=[];for(const r of i[e])t[e].push(await(0,_retrieveFile.retrieveFile)(`${e}/${r}`))}return e};exports.getConditionIndexedList=getConditionIndexedList;

package/dist/data/utilities/parsers/findConditions.d.ts

@@ -8,13 +8,15 @@ export type ParsedCondition = {
     type?: string;
 };
 /**
- * Extract condition clauses from the query: `where <field> <comparator> <value>`, or `where <field> is null`,
- * `is not null`, `exists` or `does not exist` (no value), each further one joined with `and where`. A comparison
- * with the literal null (`= null`) is refused: it would never match, as null equals nothing (see where). `or where` is refused until or is built (TASKS: the where-clauses epic): it used to be read the same as
- * `and where`, which silently returned the wrong rows.
+ * Extract the where clause from the query into a tree (see ConditionNode): `where` followed by conditions joined with
+ * `and` / `or`, `not`, and brackets, nested to any depth. Each condition is `<field> <comparator> <value>`, or
+ * `<field> is null`, `is not null`, `exists` or `does not exist`. A comparison with the literal null (`= null`) is
+ * refused: it would never match, as null equals nothing (see where). The expression ends at the next clause keyword
+ * outside brackets, so clauses may come in any order; several separate `where`s (or `and where` after another clause)
+ * are joined with `and`, as before.
  * @param parsed
  * @param query
- * @throws {Error} For `or where`, and for a comparison with null.
+ * @throws {Error} For the errors readExpression and readCondition describe, and `or where` after another clause.
  */
 export declare const findConditions: (parsed: ParsedQuery, query: string) => string;
 //# sourceMappingURL=findConditions.d.ts.map

package/dist/data/utilities/parsers/findConditions.js

@@ -5,50 +5,178 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.findConditions = void 0;
 require("core-js/modules/es.array.includes.js");
-var _removeFromQuery = require("./removeFromQuery");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.flat-map.js");
 var _parseLiteralValue = require("./parseLiteralValue");
+var _conditionTree = require("../conditionTree");
 var _maskStrings = require("./maskStrings");
-// `and`/`or`/`where` count only as whole words: in `on t.x = u.color where ...` the `or` is part of the name `color`
-const conditionMatch = new RegExp(`(^|[^a-z0-9._-])(?:(and|or)\\s+)?(where)\\s+([a-z0-9_-]+\\.?[a-z0-9_-]*)\\s+(?:(is\\s+not\\s+null|is\\s+null|exists|does\\s+not\\s+exist)(?![a-z0-9_.-])|(=|!=|>|<|>=|<=|in|between|like)\\s+(${_maskStrings.placeholderSource}|(${_parseLiteralValue.numberSource})|${_maskStrings.arraySource}|(null)|(true)|(false)))`, 'ig');
+// Keywords count only as whole words: in `on t.x = u.color where ...` the `or` is part of the name `color`
+const wordEnd = '(?![a-z0-9_.-])';
+const keyword = words => new RegExp(`^(?:${words})${wordEnd}`, 'i');
+// One condition, at the start of the text: a field, then `is [not] null` / `exists` / `does not exist`, or a comparator
+// and a value (strings and arrays are placeholders by then, see maskStrings)
+const conditionMatch = new RegExp(`^([a-z0-9_-]+\\.?[a-z0-9_-]*)\\s+(?:(is\\s+not\\s+null|is\\s+null|exists|does\\s+not\\s+exist)${wordEnd}|(<>|!=|>=|<=|=|>|<|in|between|like)\\s+(${_maskStrings.placeholderSource}|(${_parseLiteralValue.numberSource})|${_maskStrings.arraySource}|(null)|(true)|(false)))`, 'i');
+// The clause keywords that end a where expression (outside brackets), and `and on` (a join clause's own `and`)
+const expressionEnd = keyword('sort|group|limit|offset|select|merge|on|where|and\\s+on');
+const whereMatch = new RegExp(`(^|[^a-z0-9._-])((?:(and|or)\\s+)?where)${wordEnd}`, 'i');
 /**
- * Extract condition clauses from the query: `where <field> <comparator> <value>`, or `where <field> is null`,
- * `is not null`, `exists` or `does not exist` (no value), each further one joined with `and where`. A comparison
- * with the literal null (`= null`) is refused: it would never match, as null equals nothing (see where). `or where` is refused until or is built (TASKS: the where-clauses epic): it used to be read the same as
- * `and where`, which silently returned the wrong rows.
- * @param parsed
- * @param query
- * @throws {Error} For `or where`, and for a comparison with null.
+ * Read one condition from a match of conditionMatch.
+ * @param match
+ * @throws {Error} For a comparison with null, and a null between bound: they could never match (null equals nothing).
  */
-const findConditions = (parsed, query) => {
-  const conditionsFound = query.matchAll(conditionMatch);
-  // @ts-ignore
-  for (const condition of conditionsFound) {
-    if (typeof condition[2] !== 'undefined' && condition[2].toLowerCase() === 'or') {
-      throw new Error('`or where` is not supported yet: use `and where`, or run one query per alternative');
+const readCondition = match => {
+  const property = match[1];
+  if (typeof match[2] !== 'undefined') {
+    return {
+      property,
+      comparator: match[2].toLowerCase().replace(/\s+/g, ' '),
+      value: null
+    };
+  }
+  const comparator = match[3].toLowerCase();
+  const value = (0, _parseLiteralValue.parseLiteralValue)(match, 5);
+  if (value === null) {
+    throw new Error(`\`${property} ${comparator} null\` never matches (null equals nothing, as in SQL): use \`${property} is null\` or \`${property} is not null\``);
+  }
+  if (comparator === 'between' && Array.isArray(value) && value.includes(null)) {
+    throw new Error(`\`${property} between\` can't have a null bound: it would never match`);
+  }
+  return {
+    property,
+    comparator,
+    value
+  };
+};
+/**
+ * Join nodes with `and` or `or`, flattening a child of the same kind into its parent (`a and (b and c)` is one `and` of
+ * three), so the conditions every row must meet are all directly under the top-level `and` (see requiredConditions).
+ * @param kind
+ * @param nodes
+ */
+const join = (kind, nodes) => {
+  const children = nodes.flatMap(node => !(0, _conditionTree.isCondition)(node) && kind in node ? node[kind] : [node]);
+  return children.length === 1 ? children[0] : kind === 'and' ? {
+    and: children
+  } : {
+    or: children
+  };
+};
+/**
+ * Read one where expression from the masked query, starting at `start` (just after its `where`). Precedence, loosest
+ * first: `or`, `and`, `not`; brackets group. `and where` / `or where` are the older spellings of `and` / `or`.
+ * @param text
+ * @param start
+ * @returns The expression's tree and where it ends (the next clause keyword outside brackets, or the end).
+ * @throws {Error} For an unbalanced bracket, empty brackets, or an operator with no condition after it.
+ */
+const readExpression = (text, start) => {
+  let at = start;
+  const rest = () => text.slice(at);
+  const skipSpace = () => {
+    at += rest().length - rest().trimStart().length;
+  };
+  const take = pattern => {
+    skipSpace();
+    const found = rest().match(pattern);
+    if (!found) {
+      return undefined;
+    }
+    at += found[0].length;
+    return found[0];
+  };
+  const shown = () => (0, _maskStrings.unmaskStrings)(rest().trim(), '\'');
+  const factor = after => {
+    skipSpace();
+    // A condition first, so a field named like a keyword (`not = 1`, `exists exists`) still reads as a field
+    const condition = rest().match(conditionMatch);
+    if (condition) {
+      at += condition[0].length;
+      return readCondition(condition);
+    }
+    if (take(keyword('not'))) {
+      return {
+        not: factor('not')
+      };
     }
-    if (typeof condition[5] !== 'undefined') {
-      parsed['conditions'].push({
-        property: condition[4],
-        comparator: condition[5].toLowerCase().replace(/\s+/g, ' '),
-        value: null
-      });
-    } else {
-      const value = (0, _parseLiteralValue.parseLiteralValue)(condition, 8);
-      if (value === null) {
-        throw new Error(`\`${condition[4]} ${condition[6]} null\` never matches (null equals nothing, as in SQL): use \`${condition[4]} is null\` or \`${condition[4]} is not null\``);
+    if (take(/^\(/)) {
+      skipSpace();
+      if (rest().startsWith(')')) {
+        throw new Error('Empty brackets in a where clause');
       }
-      if (condition[6].toLowerCase() === 'between' && Array.isArray(value) && value.includes(null)) {
-        throw new Error(`\`${condition[4]} between\` can't have a null bound: it would never match`);
+      const node = expression('(');
+      // The query scanner already refuses unbalanced brackets (scanQuery); this guards a direct call
+      if (!take(/^\)/)) {
+        throw new Error(`Missing ) ${rest().trim() ? `before: ${shown()}` : 'at the end of the where clause'}`);
       }
-      parsed['conditions'].push({
-        property: condition[4],
-        comparator: condition[6],
-        value
-      });
+      return node;
+    }
+    throw new Error(`Missing a condition after ${after}${rest().trim() ? `: ${shown()}` : ''}`);
+  };
+  const term = after => {
+    const nodes = [factor(after)];
+    for (;;) {
+      skipSpace();
+      if (keyword('and\\s+on').test(rest())) {
+        break;
+      }
+      const connector = take(keyword('and(?:\\s+where)?'));
+      if (!connector) {
+        break;
+      }
+      nodes.push(factor(connector.toLowerCase().replace(/\s+/g, ' ')));
+    }
+    return join('and', nodes);
+  };
+  const expression = after => {
+    const nodes = [term(after)];
+    for (;;) {
+      const connector = take(keyword('or(?:\\s+where)?'));
+      if (!connector) {
+        break;
+      }
+      nodes.push(term(connector.toLowerCase().replace(/\s+/g, ' ')));
+    }
+    return join('or', nodes);
+  };
+  const node = expression('where');
+  skipSpace();
+  if (rest().startsWith(')')) {
+    throw new Error(`Unexpected ) in a where clause: ${shown()}`);
+  }
+  if (rest() && !expressionEnd.test(rest()) && conditionMatch.test(rest())) {
+    throw new Error(`Missing and/or before: ${shown()}`);
+  }
+  return {
+    node,
+    end: at
+  };
+};
+/**
+ * Extract the where clause from the query into a tree (see ConditionNode): `where` followed by conditions joined with
+ * `and` / `or`, `not`, and brackets, nested to any depth. Each condition is `<field> <comparator> <value>`, or
+ * `<field> is null`, `is not null`, `exists` or `does not exist`. A comparison with the literal null (`= null`) is
+ * refused: it would never match, as null equals nothing (see where). The expression ends at the next clause keyword
+ * outside brackets, so clauses may come in any order; several separate `where`s (or `and where` after another clause)
+ * are joined with `and`, as before.
+ * @param parsed
+ * @param query
+ * @throws {Error} For the errors readExpression and readCondition describe, and `or where` after another clause.
+ */
+const findConditions = (parsed, query) => {
+  const expressions = [];
+  for (let found = query.match(whereMatch); found; found = query.match(whereMatch)) {
+    if ((found[3] || '').toLowerCase() === 'or') {
+      throw new Error('`or where` must follow the conditions it joins: put them in one where clause');
     }
-    // Leave out the character before the condition (group 1): it isn't part of it, and an earlier removal may have trimmed it
-    query = (0, _removeFromQuery.removeFromQuery)(condition[0].slice(condition[1].length), query);
+    const whereStart = found.index + found[1].length;
+    const {
+      node,
+      end
+    } = readExpression(query, whereStart + found[2].length);
+    expressions.push(node);
+    query = `${query.slice(0, whereStart)} ${query.slice(end)}`.replace(/\s+/g, ' ').trim();
   }
+  parsed['where'] = expressions.length ? join('and', expressions) : (0, _conditionTree.allOf)([]);
   return query;
 };
 exports.findConditions = findConditions;

package/dist/data/utilities/parsers/findConditions.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.findConditions=void 0,require("core-js/modules/es.array.includes.js");var _removeFromQuery=require("./removeFromQuery"),_parseLiteralValue=require("./parseLiteralValue"),_maskStrings=require("./maskStrings");const conditionMatch=new RegExp(`(^|[^a-z0-9._-])(?:(and|or)\\s+)?(where)\\s+([a-z0-9_-]+\\.?[a-z0-9_-]*)\\s+(?:(is\\s+not\\s+null|is\\s+null|exists|does\\s+not\\s+exist)(?![a-z0-9_.-])|(=|!=|>|<|>=|<=|in|between|like)\\s+(${_maskStrings.placeholderSource}|(${_parseLiteralValue.numberSource})|${_maskStrings.arraySource}|(null)|(true)|(false)))`,"ig"),findConditions=(e,r)=>{const o=r.matchAll(conditionMatch);for(const n of o){if(void 0!==n[2]&&"or"===n[2].toLowerCase())throw new Error("`or where` is not supported yet: use `and where`, or run one query per alternative");if(void 0!==n[5])e.conditions.push({property:n[4],comparator:n[5].toLowerCase().replace(/\s+/g," "),value:null});else{const r=(0,_parseLiteralValue.parseLiteralValue)(n,8);if(null===r)throw new Error(`\`${n[4]} ${n[6]} null\` never matches (null equals nothing, as in SQL): use \`${n[4]} is null\` or \`${n[4]} is not null\``);if("between"===n[6].toLowerCase()&&Array.isArray(r)&&r.includes(null))throw new Error(`\`${n[4]} between\` can't have a null bound: it would never match`);e.conditions.push({property:n[4],comparator:n[6],value:r})}r=(0,_removeFromQuery.removeFromQuery)(n[0].slice(n[1].length),r)}return r};exports.findConditions=findConditions;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.findConditions=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.flat-map.js");var _parseLiteralValue=require("./parseLiteralValue"),_conditionTree=require("../conditionTree"),_maskStrings=require("./maskStrings");const wordEnd="(?![a-z0-9_.-])",keyword=e=>new RegExp(`^(?:${e})${wordEnd}`,"i"),conditionMatch=new RegExp(`^([a-z0-9_-]+\\.?[a-z0-9_-]*)\\s+(?:(is\\s+not\\s+null|is\\s+null|exists|does\\s+not\\s+exist)${wordEnd}|(<>|!=|>=|<=|=|>|<|in|between|like)\\s+(${_maskStrings.placeholderSource}|(${_parseLiteralValue.numberSource})|${_maskStrings.arraySource}|(null)|(true)|(false)))`,"i"),expressionEnd=keyword("sort|group|limit|offset|select|merge|on|where|and\\s+on"),whereMatch=new RegExp(`(^|[^a-z0-9._-])((?:(and|or)\\s+)?where)${wordEnd}`,"i"),readCondition=e=>{const r=e[1];if(void 0!==e[2])return{property:r,comparator:e[2].toLowerCase().replace(/\s+/g," "),value:null};const n=e[3].toLowerCase(),t=(0,_parseLiteralValue.parseLiteralValue)(e,5);if(null===t)throw new Error(`\`${r} ${n} null\` never matches (null equals nothing, as in SQL): use \`${r} is null\` or \`${r} is not null\``);if("between"===n&&Array.isArray(t)&&t.includes(null))throw new Error(`\`${r} between\` can't have a null bound: it would never match`);return{property:r,comparator:n,value:t}},join=(e,r)=>{const n=r.flatMap((r=>!(0,_conditionTree.isCondition)(r)&&e in r?r[e]:[r]));return 1===n.length?n[0]:"and"===e?{and:n}:{or:n}},readExpression=(e,r)=>{let n=r;const t=()=>e.slice(n),o=()=>{n+=t().length-t().trimStart().length},s=e=>{o();const r=t().match(e);if(r)return n+=r[0].length,r[0]},i=()=>(0,_maskStrings.unmaskStrings)(t().trim(),"'"),a=e=>{o();const r=t().match(conditionMatch);if(r)return n+=r[0].length,readCondition(r);if(s(keyword("not")))return{not:a("not")};if(s(/^\(/)){if(o(),t().startsWith(")"))throw new Error("Empty brackets in a where clause");const e=d("(");if(!s(/^\)/))throw new Error("Missing ) "+(t().trim()?`before: ${i()}`:"at the end of the where clause"));return e}throw new Error(`Missing a condition after ${e}${t().trim()?`: ${i()}`:""}`)},l=e=>{const r=[a(e)];for(;o(),!keyword("and\\s+on").test(t());){const e=s(keyword("and(?:\\s+where)?"));if(!e)break;r.push(a(e.toLowerCase().replace(/\s+/g," ")))}return join("and",r)},d=e=>{const r=[l(e)];for(;;){const e=s(keyword("or(?:\\s+where)?"));if(!e)break;r.push(l(e.toLowerCase().replace(/\s+/g," ")))}return join("or",r)},c=d("where");if(o(),t().startsWith(")"))throw new Error(`Unexpected ) in a where clause: ${i()}`);if(t()&&!expressionEnd.test(t())&&conditionMatch.test(t()))throw new Error(`Missing and/or before: ${i()}`);return{node:c,end:n}},findConditions=(e,r)=>{const n=[];for(let e=r.match(whereMatch);e;e=r.match(whereMatch)){if("or"===(e[3]||"").toLowerCase())throw new Error("`or where` must follow the conditions it joins: put them in one where clause");const t=e.index+e[1].length,{node:o,end:s}=readExpression(r,t+e[2].length);n.push(o),r=`${r.slice(0,t)} ${r.slice(s)}`.replace(/\s+/g," ").trim()}return e.where=n.length?join("and",n):(0,_conditionTree.allOf)([]),r};exports.findConditions=findConditions;

package/dist/data/utilities/parsers/parseQuery.d.ts

@@ -3,7 +3,7 @@ import { ParsedInsertRow } from './findInsertValues';
 import { ParsedUpdateValues } from './findUpdateValues';
 import { ParsedJoinEntity } from './findJoinEntity';
 import { ParsedSelect } from './findSelects';
-import { ParsedCondition } from './findConditions';
+import { ConditionNode } from '../conditionTree';
 import { ParsedJoinClause } from './findJoinClauses';
 import { ParsedMergeJoin } from './findMergeJoins';
 import { ParsedSortClause } from './findSortClauses';
@@ -18,7 +18,7 @@ export type ParsedQuery = {
     selectClauses: ParsedSelect[];
     insertValues: ParsedInsertRow[];
     updateValues: ParsedUpdateValues;
-    conditions: ParsedCondition[];
+    where: ConditionNode | undefined;
     joinClauses: ParsedJoinClause[];
     mergeJoins: ParsedMergeJoin[];
     sortClauses: ParsedSortClause[];

package/dist/data/utilities/parsers/parseQuery.js

@@ -34,7 +34,7 @@ const parseQuery = query => {
     selectClauses: [],
     insertValues: [],
     updateValues: {},
-    conditions: [],
+    where: undefined,
     joinClauses: [],
     mergeJoins: [],
     sortClauses: [],

package/dist/data/utilities/parsers/parseQuery.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseQuery=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_findCommand=require("./findCommand"),_findInsertValues=require("./findInsertValues"),_findUpdateValues=require("./findUpdateValues"),_findJoinEntity=require("./findJoinEntity"),_findSelects=require("./findSelects"),_findConditions=require("./findConditions"),_findJoinClauses=require("./findJoinClauses"),_findMergeJoins=require("./findMergeJoins"),_findSortClauses=require("./findSortClauses"),_findGroupBy=require("./findGroupBy"),_findLimit=require("./findLimit"),_findOffset=require("./findOffset"),_maskStrings=require("./maskStrings"),_parseCreate=require("./parseCreate"),_parseSchemaStatement=require("./parseSchemaStatement"),_startsQuery=require("./startsQuery");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const parseQuery=e=>{const i={command:void 0,entity:void 0,joinEntity:void 0,selectClauses:[],insertValues:[],updateValues:{},conditions:[],joinClauses:[],mergeJoins:[],sortClauses:[],groupBy:void 0,limit:void 0,offset:void 0,create:void 0,ifExists:void 0},{curry:n,pipe:r}=_siFunciona.default;if(e=(0,_maskStrings.maskArrays)((0,_maskStrings.maskStrings)(e)),_parseCreate.createMatch.test(e)){const{entity:n,create:r}=(0,_parseCreate.parseCreate)(e);return Object.assign(i,{command:"create",entity:n,create:r})}if(_parseSchemaStatement.schemaStatementMatch.test(e))return Object.assign(i,(0,_parseSchemaStatement.parseSchemaStatement)(e));if(e=r(n(_findCommand.findCommand)(i),n(_findInsertValues.findInsertValues)(i),n(_findUpdateValues.findUpdateValues)(i),n(_findJoinEntity.findJoinEntity)(i),n(_findSelects.findSelects)(i),n(_findConditions.findConditions)(i),n(_findJoinClauses.findJoinClauses)(i),n(_findMergeJoins.findMergeJoins)(i),n(_findSortClauses.findSortClauses)(i),n(_findGroupBy.findGroupBy)(i),n(_findLimit.findLimit)(i),n(_findOffset.findOffset)(i))(e)){if(_startsQuery.startsQueryMatch.test(e))throw new Error(`Missing ; before: ${(0,_maskStrings.unmaskStrings)(e.trim(),"'")}`);throw new Error(`Unrecognized query value: ${(0,_maskStrings.unmaskStrings)(e,"'")}`)}return i};exports.parseQuery=parseQuery;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseQuery=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_findCommand=require("./findCommand"),_findInsertValues=require("./findInsertValues"),_findUpdateValues=require("./findUpdateValues"),_findJoinEntity=require("./findJoinEntity"),_findSelects=require("./findSelects"),_findConditions=require("./findConditions"),_findJoinClauses=require("./findJoinClauses"),_findMergeJoins=require("./findMergeJoins"),_findSortClauses=require("./findSortClauses"),_findGroupBy=require("./findGroupBy"),_findLimit=require("./findLimit"),_findOffset=require("./findOffset"),_maskStrings=require("./maskStrings"),_parseCreate=require("./parseCreate"),_parseSchemaStatement=require("./parseSchemaStatement"),_startsQuery=require("./startsQuery");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const parseQuery=e=>{const i={command:void 0,entity:void 0,joinEntity:void 0,selectClauses:[],insertValues:[],updateValues:{},where:void 0,joinClauses:[],mergeJoins:[],sortClauses:[],groupBy:void 0,limit:void 0,offset:void 0,create:void 0,ifExists:void 0},{curry:r,pipe:n}=_siFunciona.default;if(e=(0,_maskStrings.maskArrays)((0,_maskStrings.maskStrings)(e)),_parseCreate.createMatch.test(e)){const{entity:r,create:n}=(0,_parseCreate.parseCreate)(e);return Object.assign(i,{command:"create",entity:r,create:n})}if(_parseSchemaStatement.schemaStatementMatch.test(e))return Object.assign(i,(0,_parseSchemaStatement.parseSchemaStatement)(e));if(e=n(r(_findCommand.findCommand)(i),r(_findInsertValues.findInsertValues)(i),r(_findUpdateValues.findUpdateValues)(i),r(_findJoinEntity.findJoinEntity)(i),r(_findSelects.findSelects)(i),r(_findConditions.findConditions)(i),r(_findJoinClauses.findJoinClauses)(i),r(_findMergeJoins.findMergeJoins)(i),r(_findSortClauses.findSortClauses)(i),r(_findGroupBy.findGroupBy)(i),r(_findLimit.findLimit)(i),r(_findOffset.findOffset)(i))(e)){if(_startsQuery.startsQueryMatch.test(e))throw new Error(`Missing ; before: ${(0,_maskStrings.unmaskStrings)(e.trim(),"'")}`);throw new Error(`Unrecognized query value: ${(0,_maskStrings.unmaskStrings)(e,"'")}`)}return i};exports.parseQuery=parseQuery;

package/dist/data/utilities/runQuery.js

@@ -4,9 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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");
 require("core-js/modules/esnext.set.difference.js");
@@ -44,6 +41,8 @@ var _getJoinIndexedList = require("./getJoinIndexedList");
 var _isEntityProperty = require("./parsers/isEntityProperty");
 var _splitEntityProperty = require("./parsers/splitEntityProperty");
 var _fieldType = require("./fieldType");
+var _conditionTree = require("./conditionTree");
+var _conditionEntities = require("./conditionEntities");
 /**
  * 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).
@@ -51,7 +50,7 @@ var _fieldType = require("./fieldType");
  * @param recordData
  */
 const typeClauses = async (parsed, recordData) => {
-  for (const clause of [...parsed.conditions, ...parsed.sortClauses]) {
+  for (const clause of [...(0, _conditionTree.conditionsOf)(parsed.where), ...parsed.sortClauses]) {
     let entity = parsed.entity;
     let property = clause.property;
     if ((0, _isEntityProperty.isEntityProperty)(property)) {
@@ -67,6 +66,8 @@ const typeClauses = async (parsed, recordData) => {
   }
 };
 const runQuery = async parsed => {
+  // Checked before anything is read: which entity each condition is on, and whether it needs per-pair evaluation
+  const perPair = typeof parsed.where !== 'undefined' && (0, _conditionEntities.conditionEntities)(parsed);
   // Schema statements act on the database, not on entries (for create there is no record to read yet)
   switch (parsed.command) {
     case 'create':
@@ -86,16 +87,6 @@ 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)
   };
@@ -109,7 +100,7 @@ const runQuery = async parsed => {
   // An indexed condition that matches nothing leaves dataSet[entity] at [] - the same state it starts in before
   // anything has looked at it at all. readEntity() (below) can't tell those two states apart on its own (it reloads
   // whenever the array is empty), so getConditionIndexedList reports which entities it resolved: once any indexed
-  // condition has narrowed entity's rows, they are final (the conditions left over are applied to them below) and
+  // condition has narrowed entity's rows, they are the candidates (every condition is applied to them below) and
   // must not be reloaded. This used to ask whether EVERY condition was indexed, so `where date = 'none' and where
   // reps = 10` reloaded every row and returned, updated or deleted all rows with reps 10.
   const resolved = new Set();
@@ -118,13 +109,13 @@ const runQuery = async parsed => {
   parsed = await (0, _getJoinIndexedList.getJoinIndexedList)(parsed, recordData, dataSet);
   // delete/update act on whatever is already in dataSet[entity] - unlike read, which loads
   // everything and lets the where-reduce below narrow it down afterward, they never get a second
-  // pass. So the matching rows have to be fully resolved (indexed conditions already are, via
-  // getConditionIndexedList above; anything left in parsed.conditions is not) before either runs.
+  // pass. So every condition is applied to the candidates (all rows, or the ones the indexes picked)
+  // before either runs.
   if (parsed.command === 'delete' || parsed.command === 'update') {
     if (!entityResolved) {
       dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet);
     }
-    dataSet[parsed.entity] = parsed.conditions.reduce((remainingData, condition) => (0, _where.where)(remainingData, condition), dataSet[parsed.entity]);
+    dataSet[parsed.entity] = (0, _where.whereTree)(dataSet[parsed.entity], parsed.where);
   }
   switch (parsed.command) {
     case 'delete':
@@ -144,16 +135,14 @@ const runQuery = async parsed => {
     default:
       throw new Error(`Unknown command: ${parsed.command}`);
   }
-  dataSet = await (0, _joinEntity.joinEntity)(parsed.entity, parsed.joinEntity, dataSet, parsed.joinClauses, entityResolved);
+  dataSet = await (0, _joinEntity.joinEntity)(parsed.entity, parsed.joinEntity, dataSet, parsed.joinClauses, entityResolved, resolved.has(parsed.joinEntity));
   dataSet = await (0, _mergeJoins.mergeJoins)(dataSet, parsed.mergeJoins);
-  // delete/update already had parsed.conditions applied above, before they ran. Re-applying the
+  // delete/update already had parsed.where applied above, before they ran. Re-applying the
   // same conditions here would be wrong, not just redundant, for update specifically: if the
   // update just changed the very field a condition filters on, re-checking that condition against
   // the now-changed data would filter the just-updated rows back out.
   if (parsed.command !== 'delete' && parsed.command !== 'update') {
-    dataSet[parsed.entity] = parsed.conditions.reduce((remainingData, condition) => {
-      return (0, _where.where)(remainingData, condition);
-    }, dataSet[parsed.entity]);
+    dataSet[parsed.entity] = (0, _where.whereTree)(dataSet[parsed.entity], parsed.where, perPair ? parsed.joinEntity : undefined);
   }
   dataSet[parsed.entity] = (0, _sortBy.sortBy)(dataSet[parsed.entity], parsed.sortClauses);
   dataSet[parsed.entity] = (0, _limitOffset.limitOffset)(dataSet[parsed.entity], parsed.offset, parsed.limit);

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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"),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 _deleteEntity=require("../queries/deleteEntity"),_insertEntity=require("../queries/insertEntity"),_readEntity=require("../queries/readEntity"),_updateEntity=require("../queries/updateEntity"),_createRecord=require("../queries/createRecord"),_dropRecord=require("../queries/dropRecord"),_describeRecord=require("../queries/describeRecord"),_showRecords=require("../queries/showRecords"),_joinEntity=require("../queries/joinEntity"),_mergeJoins=require("../queries/mergeJoins"),_where=require("../queries/where"),_sortBy=require("../queries/sortBy"),_groupBy=require("../queries/groupBy"),_limitOffset=require("../queries/limitOffset"),_selectFields=require("../queries/selectFields"),_retrieveRecord=require("./retrieveRecord"),_getConditionIndexedList=require("./getConditionIndexedList"),_getJoinIndexedList=require("./getJoinIndexedList"),_isEntityProperty=require("./parsers/isEntityProperty"),_splitEntityProperty=require("./parsers/splitEntityProperty"),_fieldType=require("./fieldType");const typeClauses=async(e,t)=>{for(const r of[...e.conditions,...e.sortClauses]){let i=e.entity,s=r.property;(0,_isEntityProperty.isEntityProperty)(s)&&({entity:i,property:s}=(0,_splitEntityProperty.splitEntityProperty)(s)),Object.prototype.hasOwnProperty.call(t,i)||(t[i]=await(0,_retrieveRecord.retrieveRecord)(i)),r.type=(0,_fieldType.fieldType)(t[i],s)}},runQuery=async e=>{switch(e.command){case"create":return{[e.entity]:await(0,_createRecord.createRecord)(e.entity,e.create)};case"drop":return{[e.entity]:await(0,_dropRecord.dropRecord)(e.entity,e.ifExists)};case"describe":return{[e.entity]:await(0,_describeRecord.describeRecord)(e.entity)};case"show":return{[e.entity]:await(0,_showRecords.showRecords)()}}if("update"===e.command||"delete"===e.command){const t=e.conditions.find((t=>(0,_isEntityProperty.isEntityProperty)(t.property)&&(0,_splitEntityProperty.splitEntityProperty)(t.property).entity!==e.entity));if(t)throw new Error(`${e.command} can only use conditions on ${e.entity}'s own fields, not ${t.property}`)}const t={[e.entity]:await(0,_retrieveRecord.retrieveRecord)(e.entity)};void 0!==e.joinEntity&&(t[e.joinEntity]=await(0,_retrieveRecord.retrieveRecord)(e.joinEntity)),await typeClauses(e,t);let r={[e.entity]:[]};const i=new Set;e=await(0,_getConditionIndexedList.getConditionIndexedList)(e,t,r,i);const s=i.has(e.entity);switch("delete"!==(e=await(0,_getJoinIndexedList.getJoinIndexedList)(e,t,r)).command&&"update"!==e.command||(s||(r=await(0,_readEntity.readEntity)(e.entity,r)),r[e.entity]=e.conditions.reduce(((e,t)=>(0,_where.where)(e,t)),r[e.entity])),e.command){case"delete":r=await(0,_deleteEntity.deleteEntity)(e.entity,r);break;case"insert":r=await(0,_insertEntity.insertEntity)(e.entity,e.insertValues,r);break;case"read":s||(r=await(0,_readEntity.readEntity)(e.entity,r));break;case"update":r=await(0,_updateEntity.updateEntity)(e.entity,e.updateValues,r);break;default:throw new Error(`Unknown command: ${e.command}`)}return r=await(0,_joinEntity.joinEntity)(e.entity,e.joinEntity,r,e.joinClauses,s),r=await(0,_mergeJoins.mergeJoins)(r,e.mergeJoins),"delete"!==e.command&&"update"!==e.command&&(r[e.entity]=e.conditions.reduce(((e,t)=>(0,_where.where)(e,t)),r[e.entity])),r[e.entity]=(0,_sortBy.sortBy)(r[e.entity],e.sortClauses),r[e.entity]=(0,_limitOffset.limitOffset)(r[e.entity],e.offset,e.limit),r[e.entity]=(0,_groupBy.groupBy)(r[e.entity],e.groupBy),r[e.entity]=(0,_selectFields.selectFields)(r[e.entity],e.selectClauses),r};exports.runQuery=runQuery;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.runQuery=void 0,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 _deleteEntity=require("../queries/deleteEntity"),_insertEntity=require("../queries/insertEntity"),_readEntity=require("../queries/readEntity"),_updateEntity=require("../queries/updateEntity"),_createRecord=require("../queries/createRecord"),_dropRecord=require("../queries/dropRecord"),_describeRecord=require("../queries/describeRecord"),_showRecords=require("../queries/showRecords"),_joinEntity=require("../queries/joinEntity"),_mergeJoins=require("../queries/mergeJoins"),_where=require("../queries/where"),_sortBy=require("../queries/sortBy"),_groupBy=require("../queries/groupBy"),_limitOffset=require("../queries/limitOffset"),_selectFields=require("../queries/selectFields"),_retrieveRecord=require("./retrieveRecord"),_getConditionIndexedList=require("./getConditionIndexedList"),_getJoinIndexedList=require("./getJoinIndexedList"),_isEntityProperty=require("./parsers/isEntityProperty"),_splitEntityProperty=require("./parsers/splitEntityProperty"),_fieldType=require("./fieldType"),_conditionTree=require("./conditionTree"),_conditionEntities=require("./conditionEntities");const typeClauses=async(e,t)=>{for(const r of[...(0,_conditionTree.conditionsOf)(e.where),...e.sortClauses]){let i=e.entity,s=r.property;(0,_isEntityProperty.isEntityProperty)(s)&&({entity:i,property:s}=(0,_splitEntityProperty.splitEntityProperty)(s)),Object.prototype.hasOwnProperty.call(t,i)||(t[i]=await(0,_retrieveRecord.retrieveRecord)(i)),r.type=(0,_fieldType.fieldType)(t[i],s)}},runQuery=async e=>{const t=void 0!==e.where&&(0,_conditionEntities.conditionEntities)(e);switch(e.command){case"create":return{[e.entity]:await(0,_createRecord.createRecord)(e.entity,e.create)};case"drop":return{[e.entity]:await(0,_dropRecord.dropRecord)(e.entity,e.ifExists)};case"describe":return{[e.entity]:await(0,_describeRecord.describeRecord)(e.entity)};case"show":return{[e.entity]:await(0,_showRecords.showRecords)()}}const r={[e.entity]:await(0,_retrieveRecord.retrieveRecord)(e.entity)};void 0!==e.joinEntity&&(r[e.joinEntity]=await(0,_retrieveRecord.retrieveRecord)(e.joinEntity)),await typeClauses(e,r);let i={[e.entity]:[]};const s=new Set;e=await(0,_getConditionIndexedList.getConditionIndexedList)(e,r,i,s);const n=s.has(e.entity);switch("delete"!==(e=await(0,_getJoinIndexedList.getJoinIndexedList)(e,r,i)).command&&"update"!==e.command||(n||(i=await(0,_readEntity.readEntity)(e.entity,i)),i[e.entity]=(0,_where.whereTree)(i[e.entity],e.where)),e.command){case"delete":i=await(0,_deleteEntity.deleteEntity)(e.entity,i);break;case"insert":i=await(0,_insertEntity.insertEntity)(e.entity,e.insertValues,i);break;case"read":n||(i=await(0,_readEntity.readEntity)(e.entity,i));break;case"update":i=await(0,_updateEntity.updateEntity)(e.entity,e.updateValues,i);break;default:throw new Error(`Unknown command: ${e.command}`)}return i=await(0,_joinEntity.joinEntity)(e.entity,e.joinEntity,i,e.joinClauses,n,s.has(e.joinEntity)),i=await(0,_mergeJoins.mergeJoins)(i,e.mergeJoins),"delete"!==e.command&&"update"!==e.command&&(i[e.entity]=(0,_where.whereTree)(i[e.entity],e.where,t?e.joinEntity:void 0)),i[e.entity]=(0,_sortBy.sortBy)(i[e.entity],e.sortClauses),i[e.entity]=(0,_limitOffset.limitOffset)(i[e.entity],e.offset,e.limit),i[e.entity]=(0,_groupBy.groupBy)(i[e.entity],e.groupBy),i[e.entity]=(0,_selectFields.selectFields)(i[e.entity],e.selectClauses),i};exports.runQuery=runQuery;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-fs-query",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Use json files to manage and read data.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",