json-fs-query 2.3.1 → 3.0.0

package/browser/jsonFsQuery.js

@@ -793,23 +793,85 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.groupBy = void 0;
+require("core-js/modules/es.json.stringify.js");
 require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
 require("core-js/modules/esnext.iterator.reduce.js");
-const groupBy = (dataSet = [], groupProperty = '') => {
-  if (!groupProperty) {
+require("core-js/modules/esnext.map.delete-all.js");
+require("core-js/modules/esnext.map.every.js");
+require("core-js/modules/esnext.map.filter.js");
+require("core-js/modules/esnext.map.find.js");
+require("core-js/modules/esnext.map.find-key.js");
+require("core-js/modules/esnext.map.includes.js");
+require("core-js/modules/esnext.map.key-of.js");
+require("core-js/modules/esnext.map.map-keys.js");
+require("core-js/modules/esnext.map.map-values.js");
+require("core-js/modules/esnext.map.merge.js");
+require("core-js/modules/esnext.map.reduce.js");
+require("core-js/modules/esnext.map.some.js");
+require("core-js/modules/esnext.map.update.js");
+// An object's keys in sorted order, at any depth, so { a, b } and { b, a } are the same value; arrays keep their order
+const sortedKeys = value => {
+  if (Array.isArray(value)) {
+    return value.map(sortedKeys);
+  }
+  if (value !== null && typeof value === 'object') {
+    return Object.keys(value).sort().reduce((sorted, key) => {
+      sorted[key] = sortedKeys(value[key]);
+      return sorted;
+    }, {});
+  }
+  return value;
+};
+// Rows share a group when their values are the same, type included: 1 and '1' are two groups, as are null and missing
+const groupKey = (row, field) => {
+  if (!Object.prototype.hasOwnProperty.call(row, field)) {
+    return 'missing';
+  }
+  const value = row[field];
+  return value !== null && typeof value === 'object' ? `json:${JSON.stringify(sortedKeys(value))}` : `${typeof value}:${String(value)}`;
+};
+/**
+ * Group rows by each field in turn. The groups are a list in the order their first row came, so a sort before
+ * grouping orders the groups too (and the rows within each one).
+ * @param dataSet
+ * @param fields
+ * @returns The rows as they were when there's no field, otherwise the groups.
+ */
+const groupBy = (dataSet = [], fields = []) => {
+  if (!fields.length) {
     return dataSet;
   }
-  return dataSet.reduce((groupedData, data) => {
-    const property = data[groupProperty];
-    if (!Object.prototype.hasOwnProperty.call(groupedData, property)) {
-      groupedData[property] = [];
+  const [field, ...rest] = fields;
+  const groups = new Map();
+  for (const row of dataSet) {
+    const key = groupKey(row, field);
+    if (!groups.has(key)) {
+      groups.set(key, key === 'missing' ? {
+        field,
+        missing: true,
+        rows: []
+      } : {
+        field,
+        value: row[field],
+        rows: []
+      });
     }
-    groupedData[property].push(data);
-    return groupedData;
-  }, {});
+    groups.get(key).rows.push(row);
+  }
+  return [...groups.values()].map(({
+    rows,
+    ...group
+  }) => rest.length ? {
+    ...group,
+    groups: groupBy(rows, rest)
+  } : {
+    ...group,
+    rows
+  });
 };
 exports.groupBy = groupBy;
-},{"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.reduce.js":245}],20:[function(require,module,exports){
+},{"core-js/modules/es.json.stringify.js":233,"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.map.js":244,"core-js/modules/esnext.iterator.reduce.js":245,"core-js/modules/esnext.map.delete-all.js":247,"core-js/modules/esnext.map.every.js":248,"core-js/modules/esnext.map.filter.js":249,"core-js/modules/esnext.map.find-key.js":250,"core-js/modules/esnext.map.find.js":251,"core-js/modules/esnext.map.includes.js":252,"core-js/modules/esnext.map.key-of.js":253,"core-js/modules/esnext.map.map-keys.js":254,"core-js/modules/esnext.map.map-values.js":255,"core-js/modules/esnext.map.merge.js":256,"core-js/modules/esnext.map.reduce.js":257,"core-js/modules/esnext.map.some.js":258,"core-js/modules/esnext.map.update.js":259}],20:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -977,7 +1039,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.limitOffset = void 0;
 /**
- * Slice a dataSet down to at most `limit` rows, starting after the first `offset` of them.
+ * Slice a dataSet down to at most `limit` rows (or groups, after group by), starting after the first `offset` of them.
  * @param dataSet
  * @param offset
  * @param limit
@@ -1115,7 +1177,7 @@ const queryStatus = (text = '') => {
   };
 };
 exports.queryStatus = queryStatus;
-},{"../utilities/parsers/scanQuery":67}],27:[function(require,module,exports){
+},{"../utilities/parsers/scanQuery":66}],27:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -1165,24 +1227,29 @@ const shapeRow = (row, selectClauses) => selectClauses.reduce((shaped, {
   shaped[alias || property] = row[property];
   return shaped;
 }, {});
+const shapeGroup = (group, selectClauses) => group.groups ? {
+  ...group,
+  groups: group.groups.map(inner => shapeGroup(inner, selectClauses))
+} : {
+  ...group,
+  rows: group.rows.map(row => shapeRow(row, selectClauses))
+};
 /**
- * Shape each row down to only the selected properties (aliased, when given). dataSet is either a plain array of
- * rows, or (once groupBy has run) a plain object keyed by group value, each value an array of rows - both are
- * shaped the same way, row by row.
+ * Shape each row down to only the selected properties (aliased, when given). dataSet is either a list of rows, or
+ * (once groupBy has run) a list of groups, whose rows are shaped the same way at any depth; the groups keep their
+ * field and value, selected or not.
  * @param dataSet
  * @param selectClauses
+ * @param grouped Whether dataSet is a list of groups (see groupBy)
  */
-const selectFields = (dataSet = [], selectClauses = []) => {
+const selectFields = (dataSet = [], selectClauses = [], grouped = false) => {
   if (!selectClauses.length) {
     return dataSet;
   }
-  if (Array.isArray(dataSet)) {
-    return dataSet.map(row => shapeRow(row, selectClauses));
+  if (grouped) {
+    return dataSet.map(group => shapeGroup(group, selectClauses));
   }
-  return Object.keys(dataSet).reduce((shaped, key) => {
-    shaped[key] = dataSet[key].map(row => shapeRow(row, selectClauses));
-    return shaped;
-  }, {});
+  return dataSet.map(row => shapeRow(row, selectClauses));
 };
 exports.selectFields = selectFields;
 },{"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.map.js":244,"core-js/modules/esnext.iterator.reduce.js":245}],30:[function(require,module,exports){
@@ -2536,12 +2603,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findCommand = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-const commandMatch = /^(delete|insert|read|update)\s+([a-z0-9_-]+)[\w\n]*/i;
+const commandMatch = /^(delete|insert|read|update)\s+([a-z0-9_-]+)/i;
 /**
- * Extract command clauses from the query.
+ * Read the command and record name from the start of a query's head (see splitClauses).
  * @param parsed
  * @param query
+ * @returns The rest of the head (a joined record, `.joined`, for findJoinEntity).
  */
 const findCommand = (parsed, query) => {
   const commandFound = query.match(commandMatch);
@@ -2550,12 +2617,12 @@ const findCommand = (parsed, query) => {
   if (commandFound) {
     parsed['command'] = commandFound[1].toLowerCase();
     parsed['entity'] = commandFound[2];
-    return (0, _removeFromQuery.removeFromQuery)(commandFound[0], query);
+    return query.slice(commandFound[0].length).trim();
   }
   return query;
 };
 exports.findCommand = findCommand;
-},{"./removeFromQuery":66}],49:[function(require,module,exports){
+},{}],49:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -2568,15 +2635,13 @@ require("core-js/modules/esnext.iterator.flat-map.js");
 var _parseLiteralValue = require("./parseLiteralValue");
 var _conditionTree = require("../conditionTree");
 var _maskStrings = require("./maskStrings");
+var _splitClauses = require("./splitClauses");
 // 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');
 /**
  * Read one condition from a match of conditionMatch.
  * @param match
@@ -2620,15 +2685,15 @@ const join = (kind, nodes) => {
   };
 };
 /**
- * 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`.
+ * Read one where expression from the start of a where clause body (masked, see maskStrings). Precedence, loosest
+ * first: `or`, `and`, `not`; brackets group.
  * @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.
+ * @returns The expression's tree and where it ends (at the first text that can't carry it on, or the end).
+ * @throws {Error} For an unbalanced bracket, empty brackets, an operator with no condition after it, or two conditions
+ * with no and/or between them.
  */
-const readExpression = (text, start) => {
-  let at = start;
+const readExpression = text => {
+  let at = 0;
   const rest = () => text.slice(at);
   const skipSpace = () => {
     at += rest().length - rest().trimStart().length;
@@ -2651,6 +2716,10 @@ const readExpression = (text, start) => {
       at += condition[0].length;
       return readCondition(condition);
     }
+    // The 2.x `and where` / `or where` inside brackets, where splitClauses doesn't look
+    if ((after === 'and' || after === 'or') && keyword('where').test(rest())) {
+      throw new Error(`"${after} where" is no longer supported: ${_splitClauses.whereHint}`);
+    }
     if (take(keyword('not'))) {
       return {
         not: factor('not')
@@ -2673,11 +2742,7 @@ const readExpression = (text, start) => {
   const term = after => {
     const nodes = [factor(after)];
     for (;;) {
-      skipSpace();
-      if (keyword('and\\s+on').test(rest())) {
-        break;
-      }
-      const connector = take(keyword('and(?:\\s+where)?'));
+      const connector = take(keyword('and'));
       if (!connector) {
         break;
       }
@@ -2688,7 +2753,7 @@ const readExpression = (text, start) => {
   const expression = after => {
     const nodes = [term(after)];
     for (;;) {
-      const connector = take(keyword('or(?:\\s+where)?'));
+      const connector = take(keyword('or'));
       if (!connector) {
         break;
       }
@@ -2701,7 +2766,7 @@ const readExpression = (text, start) => {
   if (rest().startsWith(')')) {
     throw new Error(`Unexpected ) in a where clause: ${shown()}`);
   }
-  if (rest() && !expressionEnd.test(rest()) && conditionMatch.test(rest())) {
+  if (conditionMatch.test(rest())) {
     throw new Error(`Missing and/or before: ${shown()}`);
   }
   return {
@@ -2710,134 +2775,137 @@ const readExpression = (text, start) => {
   };
 };
 /**
- * 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.
+ * Read a where clause body (see splitClauses) into a tree (see ConditionNode): 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).
  * @param parsed
- * @param query
- * @throws {Error} For the errors readExpression and readCondition describe, and `or where` after another clause.
+ * @param body
+ * @returns The rest of the body, after the expression.
+ * @throws {Error} For the errors readExpression and readCondition describe.
  */
-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');
-    }
-    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;
+const findConditions = (parsed, body) => {
+  const {
+    node,
+    end
+  } = readExpression(body);
+  parsed['where'] = node;
+  return body.slice(end).trim();
 };
 exports.findConditions = findConditions;
-},{"../conditionTree":37,"./maskStrings":61,"./parseLiteralValue":63,"core-js/modules/es.array.includes.js":222,"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.flat-map.js":242}],50:[function(require,module,exports){
+},{"../conditionTree":37,"./maskStrings":61,"./parseLiteralValue":63,"./splitClauses":67,"core-js/modules/es.array.includes.js":222,"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.flat-map.js":242}],50:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findGroupBy = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-const groupMatch = /group\s+by\s+(,?[a-z0-9._-]+)+/i;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+const groupMatch = /^[a-z0-9._-]+(?:\s*,\s*[a-z0-9._-]+)*/i;
 /**
- * Extract the group by clauses from the query.
+ * Read a group by clause body (`a, b`, see splitClauses).
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the last field.
+ * @throws {Error} For a field named twice.
  */
-const findGroupBy = (parsed, query) => {
-  const groupFound = query.match(groupMatch);
+const findGroupBy = (parsed, body) => {
+  const groupFound = body.match(groupMatch);
   if (groupFound) {
-    parsed['groupBy'] = groupFound ? groupFound[1] : undefined;
-    return (0, _removeFromQuery.removeFromQuery)(groupFound[0], query);
+    const fields = groupFound[0].split(/\s*,\s*/);
+    const repeated = fields.find((field, index) => fields.indexOf(field) !== index);
+    if (repeated) {
+      throw new Error(`"${repeated}" is in group by twice`);
+    }
+    parsed['groupBy'] = fields;
+    return body.slice(groupFound[0].length).trim();
   }
-  return query;
+  return body;
 };
 exports.findGroupBy = findGroupBy;
-},{"./removeFromQuery":66}],51:[function(require,module,exports){
+},{"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.find.js":241}],51:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findInsertValues = void 0;
-var _removeFromQuery = require("./removeFromQuery");
 var _parseLiteralValue = require("./parseLiteralValue");
 var _maskStrings = require("./maskStrings");
 const literal = `(?:${_maskStrings.placeholderSource.replace('(', '(?:')}|${_parseLiteralValue.numberSource}|${_maskStrings.arraySource.replace('(', '(?:')}|null|true|false)`;
-const valuesClauseMatch = new RegExp(`(values)\\s+([a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*)`, 'i');
+const valuesMatch = new RegExp(`^([a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*)`, 'i');
 const assignmentMatch = new RegExp(`([a-z0-9_-]+)\\s*=\\s*(${_maskStrings.placeholderSource}|(${_parseLiteralValue.numberSource})|${_maskStrings.arraySource}|(null)|(true)|(false))`, 'ig');
 /**
- * Extract an insert's "values field = value, field2 = value2" clause from the query, the same way
+ * Read an insert's values clause body (`field = value, field2 = value2`, see splitClauses), the same way
  * findUpdateValues() does for "set". insertEntity() accepts an array of rows for bulk inserts, but
  * a query string only describes a single row for now - wrapped in a one-element array to match.
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the last assignment.
  */
-const findInsertValues = (parsed, query) => {
-  const clauseFound = query.match(valuesClauseMatch);
+const findInsertValues = (parsed, body) => {
+  const clauseFound = body.match(valuesMatch);
   parsed['insertValues'] = [];
   if (!clauseFound) {
-    return query;
+    return body;
   }
   const row = {};
-  const assignmentsFound = clauseFound[2].matchAll(assignmentMatch);
+  const assignmentsFound = clauseFound[1].matchAll(assignmentMatch);
   // @ts-ignore
   for (const assignment of assignmentsFound) {
     row[assignment[1]] = (0, _parseLiteralValue.parseLiteralValue)(assignment, 3);
   }
   parsed['insertValues'] = [row];
-  return (0, _removeFromQuery.removeFromQuery)(clauseFound[0], query);
+  return body.slice(clauseFound[0].length).trim();
 };
 exports.findInsertValues = findInsertValues;
-},{"./maskStrings":61,"./parseLiteralValue":63,"./removeFromQuery":66}],52:[function(require,module,exports){
+},{"./maskStrings":61,"./parseLiteralValue":63}],52:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findJoinClauses = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-const joinClauseMatch = /(and)?\s*on\s+([a-z0-9_-]+\.[a-z0-9_-]+)\s+(=|!=|>|<|>=|<=|in|between|like)\s+([a-z0-9_-]+\.[a-z0-9_-]+)/ig;
+// One join condition, at the start of the text; every one after the first starts with `and on` (see splitClauses)
+const joinClauseMatch = /^([a-z0-9_-]+\.[a-z0-9_-]+)\s+(=|!=|>|<|>=|<=|in|between|like)\s+([a-z0-9_-]+\.[a-z0-9_-]+)(?![a-z0-9._-])/i;
+const nextMatch = /^and\s+on\s+/i;
 /**
- * Extract condition clauses from the query.
+ * Read an on clause body (`a.x = b.y and on b.z = c.w`, see splitClauses).
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the last join condition.
  */
-const findJoinClauses = (parsed, query) => {
-  const joinClausesFound = query.matchAll(joinClauseMatch);
-  // @ts-ignore
-  for (const joinClause of joinClausesFound) {
+const findJoinClauses = (parsed, body) => {
+  let rest = body;
+  for (let joinClause = rest.match(joinClauseMatch); joinClause; joinClause = rest.match(joinClauseMatch)) {
     parsed['joinClauses'].push({
-      propertyA: joinClause[2],
-      comparator: joinClause[3],
-      propertyB: joinClause[4]
+      propertyA: joinClause[1],
+      comparator: joinClause[2],
+      propertyB: joinClause[3]
     });
-    query = (0, _removeFromQuery.removeFromQuery)(joinClause[0], query);
+    rest = rest.slice(joinClause[0].length).trim();
+    // The connector only with another one after it, so a bad one is shown with its connector
+    const next = rest.match(nextMatch);
+    if (!next || !joinClauseMatch.test(rest.slice(next[0].length))) {
+      break;
+    }
+    rest = rest.slice(next[0].length);
   }
-  return query;
+  return rest;
 };
 exports.findJoinClauses = findJoinClauses;
-},{"./removeFromQuery":66}],53:[function(require,module,exports){
+},{}],53:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findJoinEntity = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-// Only straight after the entity (findCommand leaves `.joined ...`): a `.` later on is a number's (`1.5`) or a
-// condition's `entity.field`, not the join
+// What findCommand leaves of the head: `.joined`
 const joinEntityMatch = /^\.([a-z0-9_-]+)/i;
 /**
- * Extract the main join entity from the query.
+ * Read the joined record from what findCommand left of the head.
  * @param parsed
  * @param query
  */
@@ -2845,189 +2913,192 @@ const findJoinEntity = (parsed, query) => {
   const joinEntityFound = query.match(joinEntityMatch);
   if (joinEntityFound) {
     parsed['joinEntity'] = joinEntityFound ? joinEntityFound[1] : undefined;
-    return (0, _removeFromQuery.removeFromQuery)(joinEntityFound[0], query);
+    return query.slice(joinEntityFound[0].length).trim();
   }
   return query;
 };
 exports.findJoinEntity = findJoinEntity;
-},{"./removeFromQuery":66}],54:[function(require,module,exports){
+},{}],54:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findLimit = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-const limitMatch = /limit\s*(\d+)/i;
+const limitMatch = /^(\d+)/;
 /**
- * Extract the limit clauses from the query.
+ * Read a limit clause body (a whole number, see splitClauses).
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the number.
  */
-const findLimit = (parsed, query) => {
-  const limitFound = query.match(limitMatch);
+const findLimit = (parsed, body) => {
+  const limitFound = body.match(limitMatch);
   if (limitFound) {
     parsed['limit'] = limitFound ? parseInt(limitFound[1]) : undefined;
-    return (0, _removeFromQuery.removeFromQuery)(limitFound[0], query);
+    return body.slice(limitFound[0].length).trim();
   }
-  return query;
+  return body;
 };
 exports.findLimit = findLimit;
-},{"./removeFromQuery":66}],55:[function(require,module,exports){
+},{}],55:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findMergeJoins = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-const mergeJoinMatch = /(and)?\s*merge\s+([a-z0-9_-]+\.[a-z0-9_-]+)\s+with\s+([a-z0-9_-]+\.[a-z0-9_-]+)/ig;
+// One merge, at the start of the text; every one after the first starts with `merge` or `and merge` (see splitClauses)
+const mergeJoinMatch = /^([a-z0-9_-]+\.[a-z0-9_-]+)\s+with\s+([a-z0-9_-]+\.[a-z0-9_-]+)(?![a-z0-9._-])/i;
+const nextMatch = /^(?:and\s+)?merge\s+/i;
 /**
- * Extract merge-join clauses from the query.
+ * Read a merge clause body (`a.x with b.y merge c.z with d.w`, see splitClauses).
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the last merge.
  */
-const findMergeJoins = (parsed, query) => {
-  const mergeJoinsFound = query.matchAll(mergeJoinMatch);
-  // @ts-ignore
-  for (const mergeJoin of mergeJoinsFound) {
+const findMergeJoins = (parsed, body) => {
+  let rest = body;
+  for (let mergeJoin = rest.match(mergeJoinMatch); mergeJoin; mergeJoin = rest.match(mergeJoinMatch)) {
     parsed['mergeJoins'].push({
-      propertyA: mergeJoin[2],
-      propertyB: mergeJoin[3]
+      propertyA: mergeJoin[1],
+      propertyB: mergeJoin[2]
     });
-    query = (0, _removeFromQuery.removeFromQuery)(mergeJoin[0].trim(), query);
+    rest = rest.slice(mergeJoin[0].length).trim();
+    // The connector only with another one after it, so a bad one is shown with its connector
+    const next = rest.match(nextMatch);
+    if (!next || !mergeJoinMatch.test(rest.slice(next[0].length))) {
+      break;
+    }
+    rest = rest.slice(next[0].length);
   }
-  return query;
+  return rest;
 };
 exports.findMergeJoins = findMergeJoins;
-},{"./removeFromQuery":66}],56:[function(require,module,exports){
+},{}],56:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findOffset = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-const offsetMatch = /offset\s*(\d+)/i;
+const offsetMatch = /^(\d+)/;
 /**
- * Extract the offset clauses from the query.
+ * Read a offset clause body (a whole number, see splitClauses).
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the number.
  */
-const findOffset = (parsed, query) => {
-  const offsetFound = query.match(offsetMatch);
+const findOffset = (parsed, body) => {
+  const offsetFound = body.match(offsetMatch);
   if (offsetFound) {
     parsed['offset'] = offsetFound ? parseInt(offsetFound[1]) : undefined;
-    return (0, _removeFromQuery.removeFromQuery)(offsetFound[0], query);
+    return body.slice(offsetFound[0].length).trim();
   }
-  return query;
+  return body;
 };
 exports.findOffset = findOffset;
-},{"./removeFromQuery":66}],57:[function(require,module,exports){
+},{}],57:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findSelects = void 0;
-var _removeFromQuery = require("./removeFromQuery");
-// One field is a name, then optionally `as <alias>` (`as` as a whole word); fields are separated by commas. The first
-// field used to accept an alias without `as`, so in `select name where a = 1` the word `where` became the alias.
+// One field is a name, then optionally `as <alias>` (`as` as a whole word); fields are separated by commas
 const selectField = '[a-z0-9=._-]+(?:\\s+as\\s+[a-z0-9_-]+)?';
-const selectClausesMatch = new RegExp(`select\\s+${selectField}(?:\\s*,\\s*${selectField})*`, 'i');
-const selectClauseMatch = /(select)?\s*,?\s*([a-z0-9=._-]+)(?:\s+as\s+([a-z0-9_-]+))?/ig;
+const selectsMatch = new RegExp(`^${selectField}(?:\\s*,\\s*${selectField})*`, 'i');
+const selectFieldMatch = /,?\s*([a-z0-9=._-]+)(?:\s+as\s+([a-z0-9_-]+))?/ig;
 /**
- * Extract select clauses from the query.
+ * Read a select clause body (`a, b as c`, see splitClauses).
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the last field.
  */
-const findSelects = (parsed, query) => {
-  const selectsFound = query.match(selectClausesMatch);
+const findSelects = (parsed, body) => {
+  const selectsFound = body.match(selectsMatch);
   if (selectsFound) {
-    const selectClausesFound = selectsFound[0].matchAll(selectClauseMatch);
+    const selectClausesFound = selectsFound[0].matchAll(selectFieldMatch);
     // @ts-ignore
     for (const selectClause of selectClausesFound) {
       parsed['selectClauses'].push({
-        property: selectClause[2],
-        alias: selectClause[3]
+        property: selectClause[1],
+        alias: selectClause[2]
       });
     }
-    return (0, _removeFromQuery.removeFromQuery)(selectsFound[0], query);
+    return body.slice(selectsFound[0].length).trim();
   }
-  return query;
+  return body;
 };
 exports.findSelects = findSelects;
-},{"./removeFromQuery":66}],58:[function(require,module,exports){
+},{}],58:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findSortClauses = void 0;
-var _removeFromQuery = require("./removeFromQuery");
 // One rule is a field, then optionally asc or desc as a whole word. Rules are separated by commas, so the list ends
-// at the first word that doesn't follow a comma: in `sort a limit 1`, `limit` starts the next clause.
+// at the first word that doesn't follow a comma: in `sort a b`, `b` is left over.
 const sortRule = '[a-z0-9._-]+(?:\\s+(?:asc|desc)(?![a-z0-9._-]))?';
-const sortMatch = new RegExp(`sort\\s+${sortRule}(?:\\s*,\\s*${sortRule})*`, 'i');
-const sortRuleMatch = /(sort)?\s*,?\s*([a-z0-9._-]+)(?:\s+(asc|desc)(?![a-z0-9._-]))?/ig;
+const sortMatch = new RegExp(`^${sortRule}(?:\\s*,\\s*${sortRule})*`, 'i');
+const sortRuleMatch = /,?\s*([a-z0-9._-]+)(?:\s+(asc|desc)(?![a-z0-9._-]))?/ig;
 /**
- * Extract sort clauses from the query.
+ * Read a sort clause body (`a, b desc`, see splitClauses).
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the last rule.
  */
-const findSortClauses = (parsed, query) => {
-  const sortFound = query.match(sortMatch);
+const findSortClauses = (parsed, body) => {
+  const sortFound = body.match(sortMatch);
   if (sortFound) {
     const sortRulesFound = sortFound[0].matchAll(sortRuleMatch);
     // @ts-ignore
     for (const sortClause of sortRulesFound) {
       parsed['sortClauses'].push({
-        property: sortClause[2],
-        direction: (sortClause[3] || 'asc').toLowerCase()
+        property: sortClause[1],
+        direction: (sortClause[2] || 'asc').toLowerCase()
       });
     }
-    return (0, _removeFromQuery.removeFromQuery)(sortFound[0], query);
+    return body.slice(sortFound[0].length).trim();
   }
-  return query;
+  return body;
 };
 exports.findSortClauses = findSortClauses;
-},{"./removeFromQuery":66}],59:[function(require,module,exports){
+},{}],59:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findUpdateValues = void 0;
-var _removeFromQuery = require("./removeFromQuery");
 var _parseLiteralValue = require("./parseLiteralValue");
 var _maskStrings = require("./maskStrings");
 const literal = `(?:${_maskStrings.placeholderSource.replace('(', '(?:')}|${_parseLiteralValue.numberSource}|${_maskStrings.arraySource.replace('(', '(?:')}|null|true|false)`;
-const setClauseMatch = new RegExp(`(set)\\s+([a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*)`, 'i');
+const setMatch = new RegExp(`^([a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*)`, 'i');
 const assignmentMatch = new RegExp(`([a-z0-9_-]+)\\s*=\\s*(${_maskStrings.placeholderSource}|(${_parseLiteralValue.numberSource})|${_maskStrings.arraySource}|(null)|(true)|(false))`, 'ig');
 /**
- * Extract an update's "set field = value, field2 = value2" clause from the query. Uses a two-pass
- * match, unlike the other parsers here: the set clause's own boundary is found first (so it can
- * be removed from the query as a whole, and so the comma-separated list doesn't get confused with
- * anything that follows, like a where clause), then each individual assignment is parsed out of
- * that captured substring.
+ * Read an update's set clause body (`field = value, field2 = value2`, see splitClauses). Uses a two-pass match: the
+ * whole comma-separated list first, so anything after it is left over, then each assignment out of that list.
  * @param parsed
- * @param query
+ * @param body
+ * @returns The rest of the body, after the last assignment.
  */
-const findUpdateValues = (parsed, query) => {
-  const clauseFound = query.match(setClauseMatch);
+const findUpdateValues = (parsed, body) => {
+  const clauseFound = body.match(setMatch);
   parsed['updateValues'] = {};
   if (!clauseFound) {
-    return query;
+    return body;
   }
-  const assignmentsFound = clauseFound[2].matchAll(assignmentMatch);
+  const assignmentsFound = clauseFound[1].matchAll(assignmentMatch);
   // @ts-ignore
   for (const assignment of assignmentsFound) {
     parsed['updateValues'][assignment[1]] = (0, _parseLiteralValue.parseLiteralValue)(assignment, 3);
   }
-  return (0, _removeFromQuery.removeFromQuery)(clauseFound[0], query);
+  return body.slice(clauseFound[0].length).trim();
 };
 exports.findUpdateValues = findUpdateValues;
-},{"./maskStrings":61,"./parseLiteralValue":63,"./removeFromQuery":66}],60:[function(require,module,exports){
+},{"./maskStrings":61,"./parseLiteralValue":63}],60:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -3164,7 +3235,7 @@ const maskArrays = masked => {
   return depth > 0 ? result + masked.slice(start) : result;
 };
 exports.maskArrays = maskArrays;
-},{"./scanQuery":67,"core-js/modules/es.json.stringify.js":233,"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.map.js":244,"core-js/modules/esnext.iterator.some.js":246}],62:[function(require,module,exports){
+},{"./scanQuery":66,"core-js/modules/es.json.stringify.js":233,"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.map.js":244,"core-js/modules/esnext.iterator.some.js":246}],62:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -3568,13 +3639,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseQuery = void 0;
-var _siFunciona = _interopRequireDefault(require("si-funciona"));
 var _findCommand = require("./findCommand");
 var _findInsertValues = require("./findInsertValues");
 var _findUpdateValues = require("./findUpdateValues");
 var _findJoinEntity = require("./findJoinEntity");
 var _findSelects = require("./findSelects");
 var _findConditions = require("./findConditions");
+var _conditionTree = require("../conditionTree");
 var _findJoinClauses = require("./findJoinClauses");
 var _findMergeJoins = require("./findMergeJoins");
 var _findSortClauses = require("./findSortClauses");
@@ -3584,8 +3655,63 @@ var _findOffset = require("./findOffset");
 var _maskStrings = require("./maskStrings");
 var _parseCreate = require("./parseCreate");
 var _parseSchemaStatement = require("./parseSchemaStatement");
+var _splitClauses = require("./splitClauses");
 var _startsQuery = require("./startsQuery");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Each clause's own step, and what its body must start with (for the error when it doesn't)
