json-fs-query 3.2.0 → 3.3.0

package/dist/data/utilities/config.js

@@ -3,21 +3,61 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.trackDatabaseCall = exports.resolveDatabasePath = exports.getSetting = exports.configure = void 0;
+exports.trackDatabaseCall = exports.switchDatabase = exports.resolveDatabasePath = exports.lockPath = exports.getSetting = exports.databasesFolder = exports.configure = exports.activeDatabasePath = void 0;
+require("core-js/modules/es.json.stringify.js");
 const defaults = {
   databasePath: 'database/',
   relativePath: '',
-  enforceForeignKeys: true
+  enforceForeignKeys: true,
+  readConcurrency: 16,
+  format: 'compact'
 };
 let settings = {
   ...defaults
 };
 let activeCalls = 0;
+const databaseNameMatch = /^[a-z0-9_-]+$/i;
+const withSlash = path => path.endsWith('/') ? path : `${path}/`;
+/**
+ * The folder of the database in use: `<databasesPath>/<database>/` once both are configured (see configure and the
+ * `use` statement), otherwise databasePath, as before there could be several.
+ */
+const activeDatabasePath = () => settings.databasesPath && settings.database ? `${withSlash(settings.databasesPath)}${settings.database}/` : getSetting('databasePath', 'database/');
+/**
+ * The folder whose calls are queued together (see withDatabaseLock): with several databases, all of them, since a
+ * call can switch between them (`use`) part way; otherwise the one database.
+ */
+exports.activeDatabasePath = activeDatabasePath;
+const lockPath = () => settings.databasesPath ? withSlash(settings.databasesPath) : activeDatabasePath();
+/**
+ * The folder holding the databases, for create database, drop database, use and show databases.
+ * @throws {Error} When databasesPath isn't configured.
+ */
+exports.lockPath = lockPath;
+const databasesFolder = () => {
+  if (!settings.databasesPath) {
+    throw new Error("Several databases need a folder to hold them: configure({ databasesPath: 'databases/' }) first");
+  }
+  return withSlash(settings.databasesPath);
+};
+/**
+ * Switch the database in use, from inside a call (the `use` statement, which holds the lock for every database in
+ * databasesPath, so no other call is running): configure() refuses to while calls run.
+ * @param name
+ */
+exports.databasesFolder = databasesFolder;
+const switchDatabase = name => {
+  settings = {
+    ...settings,
+    database: name
+  };
+};
 /**
  * The folder a databasePath points to, so that `database/`, `./database` and its absolute path count as one database.
  * Node only (only Node calls are counted, see trackDatabaseCall).
  * @param databasePath
  */
