@karmaniverous/entity-manager 6.7.5 → 6.8.0

package/dist/{cjs/encodeEntityElement.js → mjs/encodeElement.js}

@@ -1,16 +1,11 @@
-'use strict';
-
-var validateEntityToken = require('./validateEntityToken.js');
-
 /**
- * Encode an {@link Entity | `Entity`} generated property element or ungenerated index component using the associated {@link Transcodes | Transcodes} `encode` function.
+ * Encode an {@link EntityItem | `EntityItem`} generated property element or ungenerated index component using the associated {@link Transcodes | Transcodes} `encode` function.
  *
  * Returns all `undefined` values.
  *
  * If `element` is the {@link Config.hashKey | `hashKey`} or {@link Config.rangeKey | `rangeKey`}, returns the value as-is.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
  * @param element - The {@link Entity | `Entity`} generated property element or ungenerated index component to encode.
  * @param item - Partial {@link ItemMap | `ItemMap`} object.
  *
@@ -18,16 +13,15 @@ var validateEntityToken = require('./validateEntityToken.js');
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function encodeEntityElement(entityManager, entityToken, element, item) {
+function encodeElement(entityManager, element, item) {
     try {
-        validateEntityToken.validateEntityToken(entityManager, entityToken);
-        const { entities, hashKey, rangeKey, transcodes } = entityManager.config;
+        const { hashKey, rangeKey, propertyTranscodes, transcodes } = entityManager.config;
         const value = item[element];
         if (value === undefined || [hashKey, rangeKey].includes(element))
             return value;
-        const encoded = transcodes[entities[entityToken].elementTranscodes[element]].encode(item[element]) || undefined;
+        const encoded = transcodes[propertyTranscodes[element]].encode(item[element]) ||
+            undefined;
         entityManager.logger.debug('encoded entity element', {
-            entityToken,
             element,
             item,
             encoded,
@@ -36,9 +30,9 @@ function encodeEntityElement(entityManager, entityToken, element, item) {
     }
     catch (error) {
         if (error instanceof Error)
-            entityManager.logger.error(error.message, { entityToken, element, item });
+            entityManager.logger.error(error.message, { element, item });
         throw error;
     }
 }
 
-exports.encodeEntityElement = encodeEntityElement;
+export { encodeElement };

package/dist/mjs/encodeGeneratedProperty.js

@@ -1,39 +1,39 @@
 import { isNil } from '@karmaniverous/entity-tools';
-import { validateEntityGeneratedProperty } from './validateEntityGeneratedProperty.js';
+import { validateGeneratedProperty } from './validateGeneratedProperty.js';
 
 /**
- * Encode a generated property value. Returns a string or undefined if atomicity requirement not met.
+ * Encode a generated property value. Returns a string or undefined if atomicity requirement of sharded properties not met.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - `entityManager.config.entities` key.
- * @param property - {@link ConfigEntityGenerated | `entityManager.config.entities.<entityToken>.generated`} key.
+ * @param property - {@link Config.generatedProperties | Generated property} key.
  * @param item - Partial {@link ItemMap | `ItemMap`} object.
  *
  * @returns Encoded generated property value.
  *
- * @throws `Error` if `entityToken` is invalid.
- * @throws `Error` if `property` is invalid.
+ * @throws `Error` if `property` is not a {@link Config.generatedProperties | generated property}.
  */
