json-fs-query 1.0.4 → 1.0.6

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

@@ -1,14 +1,14 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.typeEnum = void 0
-require('core-js/modules/es.array.includes.js')
+});
+exports.typeEnum = void 0;
+require("core-js/modules/es.array.includes.js");
 const typeEnum = (values = [], value = '', optional = false) => {
   if (values.includes(value)) {
-    return true
+    return true;
   }
-  return typeof value === 'undefined' && optional
-}
-exports.typeEnum = typeEnum
+  return typeof value === 'undefined' && optional;
+};
+exports.typeEnum = typeEnum;

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

@@ -1,2 +1,2 @@
-export declare const useDefault: (defaultValue?: string, value?: any) => any;
+export declare const useDefault: (defaultValue?: string, value?: any) => any;
 //# sourceMappingURL=useDefault.d.ts.map

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

@@ -1,13 +1,13 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.useDefault = void 0
+});
+exports.useDefault = void 0;
 const useDefault = (defaultValue = '', value = undefined) => {
   if (typeof value === 'undefined') {
-    return defaultValue
+    return defaultValue;
   }
-  return value
-}
-exports.useDefault = useDefault
+  return value;
+};
+exports.useDefault = useDefault;

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

@@ -1,2 +1,2 @@
-export declare const deleteEntity: (entity?: string, dataSet?: Object) => Promise<Object>;
+export declare const deleteEntity: (entity?: string, dataSet?: Object) => Promise<Object>;
 //# sourceMappingURL=deleteEntity.d.ts.map

package/dist/data/queries/deleteEntity.js

