json-fs-query 3.1.4 → 3.3.0

package/dist/data/utilities/deregisterRecord.js

@@ -4,31 +4,25 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.deregisterRecord = 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");
-var _config = require("./config");
-const {
-  readFile,
-  writeFile
-} = require('fs/promises');
+var _storage = require("../storage");
 /**
  * Remove a record's filename from the __RECORDS registry. A missing registry file is left
  * untouched rather than created, since there's nothing to remove from it.
  * @param recordName
  */
 const deregisterRecord = async recordName => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const registryPath = `${databasePath}__RECORDS.json`;
+  const registryPath = '__RECORDS.json';
   let registry;
   try {
-    registry = JSON.parse(await readFile(registryPath, 'utf8'));
+    registry = await (0, _storage.readJson)(registryPath);
   } catch (err) {
     return null;
   }
   const fileName = `${recordName}.json`;
   registry.entries = registry.entries.filter(entry => entry !== fileName);
-  await writeFile(registryPath, JSON.stringify(registry, null, 2));
+  await (0, _storage.writeJson)(registryPath, registry);
   return registry;
 };
 exports.deregisterRecord = deregisterRecord;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deregisterRecord=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");var _config=require("./config");const{readFile:readFile,writeFile:writeFile}=require("fs/promises"),deregisterRecord=async e=>{const r=`${(0,_config.getSetting)("databasePath","database/")}__RECORDS.json`;let t;try{t=JSON.parse(await readFile(r,"utf8"))}catch(e){return null}const s=`${e}.json`;return t.entries=t.entries.filter((e=>e!==s)),await writeFile(r,JSON.stringify(t,null,2)),t};exports.deregisterRecord=deregisterRecord;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deregisterRecord=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js");var _storage=require("../storage");const deregisterRecord=async e=>{const r="__RECORDS.json";let t;try{t=await(0,_storage.readJson)(r)}catch(e){return null}const s=`${e}.json`;return t.entries=t.entries.filter((e=>e!==s)),await(0,_storage.writeJson)(r,t),t};exports.deregisterRecord=deregisterRecord;

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/indexHas.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Whether any row of `entity` has `property` = `value` (compared by the field's declared type, as where does: a null
+ * equals nothing), answered from the index of a single-field key on the field: one file instead of every row.
+ *
+ * Undefined when there is no such index, or its file can't be read or parsed (a key added to a record by hand, a file
+ * edited badly): the caller then reads the rows, which are the truth, as these checks always did. A record with no rows
+ * has none, whatever its index says.
+ * @param entity
+ * @param property
+ * @param value
+ */
+export declare const indexHas: (entity: string, property: string, value: any) => Promise<boolean | undefined>;
+//# sourceMappingURL=indexHas.d.ts.map

package/dist/data/utilities/indexHas.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indexHas = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.some.js");
+var _storage = require("../storage");
+var _where = require("../queries/where");
+var _retrieveRecord = require("./retrieveRecord");
+var _isSingleFieldKey = require("./isSingleFieldKey");
+var _fieldType = require("./fieldType");
+/**
+ * Whether any row of `entity` has `property` = `value` (compared by the field's declared type, as where does: a null
+ * equals nothing), answered from the index of a single-field key on the field: one file instead of every row.
+ *
+ * Undefined when there is no such index, or its file can't be read or parsed (a key added to a record by hand, a file
+ * edited badly): the caller then reads the rows, which are the truth, as these checks always did. A record with no rows
+ * has none, whatever its index says.
+ * @param entity
+ * @param property
+ * @param value
+ */
+const indexHas = async (entity, property, value) => {
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+  const key = record.keys.find(key => (0, _isSingleFieldKey.isSingleFieldKey)(key, property) && key.lookup);
+  if (!key) {
+    return undefined;
+  }
+  if (!(record.entries || []).length) {
+    return false;
+  }
+  let index;
+  try {
+    index = await (0, _storage.readJson)(`__indexes/${record.path}/${key.lookup}`);
+  } catch (err) {
+    return undefined;
+  }
+  return (0, _where.where)(index, {
+    property: 'value',
+    comparator: '=',
+    value,
+    type: (0, _fieldType.fieldType)(record, property)
+  }).some(entry => Array.isArray(entry.record) && entry.record.length > 0);
+};
+exports.indexHas = indexHas;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.indexHas=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.some.js");var _storage=require("../storage"),_where=require("../queries/where"),_retrieveRecord=require("./retrieveRecord"),_isSingleFieldKey=require("./isSingleFieldKey"),_fieldType=require("./fieldType");const indexHas=async(e,r,i)=>{const t=await(0,_retrieveRecord.retrieveRecord)(e),s=t.keys.find((e=>(0,_isSingleFieldKey.isSingleFieldKey)(e,r)&&e.lookup));if(!s)return;if(!(t.entries||[]).length)return!1;let o;try{o=await(0,_storage.readJson)(`__indexes/${t.path}/${s.lookup}`)}catch(e){return}return(0,_where.where)(o,{property:"value",comparator:"=",value:i,type:(0,_fieldType.fieldType)(t,r)}).some((e=>Array.isArray(e.record)&&e.record.length>0))};exports.indexHas=indexHas;

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