+exports.switchDatabase = switchDatabase;
 const resolveDatabasePath = databasePath => require('path').resolve(databasePath);
 /**
  * Count a database call (taken by withDatabaseLock as soon as a call is queued) until the returned function is called.
@@ -46,19 +86,51 @@ const trackDatabaseCall = () => {
  * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
  * on, since strict enforcement isn't always what every consumer wants.
  *
+ * readConcurrency (default 16) is how many entry files a read has in flight at once (see retrieveFiles): in a browser,
+ * how many requests run together.
+ *
+ * format (default 'compact') is how files are written: 'compact' (no whitespace: smaller files that parse faster) or
+ * 'pretty' (indented by 2 spaces, for reading data in diffs). Either is read; formatDatabase rewrites a whole database
+ * in one.
+ *
+ * packedReads (default: true in a browser, false in Node) is whether reads use a record's packed file (see
+ * packDatabase) when it has one that matches the record, instead of reading each entry file.
+ *
  * Changing databasePath while calls are still running or queued throws (see trackDatabaseCall): await them first.
  * @param newSettings
  * @throws {Error} When databasePath would point to another folder while database calls are in progress.
+ * @throws {Error} When format is neither 'compact' nor 'pretty'.
  */
 exports.trackDatabaseCall = trackDatabaseCall;
 const configure = newSettings => {
-  if (activeCalls > 0 && typeof newSettings.databasePath !== 'undefined' && resolveDatabasePath(newSettings.databasePath) !== resolveDatabasePath(settings.databasePath)) {
-    throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);
+  if (typeof newSettings.format !== 'undefined' && newSettings.format !== 'compact' && newSettings.format !== 'pretty') {
+    throw new Error(`Unknown format "${newSettings.format}": use 'compact' or 'pretty'`);
   }
-  settings = {
+  if (typeof newSettings.database !== 'undefined' && newSettings.database !== null && !databaseNameMatch.test(newSettings.database)) {
+    throw new Error(`Invalid database name ${JSON.stringify(newSettings.database)}: names use letters, digits, _ and - only`);
+  }
+  const next = {
     ...settings,
     ...newSettings
   };
+  if (next.database && !next.databasesPath) {
+    throw new Error("A database name needs the folder that holds the databases: configure({ databasesPath: 'databases/', database: '...' })");
+  }
+  if (activeCalls > 0) {
+    const before = {
+      active: resolveDatabasePath(activeDatabasePath()),
+      lock: resolveDatabasePath(lockPath())
+    };
+    const previous = settings;
+    settings = next;
+    const changed = resolveDatabasePath(activeDatabasePath()) !== before.active || resolveDatabasePath(lockPath()) !== before.lock;
+    settings = previous;
+    if (changed) {
+      const named = ['databasePath', 'databasesPath', 'database'].filter(key => typeof newSettings[key] !== 'undefined').join(' / ');
+      throw new Error(`Can't change ${named} while ${activeCalls} database call(s) are still running or queued: await them first`);
+    }
+  }
+  settings = next;
 };
 /**
  * Read one runtime setting, falling back to the given default if it was never configured. This is

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.trackDatabaseCall=exports.resolveDatabasePath=exports.getSetting=exports.configure=void 0;const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0};let settings={...defaults},activeCalls=0;const resolveDatabasePath=t=>require("path").resolve(t);exports.resolveDatabasePath=resolveDatabasePath;const trackDatabaseCall=()=>{activeCalls++;let t=!1;return()=>{t||(t=!0,activeCalls--)}};exports.trackDatabaseCall=trackDatabaseCall;const configure=t=>{if(activeCalls>0&&void 0!==t.databasePath&&resolveDatabasePath(t.databasePath)!==resolveDatabasePath(settings.databasePath))throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);settings={...settings,...t}};exports.configure=configure;const getSetting=(t,a)=>void 0!==settings[t]?settings[t]:a;exports.getSetting=getSetting;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.trackDatabaseCall=exports.switchDatabase=exports.resolveDatabasePath=exports.lockPath=exports.getSetting=exports.databasesFolder=exports.configure=exports.activeDatabasePath=void 0,require("core-js/modules/es.json.stringify.js");const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0,readConcurrency:16,format:"compact"};let settings={...defaults},activeCalls=0;const databaseNameMatch=/^[a-z0-9_-]+$/i,withSlash=a=>a.endsWith("/")?a:`${a}/`,activeDatabasePath=()=>settings.databasesPath&&settings.database?`${withSlash(settings.databasesPath)}${settings.database}/`:getSetting("databasePath","database/");exports.activeDatabasePath=activeDatabasePath;const lockPath=()=>settings.databasesPath?withSlash(settings.databasesPath):activeDatabasePath();exports.lockPath=lockPath;const databasesFolder=()=>{if(!settings.databasesPath)throw new Error("Several databases need a folder to hold them: configure({ databasesPath: 'databases/' }) first");return withSlash(settings.databasesPath)};exports.databasesFolder=databasesFolder;const switchDatabase=a=>{settings={...settings,database:a}};exports.switchDatabase=switchDatabase;const resolveDatabasePath=a=>require("path").resolve(a);exports.resolveDatabasePath=resolveDatabasePath;const trackDatabaseCall=()=>{activeCalls++;let a=!1;return()=>{a||(a=!0,activeCalls--)}};exports.trackDatabaseCall=trackDatabaseCall;const configure=a=>{if(void 0!==a.format&&"compact"!==a.format&&"pretty"!==a.format)throw new Error(`Unknown format "${a.format}": use 'compact' or 'pretty'`);if(void 0!==a.database&&null!==a.database&&!databaseNameMatch.test(a.database))throw new Error(`Invalid database name ${JSON.stringify(a.database)}: names use letters, digits, _ and - only`);const t={...settings,...a};if(t.database&&!t.databasesPath)throw new Error("A database name needs the folder that holds the databases: configure({ databasesPath: 'databases/', database: '...' })");if(activeCalls>0){const e={active:resolveDatabasePath(activeDatabasePath()),lock:resolveDatabasePath(lockPath())},s=settings;settings=t;const o=resolveDatabasePath(activeDatabasePath())!==e.active||resolveDatabasePath(lockPath())!==e.lock;if(settings=s,o){const t=["databasePath","databasesPath","database"].filter((t=>void 0!==a[t])).join(" / ");throw new Error(`Can't change ${t} while ${activeCalls} database call(s) are still running or queued: await them first`)}}settings=t};exports.configure=configure;const getSetting=(a,t)=>void 0!==settings[a]?settings[a]:t;exports.getSetting=getSetting;

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

@@ -1,3 +1,8 @@
+/**
+ * How many calls are running in this browser page right now (they aren't queued there, see withDatabaseLock): `use`
+ * refuses to switch the database while any other call is, as that call would carry on in the other database.
+ */
+export declare const browserCallsRunning: () => number;
 /**
  * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
  * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and

package/dist/data/utilities/databaseLock.js

@@ -4,7 +4,7 @@ require("core-js/modules/esnext.weak-map.delete-all.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.withDatabaseLock = void 0;
+exports.withDatabaseLock = exports.browserCallsRunning = void 0;
 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");
@@ -24,6 +24,12 @@ var _storage = require("../storage");
 var e;
 function _interopRequireWildcard(t, r) { if (!r && t && t.__esModule) return t; var n, a, o = Object.defineProperty, f = { __proto__: null, default: t }; if (Object(t) !== t) return f; if (e || "function" != typeof WeakMap || (e = new WeakMap()), e) { if (e.has(t)) return e.get(t); e.set(t, f); } for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]); return f; }
 const queues = new Map();
+let browserCalls = 0;
+/**
+ * How many calls are running in this browser page right now (they aren't queued there, see withDatabaseLock): `use`
+ * refuses to switch the database while any other call is, as that call would carry on in the other database.
+ */
+const browserCallsRunning = () => browserCalls;
 /**
  * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
  * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and
@@ -40,11 +46,17 @@ const queues = new Map();
  * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
  * @param task
  */
+exports.browserCallsRunning = browserCallsRunning;
 const withDatabaseLock = async task => {
   if (!jsEnv.isNode) {
-    return (0, _storage.withReadCache)(task);
+    browserCalls++;
+    try {
+      return await (0, _storage.withReadCache)(task);
+    } finally {
+      browserCalls--;
+    }
   }
-  const database = (0, _config.resolveDatabasePath)((0, _config.getSetting)('databasePath', 'database/'));
+  const database = (0, _config.resolveDatabasePath)((0, _config.lockPath)());
   const ended = (0, _config.trackDatabaseCall)();
   const previous = queues.get(database) || Promise.resolve();
   let release;

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

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.withDatabaseLock=void 0,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");var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config"),_storage=require("../storage");function _interopRequireWildcard(s,r){if(!r&&s&&s.__esModule)return s;var t,a,o=Object.defineProperty,u={__proto__:null,default:s};if(Object(s)!==s)return u;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(s))return e.get(s);e.set(s,u)}for(a in s)"default"!==a&&{}.hasOwnProperty.call(s,a)&&((t=o&&Object.getOwnPropertyDescriptor(s,a))&&(t.get||t.set)?o(u,a,t):u[a]=s[a]);return u}const queues=new Map,withDatabaseLock=async e=>{if(!jsEnv.isNode)return(0,_storage.withReadCache)(e);const s=(0,_config.resolveDatabasePath)((0,_config.getSetting)("databasePath","database/")),r=(0,_config.trackDatabaseCall)(),t=queues.get(s)||Promise.resolve();let a;const o=new Promise((e=>{a=e})),u=t.then((()=>o));queues.set(s,u),await t;try{return await(0,_storage.withReadCache)(e)}finally{r(),a(),queues.get(s)===u&&queues.delete(s)}};exports.withDatabaseLock=withDatabaseLock;
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.withDatabaseLock=exports.browserCallsRunning=void 0,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");var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config"),_storage=require("../storage");function _interopRequireWildcard(r,s){if(!s&&r&&r.__esModule)return r;var t,o,a=Object.defineProperty,n={__proto__:null,default:r};if(Object(r)!==r)return n;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(r))return e.get(r);e.set(r,n)}for(o in r)"default"!==o&&{}.hasOwnProperty.call(r,o)&&((t=a&&Object.getOwnPropertyDescriptor(r,o))&&(t.get||t.set)?a(n,o,t):n[o]=r[o]);return n}const queues=new Map;let browserCalls=0;const browserCallsRunning=()=>browserCalls;exports.browserCallsRunning=browserCallsRunning;const withDatabaseLock=async e=>{if(!jsEnv.isNode){browserCalls++;try{return await(0,_storage.withReadCache)(e)}finally{browserCalls--}}const r=(0,_config.resolveDatabasePath)((0,_config.lockPath)()),s=(0,_config.trackDatabaseCall)(),t=queues.get(r)||Promise.resolve();let o;const a=new Promise((e=>{o=e})),n=t.then((()=>a));queues.set(r,n),await t;try{return await(0,_storage.withReadCache)(e)}finally{s(),o(),queues.get(r)===n&&queues.delete(r)}};exports.withDatabaseLock=withDatabaseLock;