@@ -1,100 +1,100 @@
-'use strict'
-
-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.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')
-const _retrieveRecord = require('../utilities/retrieveRecord')
-const _retrieveFile = require('../utilities/retrieveFile')
-const _removeFromIndex = require('../utilities/removeFromIndex')
-const _computeKeyValue = require('../utilities/computeKeyValue')
-const _hasDependents = require('../introspect/policies/hasDependents')
-const _config = require('../utilities/config')
-const {
-  rm,
-  writeFile
-} = require('fs/promises')
-/**
- * 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
- * key, since foreign key support itself is single-field only - a composite primary key can't be
- * the target of one yet, so there's nothing to check.
- * @param entity
- * @param primaryKey
- * @param toDelete
- */
-const assertNoDependents = async (entity, primaryKey, toDelete) => {
-  if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1) {
-    return
-  }
-  const property = primaryKey.fields[0]
-  for (const row of toDelete) {
-    if (await (0, _hasDependents.hasDependents)(entity, property, row[property])) {
-      throw new Error(`Cannot delete from "${entity}" where "${property}" = ${row[property]} - other records still reference it`)
-    }
-  }
-}
-/**
- * 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.
- * @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 data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`)
-    if (!deletedValues.has((0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data))) {
-      remainingEntries.push(fileName)
-      continue
-    }
-    await rm(`${databasePath}${record.path}/${fileName}`)
-    for (const key of record.keys) {
-      await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName)
-    }
-  }
-  return remainingEntries
-}
-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) {
-    throw new Error(`Cannot delete from "${entity}" without a primary key`)
-  }
-  const toDelete = dataSet[entity] || []
-  if (!toDelete.length) {
-    return 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))
-  return dataSet
-}
-exports.deleteEntity = deleteEntity
+"use strict";
+
+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.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");
+var _retrieveFile = require("../utilities/retrieveFile");
+var _removeFromIndex = require("../utilities/removeFromIndex");
+var _computeKeyValue = require("../utilities/computeKeyValue");
+var _hasDependents = require("../introspect/policies/hasDependents");
+var _config = require("../utilities/config");
+const {
+  rm,
+  writeFile
+} = require('fs/promises');
+/**
+ * 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
+ * key, since foreign key support itself is single-field only - a composite primary key can't be
+ * the target of one yet, so there's nothing to check.
+ * @param entity
+ * @param primaryKey
+ * @param toDelete
+ */
+const assertNoDependents = async (entity, primaryKey, toDelete) => {
+  if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1) {
+    return;
+  }
+  const property = primaryKey.fields[0];
+  for (const row of toDelete) {
+    if (await (0, _hasDependents.hasDependents)(entity, property, row[property])) {
+      throw new Error(`Cannot delete from "${entity}" where "${property}" = ${row[property]} - other records still reference it`);
+    }
+  }
+};
+/**
+ * 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.
+ * @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 data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
+    if (!deletedValues.has((0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data))) {
+      remainingEntries.push(fileName);
+      continue;
+    }
+    await rm(`${databasePath}${record.path}/${fileName}`);
+    for (const key of record.keys) {
+      await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName);
+    }
+  }
+  return remainingEntries;
+};
+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) {
+    throw new Error(`Cannot delete from "${entity}" without a primary key`);
+  }
+  const toDelete = dataSet[entity] || [];
+  if (!toDelete.length) {
+    return 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));
+  return dataSet;
+};
+exports.deleteEntity = deleteEntity;

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

@@ -1,2 +1,2 @@
-export declare const groupBy: (dataSet?: any[], groupProperty?: string) => any;
+export declare const groupBy: (dataSet?: any[], groupProperty?: string) => any;
 //# sourceMappingURL=groupBy.d.ts.map

package/dist/data/queries/groupBy.js

@@ -1,22 +1,22 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.groupBy = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.reduce.js')
-const groupBy = (dataSet = [], groupProperty = '') => {
-  if (!groupProperty) {
-    return dataSet
-  }
-  return dataSet.reduce((groupedData, data) => {
-    const property = data[groupProperty]
-    if (!Object.prototype.hasOwnProperty.call(groupedData, property)) {
-      groupedData[property] = []
-    }
-    groupedData[property].push(data)
-    return groupedData
-  }, {})
-}
-exports.groupBy = groupBy
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.groupBy = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+const groupBy = (dataSet = [], groupProperty = '') => {
+  if (!groupProperty) {
+    return dataSet;
+  }
+  return dataSet.reduce((groupedData, data) => {
+    const property = data[groupProperty];
+    if (!Object.prototype.hasOwnProperty.call(groupedData, property)) {
+      groupedData[property] = [];
+    }
+    groupedData[property].push(data);
+    return groupedData;
+  }, {});
+};
+exports.groupBy = groupBy;

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

@@ -1,2 +1,2 @@
-export declare const insertEntity: (entity?: string, values?: Object[], dataSet?: Object) => Promise<Object>;
+export declare const insertEntity: (entity?: string, values?: Object[], dataSet?: Object) => Promise<Object>;
 //# sourceMappingURL=insertEntity.d.ts.map

package/dist/data/queries/insertEntity.js

@@ -1,117 +1,117 @@
-'use strict'
-
-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')
-const _retrieveRecord = require('../utilities/retrieveRecord')
-const _updateIndex = require('../utilities/updateIndex')
-const _keyGenerate = require('../introspect/policies/keyGenerate')
-const _keyUnique = require('../introspect/policies/keyUnique')
-const _useDefault = require('../introspect/policies/useDefault')
-const _typeCheck = require('../introspect/policies/typeCheck')
-const _foreignKeyExists = require('../introspect/policies/foreignKeyExists')
-const _splitEntityProperty = require('../utilities/parsers/splitEntityProperty')
-const _computeKeyValue = require('../utilities/computeKeyValue')
-const _config = require('../utilities/config')
-const {
-  writeFile
-} = require('fs/promises')
-/**
- * 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.
- * @param entity
- * @param record
- * @param rowValues
- */
-const buildEntityValues = async (entity, record, rowValues = {}) => {
-  const entityValues = {}
-  for (const field of record.definition) {
-    let value = rowValues[field.name]
-    if (field.autoGenerate) {
-      value = await (0, _keyGenerate.keyGenerate)(entity, [field.name])
-    } else if (Object.prototype.hasOwnProperty.call(field, 'default')) {
-      value = (0, _useDefault.useDefault)(field.default, value)
-    }
-    if (typeof value === 'undefined') {
-      if (!field.optional) {
-        throw new Error(`Missing required field "${field.name}" for ${entity}`)
-      }
-      continue
-    }
-    entityValues[field.name] = (0, _typeCheck.typeCheck)(field.type, value)
-  }
-  return entityValues
-}
-/**
- * Reject the insert if it collides with an existing primary or unique key value - a single field,
- * or a composite of several for a multi-field key.
- * @param entity
- * @param record
- * @param entityValues
- */
-const assertUnique = async (entity, record, entityValues) => {
-  for (const key of record.keys) {
-    if (key.type !== 'primary' && key.type !== 'unique') {
-      continue
-    }
-    const checkKeys = key.fields.map(field => entityValues[field])
-    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys)
-    if (!isUnique) {
-      throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`)
-    }
-  }
-}
-/**
- * Reject the insert if a single-field foreign key's value doesn't exist in the record it
- * references.
- * @param entity
- * @param record
- * @param entityValues
- */
-const assertForeignKeys = async (entity, record, entityValues) => {
-  for (const key of record.keys) {
-    if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
-      continue
-    }
-    const field = key.fields[0]
-    if (!Object.prototype.hasOwnProperty.call(entityValues, field)) {
-      continue
-    }
-    const {
-      entity: refEntity,
-      property: refProperty
-    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0])
-    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, entityValues[field])
-    if (!exists) {
-      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${entityValues[field]}`)
-    }
-  }
-}
-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)) {
-    dataSet[entity] = []
-  }
-  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))
-    record.entries.push(fileName)
-    await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2))
-    for (const key of record.keys) {
-      await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName)
-    }
-    dataSet[entity].push(entityValues)
-  }
-  return dataSet
-}
-exports.insertEntity = insertEntity
+"use strict";
+
+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");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _updateIndex = require("../utilities/updateIndex");
+var _keyGenerate = require("../introspect/policies/keyGenerate");
+var _keyUnique = require("../introspect/policies/keyUnique");
+var _useDefault = require("../introspect/policies/useDefault");
+var _typeCheck = require("../introspect/policies/typeCheck");
+var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
+var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
+var _computeKeyValue = require("../utilities/computeKeyValue");
+var _config = require("../utilities/config");
+const {
+  writeFile
+} = require('fs/promises');
+/**
+ * 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.
+ * @param entity
+ * @param record
+ * @param rowValues
+ */
+const buildEntityValues = async (entity, record, rowValues = {}) => {
+  const entityValues = {};
+  for (const field of record.definition) {
+    let value = rowValues[field.name];
+    if (field.autoGenerate) {
+      value = await (0, _keyGenerate.keyGenerate)(entity, [field.name]);
+    } else if (Object.prototype.hasOwnProperty.call(field, 'default')) {
+      value = (0, _useDefault.useDefault)(field['default'], value);
+    }
+    if (typeof value === 'undefined') {
+      if (!field.optional) {
+        throw new Error(`Missing required field "${field.name}" for ${entity}`);
+      }
+      continue;
+    }
+    entityValues[field.name] = (0, _typeCheck.typeCheck)(field.type, value);
+  }
+  return entityValues;
+};
+/**
+ * Reject the insert if it collides with an existing primary or unique key value - a single field,
+ * or a composite of several for a multi-field key.
+ * @param entity
+ * @param record
+ * @param entityValues
+ */
+const assertUnique = async (entity, record, entityValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'primary' && key.type !== 'unique') {
+      continue;
+    }
+    const checkKeys = key.fields.map(field => entityValues[field]);
+    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys);
+    if (!isUnique) {
+      throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`);
+    }
+  }
+};
+/**
+ * Reject the insert if a single-field foreign key's value doesn't exist in the record it
+ * references.
+ * @param entity
+ * @param record
+ * @param entityValues
+ */
+const assertForeignKeys = async (entity, record, entityValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
+      continue;
+    }
+    const field = key.fields[0];
+    if (!Object.prototype.hasOwnProperty.call(entityValues, field)) {
+      continue;
+    }
+    const {
+      entity: refEntity,
+      property: refProperty
+    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
+    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, entityValues[field]);
+    if (!exists) {
+      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${entityValues[field]}`);
+    }
+  }
+};
+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)) {
+    dataSet[entity] = [];
+  }
+  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));
+    record.entries.push(fileName);
+    await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2));
+    for (const key of record.keys) {
+      await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName);
+    }
+    dataSet[entity].push(entityValues);
+  }
+  return dataSet;
+};
+exports.insertEntity = insertEntity;

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