@@ -0,0 +1,29 @@
+import { JoinSide } from './semiJoin';
+/**
+ * One `on` clause, with each side's record, field and the declared type it's compared by.
+ */
+export type JoinStep = {
+    entityA: string;
+    propertyA: string;
+    typeA: string | undefined;
+    comparator: string;
+    entityB: string;
+    propertyB: string;
+    typeB: string | undefined;
+};
+/**
+ * The rows a join reads for each record in it, once for the whole join (every row's join then works from them):
+ * - the queried record: its rows (already read, or narrowed by the where clause)
+ * - the joined record when the where clause already narrowed it: those rows
+ * - a record joined by `=` to one already read, through an index on its field and with both fields of one type: only
+ *   the rows whose value one of those rows has (the others can't match any row's join, and the order is the record's
+ *   own, so the join's result is the same as from all of them)
+ * - any other: all its rows, kept on the query's data as before (merge reads them from there)
+ * @param entity
+ * @param joinEntity
+ * @param dataSets
+ * @param steps
+ * @param joinAlreadyResolved
+ */
+export declare const joinBases: (entity: string, joinEntity: string, dataSets: Object, steps: JoinStep[], joinAlreadyResolved: boolean) => Promise<Map<string, JoinSide>>;
+//# sourceMappingURL=joinBases.d.ts.map