package/dist/data/utilities/getConditionIndexedList.js

@@ -28,6 +28,7 @@ var _isEntityProperty = require("./parsers/isEntityProperty");
 var _splitEntityProperty = require("./parsers/splitEntityProperty");
 var _retrieveRecord = require("./retrieveRecord");
 var _where = require("../queries/where");
+var _retrieveRecords = require("./retrieveRecords");
 var _retrieveFile = require("./retrieveFile");
 var _retrieveIndexes = require("./retrieveIndexes");
 var _isSingleFieldKey = require("./isSingleFieldKey");
@@ -149,10 +150,8 @@ const getConditionIndexedList = async (parsed, recordData, dataSet, resolved = n
   }
   for (const entity of Object.keys(matchedFiles)) {
     resolved.add(entity);
-    dataSet[entity] = [];
-    for (const file of matchedFiles[entity]) {
-      dataSet[entity].push(await (0, _retrieveFile.retrieveFile)(`${entity}/${file}`));
-    }
+    const record = recordData[entity] || (await (0, _retrieveRecord.retrieveRecord)(entity));
+    dataSet[entity] = await (0, _retrieveRecords.retrieveEntryRows)(record, [...matchedFiles[entity]], _retrieveFile.retrieveFile);
   }
   return parsed;
 };

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.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;
+"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"),_retrieveRecords=require("./retrieveRecords"),_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,i,s)=>{if(Object.prototype.hasOwnProperty.call(i,e)||(i[e]=await(0,_retrieveRecord.retrieveRecord)(e)),i[e].keys.some((e=>(0,_isSingleFieldKey.isSingleFieldKey)(e,r))))return s[e]=s[e]||{},Object.prototype.hasOwnProperty.call(s[e],r)||(s[e][r]=(await(0,_retrieveIndexes.retrieveIndexes)(e,[r],i))[r]),new Set((0,_where.where)(s[e][r],{property:"value",comparator:t.comparator,value:t.value,type:t.type}).flatMap((e=>e.record)))},candidatesOf=async(e,r,t,i)=>{if((0,_conditionTree.isCondition)(e)){const{entity:s,property:o}=conditionField(e,r);return s===r?await indexedFiles(s,o,e,t,i):void 0}if("not"in e)return;if("or"in e){const s=new Set;for(const o of e.or){const e=await candidatesOf(o,r,t,i);if(void 0===e)return;e.forEach((e=>s.add(e)))}return s}let s;for(const o of e.and){const e=await candidatesOf(o,r,t,i);void 0!==e&&(s=void 0===s?e:new Set([...s].filter((r=>e.has(r)))))}return s},getConditionIndexedList=async(e,r,t,i=new Set)=>{const s={},o={};if(void 0!==e.where){const t=await candidatesOf(e.where,e.entity,r,o);void 0!==t&&(s[e.entity]=t)}for(const t of(0,_conditionTree.requiredConditions)(e.where)){const{entity:i,property:n}=conditionField(t,e.entity);if(i===e.entity)continue;const d=await indexedFiles(i,n,t,r,o);void 0!==d&&(s[i]=Object.prototype.hasOwnProperty.call(s,i)?new Set([...s[i]].filter((e=>d.has(e)))):d)}for(const e of Object.keys(s)){i.add(e);const o=r[e]||await(0,_retrieveRecord.retrieveRecord)(e);t[e]=await(0,_retrieveRecords.retrieveEntryRows)(o,[...s[e]],_retrieveFile.retrieveFile)}return e};exports.getConditionIndexedList=getConditionIndexedList;

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

