json-fs-query 3.1.4 → 3.2.0

package/dist/data/introspect/create.js

@@ -5,14 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.create = void 0;
 require("core-js/modules/es.array.includes.js");
-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.find.js");
 require("core-js/modules/esnext.iterator.some.js");
 var _record = require("./definitions/record");
 var _registerRecord = require("../utilities/registerRecord");
-var _config = require("../utilities/config");
+var _storage = require("../storage");
 var _requireNode = require("../utilities/requireNode");
 var _typeCheck = require("./policies/typeCheck");
 const knownKeyProperties = ['type', 'fields', 'lookup', 'references'];
@@ -76,18 +75,10 @@ const assertValidDefinition = (recordName, recordContent) => {
  */
 const create = async (recordName, definition = [], keys = []) => {
   (0, _requireNode.requireNode)('create()');
-  const {
-    writeFile,
-    mkdir
-  } = require('fs/promises');
-  const {
-    existsSync
-  } = require('fs');
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
   if (recordName === '__RECORDS') {
     return null;
   }
-  if (existsSync(`${databasePath}${recordName}.json`)) {
+  if ((0, _storage.fileExists)(`${recordName}.json`)) {
     return null;
   }
   assertKnownKeyProperties(recordName, keys);
@@ -97,22 +88,16 @@ const create = async (recordName, definition = [], keys = []) => {
     keys
   });
   assertValidDefinition(recordName, recordContent);
-  await mkdir(databasePath, {
-    recursive: true
-  });
-  await writeFile(`${databasePath}${recordName}.json`, JSON.stringify(recordContent, null, 2));
-  await mkdir(`${databasePath}${recordName}`, {
-    recursive: true
-  });
+  await (0, _storage.makeDirectory)();
+  await (0, _storage.writeJson)(`${recordName}.json`, recordContent);
+  await (0, _storage.makeDirectory)(recordName);
   // Each indexed key starts with an empty index, so the new record reads like any other before its first insert
   // (a where on a key used to fail with "Could not read __indexes/...", since the file only appeared with the first row)
   const indexedKeys = recordContent.keys.filter(key => key.lookup);
   if (indexedKeys.length) {
-    await mkdir(`${databasePath}__indexes/${recordName}`, {
-      recursive: true
-    });
+    await (0, _storage.makeDirectory)(`__indexes/${recordName}`);
     for (const key of indexedKeys) {
-      await writeFile(`${databasePath}__indexes/${recordName}/${key.lookup}`, '[]');
+      await (0, _storage.writeJson)(`__indexes/${recordName}/${key.lookup}`, []);
     }
   }
   await (0, _registerRecord.registerRecord)(recordName);

package/dist/data/introspect/create.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.create=void 0,require("core-js/modules/es.array.includes.js"),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.find.js"),require("core-js/modules/esnext.iterator.some.js");var _record=require("./definitions/record"),_registerRecord=require("../utilities/registerRecord"),_config=require("../utilities/config"),_requireNode=require("../utilities/requireNode"),_typeCheck=require("./policies/typeCheck");const knownKeyProperties=["type","fields","lookup","references"],assertKnownKeyProperties=(e,r)=>{for(const i of r)for(const r of Object.keys(i))if(!knownKeyProperties.includes(r))throw new Error(`Unknown property "${r}" on ${i.type??"index"} key of ${e}; must be ${knownKeyProperties.join(", ")}`)},assertValidDefinition=(e,r)=>{for(const i of r.definition)if(Object.prototype.hasOwnProperty.call(i,"default"))try{(0,_typeCheck.typeCheck)(i.type,i.default,i.nullable)}catch(r){throw new Error(`Invalid default for field "${i.name}" of ${e}: ${r.message}`)}for(const i of r.keys){if(i.fields.length<1)throw new Error(`The ${i.type} key of ${e} must have at least one field`);for(const t of i.fields)if(!r.definition.some((e=>e.name===t)))throw new Error(`The ${i.type} key of ${e} names field "${t}", which isn't in the definition`)}const i=r.keys.find((e=>"primary"===e.type));for(const t of i?i.fields:[])if(r.definition.some((e=>e.name===t&&e.nullable)))throw new Error(`Primary key field "${t}" of ${e} can't be nullable`)},create=async(e,r=[],i=[])=>{(0,_requireNode.requireNode)("create()");const{writeFile:t,mkdir:o}=require("fs/promises"),{existsSync:s}=require("fs"),n=(0,_config.getSetting)("databasePath","database/");if("__RECORDS"===e)return null;if(s(`${n}${e}.json`))return null;assertKnownKeyProperties(e,i);const a=(0,_record.record)({path:e,definition:r,keys:i});assertValidDefinition(e,a),await o(n,{recursive:!0}),await t(`${n}${e}.json`,JSON.stringify(a,null,2)),await o(`${n}${e}`,{recursive:!0});const f=a.keys.filter((e=>e.lookup));if(f.length){await o(`${n}__indexes/${e}`,{recursive:!0});for(const r of f)await t(`${n}__indexes/${e}/${r.lookup}`,"[]")}return await(0,_registerRecord.registerRecord)(e),a};exports.create=create;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.create=void 0,require("core-js/modules/es.array.includes.js"),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.some.js");var _record=require("./definitions/record"),_registerRecord=require("../utilities/registerRecord"),_storage=require("../storage"),_requireNode=require("../utilities/requireNode"),_typeCheck=require("./policies/typeCheck");const knownKeyProperties=["type","fields","lookup","references"],assertKnownKeyProperties=(e,r)=>{for(const o of r)for(const r of Object.keys(o))if(!knownKeyProperties.includes(r))throw new Error(`Unknown property "${r}" on ${o.type??"index"} key of ${e}; must be ${knownKeyProperties.join(", ")}`)},assertValidDefinition=(e,r)=>{for(const o of r.definition)if(Object.prototype.hasOwnProperty.call(o,"default"))try{(0,_typeCheck.typeCheck)(o.type,o.default,o.nullable)}catch(r){throw new Error(`Invalid default for field "${o.name}" of ${e}: ${r.message}`)}for(const o of r.keys){if(o.fields.length<1)throw new Error(`The ${o.type} key of ${e} must have at least one field`);for(const t of o.fields)if(!r.definition.some((e=>e.name===t)))throw new Error(`The ${o.type} key of ${e} names field "${t}", which isn't in the definition`)}const o=r.keys.find((e=>"primary"===e.type));for(const t of o?o.fields:[])if(r.definition.some((e=>e.name===t&&e.nullable)))throw new Error(`Primary key field "${t}" of ${e} can't be nullable`)},create=async(e,r=[],o=[])=>{if((0,_requireNode.requireNode)("create()"),"__RECORDS"===e)return null;if((0,_storage.fileExists)(`${e}.json`))return null;assertKnownKeyProperties(e,o);const t=(0,_record.record)({path:e,definition:r,keys:o});assertValidDefinition(e,t),await(0,_storage.makeDirectory)(),await(0,_storage.writeJson)(`${e}.json`,t),await(0,_storage.makeDirectory)(e);const i=t.keys.filter((e=>e.lookup));if(i.length){await(0,_storage.makeDirectory)(`__indexes/${e}`);for(const r of i)await(0,_storage.writeJson)(`__indexes/${e}/${r.lookup}`,[])}return await(0,_registerRecord.registerRecord)(e),t};exports.create=create;

package/dist/data/introspect/drop.js

@@ -10,30 +10,20 @@ Object.defineProperty(exports, "__esModule", {
 exports.drop = void 0;
 var _retrieveFile = require("../utilities/retrieveFile");
 var _deregisterRecord = require("../utilities/deregisterRecord");
-var _config = require("../utilities/config");
 var _requireNode = require("../utilities/requireNode");
-const {
-  rm
-} = require('fs/promises');
+var _storage = require("../storage");
 const drop = async record => {
   (0, _requireNode.requireNode)('drop()');
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
   if (record === '__RECORDS') {
     return null;
   }
   const recordFile = await (0, _retrieveFile.retrieveFile)(`${record}.json`);
   for (const file of recordFile.entries) {
-    await rm(`${databasePath}${recordFile.path}/${file}`);
+    await (0, _storage.removeFile)(`${recordFile.path}/${file}`);
   }
-  await rm(`${databasePath}${recordFile.path}`, {
-    recursive: true,
-    force: true
-  });
-  await rm(`${databasePath}__indexes/${recordFile.path}`, {
-    recursive: true,
-    force: true
-  });
-  await rm(`${databasePath}${record}.json`);
+  await (0, _storage.removeDirectory)(recordFile.path);
+  await (0, _storage.removeDirectory)(`__indexes/${recordFile.path}`);
+  await (0, _storage.removeFile)(`${record}.json`);
   await (0, _deregisterRecord.deregisterRecord)(record);
 };
 exports.drop = drop;

package/dist/data/introspect/drop.min.js

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.drop=void 0;var _retrieveFile=require("../utilities/retrieveFile"),_deregisterRecord=require("../utilities/deregisterRecord"),_config=require("../utilities/config"),_requireNode=require("../utilities/requireNode");const{rm:rm}=require("fs/promises"),drop=async e=>{(0,_requireNode.requireNode)("drop()");const r=(0,_config.getSetting)("databasePath","database/");if("__RECORDS"===e)return null;const i=await(0,_retrieveFile.retrieveFile)(`${e}.json`);for(const e of i.entries)await rm(`${r}${i.path}/${e}`);await rm(`${r}${i.path}`,{recursive:!0,force:!0}),await rm(`${r}__indexes/${i.path}`,{recursive:!0,force:!0}),await rm(`${r}${e}.json`),await(0,_deregisterRecord.deregisterRecord)(e)};exports.drop=drop;
+"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.drop=void 0;var _retrieveFile=require("../utilities/retrieveFile"),_deregisterRecord=require("../utilities/deregisterRecord"),_requireNode=require("../utilities/requireNode"),_storage=require("../storage");const drop=async e=>{if((0,_requireNode.requireNode)("drop()"),"__RECORDS"===e)return null;const r=await(0,_retrieveFile.retrieveFile)(`${e}.json`);for(const e of r.entries)await(0,_storage.removeFile)(`${r.path}/${e}`);await(0,_storage.removeDirectory)(r.path),await(0,_storage.removeDirectory)(`__indexes/${r.path}`),await(0,_storage.removeFile)(`${e}.json`),await(0,_deregisterRecord.deregisterRecord)(e)};exports.drop=drop;

package/dist/data/introspect/policies/foreignKeyExists.d.ts

@@ -1,6 +1,8 @@
 /**
  * Check whether any record in the referenced entity has the given property set to the given
  * value - the mirror image of keyUnique(), which checks that no record already has a value.
+ * A referenced field with an index (a foreign key usually references a primary key) is answered from it; otherwise
+ * every row is read.
  * @param entity
  * @param property
  * @param value

package/dist/data/introspect/policies/foreignKeyExists.js

@@ -8,22 +8,28 @@ var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
 var _retrieveRecord = require("../../utilities/retrieveRecord");
 var _fieldType = require("../../utilities/fieldType");
+var _indexHas = require("../../utilities/indexHas");
 /**
  * Check whether any record in the referenced entity has the given property set to the given
  * value - the mirror image of keyUnique(), which checks that no record already has a value.
+ * A referenced field with an index (a foreign key usually references a primary key) is answered from it; otherwise
+ * every row is read.
  * @param entity
  * @param property
  * @param value
  */
 const foreignKeyExists = async (entity, property, value) => {
+  const found = await (0, _indexHas.indexHas)(entity, property, value);
+  if (typeof found !== 'undefined') {
+    return found;
+  }
   const records = await (0, _retrieveRecords.retrieveRecords)(entity);
   const type = (0, _fieldType.fieldType)(await (0, _retrieveRecord.retrieveRecord)(entity), property);
-  const found = (0, _where.where)(records, {
+  return (0, _where.where)(records, {
     property,
     comparator: '=',
     value,
     type
-  });
-  return found.length > 0;
+  }).length > 0;
 };
 exports.foreignKeyExists = foreignKeyExists;

package/dist/data/introspect/policies/foreignKeyExists.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.foreignKeyExists=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType");const foreignKeyExists=async(e,r,i)=>{const t=await(0,_retrieveRecords.retrieveRecords)(e),s=(0,_fieldType.fieldType)(await(0,_retrieveRecord.retrieveRecord)(e),r);return(0,_where.where)(t,{property:r,comparator:"=",value:i,type:s}).length>0};exports.foreignKeyExists=foreignKeyExists;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.foreignKeyExists=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType"),_indexHas=require("../../utilities/indexHas");const foreignKeyExists=async(e,r,i)=>{const t=await(0,_indexHas.indexHas)(e,r,i);if(void 0!==t)return t;const s=await(0,_retrieveRecords.retrieveRecords)(e),o=(0,_fieldType.fieldType)(await(0,_retrieveRecord.retrieveRecord)(e),r);return(0,_where.where)(s,{property:r,comparator:"=",value:i,type:o}).length>0};exports.foreignKeyExists=foreignKeyExists;

package/dist/data/introspect/policies/hasDependents.d.ts

@@ -2,9 +2,9 @@
  * Check whether any other record, in any entity, still has a single-field foreign key pointing
  * at entity.property = value - the mirror image of foreignKeyExists(), which checks the opposite
  * direction (that a new/updated foreign key value points at something real). Used to RESTRICT a
- * delete or update that would otherwise leave a dangling reference behind. Scans every record in
- * the database via the __RECORDS registry, the same "no index needed, just look" approach as
- * keyUnique()/foreignKeyExists() - correctness over speed, matching this project's overall scale.
+ * delete or update that would otherwise leave a dangling reference behind. Looks at every record in
+ * the database (via the __RECORDS registry) for a foreign key to entity.property. A foreign key field with an index
+ * (each one gets one) is answered from it; otherwise that record's rows are read.
  * @param entity
  * @param property
  * @param value

package/dist/data/introspect/policies/hasDependents.js

@@ -10,13 +10,14 @@ var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
 var _fieldType = require("../../utilities/fieldType");
 var _splitEntityProperty = require("../../utilities/parsers/splitEntityProperty");
+var _indexHas = require("../../utilities/indexHas");
 /**
  * Check whether any other record, in any entity, still has a single-field foreign key pointing
  * at entity.property = value - the mirror image of foreignKeyExists(), which checks the opposite
  * direction (that a new/updated foreign key value points at something real). Used to RESTRICT a
- * delete or update that would otherwise leave a dangling reference behind. Scans every record in
- * the database via the __RECORDS registry, the same "no index needed, just look" approach as
- * keyUnique()/foreignKeyExists() - correctness over speed, matching this project's overall scale.
+ * delete or update that would otherwise leave a dangling reference behind. Looks at every record in
+ * the database (via the __RECORDS registry) for a foreign key to entity.property. A foreign key field with an index
+ * (each one gets one) is answered from it; otherwise that record's rows are read.
  * @param entity
  * @param property
  * @param value
@@ -37,6 +38,13 @@ const hasDependents = async (entity, property, value) => {
       if (refEntity !== entity || refProperty !== property) {
         continue;
       }
+      const indexed = await (0, _indexHas.indexHas)(otherEntity, key.fields[0], value);
+      if (typeof indexed !== 'undefined') {
+        if (indexed) {
+          return true;
+        }
+        continue;
+      }
       const records = await (0, _retrieveRecords.retrieveRecords)(otherEntity);
       const found = (0, _where.where)(records, {
         property: key.fields[0],

package/dist/data/introspect/policies/hasDependents.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.hasDependents=void 0;var _describe=require("../describe"),_retrieveRecord=require("../../utilities/retrieveRecord"),_retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_fieldType=require("../../utilities/fieldType"),_splitEntityProperty=require("../../utilities/parsers/splitEntityProperty");const hasDependents=async(e,r,t)=>{const i=await(0,_describe.describe)();for(const s of i){const i=s.replace(/\.json$/,""),o=await(0,_retrieveRecord.retrieveRecord)(i);for(const s of o.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const{entity:n,property:c}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(n!==e||c!==r)continue;const p=await(0,_retrieveRecords.retrieveRecords)(i);if((0,_where.where)(p,{property:s.fields[0],comparator:"=",value:t,type:(0,_fieldType.fieldType)(o,s.fields[0])}).length)return!0}}return!1};exports.hasDependents=hasDependents;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.hasDependents=void 0;var _describe=require("../describe"),_retrieveRecord=require("../../utilities/retrieveRecord"),_retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_fieldType=require("../../utilities/fieldType"),_splitEntityProperty=require("../../utilities/parsers/splitEntityProperty"),_indexHas=require("../../utilities/indexHas");const hasDependents=async(e,r,i)=>{const t=await(0,_describe.describe)();for(const s of t){const t=s.replace(/\.json$/,""),n=await(0,_retrieveRecord.retrieveRecord)(t);for(const s of n.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const{entity:o,property:d}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(o!==e||d!==r)continue;const c=await(0,_indexHas.indexHas)(t,s.fields[0],i);if(void 0!==c){if(c)return!0;continue}const p=await(0,_retrieveRecords.retrieveRecords)(t);if((0,_where.where)(p,{property:s.fields[0],comparator:"=",value:i,type:(0,_fieldType.fieldType)(n,s.fields[0])}).length)return!0}}return!1};exports.hasDependents=hasDependents;

package/dist/data/introspect/policies/keyUnique.d.ts

@@ -2,6 +2,9 @@
  * Check that no existing record already has this combination of values across all of the given
  * fields - a single field for a normal unique/primary key, or several for a composite one.
  * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
+ *
+ * One field with an index (every primary and unique key has one) is answered from the index; a composite key, or a
+ * field without one, reads every row.
  * @param entity
  * @param references
  * @param checkKeys

package/dist/data/introspect/policies/keyUnique.js

@@ -8,10 +8,14 @@ var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
 var _retrieveRecord = require("../../utilities/retrieveRecord");
 var _fieldType = require("../../utilities/fieldType");
+var _indexHas = require("../../utilities/indexHas");
 /**
  * Check that no existing record already has this combination of values across all of the given
  * fields - a single field for a normal unique/primary key, or several for a composite one.
  * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
+ *
+ * One field with an index (every primary and unique key has one) is answered from the index; a composite key, or a
+ * field without one, reads every row.
  * @param entity
  * @param references
  * @param checkKeys
@@ -20,6 +24,12 @@ const keyUnique = async (entity, references = [], checkKeys = []) => {
   if (!references.length || references.length !== checkKeys.length) {
     return false;
   }
+  if (references.length === 1) {
+    const found = await (0, _indexHas.indexHas)(entity, references[0], checkKeys[0]);
+    if (typeof found !== 'undefined') {
+      return !found;
+    }
+  }
   let records = await (0, _retrieveRecords.retrieveRecords)(entity);
   const record = await (0, _retrieveRecord.retrieveRecord)(entity);
   for (let i = 0; i < references.length; i++) {

package/dist/data/introspect/policies/keyUnique.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyUnique=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType");const keyUnique=async(e,r=[],t=[])=>{if(!r.length||r.length!==t.length)return!1;let i=await(0,_retrieveRecords.retrieveRecords)(e);const o=await(0,_retrieveRecord.retrieveRecord)(e);for(let e=0;e<r.length;e++)i=(0,_where.where)(i,{property:r[e],comparator:"=",value:t[e],type:(0,_fieldType.fieldType)(o,r[e])});return!i.length};exports.keyUnique=keyUnique;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyUnique=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType"),_indexHas=require("../../utilities/indexHas");const keyUnique=async(e,r=[],i=[])=>{if(!r.length||r.length!==i.length)return!1;if(1===r.length){const t=await(0,_indexHas.indexHas)(e,r[0],i[0]);if(void 0!==t)return!t}let t=await(0,_retrieveRecords.retrieveRecords)(e);const s=await(0,_retrieveRecord.retrieveRecord)(e);for(let e=0;e<r.length;e++)t=(0,_where.where)(t,{property:r[e],comparator:"=",value:i[e],type:(0,_fieldType.fieldType)(s,r[e])});return!t.length};exports.keyUnique=keyUnique;

package/dist/data/queries/deleteEntity.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.deleteEntity = 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.find.js");
 require("core-js/modules/esnext.iterator.map.js");
 require("core-js/modules/esnext.set.add-all.js");
@@ -31,10 +31,8 @@ var _computeKeyValue = require("../utilities/computeKeyValue");
 var _fieldType = require("../utilities/fieldType");
 var _hasDependents = require("../introspect/policies/hasDependents");
 var _config = require("../utilities/config");
-const {
-  rm,
-  writeFile
-} = require('fs/promises');
+var _keyIndexFiles = require("../utilities/keyIndexFiles");
+var _storage = require("../storage");
 /**
  * RESTRICT: reject the whole delete (before removing anything) if any row being deleted is still
  * referenced by a single-field foreign key elsewhere. Only meaningful for a single-field primary
@@ -57,32 +55,45 @@ const assertNoDependents = async (entity, primaryKey, toDelete) => {
 };
 /**
  * A record object carries no memory of which entry file it was read from, and files are not
- * guaranteed to be named after any field's value, so the only reliable way to find a record's
- * file is to re-scan every entry and match it by its primary key value(s) - a single field, or a
- * composite of several for a multi-field primary key.
+ * guaranteed to be named after any field's value, so a deleted row's file is found by its primary
+ * key value(s) - a single field, or a composite of several for a multi-field primary key. The
+ * primary key's index says which files those are (each is read to confirm it); any deleted value
+ * the index didn't lead to, or a record without one, is found by looking at every entry, as before.
+ * Inserts and updates keep primary key values unique, so each value is one row: only a database
+ * edited by hand into two rows of one value, with an index listing just one, would keep the other
+ * (looking at every entry used to delete both).
  * @param entity
  * @param record
  * @param primaryKey
  * @param deletedValues
  */
 const removeMatchingEntries = async (entity, record, primaryKey, deletedValues) => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const remainingEntries = [];
-  for (const fileName of record.entries) {
+  const removed = new Set();
+  const found = new Set();
+  const removeIfDeleted = async fileName => {
     const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
-    if (!deletedValues.has((0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data))) {
-      remainingEntries.push(fileName);
-      continue;
+    const value = (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data);
+    if (!deletedValues.has(value)) {
+      return;
     }
-    await rm(`${databasePath}${record.path}/${fileName}`);
+    await (0, _storage.removeFile)(`${record.path}/${fileName}`);
     for (const key of record.keys) {
       await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName, (0, _fieldType.keyValueType)(record, key));
     }
+    removed.add(fileName);
+    found.add(value);
+  };
+  for (const fileName of (await (0, _keyIndexFiles.keyIndexFiles)(record, primaryKey, value => deletedValues.has(value))) ?? []) {
+    await removeIfDeleted(fileName);
   }
-  return remainingEntries;
+  if (found.size < deletedValues.size) {
+    for (const fileName of record.entries.filter(entry => !removed.has(entry))) {
+      await removeIfDeleted(fileName);
+    }
+  }
+  return record.entries.filter(fileName => !removed.has(fileName));
 };
 const deleteEntity = async (entity = '', dataSet = {}) => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
   const record = await (0, _retrieveRecord.retrieveRecord)(entity);
   const primaryKey = record.keys.find(key => key.type === 'primary');
   if (!primaryKey) {
@@ -95,7 +106,7 @@ const deleteEntity = async (entity = '', dataSet = {}) => {
   await assertNoDependents(entity, primaryKey, toDelete);
   const deletedValues = new Set(toDelete.map(row => (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row)));
   record.entries = await removeMatchingEntries(entity, record, primaryKey, deletedValues);
-  await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2));
+  await (0, _storage.writeJson)(`${record.path}.json`, record);
   return dataSet;
 };
 exports.deleteEntity = deleteEntity;

package/dist/data/queries/deleteEntity.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deleteEntity=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.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("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_hasDependents=require("../introspect/policies/hasDependents"),_config=require("../utilities/config");const{rm:rm,writeFile:writeFile}=require("fs/promises"),assertNoDependents=async(e,r,s)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==r.fields.length)return;const t=r.fields[0];for(const r of s)if(await(0,_hasDependents.hasDependents)(e,t,r[t]))throw new Error(`Cannot delete from "${e}" where "${t}" = ${r[t]} - other records still reference it`)},removeMatchingEntries=async(e,r,s,t)=>{const i=(0,_config.getSetting)("databasePath","database/"),o=[];for(const e of r.entries){const n=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`);if(t.has((0,_computeKeyValue.computeKeyValue)(s.fields,n))){await rm(`${i}${r.path}/${e}`);for(const s of r.keys)await(0,_removeFromIndex.removeFromIndex)(r.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,n),e,(0,_fieldType.keyValueType)(r,s))}else o.push(e)}return o},deleteEntity=async(e="",r={})=>{const s=(0,_config.getSetting)("databasePath","database/"),t=await(0,_retrieveRecord.retrieveRecord)(e),i=t.keys.find((e=>"primary"===e.type));if(!i)throw new Error(`Cannot delete from "${e}" without a primary key`);const o=r[e]||[];if(!o.length)return r;await assertNoDependents(e,i,o);const n=new Set(o.map((e=>(0,_computeKeyValue.computeKeyValue)(i.fields,e))));return t.entries=await removeMatchingEntries(0,t,i,n),await writeFile(`${s}${t.path}.json`,JSON.stringify(t,null,2)),r};exports.deleteEntity=deleteEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deleteEntity=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.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("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_hasDependents=require("../introspect/policies/hasDependents"),_config=require("../utilities/config"),_keyIndexFiles=require("../utilities/keyIndexFiles"),_storage=require("../storage");const assertNoDependents=async(e,r,s)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==r.fields.length)return;const t=r.fields[0];for(const r of s)if(await(0,_hasDependents.hasDependents)(e,t,r[t]))throw new Error(`Cannot delete from "${e}" where "${t}" = ${r[t]} - other records still reference it`)},removeMatchingEntries=async(e,r,s,t)=>{const i=new Set,o=new Set,n=async e=>{const n=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`),u=(0,_computeKeyValue.computeKeyValue)(s.fields,n);if(t.has(u)){await(0,_storage.removeFile)(`${r.path}/${e}`);for(const s of r.keys)await(0,_removeFromIndex.removeFromIndex)(r.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,n),e,(0,_fieldType.keyValueType)(r,s));i.add(e),o.add(u)}};for(const e of await(0,_keyIndexFiles.keyIndexFiles)(r,s,(e=>t.has(e)))??[])await n(e);if(o.size<t.size)for(const e of r.entries.filter((e=>!i.has(e))))await n(e);return r.entries.filter((e=>!i.has(e)))},deleteEntity=async(e="",r={})=>{const s=await(0,_retrieveRecord.retrieveRecord)(e),t=s.keys.find((e=>"primary"===e.type));if(!t)throw new Error(`Cannot delete from "${e}" without a primary key`);const i=r[e]||[];if(!i.length)return r;await assertNoDependents(e,t,i);const o=new Set(i.map((e=>(0,_computeKeyValue.computeKeyValue)(t.fields,e))));return s.entries=await removeMatchingEntries(0,s,t,o),await(0,_storage.writeJson)(`${s.path}.json`,s),r};exports.deleteEntity=deleteEntity;

package/dist/data/queries/insertEntity.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.insertEntity = void 0;
-require("core-js/modules/es.json.stringify.js");
 require("core-js/modules/esnext.iterator.constructor.js");
 require("core-js/modules/esnext.iterator.find.js");
 require("core-js/modules/esnext.iterator.map.js");
@@ -19,11 +18,7 @@ var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
 var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
 var _computeKeyValue = require("../utilities/computeKeyValue");
 var _fieldType = require("../utilities/fieldType");
-var _config = require("../utilities/config");
-const {
-  writeFile,
-  mkdir
-} = require('fs/promises');
+var _storage = require("../storage");
 /**
  * Build one entity's stored values from the raw input values, generating any autoGenerate
  * fields and applying field defaults, then throw if a required field still has no value.
@@ -100,7 +95,6 @@ const assertForeignKeys = async (entity, record, entityValues) => {
   }
 };
 const insertEntity = async (entity = '', values = [], dataSet = {}) => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
   const record = await (0, _retrieveRecord.retrieveRecord)(entity);
   const primaryKey = record.keys.find(key => key.type === 'primary' && key.fields.length === 1);
   if (!Object.prototype.hasOwnProperty.call(dataSet, entity)) {
@@ -108,17 +102,15 @@ const insertEntity = async (entity = '', values = [], dataSet = {}) => {
   }
   // The record's folder can be missing even though the record exists: git doesn't keep empty folders, so a database
   // committed before its first insert comes back from a fresh clone without it
-  await mkdir(`${databasePath}${record.path}`, {
-    recursive: true
-  });
+  await (0, _storage.makeDirectory)(record.path);
   for (const rowValues of values) {
     const entityValues = await buildEntityValues(entity, record, rowValues);
     await assertUnique(entity, record, entityValues);
     await assertForeignKeys(entity, record, entityValues);
     const fileName = `${primaryKey ? entityValues[primaryKey.fields[0]] : crypto.randomUUID()}.json`;
-    await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(entityValues, null, 2));
+    await (0, _storage.writeJson)(`${record.path}/${fileName}`, entityValues);
     record.entries.push(fileName);
-    await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2));
+    await (0, _storage.writeJson)(`${record.path}.json`, record);
     for (const key of record.keys) {
       await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName, (0, _fieldType.keyValueType)(record, key));
     }

package/dist/data/queries/insertEntity.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.insertEntity=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.iterator.some.js");var _retrieveRecord=require("../utilities/retrieveRecord"),_updateIndex=require("../utilities/updateIndex"),_keyGenerate=require("../introspect/policies/keyGenerate"),_keyUnique=require("../introspect/policies/keyUnique"),_useDefault=require("../introspect/policies/useDefault"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_config=require("../utilities/config");const{writeFile:writeFile,mkdir:mkdir}=require("fs/promises"),buildEntityValues=async(e,t,i={})=>{const r={};for(const s of t.definition){let t=i[s.name];if(s.autoGenerate?t=await(0,_keyGenerate.keyGenerate)(e,[s.name]):Object.prototype.hasOwnProperty.call(s,"default")&&(t=(0,_useDefault.useDefault)(s.default,t)),void 0!==t)r[s.name]=(0,_typeCheck.typeCheck)(s.type,t,s.nullable);else if(!s.optional)throw new Error(`Missing required field "${s.name}" for ${e}`)}return r},assertUnique=async(e,t,i)=>{for(const r of t.keys){if("primary"!==r.type&&"unique"!==r.type)continue;const t=r.fields.map((e=>i[e]));if(t.some((e=>null===e)))continue;if(!await(0,_keyUnique.keyUnique)(e,r.fields,t))throw new Error(`Duplicate value for ${r.type} key "${r.fields.join(", ")}" on ${e}`)}},assertForeignKeys=async(e,t,i)=>{for(const r of t.keys){if("foreign"!==r.type||1!==r.fields.length||!r.references||1!==r.references.length)continue;const t=r.fields[0];if(!Object.prototype.hasOwnProperty.call(i,t)||null===i[t])continue;const{entity:s,property:n}=(0,_splitEntityProperty.splitEntityProperty)(r.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(s,n,i[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${s}.${n} = ${i[t]}`)}},insertEntity=async(e="",t=[],i={})=>{const r=(0,_config.getSetting)("databasePath","database/"),s=await(0,_retrieveRecord.retrieveRecord)(e),n=s.keys.find((e=>"primary"===e.type&&1===e.fields.length));Object.prototype.hasOwnProperty.call(i,e)||(i[e]=[]),await mkdir(`${r}${s.path}`,{recursive:!0});for(const o of t){const t=await buildEntityValues(e,s,o);await assertUnique(e,s,t),await assertForeignKeys(e,s,t);const a=`${n?t[n.fields[0]]:crypto.randomUUID()}.json`;await writeFile(`${r}${s.path}/${a}`,JSON.stringify(t,null,2)),s.entries.push(a),await writeFile(`${r}${s.path}.json`,JSON.stringify(s,null,2));for(const e of s.keys)await(0,_updateIndex.updateIndex)(s.path,e,(0,_computeKeyValue.computeKeyValue)(e.fields,t),a,(0,_fieldType.keyValueType)(s,e));i[e].push(t)}return i};exports.insertEntity=insertEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.insertEntity=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.iterator.some.js");var _retrieveRecord=require("../utilities/retrieveRecord"),_updateIndex=require("../utilities/updateIndex"),_keyGenerate=require("../introspect/policies/keyGenerate"),_keyUnique=require("../introspect/policies/keyUnique"),_useDefault=require("../introspect/policies/useDefault"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_storage=require("../storage");const buildEntityValues=async(e,t,r={})=>{const i={};for(const s of t.definition){let t=r[s.name];if(s.autoGenerate?t=await(0,_keyGenerate.keyGenerate)(e,[s.name]):Object.prototype.hasOwnProperty.call(s,"default")&&(t=(0,_useDefault.useDefault)(s.default,t)),void 0!==t)i[s.name]=(0,_typeCheck.typeCheck)(s.type,t,s.nullable);else if(!s.optional)throw new Error(`Missing required field "${s.name}" for ${e}`)}return i},assertUnique=async(e,t,r)=>{for(const i of t.keys){if("primary"!==i.type&&"unique"!==i.type)continue;const t=i.fields.map((e=>r[e]));if(t.some((e=>null===e)))continue;if(!await(0,_keyUnique.keyUnique)(e,i.fields,t))throw new Error(`Duplicate value for ${i.type} key "${i.fields.join(", ")}" on ${e}`)}},assertForeignKeys=async(e,t,r)=>{for(const i of t.keys){if("foreign"!==i.type||1!==i.fields.length||!i.references||1!==i.references.length)continue;const t=i.fields[0];if(!Object.prototype.hasOwnProperty.call(r,t)||null===r[t])continue;const{entity:s,property:o}=(0,_splitEntityProperty.splitEntityProperty)(i.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(s,o,r[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${s}.${o} = ${r[t]}`)}},insertEntity=async(e="",t=[],r={})=>{const i=await(0,_retrieveRecord.retrieveRecord)(e),s=i.keys.find((e=>"primary"===e.type&&1===e.fields.length));Object.prototype.hasOwnProperty.call(r,e)||(r[e]=[]),await(0,_storage.makeDirectory)(i.path);for(const o of t){const t=await buildEntityValues(e,i,o);await assertUnique(e,i,t),await assertForeignKeys(e,i,t);const n=`${s?t[s.fields[0]]:crypto.randomUUID()}.json`;await(0,_storage.writeJson)(`${i.path}/${n}`,t),i.entries.push(n),await(0,_storage.writeJson)(`${i.path}.json`,i);for(const e of i.keys)await(0,_updateIndex.updateIndex)(i.path,e,(0,_computeKeyValue.computeKeyValue)(e.fields,t),n,(0,_fieldType.keyValueType)(i,e));r[e].push(t)}return r};exports.insertEntity=insertEntity;