package/dist/data/utilities/joinBases.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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");
+var _retrieveRecord = require("./retrieveRecord");
+var _retrieveRecords = require("./retrieveRecords");
+var _retrieveIndexes = require("./retrieveIndexes");
+var _joinKey = require("./joinKey");
+var _rowLookup = require("./rowLookup");
+/**
+ * The rows of `entity` whose `property` equals that field of at least one of `others`, found through the field's index
+ * (reading only those rows' files), or undefined when the field has no single-field index.
+ * @param entity
+ * @param property
+ * @param type
+ * @param others
+ * @param otherProperty
+ */
+const indexedRows = async (entity, property, type, others, otherProperty) => {
+  const index = (await (0, _retrieveIndexes.retrieveIndexes)(entity, [property], {}))[property];
+  if (!index) {
+    return undefined;
+  }
+  const wanted = new Set(others.map(row => (0, _joinKey.joinKey)(type, row[otherProperty])).filter(key => typeof key !== 'undefined'));
+  const files = new Set();
+  for (const entry of index) {
+    if (wanted.has((0, _joinKey.joinKey)(type, entry.value))) {
+      entry.record.forEach(file => files.add(file));
+    }
+  }
+  // In the record's own order, as a full read gives them
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+  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):
+ * - the queried record: its rows (already read, or narrowed by the where clause)
+ * - the joined record when the where clause already narrowed it: those rows
+ * - a record joined by `=` to one already read, through an index on its field and with both fields of one type: only
+ *   the rows whose value one of those rows has (the others can't match any row's join, and the order is the record's
+ *   own, so the join's result is the same as from all of them)
+ * - any other: all its rows, kept on the query's data as before (merge reads them from there)
+ * @param entity
+ * @param joinEntity
+ * @param dataSets
+ * @param steps
+ * @param joinAlreadyResolved
+ */
+const joinBases = async (entity, joinEntity, dataSets, steps, joinAlreadyResolved) => {
+  const bases = new Map();
+  const keep = (name, rows) => bases.set(name, {
+    rows,
+    lookups: new _rowLookup.RowLookups(rows)
+  });
+  keep(entity, dataSets[entity]);
+  if (joinAlreadyResolved) {
+    keep(joinEntity, dataSets[joinEntity]);
+  }
+  const allRows = async name => (await (0, _readEntity.readEntity)(name, dataSets))[name];
+  for (const step of steps) {
+    const sides = [{
+      name: step.entityA,
+      property: step.propertyA,
+      other: step.entityB,
+      otherProperty: step.propertyB
+    }, {
+      name: step.entityB,
+      property: step.propertyB,
+      other: step.entityA,
+      otherProperty: step.propertyA
+    }];
+    for (const {
+      name,
+      property,
+      other,
+      otherProperty
+    } of sides) {
+      if (bases.has(name)) {
+        continue;
+      }
+      // Fields of two types could disagree on which rows match (each side compares by its own), so only one type
+      const narrowable = step.comparator === '=' && step.typeA === step.typeB && (0, _joinKey.isKeyedType)(step.typeA) && bases.has(other);
+      const rows = narrowable ? await indexedRows(name, property, step.typeA, bases.get(other).rows, otherProperty) : undefined;
+      keep(name, rows ?? (await allRows(name)));
+    }
+  }
+  if (!bases.has(joinEntity)) {
+    keep(joinEntity, await allRows(joinEntity));
+  }
+  return bases;
+};
+exports.joinBases = joinBases;

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

@@ -0,0 +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"),_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/joinKey.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The key a value is looked up by when joining on `=` for a field of the given declared type: two values are equal for
+ * that field (sameValue) exactly when their keys are the same Map key. Undefined for a null or missing value, which
+ * equals nothing (as in where).
+ *
+ * Only for the types sameValue normalizes (see isKeyedType); any other type compares loosely (`==`), which no Map key
+ * can express, so those joins keep comparing row by row.
+ * @param type
+ * @param value
+ */
+export declare const joinKey: (type: string | undefined, value: any) => any;
+/**
+ * Whether `=` on a field of this declared type can be answered by joinKey lookups.
+ * @param type
+ */
+export declare const isKeyedType: (type: string | undefined) => boolean;
+//# sourceMappingURL=joinKey.d.ts.map

package/dist/data/utilities/joinKey.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinKey = exports.isKeyedType = void 0;
+require("core-js/modules/es.array.includes.js");
+var _compareAs = require("./compareAs");
+/**
+ * The key a value is looked up by when joining on `=` for a field of the given declared type: two values are equal for
+ * that field (sameValue) exactly when their keys are the same Map key. Undefined for a null or missing value, which
+ * equals nothing (as in where).
+ *
+ * Only for the types sameValue normalizes (see isKeyedType); any other type compares loosely (`==`), which no Map key
+ * can express, so those joins keep comparing row by row.
+ * @param type
+ * @param value
+ */
+const joinKey = (type, value) => {
+  if (value === null || typeof value === 'undefined') {
+    return undefined;
+  }
+  return (0, _compareAs.compareAs)(type, value);
+};
+/**
+ * Whether `=` on a field of this declared type can be answered by joinKey lookups.
+ * @param type
+ */
+exports.joinKey = joinKey;
+const isKeyedType = type => _compareAs.comparableTypes.includes(type);
+exports.isKeyedType = isKeyedType;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinKey=exports.isKeyedType=void 0,require("core-js/modules/es.array.includes.js");var _compareAs=require("./compareAs");const joinKey=(e,s)=>{if(null!=s)return(0,_compareAs.compareAs)(e,s)};exports.joinKey=joinKey;const isKeyedType=e=>_compareAs.comparableTypes.includes(e);exports.isKeyedType=isKeyedType;

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

@@ -0,0 +1,16 @@
+import { recordDefinition } from '../introspect/definitions/record';
+import { keyDefinition } from '../introspect/definitions/key';
+/**
+ * The entry files a key's index lists for the values `matches` accepts, in the record's own order (the order its rows
+ * are read in). A composite key's index holds its combined value (see computeKeyValue), so `matches` is given that.
+ *
+ * Undefined when the key has no index, or its file can't be read or parsed: the caller then looks through every row.
+ * The files are candidates: callers read each one and check its value, and look through the rows for any value the
+ * index didn't lead to, so an index that's out of step with the rows costs time, not a wrong result (for primary
+ * key values, which inserts and updates keep unique; see removeMatchingEntries for a hand-edited exception).
+ * @param record
+ * @param key
+ * @param matches
+ */
+export declare const keyIndexFiles: (record: recordDefinition, key: keyDefinition, matches: (value: any) => boolean) => Promise<string[] | undefined>;
+//# sourceMappingURL=keyIndexFiles.d.ts.map

package/dist/data/utilities/keyIndexFiles.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keyIndexFiles = 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.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 _storage = require("../storage");
+/**
+ * The entry files a key's index lists for the values `matches` accepts, in the record's own order (the order its rows
+ * are read in). A composite key's index holds its combined value (see computeKeyValue), so `matches` is given that.
+ *
+ * Undefined when the key has no index, or its file can't be read or parsed: the caller then looks through every row.
+ * The files are candidates: callers read each one and check its value, and look through the rows for any value the
+ * index didn't lead to, so an index that's out of step with the rows costs time, not a wrong result (for primary
+ * key values, which inserts and updates keep unique; see removeMatchingEntries for a hand-edited exception).
+ * @param record
+ * @param key
+ * @param matches
+ */
+const keyIndexFiles = async (record, key, matches) => {
+  if (!key.lookup) {
+    return undefined;
+  }
+  if (!(record.entries || []).length) {
+    return [];
+  }
+  let index;
+  try {
+    index = await (0, _storage.readJson)(`__indexes/${record.path}/${key.lookup}`);
+  } catch (err) {
+    return undefined;
+  }
+  const files = new Set();
+  for (const entry of Array.isArray(index) ? index : []) {
+    if (Array.isArray(entry.record) && matches(entry.value)) {
+      entry.record.forEach(file => files.add(file));
+    }
+  }
+  return record.entries.filter(file => files.has(file));
+};
+exports.keyIndexFiles = keyIndexFiles;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyIndexFiles=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.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 _storage=require("../storage");const keyIndexFiles=async(e,s,r)=>{if(!s.lookup)return;if(!(e.entries||[]).length)return[];let t;try{t=await(0,_storage.readJson)(`__indexes/${e.path}/${s.lookup}`)}catch(e){return}const o=new Set;for(const e of Array.isArray(t)?t:[])Array.isArray(e.record)&&r(e.value)&&e.record.forEach((e=>o.add(e)));return e.entries.filter((e=>o.has(e)))};exports.keyIndexFiles=keyIndexFiles;