json-fs-query 0.1.1 → 1.0.1

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

@@ -0,0 +1,13 @@
+/**
+ * Check whether any other record, in any entity, still has a single-field foreign key pointing
+ * at entity.property = value - the mirror image of foreignKeyExists(), which checks the opposite
+ * direction (that a new/updated foreign key value points at something real). Used to RESTRICT a
+ * delete or update that would otherwise leave a dangling reference behind. Scans every record in
+ * the database via the __RECORDS registry, the same "no index needed, just look" approach as
+ * keyUnique()/foreignKeyExists() - correctness over speed, matching this project's overall scale.
+ * @param entity
+ * @param property
+ * @param value
+ */
+export declare const hasDependents: (entity: string, property: string, value: any) => Promise<boolean>;
+//# sourceMappingURL=hasDependents.d.ts.map

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

@@ -0,0 +1,52 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.hasDependents = void 0
+const _describe = require('../describe')
+const _retrieveRecord = require('../../utilities/retrieveRecord')
+const _retrieveRecords = require('../../utilities/retrieveRecords')
+const _where = require('../../queries/where')
+const _splitEntityProperty = require('../../utilities/parsers/splitEntityProperty')
+/**
+ * Check whether any other record, in any entity, still has a single-field foreign key pointing
+ * at entity.property = value - the mirror image of foreignKeyExists(), which checks the opposite
+ * direction (that a new/updated foreign key value points at something real). Used to RESTRICT a
+ * delete or update that would otherwise leave a dangling reference behind. Scans every record in
+ * the database via the __RECORDS registry, the same "no index needed, just look" approach as
+ * keyUnique()/foreignKeyExists() - correctness over speed, matching this project's overall scale.
+ * @param entity
+ * @param property
+ * @param value
+ */
+const hasDependents = async (entity, property, value) => {
+  const entityFiles = await (0, _describe.describe)()
+  for (const entityFile of entityFiles) {
+    const otherEntity = entityFile.replace(/\.json$/, '')
+    const otherRecord = await (0, _retrieveRecord.retrieveRecord)(otherEntity)
+    for (const key of otherRecord.keys) {
+      if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
+        continue
+      }
+      const {
+        entity: refEntity,
+        property: refProperty
+      } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0])
+      if (refEntity !== entity || refProperty !== property) {
+        continue
+      }
+      const records = await (0, _retrieveRecords.retrieveRecords)(otherEntity)
+      const found = (0, _where.where)(records, {
+        property: key.fields[0],
+        comparator: '=',
+        value
+      })
+      if (found.length) {
+        return true
+      }
+    }
+  }
+  return false
+}
+exports.hasDependents = hasDependents

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.hasDependents=void 0;var _describe=require("../describe"),_retrieveRecord=require("../../utilities/retrieveRecord"),_retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_splitEntityProperty=require("../../utilities/parsers/splitEntityProperty");const hasDependents=async(e,r,t)=>{const i=await(0,_describe.describe)();for(const s of i){const i=s.replace(/\.json$/,""),o=await(0,_retrieveRecord.retrieveRecord)(i);for(const s of o.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const{entity:o,property:n}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(o!==e||n!==r)continue;const c=await(0,_retrieveRecords.retrieveRecords)(i);if((0,_where.where)(c,{property:s.fields[0],comparator:"=",value:t}).length)return!0}}return!1};exports.hasDependents=hasDependents;

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

@@ -10,7 +10,7 @@ const keyGenerate = async (entity, references = []) => {
   let isUnique = false
   while (!isUnique) {
     uuid = crypto.randomUUID()
-    isUnique = await (0, _keyUnique.keyUnique)(entity, references, uuid)
+    isUnique = await (0, _keyUnique.keyUnique)(entity, references, [uuid])
   }
   return uuid
 }

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyGenerate=void 0;var _keyUnique=require("./keyUnique");const keyGenerate=async(e,r=[])=>{let t=null,n=!1;for(;!n;)t=crypto.randomUUID(),n=await(0,_keyUnique.keyUnique)(e,r,t);return t};exports.keyGenerate=keyGenerate;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyGenerate=void 0;var _keyUnique=require("./keyUnique");const keyGenerate=async(e,r=[])=>{let t=null,n=!1;for(;!n;)t=crypto.randomUUID(),n=await(0,_keyUnique.keyUnique)(e,r,[t]);return t};exports.keyGenerate=keyGenerate;

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