+const clauseSteps = {
+  values: {
+    step: _findInsertValues.findInsertValues,
+    expected: 'an assignment (field = value)'
+  },
+  set: {
+    step: _findUpdateValues.findUpdateValues,
+    expected: 'an assignment (field = value)'
+  },
+  select: {
+    step: _findSelects.findSelects,
+    expected: 'a field'
+  },
+  on: {
+    step: _findJoinClauses.findJoinClauses,
+    expected: 'a join condition (a.x = b.y)'
+  },
+  merge: {
+    step: _findMergeJoins.findMergeJoins,
+    expected: 'a merge (a.x with b.y)'
+  },
+  where: {
+    step: _findConditions.findConditions,
+    expected: 'a condition'
+  },
+  'group by': {
+    step: _findGroupBy.findGroupBy,
+    expected: 'a field'
+  },
+  sort: {
+    step: _findSortClauses.findSortClauses,
+    expected: 'a field'
+  },
+  limit: {
+    step: _findLimit.findLimit,
+    expected: 'a whole number'
+  },
+  offset: {
+    step: _findOffset.findOffset,
+    expected: 'a whole number'
+  }
+};
+/**
+ * The error for text a step couldn't read: another query run on without a `;`, or text that doesn't belong.
+ * @param rest The text left over, masked
+ * @param after What was read before it, masked
+ */
+const leftoverError = (rest, after) => {
+  const shown = text => (0, _maskStrings.unmaskStrings)(text, '\'');
+  if (_startsQuery.startsQueryMatch.test(rest)) {
+    return new Error(`Missing ; before: ${shown(rest)}`);
+  }
+  return new Error(`Unexpected "${shown(rest)}" after "${shown(after)}"`);
+};
 /**
  * Break a query down into its components.
  * @param query
@@ -3608,10 +3734,6 @@ const parseQuery = query => {
     create: undefined,
     ifExists: undefined
   };
-  const {
-    curry,
-    pipe
-  } = _siFunciona.default;
   // No find* step may see inside a string or an array: each one becomes a placeholder holding its value
   query = (0, _maskStrings.maskArrays)((0, _maskStrings.maskStrings)(query));
   // A create statement has its own shape (a bracketed list of fields and keys), so it gets its own parser
@@ -3629,17 +3751,40 @@ const parseQuery = query => {
   if (_parseSchemaStatement.schemaStatementMatch.test(query)) {
     return Object.assign(parsedQuery, (0, _parseSchemaStatement.parseSchemaStatement)(query));
   }
-  query = pipe(curry(_findCommand.findCommand)(parsedQuery), curry(_findInsertValues.findInsertValues)(parsedQuery), curry(_findUpdateValues.findUpdateValues)(parsedQuery), curry(_findJoinEntity.findJoinEntity)(parsedQuery), curry(_findSelects.findSelects)(parsedQuery), curry(_findConditions.findConditions)(parsedQuery), curry(_findJoinClauses.findJoinClauses)(parsedQuery), curry(_findMergeJoins.findMergeJoins)(parsedQuery), curry(_findSortClauses.findSortClauses)(parsedQuery), curry(_findGroupBy.findGroupBy)(parsedQuery), curry(_findLimit.findLimit)(parsedQuery), curry(_findOffset.findOffset)(parsedQuery))(query);
-  if (query) {
+  // Clauses come at most once each, in a fixed order (see clauseOrder); each step reads only its own clause's body
+  const split = (0, _splitClauses.splitClauses)(query);
+  if (!split) {
+    query = query.trim();
     if (_startsQuery.startsQueryMatch.test(query)) {
-      throw new Error(`Missing ; before: ${(0, _maskStrings.unmaskStrings)(query.trim(), '\'')}`);
+      throw new Error(`Missing ; before: ${(0, _maskStrings.unmaskStrings)(query, '\'')}`);
     }
     throw new Error(`Unrecognized query value: ${(0, _maskStrings.unmaskStrings)(query, '\'')}`);
   }
+  (0, _findJoinEntity.findJoinEntity)(parsedQuery, (0, _findCommand.findCommand)(parsedQuery, split.head));
+  parsedQuery.where = (0, _conditionTree.allOf)([]);
+  if (split.leading) {
+    throw leftoverError(split.leading, split.head);
+  }
+  for (const {
+    keyword,
+    body
+  } of split.clauses) {
+    const {
+      step,
+      expected
+    } = clauseSteps[keyword];
+    const rest = step(parsedQuery, body);
+    if (rest === body) {
+      throw new Error(`Missing ${expected} after ${keyword}${body ? `: ${(0, _maskStrings.unmaskStrings)(body, '\'')}` : ''}`);
+    }
+    if (rest) {
+      throw leftoverError(rest, `${keyword} ${body.slice(0, body.length - rest.length).trim()}`);
+    }
+  }
   return parsedQuery;
 };
 exports.parseQuery = parseQuery;
-},{"./findCommand":48,"./findConditions":49,"./findGroupBy":50,"./findInsertValues":51,"./findJoinClauses":52,"./findJoinEntity":53,"./findLimit":54,"./findMergeJoins":55,"./findOffset":56,"./findSelects":57,"./findSortClauses":58,"./findUpdateValues":59,"./maskStrings":61,"./parseCreate":62,"./parseSchemaStatement":65,"./startsQuery":70,"si-funciona":360}],65:[function(require,module,exports){
+},{"../conditionTree":37,"./findCommand":48,"./findConditions":49,"./findGroupBy":50,"./findInsertValues":51,"./findJoinClauses":52,"./findJoinEntity":53,"./findLimit":54,"./findMergeJoins":55,"./findOffset":56,"./findSelects":57,"./findSortClauses":58,"./findUpdateValues":59,"./maskStrings":61,"./parseCreate":62,"./parseSchemaStatement":65,"./splitClauses":67,"./startsQuery":70}],65:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -3725,15 +3870,6 @@ exports.parseSchemaStatement = parseSchemaStatement;
 },{"./maskStrings":61,"./startsQuery":70}],66:[function(require,module,exports){
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.removeFromQuery = void 0;
-const removeFromQuery = (substring, query) => query.replace(substring, '').trim();
-exports.removeFromQuery = removeFromQuery;
-},{}],67:[function(require,module,exports){
-"use strict";
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -3890,7 +4026,147 @@ const assertClosed = scanned => {
   return scanned;
 };
 exports.assertClosed = assertClosed;
-},{}],68:[function(require,module,exports){
+},{}],67:[function(require,module,exports){
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.whereHint = exports.splitClauses = exports.clauseOrder = void 0;
+require("core-js/modules/es.array.includes.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 _maskStrings = require("./maskStrings");
+/**
+ * The clauses each command allows, in the order they must come. create, drop, describe and show have their own
+ * parsers and never get here.
+ */
+const clauseOrder = exports.clauseOrder = {
+  read: ['select', 'on', 'merge', 'where', 'group by', 'sort', 'limit', 'offset'],
+  insert: ['values'],
+  update: ['set', 'where'],
+  delete: ['where']
+};
+const clauseWords = [...new Set(Object.values(clauseOrder).flat())];
+// The command, the record name and an optional joined record (`read workouts.exercises`, or `read workouts .exercises`)
+const headMatch = /^\s*(delete|insert|read|update)\s+([a-z0-9_-]+(\s*\.[a-z0-9_-]+)?)/i;
+// Placeholders (see maskStrings) as one token each, so their hex can't read as a word; words; then the two-character
+// comparators before any other single character
+const tokenMatch = new RegExp(`${_maskStrings.placeholderSource}|${_maskStrings.arraySource}|[a-z0-9_.-]+|<>|!=|>=|<=|\\S`, 'gi');
+// What can follow a field in a condition: a clause word followed by one of these is a field (`where limit = 1`)
+const conditionWords = ['=', '!=', '<>', '>', '<', '>=', '<=', 'in', 'between', 'like', 'is', 'exists', 'does'];
+// `and on` carries on the on clause instead of starting another; so does a merge straight after another
+// (`merge a.x with b.y merge c.z with d.w`, with or without `and`)
+const continues = {
+  on: previous => previous === 'and',
+  merge: () => true
+};
+// What a second where clause should have been: its conditions joined with and / or inside the first
+const whereHint = exports.whereHint = 'use and / or inside one where clause (where a = 1 and b = 2)';
+/**
+ * Split a masked query (see maskStrings) into its clauses, reading its top-level words once, left to right. A clause
+ * word counts only as a whole word outside brackets, and not where it must be a name: as a clause's first word
+ * (`sort limit`), after a comma or `as`, or before a comparator (`where limit = 1`).
+ * @param query
+ * @returns undefined when the query doesn't start with read, insert, update or delete (left to the find* steps).
+ * @throws {Error} For a joined record outside read, a clause the command doesn't allow, a repeated clause, a clause out
+ * of order, or the 2.x forms of a second where (`and where`, `or where`, or a plain repeat).
+ */
+const splitClauses = query => {
+  const head = query.match(headMatch);
+  if (!head) {
+    return undefined;
+  }
+  const command = head[1].toLowerCase();
+  const allowed = clauseOrder[command];
+  const article = /^[aeiou]/.test(command) ? 'an' : 'a';
+  if (head[3] && command !== 'read') {
+    throw new Error(`A joined record (${head[2]}) isn't allowed in ${article} ${command} query`);
+  }
+  const tokens = [...query.slice(head[0].length).matchAll(tokenMatch)].map(({
+    0: text,
+    index
+  }) => ({
+    text,
+    lower: text.toLowerCase(),
+    start: head[0].length + index
+  }));
+  const found = [];
+  let depth = 0;
+  let bodyStarts = false;
+  for (let index = 0; index < tokens.length; index++) {
+    const {
+      lower,
+      start
+    } = tokens[index];
+    const previous = tokens[index - 1]?.lower;
+    const next = tokens[index + 1]?.lower;
+    if (lower === '(' || lower === ')') {
+      depth += lower === '(' ? 1 : -1;
+    }
+    const keyword = lower === 'group' && next === 'by' ? 'group by' : lower;
+    const isName = bodyStarts || previous === ',' || previous === 'as' || conditionWords.includes(next);
+    bodyStarts = false;
+    if (depth > 0 || keyword === 'by' || !clauseWords.includes(keyword) || isName) {
+      continue;
+    }
+    const current = found[found.length - 1]?.keyword;
+    if (current === keyword && continues[keyword]?.(previous)) {
+      continue;
+    }
+    // 2.x read `and where` / `or where` as `and` / `or`, and a second where as `and`
+    const hasWhere = found.some(clause => clause.keyword === 'where');
+    if (keyword === 'where' && hasWhere && (previous === 'and' || previous === 'or')) {
+      throw new Error(`"${previous} where" is no longer supported: ${whereHint}`);
+    }
+    if (!allowed.includes(keyword)) {
+      throw new Error(`"${keyword}" isn't allowed in ${article} ${command} query (allowed: ${allowed.join(', ')})`);
+    }
+    if (current && allowed.indexOf(keyword) < allowed.indexOf(current)) {
+      throw new Error(`"${keyword}" can't come after "${current}" (order: ${allowed.join(', ')})`);
+    }
+    if (found.some(clause => clause.keyword === keyword)) {
+      throw new Error(`Only one "${keyword}" clause is allowed${keyword === 'where' ? `: ${whereHint}` : ''}`);
+    }
+    if (keyword === 'group by') {
+      index++;
+    }
+    found.push({
+      keyword,
+      start,
+      end: tokens[index].start + tokens[index].text.length
+    });
+    bodyStarts = true;
+  }
+  return {
+    command,
+    head: head[0].trim(),
+    leading: query.slice(head[0].length, found[0]?.start ?? query.length).trim(),
+    clauses: found.map(({
+      keyword,
+      end
+    }, index) => ({
+      keyword,
+      body: query.slice(end, found[index + 1]?.start ?? query.length).trim()
+    }))
+  };
+};
+exports.splitClauses = splitClauses;
+},{"./maskStrings":61,"core-js/modules/es.array.includes.js":222,"core-js/modules/esnext.set.add-all.js":260,"core-js/modules/esnext.set.delete-all.js":261,"core-js/modules/esnext.set.difference.js":262,"core-js/modules/esnext.set.every.js":263,"core-js/modules/esnext.set.filter.js":264,"core-js/modules/esnext.set.find.js":265,"core-js/modules/esnext.set.intersection.js":266,"core-js/modules/esnext.set.is-disjoint-from.js":267,"core-js/modules/esnext.set.is-subset-of.js":268,"core-js/modules/esnext.set.is-superset-of.js":269,"core-js/modules/esnext.set.join.js":270,"core-js/modules/esnext.set.map.js":271,"core-js/modules/esnext.set.reduce.js":272,"core-js/modules/esnext.set.some.js":273,"core-js/modules/esnext.set.symmetric-difference.js":274,"core-js/modules/esnext.set.union.js":275}],68:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -3944,7 +4220,7 @@ const splitQueries = (queries = '') => {
   return [...semicolons, uncommented.length].map((end, index) => uncommented.slice(index === 0 ? 0 : semicolons[index - 1] + 1, end).trim()).filter(query => query.length > 0);
 };
 exports.splitQueries = splitQueries;
