json-fs-query 1.0.4 → 1.0.5

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

@@ -1,13 +1,13 @@
-/**
- * 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
- */
-export declare const hasDependents: (entity: string, property: string, value: any) => Promise<boolean>;
+/**
+ * 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
+ */
+export declare const hasDependents: (entity: string, property: string, value: any) => Promise<boolean>;
 //# sourceMappingURL=hasDependents.d.ts.map

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

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

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

@@ -1,2 +1,2 @@
-export declare const keyGenerate: (entity: any, references?: any[]) => Promise<any>;
+export declare const keyGenerate: (entity: any, references?: any[]) => Promise<any>;
 //# sourceMappingURL=keyGenerate.d.ts.map

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

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

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

@@ -1,10 +1,10 @@
-/**
- * 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
- */
-export declare const keyUnique: (entity: any, references?: any[], checkKeys?: any[]) => Promise<boolean>;
+/**
+ * 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
+ */
+export declare const keyUnique: (entity: any, references?: any[], checkKeys?: any[]) => Promise<boolean>;
 //# sourceMappingURL=keyUnique.d.ts.map

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

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

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

@@ -1,12 +1,12 @@
-/**
- * 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
- */
-export declare const typeCheck: (type?: string, value?: any) => any;
+/**
+ * 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
+ */
+export declare const typeCheck: (type?: string, value?: any) => any;
 //# sourceMappingURL=typeCheck.d.ts.map

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

@@ -1,9 +1,9 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.typeCheck = void 0
+});
+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
@@ -16,42 +16,42 @@ exports.typeCheck = void 0
  */
 const typeCheck = (type = 'string', value = undefined) => {
   if (typeof value === 'undefined') {
-    return value
+    return value;
   }
   switch (type) {
     case 'string':
-      return typeof value === 'string' ? value : String(value)
+      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`)
+      {
+        const coerced = Number(value);
+        if (Number.isNaN(coerced) || !Number.isInteger(coerced)) {
+          throw new Error(`Value "${value}" is not a valid int`);
+        }
+        return coerced;
       }
-      return coerced
-    }
     case 'boolean':
       if (typeof value === 'boolean') {
-        return value
+        return value;
       }
       if (value === 'true') {
-        return true
+        return true;
       }
       if (value === 'false') {
-        return false
+        return false;
       }
-      throw new Error(`Value "${value}" is not a valid boolean`)
+      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`)
+        throw new Error(`Value "${value}" is not a valid object`);
       }
-      return value
+      return value;
     case 'array':
       if (!Array.isArray(value)) {
-        throw new Error(`Value "${value}" is not a valid array`)
+        throw new Error(`Value "${value}" is not a valid array`);
       }
-      return value
+      return value;
     default:
-      return value
+      return value;
   }
-}
-exports.typeCheck = typeCheck
+};
+exports.typeCheck = typeCheck;

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

@@ -1,2 +1,2 @@
-export declare const typeEnum: (values?: any[], value?: string, optional?: boolean) => boolean;
+export declare const typeEnum: (values?: any[], value?: string, optional?: boolean) => boolean;
 //# sourceMappingURL=typeEnum.d.ts.map

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
-}
-exports.typeEnum = typeEnum
+"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.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'
-
-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
+"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.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,39 +1,39 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+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')
+});
+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')
+} = 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
@@ -45,15 +45,15 @@ const {
  */
 const assertNoDependents = async (entity, primaryKey, toDelete) => {
   if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1) {
-    return
+    return;
   }
-  const property = primaryKey.fields[0]
+  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`)
+      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
@@ -65,36 +65,36 @@ const assertNoDependents = async (entity, primaryKey, toDelete) => {
  * @param deletedValues
  */
 const removeMatchingEntries = async (entity, record, primaryKey, deletedValues) => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/')
-  const remainingEntries = []
+  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
+  const remainingEntries = [];
   for (const fileName of record.entries) {
-    const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`)
+    const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
     if (!deletedValues.has((0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data))) {
-      remainingEntries.push(fileName)
-      continue
+      remainingEntries.push(fileName);
+      continue;
     }
-    await rm(`${databasePath}${record.path}/${fileName}`)
+    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)
+      await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName);
     }
   }
-  return remainingEntries
-}
+  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')
+  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`)
+    throw new Error(`Cannot delete from "${entity}" without a primary key`);
   }
-  const toDelete = dataSet[entity] || []
+  const toDelete = dataSet[entity] || [];
   if (!toDelete.length) {
-    return dataSet
+    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
+  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'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+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')
+});
+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;
   }
   return dataSet.reduce((groupedData, data) => {
-    const property = data[groupProperty]
+    const property = data[groupProperty];
     if (!Object.prototype.hasOwnProperty.call(groupedData, property)) {
-      groupedData[property] = []
+      groupedData[property] = [];
     }
-    groupedData[property].push(data)
-    return groupedData
-  }, {})
-}
-exports.groupBy = groupBy
+    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