json-fs-query 1.1.0 → 2.0.0

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

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scanQuery = exports.assertClosed = void 0;
+const escapes = {
+  n: '\n',
+  t: '\t'
+};
+const closers = {
+  ']': '[',
+  ')': '('
+};
+/**
+ * Walk a query once, left to right, finding its strings, comments and the `;` between statements.
+ *
+ * Strings use `'` or `"` and close only with the quote they opened with. Inside a string a backslash escapes the
+ * next character: `\n` and `\t` are a newline and a tab, any other `\x` is `x` (so `\'`, `\"` and `\\` are a quote
+ * and a backslash). Outside strings a backslash has no meaning. Comments run from `--` to the end of the line, or
+ * from `/*` to `*\/`; anything inside a comment is ignored, and comment markers inside a string are just text. A `--`
+ * starts a comment only at the start of the text or after whitespace or a `;`, since names can contain `-`
+ * (`my--table` is a name). A `;` inside brackets does not end a query.
+ *
+ * Never throws: whatever is left open is reported in `end`, for a prompt which asks for more input. Use
+ * assertClosed to turn it into an error.
+ * @param text
+ */
+const scanQuery = (text = '') => {
+  const strings = [];
+  const comments = [];
+  const semicolons = [];
+  const brackets = [];
+  let strayCloser;
+  let openQuote;
+  let escape = false;
+  let blockComment = false;
+  let lastCode = -1;
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (char === '\'' || char === '"') {
+      const start = index;
+      let value = '';
+      index++;
+      while (index < text.length && text[index] !== char) {
+        if (text[index] === '\\') {
+          if (index + 1 === text.length) {
+            escape = true;
+            index++;
+            break;
+          }
+          value += escapes[text[index + 1]] ?? text[index + 1];
+          index += 2;
+          continue;
+        }
+        value += text[index];
+        index++;
+      }
+      if (index < text.length) {
+        index++;
+      } else {
+        openQuote = char;
+      }
+      strings.push({
+        start,
+        end: index,
+        quote: char,
+        value
+      });
+      lastCode = start;
+      continue;
+    }
+    if (char === '-' && next === '-' && (index === 0 || /[\s;]/.test(text[index - 1]))) {
+      const newline = text.indexOf('\n', index + 2);
+      const end = newline === -1 ? text.length : newline + 1;
+      comments.push({
+        start: index,
+        end,
+        kind: 'line'
+      });
+      index = end;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      const close = text.indexOf('*/', index + 2);
+      const end = close === -1 ? text.length : close + 2;
+      blockComment = close === -1;
+      comments.push({
+        start: index,
+        end,
+        kind: 'block'
+      });
+      index = end;
+      continue;
+    }
+    if (char === '[' || char === '(') {
+      brackets.push(char);
+    } else if (closers[char]) {
+      if (brackets[brackets.length - 1] === closers[char]) {
+        brackets.pop();
+      } else if (!strayCloser) {
+        strayCloser = {
+          char,
+          index
+        };
+      }
+    } else if (char === ';' && brackets.length === 0) {
+      semicolons.push(index);
+    }
+    if (!/\s/.test(char)) {
+      lastCode = index;
+    }
+    index++;
+  }
+  const end = {
+    quote: openQuote,
+    escape,
+    blockComment,
+    brackets,
+    strayCloser
+  };
+  const closed = !end.quote && !end.blockComment && brackets.length === 0;
+  return {
+    strings,
+    comments,
+    semicolons,
+    end,
+    closed,
+    terminated: closed && semicolons.length > 0 && semicolons[semicolons.length - 1] === lastCode
+  };
+};
+/**
+ * Throw a clear error for anything scanQuery found left open or unmatched: a string, a block comment or a bracket.
+ * @param scanned
+ */
+exports.scanQuery = scanQuery;
+const assertClosed = scanned => {
+  const {
+    end
+  } = scanned;
+  if (end.quote) {
+    const open = scanned.strings[scanned.strings.length - 1];
+    throw new Error(`Unclosed string: the ${end.quote} at position ${open.start} is never closed`);
+  }
+  if (end.blockComment) {
+    throw new Error(`Unclosed comment: the /* at position ${scanned.comments[scanned.comments.length - 1].start} is never closed`);
+  }
+  if (end.strayCloser) {
+    throw new Error(`Unexpected ${end.strayCloser.char} at position ${end.strayCloser.index}: there is nothing to close`);
+  }
+  if (end.brackets.length > 0) {
+    throw new Error(`Unclosed bracket: ${end.brackets.join(' ')} never closed`);
+  }
+  return scanned;
+};
+exports.assertClosed = assertClosed;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.scanQuery=exports.assertClosed=void 0;const escapes={n:"\n",t:"\t"},closers={"]":"[",")":"("},scanQuery=(e="")=>{const s=[],t=[],n=[],o=[];let r,l,c=!1,i=!1,a=-1,h=0;for(;h<e.length;){const d=e[h],p=e[h+1];if("'"!==d&&'"'!==d)if("-"!==d||"-"!==p||0!==h&&!/[\s;]/.test(e[h-1]))if("/"!==d||"*"!==p)"["===d||"("===d?o.push(d):closers[d]?o[o.length-1]===closers[d]?o.pop():r||(r={char:d,index:h}):";"===d&&0===o.length&&n.push(h),/\s/.test(d)||(a=h),h++;else{const s=e.indexOf("*/",h+2),n=-1===s?e.length:s+2;i=-1===s,t.push({start:h,end:n,kind:"block"}),h=n}else{const s=e.indexOf("\n",h+2),n=-1===s?e.length:s+1;t.push({start:h,end:n,kind:"line"}),h=n}else{const t=h;let n="";for(h++;h<e.length&&e[h]!==d;)if("\\"!==e[h])n+=e[h],h++;else{if(h+1===e.length){c=!0,h++;break}n+=escapes[e[h+1]]??e[h+1],h+=2}h<e.length?h++:l=d,s.push({start:t,end:h,quote:d,value:n}),a=t}}const d={quote:l,escape:c,blockComment:i,brackets:o,strayCloser:r},p=!d.quote&&!d.blockComment&&0===o.length;return{strings:s,comments:t,semicolons:n,end:d,closed:p,terminated:p&&n.length>0&&n[n.length-1]===a}};exports.scanQuery=scanQuery;const assertClosed=e=>{const{end:s}=e;if(s.quote){const t=e.strings[e.strings.length-1];throw new Error(`Unclosed string: the ${s.quote} at position ${t.start} is never closed`)}if(s.blockComment)throw new Error(`Unclosed comment: the /* at position ${e.comments[e.comments.length-1].start} is never closed`);if(s.strayCloser)throw new Error(`Unexpected ${s.strayCloser.char} at position ${s.strayCloser.index}: there is nothing to close`);if(s.brackets.length>0)throw new Error(`Unclosed bracket: ${s.brackets.join(" ")} never closed`);return e};exports.assertClosed=assertClosed;

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

