json-fs-query 1.0.4 → 1.0.6

package/dist/data/queries/updateEntity.js

@@ -1,190 +1,190 @@
-'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')
-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 {
-  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
-}
-exports.updateEntity = updateEntity
+"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;
+};
+exports.updateEntity = updateEntity;

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

@@ -1,7 +1,7 @@
-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 }?: {
+    property?: string;
+    joinEntity?: any;
+    comparator?: string;
+    value?: any;
+}) => any[];
 //# sourceMappingURL=where.d.ts.map

package/dist/data/queries/where.js

@@ -1,56 +1,56 @@
-'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)
-  })
-}
-exports.where = where
+"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);
+  });
+};
+exports.where = where;

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

@@ -1,13 +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;
+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

package/dist/data/utilities/computeKeyValue.js

@@ -1,26 +1,26 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.computeKeyValue = void 0
-require('core-js/modules/es.json.stringify.js')
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.map.js')
-/**
- * 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
- */
-const computeKeyValue = (fields, values) => {
-  if (fields.length === 1) {
-    return values[fields[0]]
-  }
-  return JSON.stringify(fields.map(field => values[field]))
-}
-exports.computeKeyValue = computeKeyValue
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeKeyValue = void 0;
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
+/**
+ * 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
+ */
+const computeKeyValue = (fields, values) => {
+  if (fields.length === 1) {
+    return values[fields[0]];
+  }
+  return JSON.stringify(fields.map(field => values[field]));
+};
+exports.computeKeyValue = computeKeyValue;

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

@@ -1,28 +1,28 @@
-export type RuntimeSettings = {
-    databasePath: string;
-    relativePath: string;
-    enforceForeignKeys: boolean;
-};
-/**
- * Set where this package's data lives: databasePath (a filesystem path, used in Node) and/or
- * relativePath (a URL prefix prepended to databasePath, used when reading over fetch() in a
- * browser). Call this once before using create()/drop()/query() - a fresh consumer has no other
- * way to point this package at their own data directory.
- *
- * enforceForeignKeys (default true) controls whether deleteEntity/updateEntity block an operation
- * that would leave another record's foreign key pointing at a value that no longer exists -
- * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
- * on, since strict enforcement isn't always what every consumer wants.
- * @param newSettings
- */
-export declare const configure: (newSettings: Partial<RuntimeSettings>) => void;
-/**
- * Read one runtime setting, falling back to the given default if it was never configured. This is
- * the package's own lightweight replacement for reading settings via js-build-tools/gulp.config -
- * that module is a dev-time build tool, not something a published package should require at
- * runtime, and it isn't available at all once a consumer installs this package on its own.
- * @param key
- * @param defaultValue
- */
-export declare const getSetting: <K extends keyof RuntimeSettings>(key: K, defaultValue: RuntimeSettings[K]) => RuntimeSettings[K];
+export type RuntimeSettings = {
+    databasePath: string;
+    relativePath: string;
+    enforceForeignKeys: boolean;
+};
+/**
+ * Set where this package's data lives: databasePath (a filesystem path, used in Node) and/or
+ * relativePath (a URL prefix prepended to databasePath, used when reading over fetch() in a
+ * browser). Call this once before using create()/drop()/query() - a fresh consumer has no other
+ * way to point this package at their own data directory.
+ *
+ * enforceForeignKeys (default true) controls whether deleteEntity/updateEntity block an operation
+ * that would leave another record's foreign key pointing at a value that no longer exists -
+ * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
+ * on, since strict enforcement isn't always what every consumer wants.
+ * @param newSettings
+ */
+export declare const configure: (newSettings: Partial<RuntimeSettings>) => void;
+/**
+ * Read one runtime setting, falling back to the given default if it was never configured. This is
+ * the package's own lightweight replacement for reading settings via js-build-tools/gulp.config -
+ * that module is a dev-time build tool, not something a published package should require at
+ * runtime, and it isn't available at all once a consumer installs this package on its own.
+ * @param key
+ * @param defaultValue
+ */
+export declare const getSetting: <K extends keyof RuntimeSettings>(key: K, defaultValue: RuntimeSettings[K]) => RuntimeSettings[K];
 //# sourceMappingURL=config.d.ts.map