json-fs-query 1.1.0 → 2.0.0

package/dist/data/queries/deleteEntity.js

@@ -1,101 +1,101 @@
-"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 _fieldType = require("../utilities/fieldType");
-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, (0, _fieldType.keyValueType)(record, key));
-    }
-  }
-  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 _fieldType = require("../utilities/fieldType");
+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, (0, _fieldType.keyValueType)(record, key));
+    }
+  }
+  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/describeRecord.d.ts

@@ -0,0 +1,9 @@
+import { recordDefinition } from '../introspect/definitions/record';
+export type recordDescription = Pick<recordDefinition, 'path' | 'definition' | 'keys'>;
+/**
+ * Run a parsed describe statement: the record's fields and keys (describe() in JS gives only the fields). An error
+ * if the record doesn't exist.
+ * @param entity
+ */
+export declare const describeRecord: (entity: string) => Promise<recordDescription>;
+//# sourceMappingURL=describeRecord.d.ts.map

package/dist/data/queries/describeRecord.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.describeRecord = void 0;
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _recordExists = require("../utilities/recordExists");
+/**
+ * Run a parsed describe statement: the record's fields and keys (describe() in JS gives only the fields). An error
+ * if the record doesn't exist.
+ * @param entity
+ */
+const describeRecord = async entity => {
+  if (!(0, _recordExists.recordExists)(entity)) {
+    throw new Error(`Record "${entity}" doesn't exist`);
+  }
+  const {
+    path,
+    definition,
+    keys
+  } = await (0, _retrieveRecord.retrieveRecord)(entity);
+  return {
+    path,
+    definition,
+    keys
+  };
+};
+exports.describeRecord = describeRecord;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.describeRecord=void 0;var _retrieveRecord=require("../utilities/retrieveRecord"),_recordExists=require("../utilities/recordExists");const describeRecord=async e=>{if(!(0,_recordExists.recordExists)(e))throw new Error(`Record "${e}" doesn't exist`);const{path:r,definition:i,keys:t}=await(0,_retrieveRecord.retrieveRecord)(e);return{path:r,definition:i,keys:t}};exports.describeRecord=describeRecord;

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

@@ -0,0 +1,9 @@
+import { recordDefinition } from '../introspect/definitions/record';
+/**
+ * Run a parsed drop statement: an error if the record doesn't exist, unless the statement says `if exists` (then
+ * nothing happens and the result is null). Otherwise drop() it and resolve to the definition it had.
+ * @param entity
+ * @param ifExists
+ */
+export declare const dropRecord: (entity: string, ifExists: boolean) => Promise<recordDefinition | null>;
+//# sourceMappingURL=dropRecord.d.ts.map

package/dist/data/queries/dropRecord.js