-},{"./scanQuery":67,"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.filter.js":240,"core-js/modules/esnext.iterator.reduce.js":245}],70:[function(require,module,exports){
+},{"./scanQuery":66,"core-js/modules/esnext.iterator.constructor.js":237,"core-js/modules/esnext.iterator.filter.js":240,"core-js/modules/esnext.iterator.reduce.js":245}],70:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -4379,8 +4655,8 @@ const runQuery = async parsed => {
   // 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 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.
+  // must not be reloaded. This used to ask whether EVERY condition was indexed, so `where date = 'none' and reps =
+  // 10` reloaded every row and returned, updated or deleted all rows with reps 10.
   const resolved = new Set();
   parsed = await (0, _getConditionIndexedList.getConditionIndexedList)(parsed, recordData, dataSet, resolved);
   const entityResolved = resolved.has(parsed.entity);
@@ -4422,10 +4698,11 @@ const runQuery = async parsed => {
   if (parsed.command !== 'delete' && parsed.command !== 'update') {
     dataSet[parsed.entity] = (0, _where.whereTree)(dataSet[parsed.entity], parsed.where, perPair ? parsed.joinEntity : undefined);
   }
+  // Sorted before grouping, so the groups come in sorted order; limit and offset count groups once there are any
   dataSet[parsed.entity] = (0, _sortBy.sortBy)(dataSet[parsed.entity], parsed.sortClauses);
-  dataSet[parsed.entity] = (0, _limitOffset.limitOffset)(dataSet[parsed.entity], parsed.offset, parsed.limit);
   dataSet[parsed.entity] = (0, _groupBy.groupBy)(dataSet[parsed.entity], parsed.groupBy);
-  dataSet[parsed.entity] = (0, _selectFields.selectFields)(dataSet[parsed.entity], parsed.selectClauses);
+  dataSet[parsed.entity] = (0, _limitOffset.limitOffset)(dataSet[parsed.entity], parsed.offset, parsed.limit);
+  dataSet[parsed.entity] = (0, _selectFields.selectFields)(dataSet[parsed.entity], parsed.selectClauses, Boolean(parsed.groupBy?.length));
   return dataSet;
 };
 exports.runQuery = runQuery;