package/dist/data/queries/joinEntity.d.ts

@@ -1,2 +1,17 @@
+/**
+ * Attach to each row of `entity` the rows of `joinEntity` its join reaches, through the `on` clauses in order.
+ *
+ * Each clause narrows both its records to the rows that match the other side: first the rows of the left one that
+ * match a right one, then the right ones that match those (see semiJoin for the order). A row's join starts from the
+ * row alone and from the rows read for every other record (see joinBases), so each record is read once for the whole
+ * join and each lookup is built once, rather than every loaded row being copied for each row joined.
+ * @param entity
+ * @param joinEntity
+ * @param dataSets
+ * @param joinClauses
+ * @param entityAlreadyResolved - Whether the where clause already narrowed entity's rows (then they aren't read again:
+ * an empty list reads as "not loaded yet", see readEntity).
+ * @param joinAlreadyResolved - The same for joinEntity.
+ */
 export declare const joinEntity: (entity: any, joinEntity: any, dataSets?: {}, joinClauses?: any[], entityAlreadyResolved?: boolean, joinAlreadyResolved?: boolean) => Promise<{}>;
 //# sourceMappingURL=joinEntity.d.ts.map

package/dist/data/queries/joinEntity.js

@@ -4,31 +4,107 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.joinEntity = void 0;
-var _siFunciona = _interopRequireDefault(require("si-funciona"));
+require("core-js/modules/esnext.iterator.constructor.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");
 var _readEntity = require("./readEntity");