@@ -0,0 +1,61 @@
+"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.drop.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dropRecord = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.some.js");
+var _drop = require("../introspect/drop");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _recordExists = require("../utilities/recordExists");
+var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
+var _config = require("../utilities/config");
+/**
+ * RESTRICT, as MySQL does for a referenced table: reject dropping a record while another record has a foreign key
+ * referencing it, since every write to that record would then fail looking for the dropped one. A record referencing
+ * itself doesn't count. Off with enforceForeignKeys, like the row-level checks.
+ * @param entity
+ */
+const assertNotReferenced = async entity => {
+  if (!(0, _config.getSetting)('enforceForeignKeys', true) || !(0, _recordExists.recordExists)('__RECORDS')) {
+    return;
+  }
+  const registry = await (0, _retrieveRecord.retrieveRecord)('__RECORDS');
+  for (const fileName of registry.entries) {
+    const other = fileName.replace(/\.json$/, '');
+    if (other === entity || !(0, _recordExists.recordExists)(other)) {
+      continue;
+    }
+    for (const key of (await (0, _retrieveRecord.retrieveRecord)(other)).keys) {
+      if (key.type !== 'foreign' || !key.references) {
+        continue;
+      }
+      if (key.references.some(reference => (0, _splitEntityProperty.splitEntityProperty)(reference.fields[0]).entity === entity)) {
+        throw new Error(`Cannot drop "${entity}": ${other}.${key.fields.join(', ')} references it`);
+      }
+    }
+  }
+};
+/**
+ * Run a parsed drop statement: an error if the record doesn't exist, unless the statement says `if exists` (then
+ * nothing happens and the result is null). Otherwise drop() it and resolve to the definition it had.
+ * @param entity
+ * @param ifExists
+ */
+const dropRecord = async (entity, ifExists) => {
+  if (!(0, _recordExists.recordExists)(entity)) {
+    if (ifExists) {
+      return null;
+    }
+    throw new Error(`Record "${entity}" doesn't exist`);
+  }
+  await assertNotReferenced(entity);
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+  await (0, _drop.drop)(entity);
+  return record;
+};
+exports.dropRecord = dropRecord;

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

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.dropRecord=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.some.js");var _drop=require("../introspect/drop"),_retrieveRecord=require("../utilities/retrieveRecord"),_recordExists=require("../utilities/recordExists"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_config=require("../utilities/config");const assertNotReferenced=async e=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||!(0,_recordExists.recordExists)("__RECORDS"))return;const r=await(0,_retrieveRecord.retrieveRecord)("__RECORDS");for(const t of r.entries){const r=t.replace(/\.json$/,"");if(r!==e&&(0,_recordExists.recordExists)(r))for(const t of(await(0,_retrieveRecord.retrieveRecord)(r)).keys)if("foreign"===t.type&&t.references&&t.references.some((r=>(0,_splitEntityProperty.splitEntityProperty)(r.fields[0]).entity===e)))throw new Error(`Cannot drop "${e}": ${r}.${t.fields.join(", ")} references it`)}},dropRecord=async(e,r)=>{if(!(0,_recordExists.recordExists)(e)){if(r)return null;throw new Error(`Record "${e}" doesn't exist`)}await assertNotReferenced(e);const t=await(0,_retrieveRecord.retrieveRecord)(e);return await(0,_drop.drop)(e),t};exports.dropRecord=dropRecord;

package/dist/data/queries/insertEntity.js

@@ -1,118 +1,123 @@
-"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 _fieldType = require("../utilities/fieldType");
-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, (0, _fieldType.keyValueType)(record, key));
-    }
-    dataSet[entity].push(entityValues);
-  }
-  return dataSet;
-};
+"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");
+require("core-js/modules/esnext.iterator.some.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 _fieldType = require("../utilities/fieldType");
+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, field.nullable);
+  }
+  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. As in SQL, a value with a null in it is never a
+ * duplicate, so a nullable unique field can hold null in any number of rows.
+ * @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]);
+    if (checkKeys.some(value => value === null)) {
+      continue;
+    }
+    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. A null references nothing, so it isn't checked (as in SQL).
+ * @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) || entityValues[field] === null) {
+      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, (0, _fieldType.keyValueType)(record, key));
+    }
+    dataSet[entity].push(entityValues);
+  }
+  return dataSet;
+};
 exports.insertEntity = insertEntity;

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

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

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

@@ -1,2 +1,2 @@
-export declare const parser: (queries?: string) => any[];
+export declare const parser: (queries?: string) => import("../utilities/parsers/parseQuery").ParsedQuery[];
 //# sourceMappingURL=parser.d.ts.map

package/dist/data/queries/parser.js

@@ -4,27 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parser = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
 var _splitQueries = require("../utilities/parsers/splitQueries");
 var _parseQuery = require("../utilities/parsers/parseQuery");
 const parser = (queries = '') => {
   const queryArray = (0, _splitQueries.splitQueries)(queries);
-  const parsedQueries = [];
-  let mergeQuery = '';
-  for (const query of queryArray) {
-    mergeQuery = mergeQuery ? `${mergeQuery}${query}` : query;
-    let parsedQuery = {};
+  return queryArray.map((query, index) => {
     try {
-      parsedQuery = (0, _parseQuery.parseQuery)(mergeQuery);
-      mergeQuery = '';
+      return (0, _parseQuery.parseQuery)(query);
     } catch (e) {
-      // attempt to combine queries to fix bad splits
-      continue;
+      const which = queryArray.length > 1 ? ` query ${index + 1} of ${queryArray.length}` : '';
+      throw new Error(`Failed to interpret${which}: ${query} (${e.message})`);
     }
-    parsedQueries.push(parsedQuery);
-  }
-  if (mergeQuery) {
-    throw new Error(`Failed to interpret: ${mergeQuery}`);
-  }
-  return parsedQueries;
+  });
 };
 exports.parser = parser;