json-fs-query 3.1.3 → 3.2.0

package/dist/data/utilities/compareAs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.sameValue = exports.compareAs = void 0;
+exports.sameValue = exports.compareAs = exports.comparableTypes = void 0;
 require("core-js/modules/es.array.includes.js");
 /**
  * Normalize a value to a field's declared type for an equality comparison - never written back,
@@ -39,7 +39,7 @@ const compareAs = (type, value) => {
   }
 };
 exports.compareAs = compareAs;
-const comparableTypes = ['string', 'int', 'boolean'];
+const comparableTypes = exports.comparableTypes = ['string', 'int', 'boolean'];
 /**
  * Whether two values are equal for a field of the given declared type: both are normalized to
  * that type (see compareAs) and compared strictly. A field with no declared type, or one that

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.sameValue=exports.compareAs=void 0,require("core-js/modules/es.array.includes.js");const compareAs=(e,r)=>{if(null==r)return r;switch(e){case"string":return"object"==typeof r?r:String(r);case"int":{const e=Number(r);return Number.isNaN(e)?r:e}case"boolean":return"true"===r||"false"!==r&&r;default:return r}};exports.compareAs=compareAs;const comparableTypes=["string","int","boolean"],sameValue=(e,r,s)=>comparableTypes.includes(e)?compareAs(e,r)===compareAs(e,s):r==s;exports.sameValue=sameValue;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.sameValue=exports.compareAs=exports.comparableTypes=void 0,require("core-js/modules/es.array.includes.js");const compareAs=(e,r)=>{if(null==r)return r;switch(e){case"string":return"object"==typeof r?r:String(r);case"int":{const e=Number(r);return Number.isNaN(e)?r:e}case"boolean":return"true"===r||"false"!==r&&r;default:return r}};exports.compareAs=compareAs;const comparableTypes=exports.comparableTypes=["string","int","boolean"],sameValue=(e,r,s)=>comparableTypes.includes(e)?compareAs(e,r)===compareAs(e,s):r==s;exports.sameValue=sameValue;

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

@@ -8,6 +8,8 @@
  * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
  * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
  *
+ * Each task also runs with a read cache (see withReadCache): the files it reads are read once for the whole call.
+ *
  * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
  * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
  * @param task

package/dist/data/utilities/databaseLock.js

@@ -20,6 +20,7 @@ require("core-js/modules/esnext.map.some.js");
 require("core-js/modules/esnext.map.update.js");
 var jsEnv = _interopRequireWildcard(require("browser-or-node"));
 var _config = require("./config");
+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();
@@ -33,13 +34,15 @@ const queues = new Map();
  * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
  * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
  *
+ * Each task also runs with a read cache (see withReadCache): the files it reads are read once for the whole call.
+ *
  * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
  * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
  * @param task
  */
 const withDatabaseLock = async task => {
   if (!jsEnv.isNode) {
-    return task();
+    return (0, _storage.withReadCache)(task);
   }
   const database = (0, _config.resolveDatabasePath)((0, _config.getSetting)('databasePath', 'database/'));
   const ended = (0, _config.trackDatabaseCall)();
@@ -52,7 +55,7 @@ const withDatabaseLock = async task => {
   queues.set(database, queued);
   await previous;
   try {
-    return await task();
+    return await (0, _storage.withReadCache)(task);
   } finally {
     ended();
     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");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 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 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=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;

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/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,136 @@
+"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 _retrieveFile = require("./retrieveFile");
+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);
+  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;
+};
+/**
+ * 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"),_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;

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;

package/dist/data/utilities/recordExists.js

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

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

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

package/dist/data/utilities/registerRecord.js

@@ -5,12 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.registerRecord = void 0;
 require("core-js/modules/es.array.includes.js");
-require("core-js/modules/es.json.stringify.js");
-var _config = require("./config");
-const {
-  readFile,
-  writeFile
-} = require('fs/promises');
+var _storage = require("../storage");
 /**
  * __RECORDS is itself an ordinary record - path/definition/keys/entries - whose entries are the
  * filenames of every other record that has been created. This is the schema it's given the first
@@ -49,11 +44,10 @@ const defaultRegistry = () => ({
  * @param recordName
  */
 const registerRecord = 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) {
     registry = defaultRegistry();
   }