@@ -1,2 +1,8 @@
+/**
+ * Split a string of queries into one query each, on the `;` between them. A `;` inside a string or a comment does
+ * not count, comments are removed, and the `;` after the last query is optional.
+ * @param queries
+ * @throws {Error} For an unclosed string, block comment or bracket.
+ */
 export declare const splitQueries: (queries?: string) => string[];
 //# sourceMappingURL=splitQueries.d.ts.map

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

@@ -6,6 +6,24 @@ Object.defineProperty(exports, "__esModule", {
 exports.splitQueries = void 0;
 require("core-js/modules/esnext.iterator.constructor.js");
 require("core-js/modules/esnext.iterator.filter.js");
-const queryMatch = /\s*(?=(?:delete|insert|read|update)\s+[a-z0-9._-]+)\s*/i;
-const splitQueries = (queries = '') => queries.split(queryMatch).filter(query => query.length > 0);
+require("core-js/modules/esnext.iterator.reduce.js");
+var _scanQuery = require("./scanQuery");
+/**
+ * Split a string of queries into one query each, on the `;` between them. A `;` inside a string or a comment does
+ * not count, comments are removed, and the `;` after the last query is optional.
+ * @param queries
+ * @throws {Error} For an unclosed string, block comment or bracket.
+ */
+const splitQueries = (queries = '') => {
+  const {
+    comments,
+    semicolons
+  } = (0, _scanQuery.assertClosed)((0, _scanQuery.scanQuery)(queries));
+  // Blank each comment out with spaces, so the positions of the ; stay the same and the words either side stay apart
+  const uncommented = comments.reduce((text, {
+    start,
+    end
+  }) => `${text.slice(0, start)}${' '.repeat(end - start)}${text.slice(end)}`, 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;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.splitQueries=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js");const queryMatch=/\s*(?=(?:delete|insert|read|update)\s+[a-z0-9._-]+)\s*/i,splitQueries=(e="")=>e.split(queryMatch).filter((e=>e.length>0));exports.splitQueries=splitQueries;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.splitQueries=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.reduce.js");var _scanQuery=require("./scanQuery");const splitQueries=(e="")=>{const{comments:r,semicolons:s}=(0,_scanQuery.assertClosed)((0,_scanQuery.scanQuery)(e)),t=r.reduce(((e,{start:r,end:s})=>`${e.slice(0,r)}${" ".repeat(s-r)}${e.slice(s)}`),e);return[...s,t.length].map(((e,r)=>t.slice(0===r?0:s[r-1]+1,e).trim())).filter((e=>e.length>0))};exports.splitQueries=splitQueries;

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

@@ -0,0 +1,5 @@
+/**
+ * Matches text that starts with a command word, for the "Missing ; before" error when a query runs on into the next.
+ */
+export declare const startsQueryMatch: RegExp;
+//# sourceMappingURL=startsQuery.d.ts.map

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startsQueryMatch = void 0;
+/**
+ * Matches text that starts with a command word, for the "Missing ; before" error when a query runs on into the next.
+ */
+const startsQueryMatch = exports.startsQueryMatch = /^\s*(create|delete|describe|drop|insert|read|show|update)(?![a-z0-9_-])/i;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.startsQueryMatch=void 0;const startsQueryMatch=exports.startsQueryMatch=/^\s*(create|delete|describe|drop|insert|read|show|update)(?![a-z0-9_-])/i;

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

@@ -0,0 +1,6 @@
+/**
+ * Whether a record (its `<name>.json` file) exists in the database. Node only, like the schema statements that use it.
+ * @param entity
+ */
+export declare const recordExists: (entity: string) => boolean;
+//# sourceMappingURL=recordExists.d.ts.map

package/dist/data/utilities/recordExists.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.recordExists = void 0;
+var _config = require("./config");
+/**
+ * Whether a record (its `<name>.json` file) exists in the database. Node only, like the schema statements that use it.
+ * @param entity
+ */
+const recordExists = entity => {
+  const {
+    existsSync
+  } = require('fs');
+  return existsSync(`${(0, _config.getSetting)('databasePath', 'database/')}${entity}.json`);
+};
+exports.recordExists = recordExists;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.recordExists=void 0;var _config=require("./config");const recordExists=e=>{const{existsSync:s}=require("fs");return s(`${(0,_config.getSetting)("databasePath","database/")}${e}.json`)};exports.recordExists=recordExists;

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

@@ -1,15 +1,15 @@
-import { keyDefinition } from '../introspect/definitions/key';
-import { recordPath } from '../introspect/definitions/record';
-import { indexEntry } from './updateIndex';
-/**
- * Remove a single entry file from the index that backs one of a record's keys, dropping a value
- * entirely once its last file is removed. A key with no lookup, or an index file that doesn't
- * exist yet, is left untouched.
- * @param path
- * @param key
- * @param value
- * @param fileName
- * @param type - The declared type of the indexed value (see keyValueType), so '3' and 3 are one entry.
- */
-export declare const removeFromIndex: (path?: recordPath, key?: keyDefinition, value?: any, fileName?: string, type?: string) => Promise<indexEntry[] | null>;
+import { keyDefinition } from '../introspect/definitions/key';
+import { recordPath } from '../introspect/definitions/record';
+import { indexEntry } from './updateIndex';
+/**
+ * Remove a single entry file from the index that backs one of a record's keys, dropping a value
+ * entirely once its last file is removed. A key with no lookup, or an index file that doesn't
+ * exist yet, is left untouched.
+ * @param path
+ * @param key
+ * @param value
+ * @param fileName
+ * @param type - The declared type of the indexed value (see keyValueType), so '3' and 3 are one entry.
+ */
+export declare const removeFromIndex: (path?: recordPath, key?: keyDefinition, value?: any, fileName?: string, type?: string) => Promise<indexEntry[] | null>;
 //# sourceMappingURL=removeFromIndex.d.ts.map

package/dist/data/utilities/removeFromIndex.js

@@ -1,46 +1,46 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.removeFromIndex = void 0;
-require("core-js/modules/es.json.stringify.js");
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.filter.js");
-require("core-js/modules/esnext.iterator.map.js");
-var _config = require("./config");
-var _compareAs = require("./compareAs");
-const {
-  readFile,
-  writeFile
-} = require('fs/promises');
-/**
- * Remove a single entry file from the index that backs one of a record's keys, dropping a value
- * entirely once its last file is removed. A key with no lookup, or an index file that doesn't
- * exist yet, is left untouched.
- * @param path
- * @param key
- * @param value
- * @param fileName
- * @param type - The declared type of the indexed value (see keyValueType), so '3' and 3 are one entry.
- */
-const removeFromIndex = async (path = '', key = null, value = undefined, fileName = '', type = undefined) => {
-  if (!key || !key.lookup) {
-    return null;
-  }
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const indexPath = `${databasePath}__indexes/${path}/${key.lookup}`;
-  let index = [];
-  try {
-    index = JSON.parse(await readFile(indexPath, 'utf8'));
-  } catch (err) {
-    return null;
-  }
-  index = index.map(entry => (0, _compareAs.sameValue)(type, entry.value, value) ? {
-    value: entry.value,
-    record: entry.record.filter(record => record !== fileName)
-  } : entry).filter(entry => entry.record.length);
-  await writeFile(indexPath, JSON.stringify(index, null, 2));
-  return index;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeFromIndex = void 0;
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.map.js");
+var _config = require("./config");
+var _compareAs = require("./compareAs");
+const {
+  readFile,
+  writeFile
+} = require('fs/promises');
+/**
+ * Remove a single entry file from the index that backs one of a record's keys, dropping a value
+ * entirely once its last file is removed. A key with no lookup, or an index file that doesn't
+ * exist yet, is left untouched.
+ * @param path
+ * @param key
+ * @param value
+ * @param fileName
+ * @param type - The declared type of the indexed value (see keyValueType), so '3' and 3 are one entry.
+ */
+const removeFromIndex = async (path = '', key = null, value = undefined, fileName = '', type = undefined) => {
+  if (!key || !key.lookup) {
+    return null;
+  }
+  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
+  const indexPath = `${databasePath}__indexes/${path}/${key.lookup}`;
+  let index = [];
+  try {
+    index = JSON.parse(await readFile(indexPath, 'utf8'));
+  } catch (err) {
+    return null;
+  }
+  index = index.map(entry => (0, _compareAs.sameValue)(type, entry.value, value) ? {
+    value: entry.value,
+    record: entry.record.filter(record => record !== fileName)
+  } : entry).filter(entry => entry.record.length);
+  await writeFile(indexPath, JSON.stringify(index, null, 2));
+  return index;
+};
 exports.removeFromIndex = removeFromIndex;

package/dist/data/utilities/runQuery.js

@@ -1,113 +1,136 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.runQuery = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.reduce.js");
-var _deleteEntity = require("../queries/deleteEntity");
-var _insertEntity = require("../queries/insertEntity");
-var _readEntity = require("../queries/readEntity");
-var _updateEntity = require("../queries/updateEntity");
-var _joinEntity = require("../queries/joinEntity");
-var _mergeJoins = require("../queries/mergeJoins");
-var _where = require("../queries/where");
-var _sortBy = require("../queries/sortBy");
-var _groupBy = require("../queries/groupBy");
-var _limitOffset = require("../queries/limitOffset");
-var _selectFields = require("../queries/selectFields");
-var _retrieveRecord = require("./retrieveRecord");
-var _getConditionIndexedList = require("./getConditionIndexedList");
-var _getJoinIndexedList = require("./getJoinIndexedList");
-var _isEntityProperty = require("./parsers/isEntityProperty");
-var _splitEntityProperty = require("./parsers/splitEntityProperty");
-var _fieldType = require("./fieldType");
-/**
- * Give each condition its field's declared type, so where compares by it (a joined entity's field
- * is looked up on that entity's record).
- * @param parsed
- * @param recordData
- */
-const typeConditions = async (parsed, recordData) => {
-  for (const condition of parsed.conditions) {
-    let entity = parsed.entity;
-    let property = condition.property;
-    if ((0, _isEntityProperty.isEntityProperty)(property)) {
-      ({
-        entity,
-        property
-      } = (0, _splitEntityProperty.splitEntityProperty)(property));
-    }
-    if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
-      recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
-    }
-    condition.type = (0, _fieldType.fieldType)(recordData[entity], property);
-  }
-};
-const runQuery = async parsed => {
-  const recordData = {
-    [parsed.entity]: await (0, _retrieveRecord.retrieveRecord)(parsed.entity)
-  };
-  if (typeof parsed.joinEntity !== 'undefined') {
-    recordData[parsed.joinEntity] = await (0, _retrieveRecord.retrieveRecord)(parsed.joinEntity);
-  }
-  await typeConditions(parsed, recordData);
-  let dataSet = {
-    [parsed.entity]: []
-  };
-  // A condition that's indexed but genuinely 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, regardless of
-  // why), so capture here, before that ambiguity can happen, whether every condition actually got
-  // resolved this way - if so, dataSet[entity] is already correct and must not be reloaded.
-  const hadConditions = parsed.conditions.length > 0;
-  parsed = await (0, _getConditionIndexedList.getConditionIndexedList)(parsed, recordData, dataSet);
-  const conditionsFullyIndexed = hadConditions && parsed.conditions.length === 0;
-  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.
-  if (parsed.command === 'delete' || parsed.command === 'update') {
-    if (!conditionsFullyIndexed) {
-      dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet);
-    }
-    dataSet[parsed.entity] = parsed.conditions.reduce((remainingData, condition) => (0, _where.where)(remainingData, condition), dataSet[parsed.entity]);
-  }
-  switch (parsed.command) {
-    case 'delete':
-      dataSet = await (0, _deleteEntity.deleteEntity)(parsed.entity, dataSet);
-      break;
-    case 'insert':
-      dataSet = await (0, _insertEntity.insertEntity)(parsed.entity, parsed.insertValues, dataSet);
-      break;
-    case 'read':
-      if (!conditionsFullyIndexed) {
-        dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet);
-      }
-      break;
-    case 'update':
-      dataSet = await (0, _updateEntity.updateEntity)(parsed.entity, parsed.updateValues, dataSet);
-      break;
-    default:
-      throw new Error(`Unknown command: ${parsed.command}`);
-  }
-  dataSet = await (0, _joinEntity.joinEntity)(parsed.entity, parsed.joinEntity, dataSet, parsed.joinClauses, conditionsFullyIndexed);
-  dataSet = await (0, _mergeJoins.mergeJoins)(dataSet, parsed.mergeJoins);
-  // delete/update already had parsed.conditions 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, _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);
-  return dataSet;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runQuery = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+var _deleteEntity = require("../queries/deleteEntity");
+var _insertEntity = require("../queries/insertEntity");
+var _readEntity = require("../queries/readEntity");
+var _updateEntity = require("../queries/updateEntity");
+var _createRecord = require("../queries/createRecord");
+var _dropRecord = require("../queries/dropRecord");
+var _describeRecord = require("../queries/describeRecord");
+var _showRecords = require("../queries/showRecords");
+var _joinEntity = require("../queries/joinEntity");
+var _mergeJoins = require("../queries/mergeJoins");
+var _where = require("../queries/where");
+var _sortBy = require("../queries/sortBy");
+var _groupBy = require("../queries/groupBy");
+var _limitOffset = require("../queries/limitOffset");
+var _selectFields = require("../queries/selectFields");
+var _retrieveRecord = require("./retrieveRecord");
+var _getConditionIndexedList = require("./getConditionIndexedList");
+var _getJoinIndexedList = require("./getJoinIndexedList");
+var _isEntityProperty = require("./parsers/isEntityProperty");
+var _splitEntityProperty = require("./parsers/splitEntityProperty");
+var _fieldType = require("./fieldType");
+/**
+ * Give each condition its field's declared type, so where compares by it (a joined entity's field
+ * is looked up on that entity's record).
+ * @param parsed
+ * @param recordData
+ */
+const typeConditions = async (parsed, recordData) => {
+  for (const condition of parsed.conditions) {
+    let entity = parsed.entity;
+    let property = condition.property;
+    if ((0, _isEntityProperty.isEntityProperty)(property)) {
+      ({
+        entity,
+        property
+      } = (0, _splitEntityProperty.splitEntityProperty)(property));
+    }
+    if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
+      recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
+    }
+    condition.type = (0, _fieldType.fieldType)(recordData[entity], property);
+  }
+};
+const runQuery = async parsed => {
+  // Schema statements act on the database, not on entries (for create there is no record to read yet)
+  switch (parsed.command) {
+    case 'create':
+      return {
+        [parsed.entity]: await (0, _createRecord.createRecord)(parsed.entity, parsed.create)
+      };
+    case 'drop':
+      return {
+        [parsed.entity]: await (0, _dropRecord.dropRecord)(parsed.entity, parsed.ifExists)
+      };
+    case 'describe':
+      return {
+        [parsed.entity]: await (0, _describeRecord.describeRecord)(parsed.entity)
+      };
+    case 'show':
+      return {
+        [parsed.entity]: await (0, _showRecords.showRecords)()
+      };
+  }
+  const recordData = {
+    [parsed.entity]: await (0, _retrieveRecord.retrieveRecord)(parsed.entity)
+  };
+  if (typeof parsed.joinEntity !== 'undefined') {
+    recordData[parsed.joinEntity] = await (0, _retrieveRecord.retrieveRecord)(parsed.joinEntity);
+  }
+  await typeConditions(parsed, recordData);
+  let dataSet = {
+    [parsed.entity]: []
+  };
+  // A condition that's indexed but genuinely 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, regardless of
+  // why), so capture here, before that ambiguity can happen, whether every condition actually got
+  // resolved this way - if so, dataSet[entity] is already correct and must not be reloaded.
+  const hadConditions = parsed.conditions.length > 0;
+  parsed = await (0, _getConditionIndexedList.getConditionIndexedList)(parsed, recordData, dataSet);
+  const conditionsFullyIndexed = hadConditions && parsed.conditions.length === 0;
+  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.
+  if (parsed.command === 'delete' || parsed.command === 'update') {
+    if (!conditionsFullyIndexed) {
+      dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet);
+    }
+    dataSet[parsed.entity] = parsed.conditions.reduce((remainingData, condition) => (0, _where.where)(remainingData, condition), dataSet[parsed.entity]);
+  }
+  switch (parsed.command) {
+    case 'delete':
+      dataSet = await (0, _deleteEntity.deleteEntity)(parsed.entity, dataSet);
+      break;
+    case 'insert':
+      dataSet = await (0, _insertEntity.insertEntity)(parsed.entity, parsed.insertValues, dataSet);
+      break;
+    case 'read':
+      if (!conditionsFullyIndexed) {
+        dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet);
+      }
+      break;
+    case 'update':
+      dataSet = await (0, _updateEntity.updateEntity)(parsed.entity, parsed.updateValues, dataSet);
+      break;
+    default:
+      throw new Error(`Unknown command: ${parsed.command}`);
+  }
+  dataSet = await (0, _joinEntity.joinEntity)(parsed.entity, parsed.joinEntity, dataSet, parsed.joinClauses, conditionsFullyIndexed);
+  dataSet = await (0, _mergeJoins.mergeJoins)(dataSet, parsed.mergeJoins);
+  // delete/update already had parsed.conditions 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, _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);
+  return dataSet;
+};
 exports.runQuery = runQuery;