@@ -1,2 +1,2 @@
-export declare const joinEntity: (entity: any, joinEntity: any, dataSets?: {}, joinClauses?: any[], entityAlreadyResolved?: boolean) => Promise<{}>;
+export declare const joinEntity: (entity: any, joinEntity: any, dataSets?: {}, joinClauses?: any[], entityAlreadyResolved?: boolean) => Promise<{}>;
 //# sourceMappingURL=joinEntity.d.ts.map

package/dist/data/queries/joinEntity.js

@@ -1,32 +1,32 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.joinEntity = void 0
-const _siFunciona = _interopRequireDefault(require('si-funciona'))
-const _readEntity = require('./readEntity')
-const _useJoinClause = require('../utilities/useJoinClause')
-function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
-const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], entityAlreadyResolved = 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
-  }
-  dataSets = await (0, _readEntity.readEntity)(joinEntity, 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)
-    }
-    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity]
-  }
-  return dataSets
-}
-exports.joinEntity = joinEntity
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinEntity = void 0;
+var _siFunciona = _interopRequireDefault(require("si-funciona"));
+var _readEntity = require("./readEntity");
+var _useJoinClause = require("../utilities/useJoinClause");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], entityAlreadyResolved = 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;
+  }
+  dataSets = await (0, _readEntity.readEntity)(joinEntity, 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);
+    }
+    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity];
+  }
+  return dataSets;
+};
+exports.joinEntity = joinEntity;

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)=>{if(r||(i=await(0,_readEntity.readEntity)(e,i)),!n.length)return i;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(let 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;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)=>{if(r||(i=await(0,_readEntity.readEntity)(e,i)),!n.length)return i;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;