-function encodeGeneratedProperty(entityManager, entityToken, property, item) {
+function encodeGeneratedProperty(entityManager, property, item) {
     try {
         // Validate params.
-        validateEntityGeneratedProperty(entityManager, entityToken, property);
-        const { atomic, elements, sharded } = entityManager.config.entities[entityToken].generated[property];
+        validateGeneratedProperty(entityManager, property);
+        const sharded = property in entityManager.config.generatedProperties.sharded;
+        const elements = entityManager.config.generatedProperties[sharded ? 'sharded' : 'unsharded'][property];
         // Map elements to [element, value] pairs.
         const elementMap = elements.map((element) => [
             element,
             item[element],
         ]);
-        // Validate atomicity requirement.
-        if (atomic && elementMap.some(([, value]) => isNil(value)))
+        // Return undefined if sharded & atomicity requirement fails.
+        if (sharded && elementMap.some(([, value]) => isNil(value)))
             return;
         // Encode property value.
         const encoded = [
-            ...(sharded ? [item[entityManager.config.hashKey]] : []),
+            ...(sharded
+                ? [item[entityManager.config.hashKey]]
+                : []),
             ...elementMap.map(([element, value]) => [element, (value ?? '').toString()].join(entityManager.config.generatedValueDelimiter)),
         ].join(entityManager.config.generatedKeyDelimiter);
         entityManager.logger.debug('encoded generated property', {
-            entityToken,
             property,
             item,
             encoded,
@@ -43,7 +43,6 @@ function encodeGeneratedProperty(entityManager, entityToken, property, item) {
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                entityToken,
                 property,
                 item,
             });

package/dist/mjs/getHashKeySpace.js

@@ -1,14 +1,14 @@
 import { range } from 'radash';
 import { encodeGeneratedProperty } from './encodeGeneratedProperty.js';
-import { validateEntityGeneratedProperty } from './validateEntityGeneratedProperty.js';
+import { validateGeneratedProperty } from './validateGeneratedProperty.js';
 
 /**
  * Return an array of {@link ConfigKeys.hashKey | `entityManager.config.hashKey`} property values covering the shard space bounded by `timestampFrom` & `timestampTo`.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
- * @param hashKeyToken - {@link ParsedConfig | `entityManager.config.hashKey`} or {@link ParsedConfig | `entityManager.config.entities.<entityToken>.generated`} key. If a generated property, must be shardable.
- * @param item - Partial {@link ItemMap | `ItemMap[EntityToken]`} object. Must include all properties required to generate the hash key space.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param hashKeyToken - {@link ParsedConfig | `entityManager.config.hashKey`} or {@link ParsedConfig | `entityManager.config.generatedProperties.sharded`} key.
+ * @param item - {@link EntityItem | `EntityItem`} object. Must include all properties required to generate the hash key space.
  * @param timestampFrom - Lower timestanp limit. Defaults to `0`.
  * @param timestampTo - Upper timestamp limit. Defaults to `Date.now()`.
  *
@@ -20,7 +20,7 @@ function getHashKeySpace(entityManager, entityToken, hashKeyToken, item, timesta
     try {
         // Validate hashKeyToken is either the global hash key or a sharded generated property.
         if (hashKeyToken !== entityManager.config.hashKey)
-            validateEntityGeneratedProperty(entityManager, entityToken, hashKeyToken, true);
+            validateGeneratedProperty(entityManager, hashKeyToken, true);
         const { shardBumps } = entityManager.config.entities[entityToken];
         const hashKeySpace = shardBumps
             // Filter shard bumps by timestamp range.
@@ -40,7 +40,7 @@ function getHashKeySpace(entityManager, entityToken, hashKeyToken, item, timesta
             let hashKey = `${entityToken}${entityManager.config.shardKeyDelimiter}${shardKey}`;
             // If hash key space basis is a different property, encode it.
             if (hashKeyToken !== entityManager.config.hashKey)
-                hashKey = encodeGeneratedProperty(entityManager, entityToken, hashKeyToken, {
+                hashKey = encodeGeneratedProperty(entityManager, hashKeyToken, {
                     ...item,
                     [entityManager.config.hashKey]: hashKey,
                 });

package/dist/mjs/getIndexComponents.js

@@ -1,22 +1,20 @@
 import { unique } from 'radash';
-import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { validateIndexToken } from './validateIndexToken.js';
 
 /**
  * Get the index components of an entity index. Adds the hash and range keys to the index components.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
- * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} key.
+ * @param indexToken - {@link Config.indexes | `entityManager.config.indexes`} key.
  *
  * @returns Array of index components.
  *
- * @throws `Error` if `entityToken` is invalid.
  * @throws `Error` if `indexToken` is invalid.
  */
-function getIndexComponents(entityManager, entityToken, indexToken) {
-    validateEntityIndexToken(entityManager, entityToken, indexToken);
-    const { hashKey, rangeKey, entities } = entityManager.config;
-    const { hashKey: indexHashKey, rangeKey: indexRangeKey } = entities[entityToken].indexes[indexToken];
+function getIndexComponents(entityManager, indexToken) {
+    validateIndexToken(entityManager, indexToken);
+    const { hashKey, rangeKey, indexes } = entityManager.config;
+    const { hashKey: indexHashKey, rangeKey: indexRangeKey } = indexes[indexToken];
     return unique([hashKey, rangeKey, indexHashKey, indexRangeKey]);
 }
 

package/dist/mjs/getShardBump.js

@@ -4,7 +4,7 @@ import { validateEntityToken } from './validateEntityToken.js';
  * Get first entity shard bump before timestamp.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param entityToken - {@link Config.entities | `this.config.entities`} key.
  * @param timestamp - Timestamp in milliseconds.
  *
  * @returns {@link ShardBump | `ShardBump`} object.

package/dist/mjs/query.js

@@ -11,7 +11,7 @@ const { compressToEncodedURIComponent, decompressFromEncodedURIComponent } = lzS
  * @remarks
  * The provided {@link ShardQueryFunction | `ShardQueryFunction`} performs the actual query of individual data pages on individual shards. This function is presumed to express provider-specific query logic, including any necessary indexing or search constraints.
  *
- * Individual shard query results will be combined, deduped by {@link ConfigEntity.uniqueProperty} property value, and sorted by {@link QueryOptions.sortOrder | `sortOrder`}.
+ * Individual shard query results will be combined, deduped by {@link Config.uniqueProperty} property value, and sorted by {@link QueryOptions.sortOrder | `sortOrder`}.
  *
  * In queries on sharded data, expect the leading and trailing edges of returned data pages to interleave somewhat with preceding & following pages.
  *

package/dist/mjs/rehydrateIndexItem.js

@@ -1,10 +1,11 @@
 import { shake, zipToObject } from 'radash';
-import { decodeEntityElement } from './decodeEntityElement.js';
+import { decodeElement } from './decodeElement.js';
 import { unwrapIndex } from './unwrapIndex.js';
-import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { validateEntityToken } from './validateEntityToken.js';
+import { validateIndexToken } from './validateIndexToken.js';
 
 /**
- * Convert a delimited string into a partial {@link ItemMap | `ItemMap`} object representing the ungenerated component elements of a Config entity index.
+ * Convert a delimited string into an {@link EntityItem | `EntityItem`} object representing the ungenerated component elements of a Config entity index, minus its hash key.
  *
  * @remarks
  * Reverses {@link EntityManager.dehydrateIndexItem | `dehydrateIndexItem`}.
@@ -12,31 +13,32 @@ import { validateEntityIndexToken } from './validateEntityIndexToken.js';
  * {@link EntityManager.dehydrateIndexItem | `dehydrateIndexItem`} alphebetically sorts unwrapped index elements during the dehydration process. This method assumes delimited element values are presented in the same order.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
- * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} key.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param indexToken - {@link Config.indexes | `entityManager.config.indexes`} key.
  * @param dehydrated - Dehydrated index value.
  *
- * @returns Partial {@link ItemMap | `ItemMap`} object containing rehydrated index component elements.
+ * @returns {@link EntityItem | `EntityItem`} object containing rehydrated index component elements.
  *
  * @throws `Error` if `entityToken` is invalid.
  * @throws `Error` if `indexToken` is invalid.
  */
 function rehydrateIndexItem(entityManager, entityToken, indexToken, dehydrated) {
     try {
-        const { generatedKeyDelimiter } = entityManager.config;
         // Validate params.
-        validateEntityIndexToken(entityManager, entityToken, indexToken);
+        validateEntityToken(entityManager, entityToken);
+        validateIndexToken(entityManager, indexToken);
         // Unwrap index elements.
-        const { hashKey } = entityManager.config.entities[entityToken].indexes[indexToken];
+        const { hashKey } = entityManager.config.indexes[indexToken];
         const elements = unwrapIndex(entityManager, entityToken, indexToken, [
             hashKey,
         ]);
         // Split dehydrated value & validate.
+        const { generatedKeyDelimiter } = entityManager.config;
         const values = dehydrated.split(generatedKeyDelimiter);
         if (elements.length !== values.length)
             throw new Error('index rehydration key-value mismatch');
         // Assign values to elements.
-        const rehydrated = shake(zipToObject(elements, values.map((value, i) => decodeEntityElement(entityManager, entityToken, elements[i], value))));
+        const rehydrated = shake(zipToObject(elements, values.map((value, i) => decodeElement(entityManager, elements[i], value))));
         entityManager.logger.debug('rehydrated index', {
             entityToken,
             indexToken,

package/dist/mjs/rehydratePageKeyMap.js

@@ -5,7 +5,8 @@ import { getHashKeySpace } from './getHashKeySpace.js';
 import { getIndexComponents } from './getIndexComponents.js';
 import { rehydrateIndexItem } from './rehydrateIndexItem.js';
 import { updateItemRangeKey } from './updateItemRangeKey.js';
-import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { validateEntityToken } from './validateEntityToken.js';
+import { validateIndexToken } from './validateIndexToken.js';
 
 /**
  * Rehydrate an array of dehydrated page keys into a {@link PageKeyMap | `PageKeyMap`} object.
@@ -13,8 +14,8 @@ import { validateEntityIndexToken } from './validateEntityIndexToken.js';
  * Reverses the {@link EntityManager.dehydratePageKeyMap | `dehydratePageKeyMap`} method.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
- * @param indexTokens - Array of {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} keys used as keys of the original {@link PageKeyMap | `PageKeyMap`}.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param indexTokens - Array of {@link Config.indexes | `entityManager.config.indexes`} keys used as keys of the original {@link PageKeyMap | `PageKeyMap`}.
  * @param item - Partial item object sufficiently populated to generate index hash keys.
  * @param dehydrated - Array of dehydrated page keys or undefined if new query.
  * @param timestampFrom - Lower timestanp limit used to generate the original {@link PageKeyMap | `PageKeyMap`}. Defaults to `0`.
@@ -30,20 +31,21 @@ import { validateEntityIndexToken } from './validateEntityIndexToken.js';
  */
 function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehydrated, timestampFrom = 0, timestampTo = Date.now()) {
     try {
+        // Validate params.
+        validateEntityToken(entityManager, entityToken);
         // Validate indexTokens populated.
         if (!indexTokens.length)
             throw new Error('indexTokens empty');
         // Validate indexTokens exist.
         const hashKeys = unique(indexTokens.map((indexToken) => {
-            validateEntityIndexToken(entityManager, entityToken, indexToken);
-            return entityManager.config.entities[entityToken].indexes[indexToken]
-                .hashKey;
+            validateIndexToken(entityManager, indexToken);
+            return entityManager.config.indexes[indexToken].hashKey;
         }));
         // Validate hashKeys consistent.
         if (hashKeys.length > 1)
             throw new Error('inconsistent hashKeys');
         const [hashKeyToken] = hashKeys;
-        indexTokens.map((index) => validateEntityIndexToken(entityManager, entityToken, index));
+        indexTokens.map((index) => validateIndexToken(entityManager, index));
         // Shortcut empty dehydrated.
         if (dehydrated && !dehydrated.length)
             return [hashKeyToken, {}];
@@ -55,17 +57,22 @@ function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehy
         if (dehydrated.length !== hashKeySpace.length * indexTokens.length)
             throw new Error('dehydrated length mismatch');
         // Rehydrate pageKeys.
+        const uniqueProperty = entityManager.config.entities[entityToken]
+            .uniqueProperty;
+        const { sharded, unsharded } = entityManager.config.generatedProperties;
         const rehydrated = mapValues(zipToObject(indexTokens, cluster(dehydrated, hashKeySpace.length)), (dehydratedIndexPageKeyMaps, index) => zipToObject(hashKeySpace, (hashKey, i) => {
             if (!dehydratedIndexPageKeyMaps[i])
                 return;
             let pageKeyItem = {
-                ...decodeGeneratedProperty(entityManager, entityToken, hashKey),
+                ...decodeGeneratedProperty(entityManager, hashKey),
                 ...rehydrateIndexItem(entityManager, entityToken, index, dehydratedIndexPageKeyMaps[i]),
             };
             pageKeyItem = updateItemRangeKey(entityManager, entityToken, pageKeyItem);
-            return zipToObject(getIndexComponents(entityManager, entityToken, index), (component) => entityManager.config.entities[entityToken].generated[component]
-                ? encodeGeneratedProperty(entityManager, entityToken, component, pageKeyItem)
-                : pageKeyItem[component]);
+            return zipToObject(getIndexComponents(entityManager, index), (component) => component === entityManager.config.rangeKey
+                ? [uniqueProperty, pageKeyItem[uniqueProperty]].join(entityManager.config.generatedValueDelimiter)
+                : component in sharded || component in unsharded
+                    ? encodeGeneratedProperty(entityManager, component, pageKeyItem)
+                    : pageKeyItem[component]);
         }));
         entityManager.logger.debug('rehydrated page key map', {
             entityToken,

package/dist/mjs/removeKeys.js

@@ -4,7 +4,7 @@ import { validateEntityToken } from './validateEntityToken.js';
  * Strips generated properties, hash key, and range key from an {@link ItemMap | `ItemMap`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
  * @param item - {@link ItemMap | `ItemMap`} object.
  *
  * @returns Shallow clone of `item` without generated properties, hash key or range key.
@@ -20,7 +20,8 @@ function removeKeys(entityManager, entityToken, item) {
         delete newItem[entityManager.config.hashKey];
         delete newItem[entityManager.config.rangeKey];
         // Delete generated properties.
-        for (const property in entityManager.config.entities[entityToken].generated)
+        const { sharded, unsharded } = entityManager.config.generatedProperties;
+        for (const property in { ...sharded, ...unsharded })
             delete newItem[property];
         entityManager.logger.debug('stripped entity item generated properties', {
             entityToken,

package/dist/mjs/unwrapIndex.js

@@ -1,12 +1,13 @@
-import { shake, unique } from 'radash';
+import { unique } from 'radash';
 import { getIndexComponents } from './getIndexComponents.js';
-import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { validateEntityToken } from './validateEntityToken.js';
+import { validateIndexToken } from './validateIndexToken.js';
 
 /**
- * Unwraps an {@link ConfigEntity.indexes | Entity index} into deduped, sorted, ungenerated index component elements.
+ * Unwraps an {@link Config.indexes | index} into deduped, sorted, ungenerated index component elements.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
  * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} key.
  * @param omit - Array of index components or elements to omit from the output value.
  *
@@ -18,24 +19,37 @@ import { validateEntityIndexToken } from './validateEntityIndexToken.js';
 function unwrapIndex(entityManager, entityToken, indexToken, omit = []) {
     try {
         // Validate params.
-        validateEntityIndexToken(entityManager, entityToken, indexToken);
-        const generated = entityManager.config.entities[entityToken].generated;
-        const generatedKeys = Object.keys(shake(generated));
-        return unique(getIndexComponents(entityManager, entityToken, indexToken)
+        validateEntityToken(entityManager, entityToken);
+        validateIndexToken(entityManager, indexToken);
+        const { sharded, unsharded } = entityManager.config.generatedProperties;
+        const unwrapped = unique(getIndexComponents(entityManager, indexToken)
             .filter((component) => !omit.includes(component))
             .map((component) => component === entityManager.config.hashKey
             ? entityManager.config.entities[entityToken].timestampProperty
             : component === entityManager.config.rangeKey
                 ? entityManager.config.entities[entityToken].uniqueProperty
-                : generatedKeys.includes(component)
-                    ? generated[component].elements
-                    : component)
+                : component in sharded
+                    ? sharded[component]
+                    : component in unsharded
+                        ? unsharded[component]
+                        : component)
             .flat()
             .filter((element) => !omit.includes(element))).sort();
+        entityManager.logger.debug('unwrapped index', {
+            entityToken,
+            indexToken,
+            omit,
+            unwrapped,
+        });
+        return unwrapped;
     }
     catch (error) {
         if (error instanceof Error)
-            entityManager.logger.error(error.message, { indexToken, entityToken });
+            entityManager.logger.error(error.message, {
+                entityToken,
+                indexToken,
+                omit,
+            });
         throw error;
     }
 }

package/dist/mjs/updateItemHashKey.js

@@ -7,7 +7,7 @@ import { validateEntityToken } from './validateEntityToken.js';
  * Update the hash key on a partial {@link ItemMap | `ItemMap`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param entityToken - {@link Config.entities | `this.config.entities`} key.
  * @param item - Partial {@link ItemMap | `ItemMap`} object.
  * @param overwrite - Overwrite existing {@link ConfigKeys.hashKey | `this.config.hashKey`} property value (default `false`).
  *
@@ -20,7 +20,8 @@ function updateItemHashKey(entityManager, entityToken, item, overwrite = false)
         // Validate params.
         validateEntityToken(entityManager, entityToken);
         // Return current item if hashKey exists and overwrite is false.
-        if (item[entityManager.config.hashKey] && !overwrite) {
+        if (item[entityManager.config.hashKey] &&
+            !overwrite) {
             entityManager.logger.debug('did not overwrite existing entity item hash key', {
                 item,
                 entityToken,
@@ -29,7 +30,8 @@ function updateItemHashKey(entityManager, entityToken, item, overwrite = false)
             return { ...item };
         }
         // Get item timestamp property & validate.
-        const timestamp = item[entityManager.config.entities[entityToken].timestampProperty];
+        const timestamp = item[entityManager.config.entities[entityToken]
+            .timestampProperty];
         if (isNil(timestamp))
             throw new Error(`missing item timestamp property`);
         // Find first entity sharding bump before timestamp.

package/dist/mjs/updateItemRangeKey.js

@@ -5,21 +5,22 @@ import { validateEntityToken } from './validateEntityToken.js';
  * Update the range key on a partial {@link ItemMap | `ItemMap`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param entityToken - {@link Config.entities | `this.config.entities`} key.
  * @param item - Partial {@link ItemMap | `ItemMap`} object.
  * @param overwrite - Overwrite existing {@link ConfigKeys.rangeKey | `this.config.rangeKey`} property value (default `false`).
  *
  * @returns Shallow clone of `item` with updated range key.
  *
  * @throws `Error` if `entityToken` is invalid.
- * @throws `Error` if `item` {@link ConfigEntity.uniqueProperty | `this.config.entities<entityToken>.uniqueProperty`} property value is missing.
+ * @throws `Error` if `item` {@link Config.uniqueProperty | `this.config.entities<entityToken>.uniqueProperty`} property value is missing.
  */
 function updateItemRangeKey(entityManager, entityToken, item, overwrite = false) {
     try {
         // Validate params.
         validateEntityToken(entityManager, entityToken);
         // Return current item if rangeKey exists and overwrite is false.
-        if (item[entityManager.config.rangeKey] && !overwrite) {
+        if (item[entityManager.config.rangeKey] &&
+            !overwrite) {
             entityManager.logger.debug('did not overwrite existing entity item range key', {
                 entityToken,
                 item,
@@ -28,7 +29,8 @@ function updateItemRangeKey(entityManager, entityToken, item, overwrite = false)
             return { ...item };
         }
         // Get item unique property & validate.
-        const uniqueProperty = item[entityManager.config.entities[entityToken].uniqueProperty];
+        const uniqueProperty = item[entityManager.config.entities[entityToken]
+            .uniqueProperty];
         if (isNil(uniqueProperty))
             throw new Error(`missing item unique property`);
         // Update range key.

package/dist/mjs/validateGeneratedProperty.js

@@ -0,0 +1,21 @@
+/**
+ * Validate that a property is defined as an {@link EntityManager | `EntityManager`} {@link Config.generatedProperties | generated property}.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param property - {@link Config.generatedProperties | Generated property} key.
+ * @param isSharded - Whether the generated property is sharded. `undefined` indicates no constraint.
+ *
+ * @throws `Error` if `property` is not a {@link Config.generatedProperties | generated property}.
+ * @throws `Error` if `sharded` is specified & does not match {@link Config.generatedProperties | generated property} type.
+ */
+function validateGeneratedProperty(entityManager, property, isSharded) {
+    const { sharded, unsharded } = entityManager.config.generatedProperties;
+    if (!(property in sharded) && !(property in unsharded))
+        throw new Error('invalid generated property');
+    if (isSharded !== undefined &&
+        ((isSharded && !(property in sharded)) ||
+            (!isSharded && !(property in unsharded))))
+        throw new Error(`generated property ${isSharded ? 'not ' : ''}sharded`);
+}
+
+export { validateGeneratedProperty };

package/dist/mjs/validateIndexToken.js

@@ -0,0 +1,14 @@
+/**
+ * Validate that an entity index is defined in EntityManager config.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param indexToken - {@link Config.indexes | `entityManager.config.indexes`} key.
+ *
+ * @throws `Error` if `indexToken` is invalid.
+ */
+function validateIndexToken(entityManager, indexToken) {
+    if (!(indexToken in entityManager.config.indexes))
+        throw new Error('invalid index token');
+}
+
+export { validateIndexToken };

package/dist/mjs/validateTranscodedProperty.js

@@ -0,0 +1,14 @@
+/**
+ * Validate that a property is defined as an {@link EntityManager | `EntityManager`} {@link Config.propertyTranscodes | transcoded property}.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param property - {@link Config.propertyTranscodes | Transcoded property} key.
+ *
+ * @throws `Error` if `property` is not a {@link Config.propertyTranscodes | transcoded property}.
+ */
+function validateTranscodedProperty(entityManager, property) {
+    if (!(property in entityManager.config.propertyTranscodes))
+        throw new Error('invalid transcoded property');
+}
+
+export { validateTranscodedProperty };

package/package.json

@@ -5,7 +5,7 @@
   },
   "dependencies": {
     "@karmaniverous/batch-process": "^0.1.0",
-    "@karmaniverous/entity-tools": "^0.4.4",
+    "@karmaniverous/entity-tools": "^0.5.0",
     "@karmaniverous/string-utilities": "^0.2.1",
     "lz-string": "^1.5.0",
     "radash": "^12.1.0",
@@ -17,7 +17,7 @@
     "@dotenvx/dotenvx": "^1.22.0",
     "@eslint/js": "^9.14.0",
     "@faker-js/faker": "^9.2.0",
-    "@karmaniverous/mock-db": "^0.3.3",
+    "@karmaniverous/mock-db": "^0.3.4",
     "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-commonjs": "^28.0.1",
     "@rollup/plugin-json": "^6.1.0",
@@ -46,13 +46,13 @@
     "prettier": "^3.3.3",
     "release-it": "^17.10.0",
     "rimraf": "^6.0.1",
-    "rollup": "^4.24.4",
+    "rollup": "^4.25.0",
     "rollup-plugin-dts": "^6.1.1",
     "source-map-support": "^0.5.21",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typedoc": "^0.26.11",
-    "typedoc-plugin-mdn-links": "^3.3.6",
+    "typedoc-plugin-mdn-links": "^3.3.7",
     "typedoc-plugin-replace-text": "^4.0.0",
     "typedoc-plugin-zod": "^1.2.1",
     "typescript": "^5.6.3",
@@ -132,5 +132,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "6.7.5"
+  "version": "6.8.0"
 }

package/dist/cjs/validateEntityGeneratedProperty.js

@@ -1,29 +0,0 @@
-'use strict';
-
-var validateEntityToken = require('./validateEntityToken.js');
-
-/**
- * Validate that an entity generated property is defined in EntityManager
- * config.
- *
- * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
- * @param property - {@link ConfigEntityGenerated | `this.config.entities.<entityToken>.generated`} key.
- * @param sharded - Whether the generated property is sharded. `undefined` indicates no constraint.
- *
- * @throws `Error` if `entityToken` is invalid.
- * @throws `Error` if `property` is invalid.
- * @throws `Error` if `sharded` is specified & does not match `this.config.entities.<entityToken>.generated.<property>.sharded`.
- */
-function validateEntityGeneratedProperty(entityManager, entityToken, property, sharded) {
-    validateEntityToken.validateEntityToken(entityManager, entityToken);
-    const generated = entityManager.config.entities[entityToken].generated[property];
-    if (!generated && property !== entityManager.config.hashKey)
-        throw new Error('invalid entity generated property');
-    if (sharded !== undefined &&
-        ((generated && sharded !== generated.sharded) ||
-            (!sharded && property === entityManager.config.hashKey)))
-        throw new Error(`entity generated property ${sharded ? 'not ' : ''}sharded`);
-}
-
-exports.validateEntityGeneratedProperty = validateEntityGeneratedProperty;

package/dist/cjs/validateEntityIndexToken.js

@@ -1,22 +0,0 @@
-'use strict';
-
-var validateEntityToken = require('./validateEntityToken.js');
-
-/**
- * Validate that an entity index is defined in EntityManager config.
- *
- * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
- * @param indexToken - {@link ConfigEntity.indexes | `this.config.entities.<entityToken>.indexes`} key.
- *
- * @throws `Error` if `entityToken` is invalid.
- * @throws `Error` if `indexToken` is invalid.
- */
-function validateEntityIndexToken(entityManager, entityToken, indexToken) {
-    validateEntityToken.validateEntityToken(entityManager, entityToken);
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!entityManager.config.entities[entityToken].indexes[indexToken])
-        throw new Error('invalid entity index token');
-}
-
-exports.validateEntityIndexToken = validateEntityIndexToken;