-var _useJoinClause = require("../utilities/useJoinClause");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
+var _fieldType = require("../utilities/fieldType");
+var _semiJoin = require("../utilities/semiJoin");
+var _joinBases = require("../utilities/joinBases");
+/**
+ * Each `on` clause with the types its two sides are compared by. Each record is read here, before its type is looked
+ * up, so a record that doesn't exist fails with "Could not read <record>.json", as it always has.
+ * @param joinClauses
+ */
+const joinSteps = async joinClauses => {
+  const steps = [];
+  for (const {
+    propertyA,
+    comparator,
+    propertyB
+  } of joinClauses) {
+    const {
+      entity: entityA,
+      property: a
+    } = (0, _splitEntityProperty.splitEntityProperty)(propertyA);
+    const {
+      entity: entityB,
+      property: b
+    } = (0, _splitEntityProperty.splitEntityProperty)(propertyB);
+    steps.push({
+      entityA,
+      propertyA: a,
+      typeA: (0, _fieldType.fieldType)(await (0, _retrieveRecord.retrieveRecord)(entityA), a),
+      comparator,
+      entityB,
+      propertyB: b,
+      typeB: (0, _fieldType.fieldType)(await (0, _retrieveRecord.retrieveRecord)(entityB), b)
+    });
+  }
+  return steps;
+};
+/**
+ * What a row gets for its joined rows. Today every row is kept with the list of rows its join found (none is an empty
+ * list), and a condition on the joined record's fields then drops rows with none (whereTree): an inner join. This is
+ * the one place a join type (left, right, outer) would decide differently.
+ * @param matches - The joined rows the row's join found, shared with other rows' joins until copied here.
+ */
+const joinedRows = matches => matches.map(match => structuredClone(match));
+/**
+ * Attach to each row of `entity` the rows of `joinEntity` its join reaches, through the `on` clauses in order.
+ *
+ * Each clause narrows both its records to the rows that match the other side: first the rows of the left one that
+ * match a right one, then the right ones that match those (see semiJoin for the order). A row's join starts from the
+ * row alone and from the rows read for every other record (see joinBases), so each record is read once for the whole
+ * join and each lookup is built once, rather than every loaded row being copied for each row joined.
+ * @param entity
+ * @param joinEntity
+ * @param dataSets
+ * @param joinClauses
+ * @param entityAlreadyResolved - Whether the where clause already narrowed entity's rows (then they aren't read again:
+ * an empty list reads as "not loaded yet", see readEntity).
+ * @param joinAlreadyResolved - The same for joinEntity.
+ */
 const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], entityAlreadyResolved = false, joinAlreadyResolved = false) => {
-  // Same ambiguity readEntity() always has (can't tell "never loaded" from "loaded, zero rows
-  // matched") - runQuery already resolved entity's rows via an indexed condition in that second
-  // case, so entityAlreadyResolved tells this call not to reload and silently discard that result.
   if (!entityAlreadyResolved) {
     dataSets = await (0, _readEntity.readEntity)(entity, dataSets);
   }
   if (!joinClauses.length) {
     return dataSets;
   }
-  // The same for joinEntity: an indexed condition on its field may have resolved its rows to none
-  if (!joinAlreadyResolved) {
-    dataSets = await (0, _readEntity.readEntity)(joinEntity, dataSets);
+  const steps = await joinSteps(joinClauses);
+  if (!dataSets[entity].length) {
+    return dataSets;
   }
-  for (const anEntity in dataSets[entity]) {
-    let filterJoins = _siFunciona.default.cloneObject(dataSets);
-    filterJoins[entity] = [dataSets[entity][anEntity]];
-    for (const joinClause of joinClauses) {
-      filterJoins = await (0, _useJoinClause.useJoinClause)(joinClause, dataSets, filterJoins);
+  const bases = await (0, _joinBases.joinBases)(entity, joinEntity, dataSets, steps, joinAlreadyResolved);
+  for (const row of dataSets[entity]) {
+    const sides = new Map(bases);
+    sides.set(entity, {
+      rows: [row]
+    });
+    for (const step of steps) {
+      sides.set(step.entityA, {
+        rows: (0, _semiJoin.semiJoin)(sides.get(step.entityA), sides.get(step.entityB), step.propertyA, step.propertyB, step.comparator, step.typeA)
+      });
+      sides.set(step.entityB, {
+        rows: (0, _semiJoin.semiJoin)(sides.get(step.entityB), sides.get(step.entityA), step.propertyB, step.propertyA, step.comparator, step.typeB)
+      });
     }
-    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity];
+    row[joinEntity] = joinedRows(sides.get(joinEntity).rows);
   }
   return dataSets;
 };

package/dist/data/queries/joinEntity.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinEntity=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_readEntity=require("./readEntity"),_useJoinClause=require("../utilities/useJoinClause");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const joinEntity=async(e,t,i={},n=[],r=!1,u=!1)=>{if(r||(i=await(0,_readEntity.readEntity)(e,i)),!n.length)return i;u||(i=await(0,_readEntity.readEntity)(t,i));for(const r in i[e]){let u=_siFunciona.default.cloneObject(i);u[e]=[i[e][r]];for(const e of n)u=await(0,_useJoinClause.useJoinClause)(e,i,u);i[e][r][t]=u[t]}return i};exports.joinEntity=joinEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinEntity=void 0,require("core-js/modules/esnext.iterator.constructor.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");var _readEntity=require("./readEntity"),_retrieveRecord=require("../utilities/retrieveRecord"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_fieldType=require("../utilities/fieldType"),_semiJoin=require("../utilities/semiJoin"),_joinBases=require("../utilities/joinBases");const joinSteps=async e=>{const t=[];for(const{propertyA:r,comparator:s,propertyB:i}of e){const{entity:e,property:o}=(0,_splitEntityProperty.splitEntityProperty)(r),{entity:n,property:p}=(0,_splitEntityProperty.splitEntityProperty)(i);t.push({entityA:e,propertyA:o,typeA:(0,_fieldType.fieldType)(await(0,_retrieveRecord.retrieveRecord)(e),o),comparator:s,entityB:n,propertyB:p,typeB:(0,_fieldType.fieldType)(await(0,_retrieveRecord.retrieveRecord)(n),p)})}return t},joinedRows=e=>e.map((e=>structuredClone(e))),joinEntity=async(e,t,r={},s=[],i=!1,o=!1)=>{if(i||(r=await(0,_readEntity.readEntity)(e,r)),!s.length)return r;const n=await joinSteps(s);if(!r[e].length)return r;const p=await(0,_joinBases.joinBases)(e,t,r,n,o);for(const s of r[e]){const r=new Map(p);r.set(e,{rows:[s]});for(const e of n)r.set(e.entityA,{rows:(0,_semiJoin.semiJoin)(r.get(e.entityA),r.get(e.entityB),e.propertyA,e.propertyB,e.comparator,e.typeA)}),r.set(e.entityB,{rows:(0,_semiJoin.semiJoin)(r.get(e.entityB),r.get(e.entityA),e.propertyB,e.propertyA,e.comparator,e.typeB)});s[t]=joinedRows(r.get(t).rows)}return r};exports.joinEntity=joinEntity;