@@ -0,0 +1,35 @@
+import { indexEntry } from './updateIndex';
+/**
+ * One index file held in memory while a statement changes it many times: values are found through a Map instead of a
+ * search of the whole index each time, and the file is written once at the end (see insertEntity). It holds and
+ * changes the index exactly as updateIndex would, one row after another: a new value is added at the end, a file
+ * already listed for its value isn't listed twice.
+ */
+export declare class IndexBuffer {
+    readonly entries: indexEntry[];
+    private readonly type;
+    private readonly byKey;
+    private readonly listed;
+    /**
+     * @param entries - The index as read from its file ([] when there's none yet).
+     * @param type - The key's value type (see keyValueType).
+     */
+    constructor(entries: indexEntry[], type: string | undefined);
+    /**
+     * The entry for `value`, as updateIndex finds it.
+     * @param value
+     */
+    find(value: any): indexEntry | undefined;
+    /**
+     * Whether a row holds `value`, as indexHas answers it: an entry for it lists a file (never for null or undefined).
+     * @param value
+     */
+    has(value: any): boolean;
+    /**
+     * List `fileName` under `value`, as updateIndex does.
+     * @param value
+     * @param fileName
+     */
+    add(value: any, fileName: string): void;
+}
+//# sourceMappingURL=indexBuffer.d.ts.map