@@ -61,7 +55,7 @@ const registerRecord = async recordName => {
   if (!registry.entries.includes(fileName)) {
     registry.entries.push(fileName);
   }
-  await writeFile(registryPath, JSON.stringify(registry, null, 2));
+  await (0, _storage.writeJson)(registryPath, registry);
   return registry;
 };
 exports.registerRecord = registerRecord;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.registerRecord=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/es.json.stringify.js");var _config=require("./config");const{readFile:readFile,writeFile:writeFile}=require("fs/promises"),defaultRegistry=()=>({path:"",definition:[{name:"path",type:"string",optional:!1,autoGenerate:!1},{name:"definition",type:"object",optional:!1,autoGenerate:!1},{name:"keys",type:"array",optional:!1,autoGenerate:!1},{name:"entries",type:"array",optional:!1,autoGenerate:!1}],keys:[],entries:[]}),registerRecord=async e=>{const t=`${(0,_config.getSetting)("databasePath","database/")}__RECORDS.json`;let r;try{r=JSON.parse(await readFile(t,"utf8"))}catch(e){r=defaultRegistry()}const i=`${e}.json`;return r.entries.includes(i)||r.entries.push(i),await writeFile(t,JSON.stringify(r,null,2)),r};exports.registerRecord=registerRecord;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.registerRecord=void 0,require("core-js/modules/es.array.includes.js");var _storage=require("../storage");const defaultRegistry=()=>({path:"",definition:[{name:"path",type:"string",optional:!1,autoGenerate:!1},{name:"definition",type:"object",optional:!1,autoGenerate:!1},{name:"keys",type:"array",optional:!1,autoGenerate:!1},{name:"entries",type:"array",optional:!1,autoGenerate:!1}],keys:[],entries:[]}),registerRecord=async e=>{const t="__RECORDS.json";let r;try{r=await(0,_storage.readJson)(t)}catch(e){r=defaultRegistry()}const a=`${e}.json`;return r.entries.includes(a)||r.entries.push(a),await(0,_storage.writeJson)(t,r),r};exports.registerRecord=registerRecord;

package/dist/data/utilities/removeFromIndex.js

@@ -4,16 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.removeFromIndex = void 0;
-require("core-js/modules/es.json.stringify.js");
 require("core-js/modules/esnext.iterator.constructor.js");
 require("core-js/modules/esnext.iterator.filter.js");
 require("core-js/modules/esnext.iterator.map.js");
-var _config = require("./config");
 var _compareAs = require("./compareAs");
-const {
-  readFile,
-  writeFile
-} = require('fs/promises');
+var _storage = require("../storage");
 /**
  * Remove a single entry file from the index that backs one of a record's keys, dropping a value
  * entirely once its last file is removed. A key with no lookup, or an index file that doesn't
@@ -28,11 +23,10 @@ const removeFromIndex = async (path = '', key = null, value = undefined, fileNam
   if (!key || !key.lookup) {
     return null;
   }
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const indexPath = `${databasePath}__indexes/${path}/${key.lookup}`;
+  const indexPath = `__indexes/${path}/${key.lookup}`;
   let index = [];
   try {
-    index = JSON.parse(await readFile(indexPath, 'utf8'));
+    index = await (0, _storage.readJson)(indexPath);
   } catch (err) {
     return null;
   }
@@ -40,7 +34,7 @@ const removeFromIndex = async (path = '', key = null, value = undefined, fileNam
     value: entry.value,
     record: entry.record.filter(record => record !== fileName)
   } : entry).filter(entry => entry.record.length);
-  await writeFile(indexPath, JSON.stringify(index, null, 2));
+  await (0, _storage.writeJson)(indexPath, index);
   return index;
 };
 exports.removeFromIndex = removeFromIndex;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeFromIndex=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.map.js");var _config=require("./config"),_compareAs=require("./compareAs");const{readFile:readFile,writeFile:writeFile}=require("fs/promises"),removeFromIndex=async(e="",r=null,o=void 0,t="",i=void 0)=>{if(!r||!r.lookup)return null;const s=`${(0,_config.getSetting)("databasePath","database/")}__indexes/${e}/${r.lookup}`;let a=[];try{a=JSON.parse(await readFile(s,"utf8"))}catch(e){return null}return a=a.map((e=>(0,_compareAs.sameValue)(i,e.value,o)?{value:e.value,record:e.record.filter((e=>e!==t))}:e)).filter((e=>e.record.length)),await writeFile(s,JSON.stringify(a,null,2)),a};exports.removeFromIndex=removeFromIndex;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeFromIndex=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.map.js");var _compareAs=require("./compareAs"),_storage=require("../storage");const removeFromIndex=async(e="",r=null,o=void 0,t="",s=void 0)=>{if(!r||!r.lookup)return null;const a=`__indexes/${e}/${r.lookup}`;let u=[];try{u=await(0,_storage.readJson)(a)}catch(e){return null}return u=u.map((e=>(0,_compareAs.sameValue)(s,e.value,o)?{value:e.value,record:e.record.filter((e=>e!==t))}:e)).filter((e=>e.record.length)),await(0,_storage.writeJson)(a,u),u};exports.removeFromIndex=removeFromIndex;

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

@@ -1,2 +1,7 @@
+/**
+ * Read one JSON file of the database (see readJson), logging the underlying error and throwing one that names the file.
+ * @param path - A path inside the database, such as `users.json`.
+ * @throws {Error} `Could not read <path>` when the file can't be read.
+ */
 export declare const retrieveFile: (path: any) => Promise<any>;
 //# sourceMappingURL=retrieveFile.d.ts.map