@@ -1,2 +1,10 @@
-export declare const keyUnique: (entity: any, references?: any[], checkKey?: any) => Promise<boolean>;
+/**
+ * Check that no existing record already has this combination of values across all of the given
+ * fields - a single field for a normal unique/primary key, or several for a composite one.
+ * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
+ * @param entity
+ * @param references
+ * @param checkKeys
+ */
+export declare const keyUnique: (entity: any, references?: any[], checkKeys?: any[]) => Promise<boolean>;
 //# sourceMappingURL=keyUnique.d.ts.map

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

@@ -6,16 +6,26 @@ Object.defineProperty(exports, '__esModule', {
 exports.keyUnique = void 0
 const _retrieveRecords = require('../../utilities/retrieveRecords')
 const _where = require('../../queries/where')
-const keyUnique = async (entity, references = [], checkKey = null) => {
-  if (references.length !== 1) {
+/**
+ * Check that no existing record already has this combination of values across all of the given
+ * fields - a single field for a normal unique/primary key, or several for a composite one.
+ * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
+ * @param entity
+ * @param references
+ * @param checkKeys
+ */
+const keyUnique = async (entity, references = [], checkKeys = []) => {
+  if (!references.length || references.length !== checkKeys.length) {
     return false
   }
-  const records = await (0, _retrieveRecords.retrieveRecords)(entity)
-  const found = (0, _where.where)(records, {
-    property: references[0],
-    comparator: '=',
-    value: checkKey
-  })
-  return !found.length
+  let records = await (0, _retrieveRecords.retrieveRecords)(entity)
+  for (let i = 0; i < references.length; i++) {
+    records = (0, _where.where)(records, {
+      property: references[i],
+      comparator: '=',
+      value: checkKeys[i]
+    })
+  }
+  return !records.length
 }
 exports.keyUnique = keyUnique

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyUnique=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where");const keyUnique=async(e,r=[],t=null)=>{if(1!==r.length)return!1;const i=await(0,_retrieveRecords.retrieveRecords)(e);return!(0,_where.where)(i,{property:r[0],comparator:"=",value:t}).length};exports.keyUnique=keyUnique;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyUnique=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where");const keyUnique=async(e,r=[],t=[])=>{if(!r.length||r.length!==t.length)return!1;let i=await(0,_retrieveRecords.retrieveRecords)(e);for(let e=0;e<r.length;e++)i=(0,_where.where)(i,{property:r[e],comparator:"=",value:t[e]});return!i.length};exports.keyUnique=keyUnique;

package/dist/data/queries/deleteEntity.js

@@ -27,34 +27,55 @@ require('core-js/modules/esnext.set.union.js')
 const _retrieveRecord = require('../utilities/retrieveRecord')
 const _retrieveFile = require('../utilities/retrieveFile')
 const _removeFromIndex = require('../utilities/removeFromIndex')
+const _computeKeyValue = require('../utilities/computeKeyValue')
+const _hasDependents = require('../introspect/policies/hasDependents')
 const _config = require('../utilities/config')
 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.
+ * 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 primaryField
+ * @param primaryKey
  * @param deletedValues
  */
-const removeMatchingEntries = async (entity, record, primaryField, 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(data[primaryField])) {
+    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) {
-      if (key.fields.length === 1) {
-        await (0, _removeFromIndex.removeFromIndex)(record.path, key, data[key.fields[0]], fileName)
-      }
+      await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName)
     }
   }
   return remainingEntries
@@ -62,17 +83,17 @@ const removeMatchingEntries = async (entity, record, primaryField, deletedValues
 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' && key.fields.length === 1)
+  const primaryKey = record.keys.find(key => key.type === 'primary')
   if (!primaryKey) {
-    throw new Error(`Cannot delete from "${entity}" without a single-field primary key`)
+    throw new Error(`Cannot delete from "${entity}" without a primary key`)
   }
-  const primaryField = primaryKey.fields[0]
   const toDelete = dataSet[entity] || []
   if (!toDelete.length) {
     return dataSet
   }
-  const deletedValues = new Set(toDelete.map(row => row[primaryField]))
-  record.entries = await removeMatchingEntries(entity, record, primaryField, deletedValues)
+  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
 }

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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"),_retrieveFile=require("../utilities/retrieveFile"),_removeFromIndex=require("../utilities/removeFromIndex"),_config=require("../utilities/config");const{rm:rm,writeFile:writeFile}=require("fs/promises"),removeMatchingEntries=async(e,r,s,t)=>{const i=(0,_config.getSetting)("databasePath","database/"),o=[];for(const e of r.entries){const n=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`);if(t.has(n[s])){await rm(`${i}${r.path}/${e}`);for(const s of r.keys)1===s.fields.length&&await(0,_removeFromIndex.removeFromIndex)(r.path,s,n[s.fields[0]],e)}else o.push(e)}return o},deleteEntity=async(e="",r={})=>{const s=(0,_config.getSetting)("databasePath","database/"),t=await(0,_retrieveRecord.retrieveRecord)(e),i=t.keys.find((e=>"primary"===e.type&&1===e.fields.length));if(!i)throw new Error(`Cannot delete from "${e}" without a single-field primary key`);const o=i.fields[0],n=r[e]||[];if(!n.length)return r;const u=new Set(n.map((e=>e[o])));return t.entries=await removeMatchingEntries(0,t,o,u),await writeFile(`${s}${t.path}.json`,JSON.stringify(t,null,2)),r};exports.deleteEntity=deleteEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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"),_retrieveFile=require("../utilities/retrieveFile"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_hasDependents=require("../introspect/policies/hasDependents"),_config=require("../utilities/config");const{rm:rm,writeFile:writeFile}=require("fs/promises"),assertNoDependents=async(e,r,s)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==r.fields.length)return;const t=r.fields[0];for(const r of s)if(await(0,_hasDependents.hasDependents)(e,t,r[t]))throw new Error(`Cannot delete from "${e}" where "${t}" = ${r[t]} - other records still reference it`)},removeMatchingEntries=async(e,r,s,t)=>{const i=(0,_config.getSetting)("databasePath","database/"),o=[];for(const e of r.entries){const n=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`);if(t.has((0,_computeKeyValue.computeKeyValue)(s.fields,n))){await rm(`${i}${r.path}/${e}`);for(const s of r.keys)await(0,_removeFromIndex.removeFromIndex)(r.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,n),e)}else o.push(e)}return o},deleteEntity=async(e="",r={})=>{const s=(0,_config.getSetting)("databasePath","database/"),t=await(0,_retrieveRecord.retrieveRecord)(e),i=t.keys.find((e=>"primary"===e.type));if(!i)throw new Error(`Cannot delete from "${e}" without a primary key`);const o=r[e]||[];if(!o.length)return r;await assertNoDependents(e,i,o);const n=new Set(o.map((e=>(0,_computeKeyValue.computeKeyValue)(i.fields,e))));return t.entries=await removeMatchingEntries(0,t,i,n),await writeFile(`${s}${t.path}.json`,JSON.stringify(t,null,2)),r};exports.deleteEntity=deleteEntity;

package/dist/data/queries/insertEntity.js

@@ -7,6 +7,7 @@ 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')
 const _retrieveRecord = require('../utilities/retrieveRecord')
 const _updateIndex = require('../utilities/updateIndex')
 const _keyGenerate = require('../introspect/policies/keyGenerate')
@@ -15,6 +16,7 @@ const _useDefault = require('../introspect/policies/useDefault')
 const _typeCheck = require('../introspect/policies/typeCheck')
 const _foreignKeyExists = require('../introspect/policies/foreignKeyExists')
 const _splitEntityProperty = require('../utilities/parsers/splitEntityProperty')
+const _computeKeyValue = require('../utilities/computeKeyValue')
 const _config = require('../utilities/config')
 const {
   writeFile
@@ -46,19 +48,21 @@ const buildEntityValues = async (entity, record, rowValues = {}) => {
   return entityValues
 }
 /**
- * Reject the insert if it collides with an existing primary or unique single-field key value.
+ * 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' || key.fields.length !== 1) {
+    if (key.type !== 'primary' && key.type !== 'unique') {
       continue
     }
-    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, entityValues[key.fields[0]])
+    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[0]}" on ${entity}`)
+      throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`)
     }
   }
 }
@@ -104,9 +108,7 @@ const insertEntity = async (entity = '', values = [], dataSet = {}) => {
     record.entries.push(fileName)
     await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2))
     for (const key of record.keys) {
-      if (key.fields.length === 1) {
-        await (0, _updateIndex.updateIndex)(record.path, key, entityValues[key.fields[0]], fileName)
-      }
+      await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName)
     }
     dataSet[entity].push(entityValues)
   }

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");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"),_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||1!==r.fields.length)continue;if(!await(0,_keyUnique.keyUnique)(e,r.fields,i[r.fields[0]]))throw new Error(`Duplicate value for ${r.type} key "${r.fields[0]}" 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)1===e.fields.length&&await(0,_updateIndex.updateIndex)(s.path,e,t[e.fields[0]],a);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");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"),_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);i[e].push(t)}return i};exports.insertEntity=insertEntity;

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

