json-fs-query 1.0.4 → 1.0.6

package/dist/data/introspect/drop.js

@@ -1,37 +1,37 @@
-'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: true
-})
-exports.drop = void 0
-const _retrieveFile = require('../utilities/retrieveFile')
-const _deregisterRecord = require('../utilities/deregisterRecord')
-const _config = require('../utilities/config')
-const {
-  rm
-} = require('fs/promises')
-const drop = async record => {
-  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 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, _deregisterRecord.deregisterRecord)(record)
-}
-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: true
+});
+exports.drop = void 0;
+var _retrieveFile = require("../utilities/retrieveFile");
+var _deregisterRecord = require("../utilities/deregisterRecord");
+var _config = require("../utilities/config");
+const {
+  rm
+} = require('fs/promises');
+const drop = async record => {
+  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 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, _deregisterRecord.deregisterRecord)(record);
+};
+exports.drop = drop;

package/dist/data/introspect/index.d.ts

@@ -1,8 +1,8 @@
-export { create } from './create';
-export { drop } from './drop';
-export { describe } from './describe';
-export { fieldProperties, fieldDefinition, fieldName } from './definitions/field';
-export { keyProperties, keyDefinition, indexType, indexLocation } from './definitions/key';
-export { referenceProperties, reference } from './definitions/keyReference';
-export { recordProperties, recordDefinition, recordPath, entityPath } from './definitions/record';
+export { create } from './create';
+export { drop } from './drop';
+export { describe } from './describe';
+export { fieldProperties, fieldDefinition, fieldName } from './definitions/field';
+export { keyProperties, keyDefinition, indexType, indexLocation } from './definitions/key';
+export { referenceProperties, reference } from './definitions/keyReference';
+export { recordProperties, recordDefinition, recordPath, entityPath } from './definitions/record';
 //# sourceMappingURL=index.d.ts.map

package/dist/data/introspect/index.js

@@ -1,30 +1,30 @@
-'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: true
-})
-Object.defineProperty(exports, 'create', {
-  enumerable: true,
-  get: function () {
-    return _create.create
-  }
-})
-Object.defineProperty(exports, 'describe', {
-  enumerable: true,
-  get: function () {
-    return _describe.describe
-  }
-})
-Object.defineProperty(exports, 'drop', {
-  enumerable: true,
-  get: function () {
-    return _drop.drop
-  }
-})
-var _create = require('./create')
-var _drop = require('./drop')
-var _describe = require('./describe')
+"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: true
+});
+Object.defineProperty(exports, "create", {
+  enumerable: true,
+  get: function () {
+    return _create.create;
+  }
+});
+Object.defineProperty(exports, "describe", {
+  enumerable: true,
+  get: function () {
+    return _describe.describe;
+  }
+});
+Object.defineProperty(exports, "drop", {
+  enumerable: true,
+  get: function () {
+    return _drop.drop;
+  }
+});
+var _create = require("./create");
+var _drop = require("./drop");
+var _describe = require("./describe");

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

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

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

@@ -1,25 +1,25 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.foreignKeyExists = void 0
-const _retrieveRecords = require('../../utilities/retrieveRecords')
-const _where = require('../../queries/where')
-/**
- * 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.
- * @param entity
- * @param property
- * @param value
- */
-const foreignKeyExists = async (entity, property, value) => {
-  const records = await (0, _retrieveRecords.retrieveRecords)(entity)
-  const found = (0, _where.where)(records, {
-    property,
-    comparator: '=',
-    value
-  })
-  return found.length > 0
-}
-exports.foreignKeyExists = foreignKeyExists
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.foreignKeyExists = void 0;
+var _retrieveRecords = require("../../utilities/retrieveRecords");
+var _where = require("../../queries/where");
+/**
+ * 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.
+ * @param entity
+ * @param property
+ * @param value
+ */
+const foreignKeyExists = async (entity, property, value) => {
+  const records = await (0, _retrieveRecords.retrieveRecords)(entity);
+  const found = (0, _where.where)(records, {
+    property,
+    comparator: '=',
+    value
+  });
+  return found.length > 0;
+};
+exports.foreignKeyExists = foreignKeyExists;

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,52 +1,52 @@
-'use strict'
-
-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')
-/**
- * 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
+"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.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'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.keyGenerate = void 0
-const _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
+"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.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,31 +1,31 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.keyUnique = void 0
-const _retrieveRecords = require('../../utilities/retrieveRecords')
-const _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
+"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.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,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
-  }
-}
-exports.typeCheck = typeCheck
+"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.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