json-fs-query 1.1.0 → 2.0.0

package/dist/data/queries/updateEntity.js

@@ -1,194 +1,246 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.updateEntity = 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 _retrieveFile = require("../utilities/retrieveFile");
-var _updateIndex = require("../utilities/updateIndex");
-var _removeFromIndex = require("../utilities/removeFromIndex");
-var _computeKeyValue = require("../utilities/computeKeyValue");
-var _fieldType = require("../utilities/fieldType");
-var _compareAs = require("../utilities/compareAs");
-var _keyUnique = require("../introspect/policies/keyUnique");
-var _typeCheck = require("../introspect/policies/typeCheck");
-var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
-var _hasDependents = require("../introspect/policies/hasDependents");
-var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
-var _config = require("../utilities/config");
-const {
-  writeFile
-} = require('fs/promises');
-/**
- * Same reasoning as deleteEntity: a record object carries no memory of which entry file it came
- * from, so re-scan entries[] and match by the record's own primary key value(s) - a single field,
- * or a composite of several for a multi-field primary key.
- * @param record
- * @param primaryKey
- * @param primaryValue
- */
-const findEntryFile = async (record, primaryKey, primaryValue) => {
-  for (const fileName of record.entries) {
-    const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
-    if ((0, _compareAs.sameValue)((0, _fieldType.keyValueType)(record, primaryKey), (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data), primaryValue)) {
-      return fileName;
-    }
-  }
-  return null;
-};
-/**
- * True if the update actually changes at least one of this key's fields - a key none of whose
- * fields appear in newValues, or whose given values are all unchanged, doesn't need re-checking.
- * @param record
- * @param key
- * @param oldData
- * @param newValues
- */
-const keyFieldsChanged = (record, key, oldData, newValues) => key.fields.some(field => Object.prototype.hasOwnProperty.call(newValues, field) && !(0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field]));
-/**
- * Only check uniqueness for a primary/unique key (single-field, or composite) whose value is
- * actually changing - checking an unchanged value would find the record's own existing entry and
- * wrongly report it as a duplicate of itself.
- * @param entity
- * @param record
- * @param oldData
- * @param newData
- * @param newValues
- */
-const assertUniqueForUpdate = async (entity, record, oldData, newData, newValues) => {
-  for (const key of record.keys) {
-    if (key.type !== 'primary' && key.type !== 'unique' || !keyFieldsChanged(record, key, oldData, newValues)) {
-      continue;
-    }
-    const checkKeys = key.fields.map(field => newData[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}`);
-    }
-  }
-};
-/**
- * Same "only if it actually changed" scoping as assertUniqueForUpdate: re-checking an unchanged
- * foreign key value would re-validate a reference this update never touches, which could fail an
- * unrelated field's update if that parent record happened to be deleted since.
- * @param entity
- * @param record
- * @param oldData
- * @param newValues
- */
-const assertForeignKeysForUpdate = async (entity, record, oldData, newValues) => {
-  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(newValues, field) || (0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field])) {
-      continue;
-    }
-    const {
-      entity: refEntity,
-      property: refProperty
-    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
-    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, newValues[field]);
-    if (!exists) {
-      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${newValues[field]}`);
-    }
-  }
-};
-/**
- * RESTRICT: reject an update that would change a single-field primary key's value while another
- * entity's foreign key still points at the old one - that reference would otherwise be left
- * dangling, since the row itself isn't gone, just re-keyed. Only meaningful for a single-field
- * primary key, matching foreign key support's own single-field-only scope.
- * @param entity
- * @param record
- * @param primaryKey
- * @param oldData
- * @param newValues
- */
-const assertNoDependentsForUpdate = async (entity, record, primaryKey, oldData, newValues) => {
-  if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1 || !keyFieldsChanged(record, primaryKey, oldData, newValues)) {
-    return;
-  }
-  const property = primaryKey.fields[0];
-  if (await (0, _hasDependents.hasDependents)(entity, property, oldData[property])) {
-    throw new Error(`Cannot update "${entity}" where "${property}" = ${oldData[property]} - other records still reference it`);
-  }
-};
-/**
- * Move a key's index entry (single-field, or a composite for a multi-field key) from the old
- * value to the new one wherever the update actually changed one of its fields.
- * @param record
- * @param oldData
- * @param newData
- * @param newValues
- * @param fileName
- */
-const reconcileIndexes = async (record, oldData, newData, newValues, fileName) => {
-  for (const key of record.keys) {
-    if (!keyFieldsChanged(record, key, oldData, newValues)) {
-      continue;
-    }
-    await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, oldData), fileName, (0, _fieldType.keyValueType)(record, key));
-    await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, newData), fileName, (0, _fieldType.keyValueType)(record, key));
-  }
-};
-const assertRequiredFields = (entity, record, newData) => {
-  for (const field of record.definition) {
-    if (!field.optional && typeof newData[field.name] === 'undefined') {
-      throw new Error(`Missing required field "${field.name}" for ${entity}`);
-    }
-  }
-};
-/**
- * Type-check (and coerce) only the fields actually present in an update's values, never the rest
- * of the merged record - a field whose already-stored value doesn't match its declared type
- * (nothing enforced this before typeCheck() existed) must not block an update that never touches
- * that field.
- * @param record
- * @param values
- */
-const applyFieldTypes = (record, values) => {
-  const typedValues = Object.assign({}, values);
-  for (const field of record.definition) {
-    if (Object.prototype.hasOwnProperty.call(typedValues, field.name)) {
-      typedValues[field.name] = (0, _typeCheck.typeCheck)(field.type, typedValues[field.name]);
-    }
-  }
-  return typedValues;
-};
-const updateEntity = 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');
-  if (!primaryKey) {
-    throw new Error(`Cannot update "${entity}" without a primary key`);
-  }
-  const typedValues = applyFieldTypes(record, values);
-  const toUpdate = dataSet[entity] || [];
-  const updatedRows = [];
-  for (const row of toUpdate) {
-    const fileName = await findEntryFile(record, primaryKey, (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row));
-    if (!fileName) {
-      throw new Error(`Could not find entry for ${entity} where "${primaryKey.fields.join(', ')}" = ${(0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row)}`);
-    }
-    const oldData = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
-    const newData = Object.assign({}, oldData, typedValues);
-    await assertUniqueForUpdate(entity, record, oldData, newData, typedValues);
-    await assertForeignKeysForUpdate(entity, record, oldData, typedValues);
-    await assertNoDependentsForUpdate(entity, record, primaryKey, oldData, typedValues);
-    assertRequiredFields(entity, record, newData);
-    await reconcileIndexes(record, oldData, newData, typedValues, fileName);
-    await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(newData, null, 2));
-    updatedRows.push(newData);
-  }
-  dataSet[entity] = updatedRows;
-  return dataSet;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateEntity = 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 _retrieveFile = require("../utilities/retrieveFile");
+var _updateIndex = require("../utilities/updateIndex");
+var _removeFromIndex = require("../utilities/removeFromIndex");
+var _computeKeyValue = require("../utilities/computeKeyValue");
+var _fieldType = require("../utilities/fieldType");
+var _compareAs = require("../utilities/compareAs");
+var _keyUnique = require("../introspect/policies/keyUnique");
+var _typeCheck = require("../introspect/policies/typeCheck");
+var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
+var _hasDependents = require("../introspect/policies/hasDependents");
+var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
+var _config = require("../utilities/config");
+const {
+  writeFile
+} = require('fs/promises');
+/**
+ * Same reasoning as deleteEntity: a record object carries no memory of which entry file it came
+ * from, so re-scan entries[] and match by the record's own primary key value(s) - a single field,
+ * or a composite of several for a multi-field primary key.
+ * @param record
+ * @param primaryKey
+ * @param primaryValue
+ */
+const findEntryFile = async (record, primaryKey, primaryValue) => {
+  for (const fileName of record.entries) {
+    const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
+    if ((0, _compareAs.sameValue)((0, _fieldType.keyValueType)(record, primaryKey), (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data), primaryValue)) {
+      return fileName;
+    }
+  }
+  return null;
+};
+/**
+ * True if the update actually changes at least one of this key's fields - a key none of whose
+ * fields appear in newValues, or whose given values are all unchanged, doesn't need re-checking.
+ * @param record
+ * @param key
+ * @param oldData
+ * @param newValues
+ */
+const keyFieldsChanged = (record, key, oldData, newValues) => key.fields.some(field => Object.prototype.hasOwnProperty.call(newValues, field) && !(0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field]));
+/**
+ * Only check uniqueness for a primary/unique key (single-field, or composite) whose value is
+ * actually changing - checking an unchanged value would find the record's own existing entry and
+ * wrongly report it as a duplicate of itself. A value with a null in it is never a duplicate (as in
+ * SQL).
+ * @param entity
+ * @param record
+ * @param oldData
+ * @param newData
+ * @param newValues
+ */
+const assertUniqueForUpdate = async (entity, record, oldData, newData, newValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'primary' && key.type !== 'unique' || !keyFieldsChanged(record, key, oldData, newValues)) {
+      continue;
+    }
+    const checkKeys = key.fields.map(field => newData[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}`);
+    }
+  }
+};
+/**
+ * Same "only if it actually changed" scoping as assertUniqueForUpdate: re-checking an unchanged
+ * foreign key value would re-validate a reference this update never touches, which could fail an
+ * unrelated field's update if that parent record happened to be deleted since. A null references
+ * nothing, so it isn't checked.
+ * @param entity
+ * @param record
+ * @param oldData
+ * @param newValues
+ */
+const assertForeignKeysForUpdate = async (entity, record, oldData, newValues) => {
+  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(newValues, field) || newValues[field] === null || (0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field])) {
+      continue;
+    }
+    const {
+      entity: refEntity,
+      property: refProperty
+    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
+    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, newValues[field]);
+    if (!exists) {
+      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${newValues[field]}`);
+    }
+  }
+};
+/**
+ * RESTRICT: reject an update that would change a single-field primary key's value while another
+ * entity's foreign key still points at the old one - that reference would otherwise be left
+ * dangling, since the row itself isn't gone, just re-keyed. Only meaningful for a single-field
+ * primary key, matching foreign key support's own single-field-only scope.
+ * @param entity
+ * @param record
+ * @param primaryKey
+ * @param oldData
+ * @param newValues
+ */
+const assertNoDependentsForUpdate = async (entity, record, primaryKey, oldData, newValues) => {
+  if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1 || !keyFieldsChanged(record, primaryKey, oldData, newValues)) {
+    return;
+  }
+  const property = primaryKey.fields[0];
+  if (await (0, _hasDependents.hasDependents)(entity, property, oldData[property])) {
+    throw new Error(`Cannot update "${entity}" where "${property}" = ${oldData[property]} - other records still reference it`);
+  }
+};
+/**
+ * Move a key's index entry (single-field, or a composite for a multi-field key) from the old
+ * value to the new one wherever the update actually changed one of its fields.
+ * @param record
+ * @param oldData
+ * @param newData
+ * @param newValues
+ * @param fileName
+ */
+const reconcileIndexes = async (record, oldData, newData, newValues, fileName) => {
+  for (const key of record.keys) {
+    if (!keyFieldsChanged(record, key, oldData, newValues)) {
+      continue;
+    }
+    await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, oldData), fileName, (0, _fieldType.keyValueType)(record, key));
+    await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, newData), fileName, (0, _fieldType.keyValueType)(record, key));
+  }
+};
+/**
+ * The rows of one update are checked before any is written, so a check can't see the batch's own new values on disk.
+ * Reject the update if two of its rows would end with the same value for a primary or unique key that it changes (a
+ * value with a null in it is never a duplicate, as in assertUniqueForUpdate).
+ * @param entity
+ * @param record
+ * @param planned
+ * @param newValues
+ */
+const assertUniqueWithinUpdate = (entity, record, planned, newValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'primary' && key.type !== 'unique') {
+      continue;
+    }
+    const claimed = [];
+    for (const {
+      oldData,
+      newData
+    } of planned) {
+      if (!keyFieldsChanged(record, key, oldData, newValues) || key.fields.some(field => newData[field] === null)) {
+        continue;
+      }
+      const value = (0, _computeKeyValue.computeKeyValue)(key.fields, newData);
+      if (claimed.some(other => (0, _compareAs.sameValue)((0, _fieldType.keyValueType)(record, key), other, value))) {
+        throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`);
+      }
+      claimed.push(value);
+    }
+  }
+};
+const assertRequiredFields = (entity, record, newData) => {
+  for (const field of record.definition) {
+    if (!field.optional && typeof newData[field.name] === 'undefined') {
+      throw new Error(`Missing required field "${field.name}" for ${entity}`);
+    }
+  }
+};
+/**
+ * Type-check (and coerce) only the fields actually present in an update's values, never the rest
+ * of the merged record - a field whose already-stored value doesn't match its declared type
+ * (nothing enforced this before typeCheck() existed) must not block an update that never touches
+ * that field.
+ * @param record
+ * @param values
+ */
+const applyFieldTypes = (record, values) => {
+  const typedValues = Object.assign({}, values);
+  for (const field of record.definition) {
+    if (Object.prototype.hasOwnProperty.call(typedValues, field.name)) {
+      typedValues[field.name] = (0, _typeCheck.typeCheck)(field.type, typedValues[field.name], field.nullable);
+    }
+  }
+  return typedValues;
+};
+const updateEntity = 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');
+  if (!primaryKey) {
+    throw new Error(`Cannot update "${entity}" without a primary key`);
+  }
+  const typedValues = applyFieldTypes(record, values);
+  // Check every row first and write only once all of them pass, so a row that fails leaves the others unchanged too
+  const planned = [];
+  for (const row of dataSet[entity] || []) {
+    const fileName = await findEntryFile(record, primaryKey, (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row));
+    if (!fileName) {
+      throw new Error(`Could not find entry for ${entity} where "${primaryKey.fields.join(', ')}" = ${(0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row)}`);
+    }
+    if (planned.some(other => other.fileName === fileName)) {
+      // The same entry given twice is one row: updating it once is enough, and it can't collide with itself
+      continue;
+    }
+    const oldData = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
+    const newData = Object.assign({}, oldData, typedValues);
+    await assertUniqueForUpdate(entity, record, oldData, newData, typedValues);
+    await assertForeignKeysForUpdate(entity, record, oldData, typedValues);
+    await assertNoDependentsForUpdate(entity, record, primaryKey, oldData, typedValues);
+    assertRequiredFields(entity, record, newData);
+    planned.push({
+      fileName,
+      oldData,
+      newData
+    });
+  }
+  assertUniqueWithinUpdate(entity, record, planned, typedValues);
+  for (const {
+    fileName,
+    oldData,
+    newData
+  } of planned) {
+    await reconcileIndexes(record, oldData, newData, typedValues, fileName);
+    await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(newData, null, 2));
+  }
+  dataSet[entity] = planned.map(({
+    newData
+  }) => newData);
+  return dataSet;
+};
 exports.updateEntity = updateEntity;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.updateEntity=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"),_retrieveFile=require("../utilities/retrieveFile"),_updateIndex=require("../utilities/updateIndex"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_compareAs=require("../utilities/compareAs"),_keyUnique=require("../introspect/policies/keyUnique"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_hasDependents=require("../introspect/policies/hasDependents"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_config=require("../utilities/config");const{writeFile:writeFile}=require("fs/promises"),findEntryFile=async(e,t,i)=>{for(const r of e.entries){const s=await(0,_retrieveFile.retrieveFile)(`${e.path}/${r}`);if((0,_compareAs.sameValue)((0,_fieldType.keyValueType)(e,t),(0,_computeKeyValue.computeKeyValue)(t.fields,s),i))return r}return null},keyFieldsChanged=(e,t,i,r)=>t.fields.some((t=>Object.prototype.hasOwnProperty.call(r,t)&&!(0,_compareAs.sameValue)((0,_fieldType.fieldType)(e,t),r[t],i[t]))),assertUniqueForUpdate=async(e,t,i,r,s)=>{for(const o of t.keys){if("primary"!==o.type&&"unique"!==o.type||!keyFieldsChanged(t,o,i,s))continue;const n=o.fields.map((e=>r[e]));if(!await(0,_keyUnique.keyUnique)(e,o.fields,n))throw new Error(`Duplicate value for ${o.type} key "${o.fields.join(", ")}" on ${e}`)}},assertForeignKeysForUpdate=async(e,t,i,r)=>{for(const s of t.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const o=s.fields[0];if(!Object.prototype.hasOwnProperty.call(r,o)||(0,_compareAs.sameValue)((0,_fieldType.fieldType)(t,o),r[o],i[o]))continue;const{entity:n,property:a}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(n,a,r[o]))throw new Error(`Foreign key "${o}" on ${e} references a nonexistent ${n}.${a} = ${r[o]}`)}},assertNoDependentsForUpdate=async(e,t,i,r,s)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==i.fields.length||!keyFieldsChanged(t,i,r,s))return;const o=i.fields[0];if(await(0,_hasDependents.hasDependents)(e,o,r[o]))throw new Error(`Cannot update "${e}" where "${o}" = ${r[o]} - other records still reference it`)},reconcileIndexes=async(e,t,i,r,s)=>{for(const o of e.keys)keyFieldsChanged(e,o,t,r)&&(await(0,_removeFromIndex.removeFromIndex)(e.path,o,(0,_computeKeyValue.computeKeyValue)(o.fields,t),s,(0,_fieldType.keyValueType)(e,o)),await(0,_updateIndex.updateIndex)(e.path,o,(0,_computeKeyValue.computeKeyValue)(o.fields,i),s,(0,_fieldType.keyValueType)(e,o)))},assertRequiredFields=(e,t,i)=>{for(const r of t.definition)if(!r.optional&&void 0===i[r.name])throw new Error(`Missing required field "${r.name}" for ${e}`)},applyFieldTypes=(e,t)=>{const i=Object.assign({},t);for(const t of e.definition)Object.prototype.hasOwnProperty.call(i,t.name)&&(i[t.name]=(0,_typeCheck.typeCheck)(t.type,i[t.name]));return i},updateEntity=async(e="",t={},i={})=>{const r=(0,_config.getSetting)("databasePath","database/"),s=await(0,_retrieveRecord.retrieveRecord)(e),o=s.keys.find((e=>"primary"===e.type));if(!o)throw new Error(`Cannot update "${e}" without a primary key`);const n=applyFieldTypes(s,t),a=i[e]||[],p=[];for(const t of a){const i=await findEntryFile(s,o,(0,_computeKeyValue.computeKeyValue)(o.fields,t));if(!i)throw new Error(`Could not find entry for ${e} where "${o.fields.join(", ")}" = ${(0,_computeKeyValue.computeKeyValue)(o.fields,t)}`);const a=await(0,_retrieveFile.retrieveFile)(`${s.path}/${i}`),l=Object.assign({},a,n);await assertUniqueForUpdate(e,s,a,l,n),await assertForeignKeysForUpdate(e,s,a,n),await assertNoDependentsForUpdate(e,s,o,a,n),assertRequiredFields(e,s,l),await reconcileIndexes(s,a,l,n,i),await writeFile(`${r}${s.path}/${i}`,JSON.stringify(l,null,2)),p.push(l)}return i[e]=p,i};exports.updateEntity=updateEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.updateEntity=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"),_retrieveFile=require("../utilities/retrieveFile"),_updateIndex=require("../utilities/updateIndex"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_compareAs=require("../utilities/compareAs"),_keyUnique=require("../introspect/policies/keyUnique"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_hasDependents=require("../introspect/policies/hasDependents"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_config=require("../utilities/config");const{writeFile:writeFile}=require("fs/promises"),findEntryFile=async(e,t,i)=>{for(const r of e.entries){const o=await(0,_retrieveFile.retrieveFile)(`${e.path}/${r}`);if((0,_compareAs.sameValue)((0,_fieldType.keyValueType)(e,t),(0,_computeKeyValue.computeKeyValue)(t.fields,o),i))return r}return null},keyFieldsChanged=(e,t,i,r)=>t.fields.some((t=>Object.prototype.hasOwnProperty.call(r,t)&&!(0,_compareAs.sameValue)((0,_fieldType.fieldType)(e,t),r[t],i[t]))),assertUniqueForUpdate=async(e,t,i,r,o)=>{for(const s of t.keys){if("primary"!==s.type&&"unique"!==s.type||!keyFieldsChanged(t,s,i,o))continue;const n=s.fields.map((e=>r[e]));if(n.some((e=>null===e)))continue;if(!await(0,_keyUnique.keyUnique)(e,s.fields,n))throw new Error(`Duplicate value for ${s.type} key "${s.fields.join(", ")}" on ${e}`)}},assertForeignKeysForUpdate=async(e,t,i,r)=>{for(const o of t.keys){if("foreign"!==o.type||1!==o.fields.length||!o.references||1!==o.references.length)continue;const s=o.fields[0];if(!Object.prototype.hasOwnProperty.call(r,s)||null===r[s]||(0,_compareAs.sameValue)((0,_fieldType.fieldType)(t,s),r[s],i[s]))continue;const{entity:n,property:a}=(0,_splitEntityProperty.splitEntityProperty)(o.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(n,a,r[s]))throw new Error(`Foreign key "${s}" on ${e} references a nonexistent ${n}.${a} = ${r[s]}`)}},assertNoDependentsForUpdate=async(e,t,i,r,o)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==i.fields.length||!keyFieldsChanged(t,i,r,o))return;const s=i.fields[0];if(await(0,_hasDependents.hasDependents)(e,s,r[s]))throw new Error(`Cannot update "${e}" where "${s}" = ${r[s]} - other records still reference it`)},reconcileIndexes=async(e,t,i,r,o)=>{for(const s of e.keys)keyFieldsChanged(e,s,t,r)&&(await(0,_removeFromIndex.removeFromIndex)(e.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,t),o,(0,_fieldType.keyValueType)(e,s)),await(0,_updateIndex.updateIndex)(e.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,i),o,(0,_fieldType.keyValueType)(e,s)))},assertUniqueWithinUpdate=(e,t,i,r)=>{for(const o of t.keys){if("primary"!==o.type&&"unique"!==o.type)continue;const s=[];for(const{oldData:n,newData:a}of i){if(!keyFieldsChanged(t,o,n,r)||o.fields.some((e=>null===a[e])))continue;const i=(0,_computeKeyValue.computeKeyValue)(o.fields,a);if(s.some((e=>(0,_compareAs.sameValue)((0,_fieldType.keyValueType)(t,o),e,i))))throw new Error(`Duplicate value for ${o.type} key "${o.fields.join(", ")}" on ${e}`);s.push(i)}}},assertRequiredFields=(e,t,i)=>{for(const r of t.definition)if(!r.optional&&void 0===i[r.name])throw new Error(`Missing required field "${r.name}" for ${e}`)},applyFieldTypes=(e,t)=>{const i=Object.assign({},t);for(const t of e.definition)Object.prototype.hasOwnProperty.call(i,t.name)&&(i[t.name]=(0,_typeCheck.typeCheck)(t.type,i[t.name],t.nullable));return i},updateEntity=async(e="",t={},i={})=>{const r=(0,_config.getSetting)("databasePath","database/"),o=await(0,_retrieveRecord.retrieveRecord)(e),s=o.keys.find((e=>"primary"===e.type));if(!s)throw new Error(`Cannot update "${e}" without a primary key`);const n=applyFieldTypes(o,t),a=[];for(const t of i[e]||[]){const i=await findEntryFile(o,s,(0,_computeKeyValue.computeKeyValue)(s.fields,t));if(!i)throw new Error(`Could not find entry for ${e} where "${s.fields.join(", ")}" = ${(0,_computeKeyValue.computeKeyValue)(s.fields,t)}`);if(a.some((e=>e.fileName===i)))continue;const r=await(0,_retrieveFile.retrieveFile)(`${o.path}/${i}`),l=Object.assign({},r,n);await assertUniqueForUpdate(e,o,r,l,n),await assertForeignKeysForUpdate(e,o,r,n),await assertNoDependentsForUpdate(e,o,s,r,n),assertRequiredFields(e,o,l),a.push({fileName:i,oldData:r,newData:l})}assertUniqueWithinUpdate(e,o,a,n);for(const{fileName:e,oldData:t,newData:i}of a)await reconcileIndexes(o,t,i,n,e),await writeFile(`${r}${o.path}/${e}`,JSON.stringify(i,null,2));return i[e]=a.map((({newData:e})=>e)),i};exports.updateEntity=updateEntity;

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

@@ -1,8 +1,8 @@
-export declare const where: (dataSet?: any[], { property, joinEntity, comparator, value, type }?: {
-    property?: string;
-    joinEntity?: any;
-    comparator?: string;
-    value?: any;
-    type?: any;
-}) => any[];
+export declare const where: (dataSet?: any[], { property, joinEntity, comparator, value, type }?: {
+    property?: string;
+    joinEntity?: any;
+    comparator?: string;
+    value?: any;
+    type?: any;
+}) => any[];
 //# sourceMappingURL=where.d.ts.map

package/dist/data/queries/where.js

@@ -1,68 +1,68 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.where = void 0;
-require("core-js/modules/es.array.includes.js");
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.filter.js");
-require("core-js/modules/esnext.iterator.some.js");
-var _compareAs = require("../utilities/compareAs");
-const likeMatch = (dataValue, pattern) => {
-  if (typeof dataValue !== 'string' || typeof pattern !== 'string') {
-    return false;
-  }
-  const regexPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.');
-  return new RegExp(`^${regexPattern}$`, 'i').test(dataValue);
-};
-/**
- * Equality (=, !=, <>, in) compares by the field's declared type when given one (see sameValue), so
- * '3' and 3 match in a string or int field. Ordering (>, <, between, like) compares the raw values.
- * @param data
- * @param property
- * @param comparator
- * @param value
- * @param type
- */
-const makeCondition = (data, property, comparator, value, type = undefined) => {
-  if (!Object.prototype.hasOwnProperty.call(data, property)) {
-    return false;
-  }
-  const dataValue = data[property];
-  switch (comparator) {
-    case '=':
-      return (0, _compareAs.sameValue)(type, dataValue, value);
-    case '!=':
-    case '<>':
-      return !(0, _compareAs.sameValue)(type, dataValue, value);
-    case '>':
-      return dataValue > value;
-    case '>=':
-      return dataValue >= value;
-    case '<':
-      return dataValue < value;
-    case '<=':
-      return dataValue <= value;
-    case 'in':
-      return Array.isArray(value) && (type ? value.some(item => (0, _compareAs.sameValue)(type, dataValue, item)) : value.includes(dataValue));
-    case 'between':
-      return Array.isArray(value) && value.length === 2 && dataValue >= value[0] && dataValue <= value[1];
-    case 'like':
-      return likeMatch(dataValue, value);
-  }
-  return false;
-};
-const where = (dataSet = [], {
-  property = '',
-  joinEntity = undefined,
-  comparator = '=',
-  value = null,
-  type = undefined
-} = {}) => {
-  return dataSet.filter(data => {
-    const testProperty = joinEntity ? `${joinEntity}.${property}` : property;
-    return makeCondition(data, testProperty, comparator, value, type);
-  });
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.where = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.some.js");
+var _compareAs = require("../utilities/compareAs");
+const likeMatch = (dataValue, pattern) => {
+  if (typeof dataValue !== 'string' || typeof pattern !== 'string') {
+    return false;
+  }
+  const regexPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.');
+  return new RegExp(`^${regexPattern}$`, 'i').test(dataValue);
+};
+/**
+ * Equality (=, !=, <>, in) compares by the field's declared type when given one (see sameValue), so
+ * '3' and 3 match in a string or int field. Ordering (>, <, between, like) compares the raw values.
+ * @param data
+ * @param property
+ * @param comparator
+ * @param value
+ * @param type
+ */
+const makeCondition = (data, property, comparator, value, type = undefined) => {
+  if (!Object.prototype.hasOwnProperty.call(data, property)) {
+    return false;
+  }
+  const dataValue = data[property];
+  switch (comparator) {
+    case '=':
+      return (0, _compareAs.sameValue)(type, dataValue, value);
+    case '!=':
+    case '<>':
+      return !(0, _compareAs.sameValue)(type, dataValue, value);
+    case '>':
+      return dataValue > value;
+    case '>=':
+      return dataValue >= value;
+    case '<':
+      return dataValue < value;
+    case '<=':
+      return dataValue <= value;
+    case 'in':
+      return Array.isArray(value) && (type ? value.some(item => (0, _compareAs.sameValue)(type, dataValue, item)) : value.includes(dataValue));
+    case 'between':
+      return Array.isArray(value) && value.length === 2 && dataValue >= value[0] && dataValue <= value[1];
+    case 'like':
+      return likeMatch(dataValue, value);
+  }
+  return false;
+};
+const where = (dataSet = [], {
+  property = '',
+  joinEntity = undefined,
+  comparator = '=',
+  value = null,
+  type = undefined
+} = {}) => {
+  return dataSet.filter(data => {
+    const testProperty = joinEntity ? `${joinEntity}.${property}` : property;
+    return makeCondition(data, testProperty, comparator, value, type);
+  });
+};
 exports.where = where;