@@ -0,0 +1,8 @@
+/**
+ * Slice a dataSet down to at most `limit` rows, starting after the first `offset` of them.
+ * @param dataSet
+ * @param offset
+ * @param limit
+ */
+export declare const limitOffset: (dataSet: Object[], offset: number | undefined, limit: number | undefined) => Object[];
+//# sourceMappingURL=limitOffset.d.ts.map

package/dist/data/queries/limitOffset.js

@@ -0,0 +1,21 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.limitOffset = void 0
+/**
+ * Slice a dataSet down to at most `limit` rows, starting after the first `offset` of them.
+ * @param dataSet
+ * @param offset
+ * @param limit
+ */
+const limitOffset = (dataSet = [], offset, limit) => {
+  if (typeof offset === 'undefined' && typeof limit === 'undefined') {
+    return dataSet
+  }
+  const start = offset ?? 0
+  const end = typeof limit === 'number' ? start + limit : undefined
+  return dataSet.slice(start, end)
+}
+exports.limitOffset = limitOffset

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.limitOffset=void 0;const limitOffset=(e=[],t,i)=>{if(void 0===t&&void 0===i)return e;const s=t??0,o="number"==typeof i?s+i:void 0;return e.slice(s,o)};exports.limitOffset=limitOffset;

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

