json-fs-query 1.0.5 → 1.0.6

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

@@ -1,52 +1,52 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.hasDependents = void 0;
-var _describe = require("../describe");
-var _retrieveRecord = require("../../utilities/retrieveRecord");
-var _retrieveRecords = require("../../utilities/retrieveRecords");
-var _where = require("../../queries/where");
-var _splitEntityProperty = require("../../utilities/parsers/splitEntityProperty");
-/**
- * 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.
- * @param entity
- * @param property
- * @param value
- */
-const hasDependents = async (entity, property, value) => {
-  const entityFiles = await (0, _describe.describe)();
-  for (const entityFile of entityFiles) {
-    const otherEntity = entityFile.replace(/\.json$/, '');
-    const otherRecord = await (0, _retrieveRecord.retrieveRecord)(otherEntity);
-    for (const key of otherRecord.keys) {
-      if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
-        continue;
-      }
-      const {
-        entity: refEntity,
-        property: refProperty
-      } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
-      if (refEntity !== entity || refProperty !== property) {
-        continue;
-      }
-      const records = await (0, _retrieveRecords.retrieveRecords)(otherEntity);
-      const found = (0, _where.where)(records, {
-        property: key.fields[0],
-        comparator: '=',
-        value
-      });
-      if (found.length) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasDependents = void 0;
+var _describe = require("../describe");
+var _retrieveRecord = require("../../utilities/retrieveRecord");
+var _retrieveRecords = require("../../utilities/retrieveRecords");
+var _where = require("../../queries/where");
+var _splitEntityProperty = require("../../utilities/parsers/splitEntityProperty");
+/**
+ * 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.
+ * @param entity
+ * @param property
+ * @param value
+ */
+const hasDependents = async (entity, property, value) => {
+  const entityFiles = await (0, _describe.describe)();
+  for (const entityFile of entityFiles) {
+    const otherEntity = entityFile.replace(/\.json$/, '');
+    const otherRecord = await (0, _retrieveRecord.retrieveRecord)(otherEntity);
+    for (const key of otherRecord.keys) {
+      if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
+        continue;
+      }
+      const {
+        entity: refEntity,
+        property: refProperty
+      } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
+      if (refEntity !== entity || refProperty !== property) {
+        continue;
+      }
+      const records = await (0, _retrieveRecords.retrieveRecords)(otherEntity);
+      const found = (0, _where.where)(records, {
+        property: key.fields[0],
+        comparator: '=',
+        value
+      });
+      if (found.length) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
 exports.hasDependents = hasDependents;

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

@@ -1,17 +1,17 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.keyGenerate = void 0;
-var _keyUnique = require("./keyUnique");
-const keyGenerate = async (entity, references = []) => {
-  let uuid = null;
-  let isUnique = false;
-  while (!isUnique) {
-    uuid = crypto.randomUUID();
-    isUnique = await (0, _keyUnique.keyUnique)(entity, references, [uuid]);
-  }
-  return uuid;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keyGenerate = void 0;
+var _keyUnique = require("./keyUnique");
+const keyGenerate = async (entity, references = []) => {
+  let uuid = null;
+  let isUnique = false;
+  while (!isUnique) {
+    uuid = crypto.randomUUID();
+    isUnique = await (0, _keyUnique.keyUnique)(entity, references, [uuid]);
+  }
+  return uuid;
+};
 exports.keyGenerate = keyGenerate;

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

@@ -1,31 +1,31 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.keyUnique = void 0;
-var _retrieveRecords = require("../../utilities/retrieveRecords");
-var _where = require("../../queries/where");
-/**
- * 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].
- * @param entity
- * @param references
- * @param checkKeys
- */
-const keyUnique = async (entity, references = [], checkKeys = []) => {
-  if (!references.length || references.length !== checkKeys.length) {
-    return false;
-  }
-  let records = await (0, _retrieveRecords.retrieveRecords)(entity);
-  for (let i = 0; i < references.length; i++) {
-    records = (0, _where.where)(records, {
-      property: references[i],
-      comparator: '=',
-      value: checkKeys[i]
-    });
-  }
-  return !records.length;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keyUnique = void 0;
+var _retrieveRecords = require("../../utilities/retrieveRecords");
+var _where = require("../../queries/where");
+/**
+ * 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].
+ * @param entity
+ * @param references
+ * @param checkKeys
+ */
+const keyUnique = async (entity, references = [], checkKeys = []) => {
+  if (!references.length || references.length !== checkKeys.length) {
+    return false;
+  }
+  let records = await (0, _retrieveRecords.retrieveRecords)(entity);
+  for (let i = 0; i < references.length; i++) {
+    records = (0, _where.where)(records, {
+      property: references[i],
+      comparator: '=',
+      value: checkKeys[i]
+    });
+  }
+  return !records.length;
+};
 exports.keyUnique = keyUnique;

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

@@ -1,57 +1,57 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.typeCheck = void 0;
-/**
- * Validate (and where sensible, coerce) a value against a field's declared type. Runs only
- * against values being written by insertEntity/updateEntity - it never re-validates data already
- * on disk, so a field whose declared type doesn't match its already-stored values (which can
- * happen, since nothing enforced this before) is left alone until something actually updates it.
- * An unrecognized type name is treated as unconstrained rather than rejected, so a typo in a
- * schema's field type can't silently block every write to that field.
- * @param type
- * @param value
- */
-const typeCheck = (type = 'string', value = undefined) => {
-  if (typeof value === 'undefined') {
-    return value;
-  }
-  switch (type) {
-    case 'string':
-      return typeof value === 'string' ? value : String(value);
-    case 'int':
-      {
-        const coerced = Number(value);
-        if (Number.isNaN(coerced) || !Number.isInteger(coerced)) {
-          throw new Error(`Value "${value}" is not a valid int`);
-        }
-        return coerced;
-      }
-    case 'boolean':
-      if (typeof value === 'boolean') {
-        return value;
-      }
-      if (value === 'true') {
-        return true;
-      }
-      if (value === 'false') {
-        return false;
-      }
-      throw new Error(`Value "${value}" is not a valid boolean`);
-    case 'object':
-      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-        throw new Error(`Value "${value}" is not a valid object`);
-      }
-      return value;
-    case 'array':
-      if (!Array.isArray(value)) {
-        throw new Error(`Value "${value}" is not a valid array`);
-      }
-      return value;
-    default:
-      return value;
-  }
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeCheck = void 0;
+/**
+ * Validate (and where sensible, coerce) a value against a field's declared type. Runs only
+ * against values being written by insertEntity/updateEntity - it never re-validates data already
+ * on disk, so a field whose declared type doesn't match its already-stored values (which can
+ * happen, since nothing enforced this before) is left alone until something actually updates it.
+ * An unrecognized type name is treated as unconstrained rather than rejected, so a typo in a
+ * schema's field type can't silently block every write to that field.
+ * @param type
+ * @param value
+ */
+const typeCheck = (type = 'string', value = undefined) => {
+  if (typeof value === 'undefined') {
+    return value;
+  }
+  switch (type) {
+    case 'string':
+      return typeof value === 'string' ? value : String(value);
+    case 'int':
+      {
+        const coerced = Number(value);
+        if (Number.isNaN(coerced) || !Number.isInteger(coerced)) {
+          throw new Error(`Value "${value}" is not a valid int`);
+        }
+        return coerced;
+      }
+    case 'boolean':
+      if (typeof value === 'boolean') {
+        return value;
+      }
+      if (value === 'true') {
+        return true;
+      }
+      if (value === 'false') {
+        return false;
+      }
+      throw new Error(`Value "${value}" is not a valid boolean`);
+    case 'object':
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`Value "${value}" is not a valid object`);
+      }
+      return value;
+    case 'array':
+      if (!Array.isArray(value)) {
+        throw new Error(`Value "${value}" is not a valid array`);
+      }
+      return value;
+    default:
+      return value;
+  }
+};
 exports.typeCheck = typeCheck;

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

@@ -1,14 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-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 typeof value === 'undefined' && optional;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 typeof value === 'undefined' && optional;
+};
 exports.typeEnum = typeEnum;

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

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

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");
-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;
-};
+"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.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;
-  }, {});
-};
+"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;