package/dist/data/utilities/indexBuffer.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexBuffer = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.some.js");
+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");
+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");
+require("core-js/modules/esnext.weak-map.delete-all.js");
+var _compareAs = require("./compareAs");
+const unkeyed = Symbol('unkeyed');
+/**
+ * The key a value is found by in a Map, so that two values share a key exactly when sameValue says they're the same:
+ * compareAs gives that for the comparable types (a Map compares keys like ===). Other types compare with ==, and a
+ * value compareAs leaves as an object compares by identity, so those are searched in turn instead.
+ * @param type
+ * @param value
+ */
+const keyOf = (type, value) => {
+  if (!_compareAs.comparableTypes.includes(type)) {
+    return unkeyed;
+  }
+  const key = (0, _compareAs.compareAs)(type, value);
+  return typeof key === 'object' && key !== null ? unkeyed : key;
+};
+/**
+ * One index file held in memory while a statement changes it many times: values are found through a Map instead of a
+ * search of the whole index each time, and the file is written once at the end (see insertEntity). It holds and
+ * changes the index exactly as updateIndex would, one row after another: a new value is added at the end, a file
+ * already listed for its value isn't listed twice.
+ */
+class IndexBuffer {
+  /**
+   * @param entries - The index as read from its file ([] when there's none yet).
+   * @param type - The key's value type (see keyValueType).
+   */
+  constructor(entries, type) {
+    this.byKey = new Map();
+    // The files each entry lists, built when a file is first added to it: a value shared by every row (a foreign key to
+    // one parent) would otherwise be searched once per row, which grows with the square of the rows
+    this.listed = new WeakMap();
+    this.entries = entries;
+    this.type = type;
+    for (const entry of entries) {
+      const key = keyOf(type, entry.value);
+      // The first entry for a value is the one updateIndex's find() would give
+      if (key !== unkeyed && !this.byKey.has(key)) {
+        this.byKey.set(key, entry);
+      }
+    }
+  }
+  /**
+   * The entry for `value`, as updateIndex finds it.
+   * @param value
+   */
+  find(value) {
+    const key = keyOf(this.type, value);
+    return key === unkeyed ? this.entries.find(entry => (0, _compareAs.sameValue)(this.type, entry.value, value)) : this.byKey.get(key);
+  }
+  /**
+   * Whether a row holds `value`, as indexHas answers it: an entry for it lists a file (never for null or undefined).
+   * @param value
+   */
+  has(value) {
+    // where's = never matches null or a missing value (an index entry for a row without the field has no value)
+    if (value === null || typeof value === 'undefined') {
+      return false;
+    }
+    const listsFiles = entry => Boolean(entry && Array.isArray(entry.record) && entry.record.length);
+    const first = this.find(value);
+    if (!first || listsFiles(first)) {
+      // No entry at all for the value (the Map holds the first of each), or one that lists a file
+      return listsFiles(first);
+    }
+    // indexHas looks at every entry for the value; an index edited by hand can hold more than one
+    return this.entries.some(entry => (0, _compareAs.sameValue)(this.type, entry.value, value) && listsFiles(entry));
+  }
+  /**
+   * List `fileName` under `value`, as updateIndex does.
+   * @param value
+   * @param fileName
+   */
+  add(value, fileName) {
+    const existing = this.find(value);
+    if (existing) {
+      if (!this.listed.has(existing)) {
+        this.listed.set(existing, new Set(existing.record));
+      }
+      const files = this.listed.get(existing);
+      if (!files.has(fileName)) {
+        files.add(fileName);
+        existing.record.push(fileName);
+      }
+      return;
+    }
+    const entry = {
+      value,
+      record: [fileName]
+    };
+    this.entries.push(entry);
+    this.listed.set(entry, new Set(entry.record));
+    const key = keyOf(this.type, value);
+    if (key !== unkeyed) {
+      this.byKey.set(key, entry);
+    }
+  }
+}
+exports.IndexBuffer = IndexBuffer;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.IndexBuffer=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.some.js"),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"),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"),require("core-js/modules/esnext.weak-map.delete-all.js");var _compareAs=require("./compareAs");const unkeyed=Symbol("unkeyed"),keyOf=(e,s)=>{if(!_compareAs.comparableTypes.includes(e))return unkeyed;const r=(0,_compareAs.compareAs)(e,s);return"object"==typeof r&&null!==r?unkeyed:r};class IndexBuffer{constructor(e,s){this.byKey=new Map,this.listed=new WeakMap,this.entries=e,this.type=s;for(const r of e){const e=keyOf(s,r.value);e===unkeyed||this.byKey.has(e)||this.byKey.set(e,r)}}find(e){const s=keyOf(this.type,e);return s===unkeyed?this.entries.find((s=>(0,_compareAs.sameValue)(this.type,s.value,e))):this.byKey.get(s)}has(e){if(null==e)return!1;const s=e=>Boolean(e&&Array.isArray(e.record)&&e.record.length),r=this.find(e);return!r||s(r)?s(r):this.entries.some((r=>(0,_compareAs.sameValue)(this.type,r.value,e)&&s(r)))}add(e,s){const r=this.find(e);if(r){this.listed.has(r)||this.listed.set(r,new Set(r.record));const e=this.listed.get(r);return void(e.has(s)||(e.add(s),r.record.push(s)))}const t={value:e,record:[s]};this.entries.push(t),this.listed.set(t,new Set(t.record));const o=keyOf(this.type,e);o!==unkeyed&&this.byKey.set(o,t)}}exports.IndexBuffer=IndexBuffer;