@@ -0,0 +1,10 @@
+import { ParsedSelect } from '../utilities/parsers/findSelects';
+/**
+ * Shape each row down to only the selected properties (aliased, when given). dataSet is either a plain array of
+ * rows, or (once groupBy has run) a plain object keyed by group value, each value an array of rows - both are
+ * shaped the same way, row by row.
+ * @param dataSet
+ * @param selectClauses
+ */
+export declare const selectFields: (dataSet?: Object[] | Object, selectClauses?: ParsedSelect[]) => Object[] | Object;
+//# sourceMappingURL=selectFields.d.ts.map

package/dist/data/queries/selectFields.js

@@ -0,0 +1,36 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.selectFields = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.map.js')
+require('core-js/modules/esnext.iterator.reduce.js')
+const shapeRow = (row, selectClauses) => selectClauses.reduce((shaped, {
+  property,
+  alias
+}) => {
+  shaped[alias || property] = row[property]
+  return shaped
+}, {})
+/**
+ * Shape each row down to only the selected properties (aliased, when given). dataSet is either a plain array of
+ * rows, or (once groupBy has run) a plain object keyed by group value, each value an array of rows - both are
+ * shaped the same way, row by row.
+ * @param dataSet
+ * @param selectClauses
+ */
+const selectFields = (dataSet = [], selectClauses = []) => {
+  if (!selectClauses.length) {
+    return dataSet
+  }
+  if (Array.isArray(dataSet)) {
+    return dataSet.map(row => shapeRow(row, selectClauses))
+  }
+  return Object.keys(dataSet).reduce((shaped, key) => {
+    shaped[key] = dataSet[key].map(row => shapeRow(row, selectClauses))
+    return shaped
+  }, {})
+}
+exports.selectFields = selectFields

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.selectFields=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.iterator.reduce.js");const shapeRow=(e,s)=>s.reduce(((s,{property:r,alias:t})=>(s[t||r]=e[r],s)),{}),selectFields=(e=[],s=[])=>s.length?Array.isArray(e)?e.map((e=>shapeRow(e,s))):Object.keys(e).reduce(((r,t)=>(r[t]=e[t].map((e=>shapeRow(e,s))),r)),{}):e;exports.selectFields=selectFields;

