json-fs-query 1.0.6 → 1.1.0

package/dist/data/queries/updateEntity.js

@@ -1,190 +1,194 @@
-"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 _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, _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 key
- * @param oldData
- * @param newValues
- */
-const keyFieldsChanged = (key, oldData, newValues) => key.fields.some(field => Object.prototype.hasOwnProperty.call(newValues, 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(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) || 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 primaryKey
- * @param oldData
- * @param newValues
- */
-const assertNoDependentsForUpdate = async (entity, primaryKey, oldData, newValues) => {
-  if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1 || !keyFieldsChanged(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(key, oldData, newValues)) {
-      continue;
-    }
-    await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, oldData), fileName);
-    await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, newData), fileName);
-  }
-};
-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, 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.
+ * @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;
+};
 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"),_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,r)=>{for(const i of e.entries){const s=await(0,_retrieveFile.retrieveFile)(`${e.path}/${i}`);if((0,_computeKeyValue.computeKeyValue)(t.fields,s)==r)return i}return null},keyFieldsChanged=(e,t,r)=>e.fields.some((e=>Object.prototype.hasOwnProperty.call(r,e)&&r[e]!=t[e])),assertUniqueForUpdate=async(e,t,r,i,s)=>{for(const o of t.keys){if("primary"!==o.type&&"unique"!==o.type||!keyFieldsChanged(o,r,s))continue;const t=o.fields.map((e=>i[e]));if(!await(0,_keyUnique.keyUnique)(e,o.fields,t))throw new Error(`Duplicate value for ${o.type} key "${o.fields.join(", ")}" on ${e}`)}},assertForeignKeysForUpdate=async(e,t,r,i)=>{for(const s of t.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const t=s.fields[0];if(!Object.prototype.hasOwnProperty.call(i,t)||i[t]==r[t])continue;const{entity:o,property:n}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(o,n,i[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${o}.${n} = ${i[t]}`)}},assertNoDependentsForUpdate=async(e,t,r,i)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==t.fields.length||!keyFieldsChanged(t,r,i))return;const s=t.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,r,i,s)=>{for(const o of e.keys)keyFieldsChanged(o,t,i)&&(await(0,_removeFromIndex.removeFromIndex)(e.path,o,(0,_computeKeyValue.computeKeyValue)(o.fields,t),s),await(0,_updateIndex.updateIndex)(e.path,o,(0,_computeKeyValue.computeKeyValue)(o.fields,r),s))},assertRequiredFields=(e,t,r)=>{for(const i of t.definition)if(!i.optional&&void 0===r[i.name])throw new Error(`Missing required field "${i.name}" for ${e}`)},applyFieldTypes=(e,t)=>{const r=Object.assign({},t);for(const t of e.definition)Object.prototype.hasOwnProperty.call(r,t.name)&&(r[t.name]=(0,_typeCheck.typeCheck)(t.type,r[t.name]));return r},updateEntity=async(e="",t={},r={})=>{const i=(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=r[e]||[],p=[];for(const t of a){const r=await findEntryFile(s,o,(0,_computeKeyValue.computeKeyValue)(o.fields,t));if(!r)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}/${r}`),u=Object.assign({},a,n);await assertUniqueForUpdate(e,s,a,u,n),await assertForeignKeysForUpdate(e,s,a,n),await assertNoDependentsForUpdate(e,o,a,n),assertRequiredFields(e,s,u),await reconcileIndexes(s,a,u,n,r),await writeFile(`${i}${s.path}/${r}`,JSON.stringify(u,null,2)),p.push(u)}return r[e]=p,r};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 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;

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

@@ -1,7 +1,8 @@
-export declare const where: (dataSet?: any[], { property, joinEntity, comparator, value }?: {
-    property?: string;
-    joinEntity?: any;
-    comparator?: string;
-    value?: 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,56 +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");
-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);
-};
-const makeCondition = (data, property, comparator, value) => {
-  if (!Object.prototype.hasOwnProperty.call(data, property)) {
-    return false;
-  }
-  const dataValue = data[property];
-  switch (comparator) {
-    case '=':
-      return dataValue == value;
-    case '!=':
-    case '<>':
-      return dataValue != value;
-    case '>':
-      return dataValue > value;
-    case '>=':
-      return dataValue >= value;
-    case '<':
-      return dataValue < value;
-    case '<=':
-      return dataValue <= value;
-    case 'in':
-      return Array.isArray(value) && 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
-} = {}) => {
-  return dataSet.filter(data => {
-    const testProperty = joinEntity ? `${joinEntity}.${property}` : property;
-    return makeCondition(data, testProperty, comparator, value);
-  });
-};
+"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;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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");const likeMatch=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const t=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${t}$`,"i").test(e)},makeCondition=(e,r,t,s)=>{if(!Object.prototype.hasOwnProperty.call(e,r))return!1;const n=e[r];switch(t){case"=":return n==s;case"!=":case"<>":return n!=s;case">":return n>s;case">=":return n>=s;case"<":return n<s;case"<=":return n<=s;case"in":return Array.isArray(s)&&s.includes(n);case"between":return Array.isArray(s)&&2===s.length&&n>=s[0]&&n<=s[1];case"like":return likeMatch(n,s)}return!1},where=(e=[],{property:r="",joinEntity:t,comparator:s="=",value:n=null}={})=>e.filter((e=>makeCondition(e,t?`${t}.${r}`:r,s,n)));exports.where=where;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const t=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${t}$`,"i").test(e)},makeCondition=(e,r,t,s,a=void 0)=>{if(!Object.prototype.hasOwnProperty.call(e,r))return!1;const o=e[r];switch(t){case"=":return(0,_compareAs.sameValue)(a,o,s);case"!=":case"<>":return!(0,_compareAs.sameValue)(a,o,s);case">":return o>s;case">=":return o>=s;case"<":return o<s;case"<=":return o<=s;case"in":return Array.isArray(s)&&(a?s.some((e=>(0,_compareAs.sameValue)(a,o,e))):s.includes(o));case"between":return Array.isArray(s)&&2===s.length&&o>=s[0]&&o<=s[1];case"like":return likeMatch(o,s)}return!1},where=(e=[],{property:r="",joinEntity:t,comparator:s="=",value:a=null,type:o}={})=>e.filter((e=>makeCondition(e,t?`${t}.${r}`:r,s,a,o)));exports.where=where;

package/dist/data/utilities/compareAs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Normalize a value to a field's declared type for an equality comparison - never written back,
+ * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
+ * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
+ * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
+ * are the same value. A missing or unrecognized type returns the value unchanged.
+ * @param type
+ * @param value
+ */
+export declare const compareAs: (type: string | undefined, value: any) => any;
+/**
+ * Whether two values are equal for a field of the given declared type: both are normalized to
+ * that type (see compareAs) and compared strictly. A field with no declared type, or one that
+ * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
+ * @param type
+ * @param a
+ * @param b
+ */
+export declare const sameValue: (type: string | undefined, a: any, b: any) => boolean;
+//# sourceMappingURL=compareAs.d.ts.map