package/dist/data/utilities/joinBases.js

@@ -39,7 +39,7 @@ require("core-js/modules/esnext.set.symmetric-difference.js");
 require("core-js/modules/esnext.set.union.js");
 var _readEntity = require("../queries/readEntity");
 var _retrieveRecord = require("./retrieveRecord");
-var _retrieveFile = require("./retrieveFile");
+var _retrieveRecords = require("./retrieveRecords");
 var _retrieveIndexes = require("./retrieveIndexes");
 var _joinKey = require("./joinKey");
 var _rowLookup = require("./rowLookup");
@@ -66,15 +66,7 @@ const indexedRows = async (entity, property, type, others, otherProperty) => {
   }
   // In the record's own order, as a full read gives them
   const record = await (0, _retrieveRecord.retrieveRecord)(entity);
-  const rows = [];
-  for (const file of record.entries.filter(entry => files.has(entry))) {
-    const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${file}`).catch(err => console.error(err));
-    if (!data) {
-      throw new Error(`Could not read entity ${file}`);
-    }
-    rows.push(data);
-  }
-  return rows;
+  return (0, _retrieveRecords.retrieveEntryRows)(record, record.entries.filter(entry => files.has(entry)));
 };
 /**
  * The rows a join reads for each record in it, once for the whole join (every row's join then works from them):

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinBases=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.for-each.js"),require("core-js/modules/esnext.iterator.map.js"),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"),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 _readEntity=require("../queries/readEntity"),_retrieveRecord=require("./retrieveRecord"),_retrieveFile=require("./retrieveFile"),_retrieveIndexes=require("./retrieveIndexes"),_joinKey=require("./joinKey"),_rowLookup=require("./rowLookup");const indexedRows=async(e,r,s,o,t)=>{const i=(await(0,_retrieveIndexes.retrieveIndexes)(e,[r],{}))[r];if(!i)return;const n=new Set(o.map((e=>(0,_joinKey.joinKey)(s,e[t]))).filter((e=>void 0!==e))),u=new Set;for(const e of i)n.has((0,_joinKey.joinKey)(s,e.value))&&e.record.forEach((e=>u.add(e)));const j=await(0,_retrieveRecord.retrieveRecord)(e),d=[];for(const e of j.entries.filter((e=>u.has(e)))){const r=await(0,_retrieveFile.retrieveFile)(`${j.path}/${e}`).catch((e=>console.error(e)));if(!r)throw new Error(`Could not read entity ${e}`);d.push(r)}return d},joinBases=async(e,r,s,o,t)=>{const i=new Map,n=(e,r)=>i.set(e,{rows:r,lookups:new _rowLookup.RowLookups(r)});n(e,s[e]),t&&n(r,s[r]);const u=async e=>(await(0,_readEntity.readEntity)(e,s))[e];for(const e of o){const r=[{name:e.entityA,property:e.propertyA,other:e.entityB,otherProperty:e.propertyB},{name:e.entityB,property:e.propertyB,other:e.entityA,otherProperty:e.propertyA}];for(const{name:s,property:o,other:t,otherProperty:j}of r){if(i.has(s))continue;n(s,("="===e.comparator&&e.typeA===e.typeB&&(0,_joinKey.isKeyedType)(e.typeA)&&i.has(t)?await indexedRows(s,o,e.typeA,i.get(t).rows,j):void 0)??await u(s))}}return i.has(r)||n(r,await u(r)),i};exports.joinBases=joinBases;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinBases=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.for-each.js"),require("core-js/modules/esnext.iterator.map.js"),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"),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 _readEntity=require("../queries/readEntity"),_retrieveRecord=require("./retrieveRecord"),_retrieveRecords=require("./retrieveRecords"),_retrieveIndexes=require("./retrieveIndexes"),_joinKey=require("./joinKey"),_rowLookup=require("./rowLookup");const indexedRows=async(e,r,s,o,t)=>{const i=(await(0,_retrieveIndexes.retrieveIndexes)(e,[r],{}))[r];if(!i)return;const n=new Set(o.map((e=>(0,_joinKey.joinKey)(s,e[t]))).filter((e=>void 0!==e))),u=new Set;for(const e of i)n.has((0,_joinKey.joinKey)(s,e.value))&&e.record.forEach((e=>u.add(e)));const j=await(0,_retrieveRecord.retrieveRecord)(e);return(0,_retrieveRecords.retrieveEntryRows)(j,j.entries.filter((e=>u.has(e))))},joinBases=async(e,r,s,o,t)=>{const i=new Map,n=(e,r)=>i.set(e,{rows:r,lookups:new _rowLookup.RowLookups(r)});n(e,s[e]),t&&n(r,s[r]);const u=async e=>(await(0,_readEntity.readEntity)(e,s))[e];for(const e of o){const r=[{name:e.entityA,property:e.propertyA,other:e.entityB,otherProperty:e.propertyB},{name:e.entityB,property:e.propertyB,other:e.entityA,otherProperty:e.propertyA}];for(const{name:s,property:o,other:t,otherProperty:j}of r){if(i.has(s))continue;n(s,("="===e.comparator&&e.typeA===e.typeB&&(0,_joinKey.isKeyedType)(e.typeA)&&i.has(t)?await indexedRows(s,o,e.typeA,i.get(t).rows,j):void 0)??await u(s))}}return i.has(r)||n(r,await u(r)),i};exports.joinBases=joinBases;

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

@@ -0,0 +1,26 @@
+import { recordDefinition } from '../introspect/definitions/record';
+/**
+ * Throw unless `record` defines every one of `fields`, naming the first that it doesn't and the fields it has: a
+ * misspelled field would otherwise be dropped from an insert, stored by an update, or match nothing in a read.
+ * @param entity - The record's name, for the message.
+ * @param record
+ * @param fields
+ * @param where - Where the fields were given (`insert`, `set`, `where`...), for the message.
+ * @throws {Error} `Unknown field "<field>" in <where>: <entity> has <fields>`.
+ */
+export declare const assertFieldsDefined: (entity: string, record: recordDefinition, fields: string[], where: string) => void;
+/**
+ * Throw unless every field a query names (in `where`, `sort`, `group by`, `select`, `on`, `merge`, and an insert's or
+ * update's values) is defined by its record, before anything is read: the queried record for a plain name, the named
+ * one for `<record>.<field>` (any record, as a join through another one names it). In `select`, the joined record's
+ * name stands for its rows, and `<record>.<field>` names the queried record's own field or a merged record's (a joined
+ * record's rows are a list, with no one value to pick).
+ * @param parsed - The parsed query.
+ * @param recordData - Records already read, by name (more are read as they're named, and kept here).
+ * @throws {Error} `Unknown field ...` (see assertFieldsDefined), or `Record "<name>" doesn't exist` for a record that
+ *   doesn't.
+ */
+export declare const assertKnownFields: (parsed: any, recordData: {
+    [entity: string]: recordDefinition;
+}) => Promise<void>;
+//# sourceMappingURL=knownFields.d.ts.map

package/dist/data/utilities/knownFields.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertKnownFields = exports.assertFieldsDefined = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.flat-map.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.js");
+var _retrieveRecord = require("./retrieveRecord");
+var _isEntityProperty = require("./parsers/isEntityProperty");
+var _splitEntityProperty = require("./parsers/splitEntityProperty");
+var _conditionTree = require("./conditionTree");
+/**
+ * The fields a record defines, for an error message.
+ * @param record
+ */
+const fieldList = record => record.definition.map(field => field.name).join(', ');
+/**
+ * Throw unless `record` defines every one of `fields`, naming the first that it doesn't and the fields it has: a
+ * misspelled field would otherwise be dropped from an insert, stored by an update, or match nothing in a read.
+ * @param entity - The record's name, for the message.
+ * @param record
+ * @param fields
+ * @param where - Where the fields were given (`insert`, `set`, `where`...), for the message.
+ * @throws {Error} `Unknown field "<field>" in <where>: <entity> has <fields>`.
+ */
+const assertFieldsDefined = (entity, record, fields, where) => {
+  const defined = new Set(record.definition.map(field => field.name));
+  const unknown = fields.find(field => !defined.has(field));
+  if (typeof unknown !== 'undefined') {
+    throw new Error(`Unknown field "${unknown}" in ${where}: ${entity} has ${fieldList(record)}`);
+  }
+};
+/**
+ * Throw unless every field a query names (in `where`, `sort`, `group by`, `select`, `on`, `merge`, and an insert's or
+ * update's values) is defined by its record, before anything is read: the queried record for a plain name, the named
+ * one for `<record>.<field>` (any record, as a join through another one names it). In `select`, the joined record's
+ * name stands for its rows, and `<record>.<field>` names the queried record's own field or a merged record's (a joined
+ * record's rows are a list, with no one value to pick).
+ * @param parsed - The parsed query.
+ * @param recordData - Records already read, by name (more are read as they're named, and kept here).
+ * @throws {Error} `Unknown field ...` (see assertFieldsDefined), or `Record "<name>" doesn't exist` for a record that
+ *   doesn't.
+ */
+exports.assertFieldsDefined = assertFieldsDefined;
+const assertKnownFields = async (parsed, recordData) => {
+  // A merged record's fields are on each row as `<record>.<field>`, so select can name them; a joined one's rows are a
+  // list, with no one value to pick
+  const merged = new Set((parsed.mergeJoins || []).map(merge => (0, _splitEntityProperty.splitEntityProperty)(merge.propertyB).entity));
+  const named = [...(0, _conditionTree.conditionsOf)(parsed.where).map(condition => ({
+    property: condition.property,
+    clause: 'where'
+  })), ...(parsed.sortClauses || []).map(sort => ({
+    property: sort.property,
+    clause: 'sort'
+  })), ...(parsed.groupBy || []).map(property => ({
+    property,
+    clause: 'group by'
+  })), ...(parsed.selectClauses || []).filter(select => select.property !== parsed.joinEntity).map(select => ({
+    property: select.property,
+    clause: 'select'
+  })), ...(parsed.insertValues || []).flatMap(row => Object.keys(row || {}).map(property => ({
+    property,
+    clause: 'insert',
+    own: true
+  }))), ...Object.keys(parsed.updateValues || {}).map(property => ({
+    property,
+    clause: 'set',
+    own: true
+  })), ...(parsed.joinClauses || []).flatMap(join => [{
+    property: join.propertyA,
+    clause: 'on'
+  }, {
+    property: join.propertyB,
+    clause: 'on'
+  }]), ...(parsed.mergeJoins || []).flatMap(merge => [{
+    property: merge.propertyA,
+    clause: 'merge'
+  }, {
+    property: merge.propertyB,
+    clause: 'merge'
+  }])];
+  for (const {
+    property,
+    clause,
+    own
+  } of named) {
+    if (typeof property !== 'string') {
+      continue;
+    }
+    let entity = parsed.entity;
+    let field = property;
+    // Insert and set values are always the queried record's own fields, whatever their name
+    if (!own && (0, _isEntityProperty.isEntityProperty)(property)) {
+      ({
+        entity,
+        property: field
+      } = (0, _splitEntityProperty.splitEntityProperty)(property));
+    }
+    if (clause === 'select' && entity !== parsed.entity && !merged.has(entity)) {
+      throw new Error(`Can't select "${property}": a joined record's rows are a list under its name (select ${entity}), ` + `and its fields are on each row only when merged (merge ... with ${entity}.<field>)`);
+    }
+    if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
+      recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
+    }
+    assertFieldsDefined(entity, recordData[entity], [field], clause);
+  }
+};
+exports.assertKnownFields = assertKnownFields;