package/dist/data/queries/updateEntity.js

@@ -7,13 +7,17 @@ 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')
 const _retrieveRecord = require('../utilities/retrieveRecord')
 const _retrieveFile = require('../utilities/retrieveFile')
 const _updateIndex = require('../utilities/updateIndex')
 const _removeFromIndex = require('../utilities/removeFromIndex')
+const _computeKeyValue = require('../utilities/computeKeyValue')
 const _keyUnique = require('../introspect/policies/keyUnique')
 const _typeCheck = require('../introspect/policies/typeCheck')
 const _foreignKeyExists = require('../introspect/policies/foreignKeyExists')
+const _hasDependents = require('../introspect/policies/hasDependents')
 const _splitEntityProperty = require('../utilities/parsers/splitEntityProperty')
 const _config = require('../utilities/config')
 const {
@@ -21,53 +25,51 @@ const {
 } = 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.
+ * 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 primaryField
+ * @param primaryKey
  * @param primaryValue
  */
-const findEntryFile = async (record, primaryField, primaryValue) => {
+const findEntryFile = async (record, primaryKey, primaryValue) => {
   for (const fileName of record.entries) {
     const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`)
-    if (data[primaryField] == primaryValue) {
+    if ((0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data) == primaryValue) {
       return fileName
     }
   }
   return null
 }
 /**
- * Only check uniqueness for a single-field primary/unique key 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.
+ * 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, newValues) => {
+const assertUniqueForUpdate = async (entity, record, oldData, newData, newValues) => {
   for (const key of record.keys) {
-    if (key.type !== 'primary' && key.type !== 'unique' || key.fields.length !== 1) {
+    if (key.type !== 'primary' && key.type !== 'unique' || !keyFieldsChanged(key, oldData, newValues)) {
       continue
     }
-    const field = key.fields[0]
-    if (!Object.prototype.hasOwnProperty.call(newValues, field) || newValues[field] == oldData[field]) {
-      continue
-    }
-    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, newValues[field])
+    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 "${field}" on ${entity}`)
+      throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`)
     }
   }
 }
-/**
- * Move a single-field key's index entry from the old value to the new one wherever the update
- * actually changed that field.
- * @param record
- * @param oldData
- * @param newData
- * @param newValues
- * @param fileName
- */
 /**
  * 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
@@ -96,17 +98,41 @@ const assertForeignKeysForUpdate = async (entity, record, oldData, newValues) =>
     }
   }
 }
+/**
+ * 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 (key.fields.length !== 1) {
+    if (!keyFieldsChanged(key, oldData, newValues)) {
       continue
     }
-    const field = key.fields[0]
-    if (!Object.prototype.hasOwnProperty.call(newValues, field) || newValues[field] == oldData[field]) {
-      continue
-    }
-    await (0, _removeFromIndex.removeFromIndex)(record.path, key, oldData[field], fileName)
-    await (0, _updateIndex.updateIndex)(record.path, key, newData[field], fileName)
+    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) => {
@@ -136,23 +162,23 @@ const applyFieldTypes = (record, values) => {
 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' && key.fields.length === 1)
+  const primaryKey = record.keys.find(key => key.type === 'primary')
   if (!primaryKey) {
-    throw new Error(`Cannot update "${entity}" without a single-field primary key`)
+    throw new Error(`Cannot update "${entity}" without a primary key`)
   }
-  const primaryField = primaryKey.fields[0]
   const typedValues = applyFieldTypes(record, values)
   const toUpdate = dataSet[entity] || []
   const updatedRows = []
   for (const row of toUpdate) {
-    const fileName = await findEntryFile(record, primaryField, row[primaryField])
+    const fileName = await findEntryFile(record, primaryKey, (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row))
     if (!fileName) {
-      throw new Error(`Could not find entry for ${entity} where "${primaryField}" = ${row[primaryField]}`)
+      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}`)
-    await assertUniqueForUpdate(entity, record, oldData, typedValues)
-    await assertForeignKeysForUpdate(entity, record, oldData, typedValues)
     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))

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");var _retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_updateIndex=require("../utilities/updateIndex"),_removeFromIndex=require("../utilities/removeFromIndex"),_keyUnique=require("../introspect/policies/keyUnique"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_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){if((await(0,_retrieveFile.retrieveFile)(`${e.path}/${i}`))[t]==r)return i}return null},assertUniqueForUpdate=async(e,t,r,i)=>{for(const n of t.keys){if("primary"!==n.type&&"unique"!==n.type||1!==n.fields.length)continue;const t=n.fields[0];if(!Object.prototype.hasOwnProperty.call(i,t)||i[t]==r[t])continue;if(!await(0,_keyUnique.keyUnique)(e,n.fields,i[t]))throw new Error(`Duplicate value for ${n.type} key "${t}" on ${e}`)}},assertForeignKeysForUpdate=async(e,t,r,i)=>{for(const n of t.keys){if("foreign"!==n.type||1!==n.fields.length||!n.references||1!==n.references.length)continue;const t=n.fields[0];if(!Object.prototype.hasOwnProperty.call(i,t)||i[t]==r[t])continue;const{entity:o,property:s}=(0,_splitEntityProperty.splitEntityProperty)(n.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(o,s,i[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${o}.${s} = ${i[t]}`)}},reconcileIndexes=async(e,t,r,i,n)=>{for(const o of e.keys){if(1!==o.fields.length)continue;const s=o.fields[0];Object.prototype.hasOwnProperty.call(i,s)&&i[s]!=t[s]&&(await(0,_removeFromIndex.removeFromIndex)(e.path,o,t[s],n),await(0,_updateIndex.updateIndex)(e.path,o,r[s],n))}},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/"),n=await(0,_retrieveRecord.retrieveRecord)(e),o=n.keys.find((e=>"primary"===e.type&&1===e.fields.length));if(!o)throw new Error(`Cannot update "${e}" without a single-field primary key`);const s=o.fields[0],a=applyFieldTypes(n,t),p=r[e]||[],c=[];for(const t of p){const r=await findEntryFile(n,s,t[s]);if(!r)throw new Error(`Could not find entry for ${e} where "${s}" = ${t[s]}`);const o=await(0,_retrieveFile.retrieveFile)(`${n.path}/${r}`);await assertUniqueForUpdate(e,n,o,a),await assertForeignKeysForUpdate(e,n,o,a);const p=Object.assign({},o,a);assertRequiredFields(e,n,p),await reconcileIndexes(n,o,p,a,r),await writeFile(`${i}${n.path}/${r}`,JSON.stringify(p,null,2)),c.push(p)}return r[e]=c,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"),_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;

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

@@ -0,0 +1,13 @@
+import { fieldName } from '../introspect/definitions/field';
+/**
+ * The value a key (of any field count) indexes and checks uniqueness by. A single-field key uses
+ * the field's own raw value directly - this is the pre-existing, already-shipped index file
+ * format (e.g. a plain "2024-06-02" or 1), and stays exactly as it was for backward compatibility
+ * with real fixture data. A multi-field key has no single value to use, so its fields' values are
+ * combined into one deterministic composite (a JSON array), in the same field order as key.fields
+ * - two records only share a composite value if every field matches.
+ * @param fields
+ * @param values
+ */
+export declare const computeKeyValue: (fields: fieldName[], values: Object) => any;
+//# sourceMappingURL=computeKeyValue.d.ts.map