@karmaniverous/entity-manager 6.7.5 → 6.8.1

package/dist/mjs/BaseEntityClient.js

@@ -7,7 +7,7 @@ class BaseEntityClient {
     /**
      * DynamoDB EntityClient constructor.
      *
-     * @param options - {@link EntityClientOptions | `EntityClientOptions`} object.
+     * @param options - {@link BaseEntityClientOptions | `BaseEntityClientOptions`} object.
      */
     constructor(options) {
         const { batchProcessOptions = {}, logger = console } = options;

package/dist/mjs/BaseQueryBuilder.js

@@ -3,7 +3,11 @@ import { mapValues } from 'radash';
 /**
  * Abstract base class supporting a fluent API for building a {@link ShardQueryMap | `ShardQueryMap`} using a database client.
  *
- * @category ShardQueryMapBuilder
+ * @typeParam C - {@link ConfigMap | `ConfigMap`} that defines an {@link Config | `EntityManager configuration`}'s {@link EntityMap | `EntityMap`}, key properties, and {@link TranscodeMap | `TranscodeMap`}. If omitted, defaults to {@link BaseConfigMap | `BaseConfigMap`}.
+ * @typeParam EntityClient - {@link BaseEntityClient | `BaseEntityClient`} derived class instance.
+ * @typeParam IndexParams - Database platform-specific, index-specific query parameters.
+ *
+ * @category QueryBuilder
  */
 class BaseQueryBuilder {
     /** BaseQueryBuilder constructor. */

package/dist/mjs/EntityManager.js

@@ -9,7 +9,12 @@ var _EntityManager_config;
  * The EntityManager class applies a configuration-driven sharded data model &
  * query strategy to NoSql data.
  *
- * @category Entity Manager
+ * @typeParam C - {@link ConfigMap | `ConfigMap`} that defines the configuration's {@link EntityMap | `EntityMap`}, key properties, and {@link TranscodeMap | `TranscodeMap`}. If omitted, defaults to {@link BaseConfigMap | `BaseConfigMap`}.
+ *
+ * @remarks
+ * While the {@link EntityManager.query | `query`} method is `public`, normally it should not be called directly. The `query` method is used by a platform-specific {@link BaseQueryBuilder.query | `QueryBuilder.query`} method to provide a fluent query API.
+ *
+ * @category EntityManager
  */
 class EntityManager {
     /**
@@ -40,10 +45,10 @@ class EntityManager {
         __classPrivateFieldSet(this, _EntityManager_config, configSchema.parse(value), "f");
     }
     /**
-     * Update generated properties, hash key, and range key on an {@link ItemMap | `ItemMap`} object.
+     * Update generated properties, hash key, and range key on an {@link EntityItem | `EntityItem`} object.
      *
-     * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
-     * @param item - {@link ItemMap | `ItemMap`} object.
+     * @param entityToken - {@link Config | `Config`} `entities` key.
+     * @param item - {@link EntityItem | `EntityItem`} object.
      * @param overwrite - Overwrite existing properties (default `false`).
      *
      * @returns Shallow clone of `item` with updated properties.
@@ -54,10 +59,10 @@ class EntityManager {
         return addKeys(this, entityToken, item, overwrite);
     }
     /**
-     * Strips generated properties, hash key, and range key from an {@link ItemMap | `ItemMap`} object.
+     * Strips generated properties, hash key, and range key from an {@link EntityItem | `EntityItem`} object.
      *
-     * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
-     * @param item - {@link ItemMap | `ItemMap`} object.
+     * @param entityToken - {@link Config | `Config`} `entities` key.
+     * @param item - {@link EntityItem | `EntityItem`} object.
      *
      * @returns Shallow clone of `item` without generated properties, hash key or range key.
      *
@@ -72,17 +77,21 @@ class EntityManager {
      * @remarks
      * The provided `shardQueryMap` performs the actual query of individual data pages on individual index/shard combinations.
      *
-     * 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 | `Config`} `uniqueProperty` 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.
      *
      * Unsharded query results should sort & page as expected.
      *
+     * **Normally this method should not be called directly!** It is used by a platform-specific {@link BaseQueryBuilder.query | `QueryBuilder.query`} method to provide a fluent query API.
+     *
      * @param options - {@link QueryOptions | `QueryOptions`} object.
      *
      * @returns {@link QueryResult} object.
      *
-     * @throws Error if {@link QueryOptions.shardQueryMapBuilder | `shardQueryMapBuilder`} `pageKeyMap` keys do not match its `shardQueryMap` keys.
+     * @throws Error if `options` {@link QueryOptions.pageKeyMap | `pageKeyMap`} `pageKeyMap` keys do not match {@link QueryOptions.shardQueryMap | `shardQueryMap`} keys.
+     *
+     * @protected
      */
     async query(options) {
         return await query(this, options);

package/dist/mjs/ParsedConfig.js

@@ -9,16 +9,18 @@ const validateArrayUnique = (arr, ctx, identity = (item) => item, path = []) =>
         if (count > 1)
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
-                message: `duplicate array element '${element}'`,
+                message: `duplicate array element`,
+                params: { element },
                 path,
             });
     }
 };
-const validateKeyExclusive = (key, label, ref, ctx) => {
-    if (ref.includes(key))
+const validateKeysExclusive = (keys, label, ref, ctx) => {
+    const intersection = keys.filter((key) => ref.includes(key));
+    if (intersection.length)
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: `${label} '${key}' is not exclusive`,
+            message: `${label} key collision: ${intersection.toString()}`,
         });
 };
 const componentArray = z
@@ -44,25 +46,6 @@ const configSchema = z
             .safe()
             .optional()
             .default(10),
-        generated: z
-            .record(z
-            .object({
-            atomic: z.boolean().optional().default(false),
-            elements: componentArray,
-            sharded: z.boolean().optional().default(false),
-        })
-            .optional())
-            .optional()
-            .default({}),
-        elementTranscodes: z.record(z.string()).optional().default({}),
-        indexes: z
-            .record(z.object({
-            hashKey: z.string().min(1),
-            rangeKey: z.string().min(1),
-            projections: componentArray.optional(),
-        }))
-            .optional()
-            .default({}),
         shardBumps: z
             .array(z
             .object({
@@ -103,21 +86,30 @@ const configSchema = z
         timestampProperty: z.string().min(1),
         uniqueProperty: z.string().min(1),
     })
-        .strict()
-        .superRefine((data, ctx) => {
-        const generatedKeys = Object.keys(data.generated);
-        // validate timestampProperty is not a generated key.
-        validateKeyExclusive(data.timestampProperty, 'timestampProperty', generatedKeys, ctx);
-        // validate uniqueProperty is not a generated key.
-        validateKeyExclusive(data.uniqueProperty, 'uniqueProperty', generatedKeys, ctx);
+        .strict())
+        .optional()
+        .default({}),
+    generatedProperties: z
+        .object({
+        sharded: z.record(componentArray).optional().default({}),
+        unsharded: z.record(componentArray).optional().default({}),
+    })
+        .optional()
+        .default({ sharded: {}, unsharded: {} }),
+    hashKey: z.string(),
+    indexes: z
+        .record(z.object({
+        hashKey: z.string().min(1),
+        rangeKey: z.string().min(1),
+        projections: componentArray.optional(),
     }))
         .optional()
         .default({}),
     generatedKeyDelimiter: z.string().regex(/\W+/).optional().default('|'),
     generatedValueDelimiter: z.string().regex(/\W+/).optional().default('#'),
+    propertyTranscodes: z.record(z.string()).optional().default({}),
+    rangeKey: z.string(),
     shardKeyDelimiter: z.string().regex(/\W+/).optional().default('!'),
-    hashKey: z.string().optional().default('hashKey'),
-    rangeKey: z.string().optional().default('rangeKey'),
     throttle: z.number().int().positive().safe().optional().default(10),
     transcodes: z
         .record(z
@@ -136,12 +128,20 @@ const configSchema = z
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: 'generatedKeyDelimiter contains generatedValueDelimiter',
+            params: {
+                generatedKeyDelimiter: data.generatedKeyDelimiter,
+                generatedValueDelimiter: data.generatedValueDelimiter,
+            },
             path: ['generatedKeyDelimiter'],
         });
     if (data.generatedKeyDelimiter.includes(data.shardKeyDelimiter))
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: 'generatedKeyDelimiter contains shardKeyDelimiter',
+            params: {
+                generatedKeyDelimiter: data.generatedKeyDelimiter,
+                shardKeyDelimiter: data.shardKeyDelimiter,
+            },
             path: ['generatedKeyDelimiter'],
         });
     // validate no generated value delimiter collision
@@ -149,12 +149,20 @@ const configSchema = z
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: 'generatedValueDelimiter contains generatedKeyDelimiter',
+            params: {
+                generatedValueDelimiter: data.generatedValueDelimiter,
+                generatedKeyDelimiter: data.generatedKeyDelimiter,
+            },
             path: ['generatedValueDelimiter'],
         });
     if (data.generatedValueDelimiter.includes(data.shardKeyDelimiter))
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: 'generatedValueDelimiter contains shardKeyDelimiter',
+            params: {
+                generatedValueDelimiter: data.generatedValueDelimiter,
+                shardKeyDelimiter: data.shardKeyDelimiter,
+            },
             path: ['generatedValueDelimiter'],
         });
     // validate no shard key delimiter collision
@@ -162,103 +170,125 @@ const configSchema = z
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: 'shardKeyDelimiter contains generatedKeyDelimiter',
+            params: {
+                generatedKeyDelimiter: data.generatedKeyDelimiter,
+                shardKeyDelimiter: data.shardKeyDelimiter,
+            },
             path: ['shardKeyDelimiter'],
         });
     if (data.shardKeyDelimiter.includes(data.generatedValueDelimiter))
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: 'shardKeyDelimiter contains generatedValueDelimiter',
+            params: {
+                generatedValueDelimiter: data.generatedValueDelimiter,
+                shardKeyDelimiter: data.shardKeyDelimiter,
+            },
             path: ['shardKeyDelimiter'],
         });
-    const reservedKeys = Object.values(data.entities).reduce((reserved, { generated, timestampProperty, uniqueProperty }) => new Set([
-        ...reserved,
-        ...Object.keys(generated),
-        timestampProperty,
-        uniqueProperty,
-    ]), new Set());
-    // validate hashKey is not a reserved key.
-    validateKeyExclusive(data.hashKey, 'hashKey', [...reservedKeys, data.rangeKey], ctx);
-    // validate rangeKey is not a reserved key.
-    validateKeyExclusive(data.rangeKey, 'rangeKey', [...reservedKeys, data.hashKey], ctx);
-    // validate entities
+    // get reserved keys
+    const shardedKeys = Object.keys(data.generatedProperties.sharded);
+    const unshardedKeys = Object.keys(data.generatedProperties.unsharded);
+    const transcodedProperties = Object.keys(data.propertyTranscodes);
+    // validate hashKey exclusive.
+    validateKeysExclusive([data.hashKey], 'hashKey', [
+        data.rangeKey,
+        ...shardedKeys,
+        ...unshardedKeys,
+        ...transcodedProperties,
+    ], ctx);
+    // validate rangeKey exclusive.
+    validateKeysExclusive([data.rangeKey], 'rangeKey', [...shardedKeys, ...unshardedKeys, ...transcodedProperties], ctx);
+    // validate shardedKeys exclusive.
+    validateKeysExclusive(shardedKeys, 'shardedKeys', [...unshardedKeys, ...transcodedProperties], ctx);
+    // validate unshardedKeys exclusive.
+    validateKeysExclusive(unshardedKeys, 'unshardedKeys', transcodedProperties, ctx);
+    // validate all propertyTranscode values are transcode keys.
     const transcodes = Object.keys(data.transcodes);
-    for (const [entityToken, entity] of Object.entries(data.entities)) {
-        // validate all entity generated element type values are transcode keys.
-        for (const [element, generatedElementType] of Object.entries(entity.elementTranscodes))
-            if (!transcodes.includes(generatedElementType))
+    for (const [property, transcode] of Object.entries(data.propertyTranscodes))
+        if (!transcodes.includes(transcode))
+            ctx.addIssue({
+                code: z.ZodIssueCode.invalid_enum_value,
+                options: transcodes,
+                path: ['propertyTranscodes', property],
+                received: transcode,
+            });
+    // Validate all sharded property elements are transcoded properties.
+    for (const [property, elements] of Object.entries(data.generatedProperties.sharded))
+        for (const element of elements)
+            if (!transcodedProperties.includes(element))
                 ctx.addIssue({
                     code: z.ZodIssueCode.invalid_enum_value,
-                    options: transcodes,
-                    path: ['entities', entityToken, 'elementTranscodes', element],
-                    received: generatedElementType,
-                });
-        // validate all entity generated property elements have a corresponding entity element type.
-        const typedElements = Object.keys(entity.elementTranscodes);
-        for (const [generatedKey, generated] of Object.entries(entity.generated))
-            for (const element of generated?.elements ?? [])
-                if (!typedElements.includes(element))
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.invalid_enum_value,
-                        options: typedElements,
-                        path: [
-                            'entities',
-                            entityToken,
-                            'generated',
-                            generatedKey,
-                            'elements',
-                        ],
-                        received: element,
-                    });
-        // validate indexes.
-        const generatedProperties = Object.keys(entity.generated);
-        for (const [indexKey, { hashKey, rangeKey, projections },] of Object.entries(entity.indexes)) {
-            // validate index hash key is sharded
-            if (hashKey !== data.hashKey && !entity.generated[hashKey]?.sharded)
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: 'index hash key is not sharded',
-                    path: ['entities', entityToken, 'indexes', indexKey, 'hashKey'],
+                    options: transcodedProperties,
+                    received: element,
+                    path: ['generatedProperties', 'sharded', property],
                 });
-            // validate index range key is unsharded
-            if (rangeKey !== data.rangeKey && entity.generated[rangeKey]?.sharded)
+    // Validate all unsharded property elements are transcoded properties.
+    for (const [property, elements] of Object.entries(data.generatedProperties.unsharded))
+        for (const element of elements)
+            if (!transcodedProperties.includes(element))
                 ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: 'index range key is sharded',
-                    path: ['entities', entityToken, 'indexes', indexKey, 'rangeKey'],
+                    code: z.ZodIssueCode.invalid_enum_value,
+                    options: transcodedProperties,
+                    received: element,
+                    path: ['generatedProperties', 'unsharded', property],
                 });
-            // validate all ungenerated entity index components have a corresponding entity element type
-            for (const component of [hashKey, rangeKey])
-                if (![data.hashKey, data.rangeKey, ...generatedProperties].includes(component) &&
-                    !typedElements.includes(component))
+    // Validate indexes.
+    for (const [indexKey, { hashKey, rangeKey, projections }] of Object.entries(data.indexes)) {
+        // Validate hash key is sharded.
+        if (![data.hashKey, ...shardedKeys].includes(hashKey)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.invalid_enum_value,
+                options: [data.hashKey, ...shardedKeys],
+                path: ['indexes', indexKey, 'hashKey'],
+                received: hashKey,
+            });
+        }
+        // Validate range key is unsharded or transcodable.
+        if (![data.rangeKey, ...unshardedKeys, ...transcodedProperties].includes(rangeKey)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.invalid_enum_value,
+                options: [data.rangeKey, ...unshardedKeys],
+                path: ['indexes', indexKey, 'rangeKey'],
+                received: rangeKey,
+            });
+        }
+        // Validate no index projections are keys.
+        if (projections)
+            for (const projection of projections)
+                if ([
+                    data.hashKey,
+                    data.rangeKey,
+                    hashKey,
+                    rangeKey,
+                    ...shardedKeys,
+                    ...unshardedKeys,
+                ].includes(projection))
                     ctx.addIssue({
-                        code: z.ZodIssueCode.invalid_enum_value,
-                        options: typedElements,
-                        path: [
-                            'entities',
-                            entityToken,
-                            'indexes',
-                            indexKey,
-                            'components',
-                        ],
-                        received: component,
+                        code: z.ZodIssueCode.custom,
+                        message: 'index projection is a key',
+                        params: { projection },
+                        path: ['indexes', indexKey, 'projections'],
                     });
-            // validate no index projections are index components, hashKey, or rangeKey
-            if (projections)
-                for (const projection of projections) {
-                    if ([data.hashKey, data.rangeKey, hashKey, rangeKey].includes(projection))
-                        ctx.addIssue({
-                            code: z.ZodIssueCode.custom,
-                            message: 'index projection is an index component, hash key, or range key',
-                            path: [
-                                'entities',
-                                entityToken,
-                                'indexes',
-                                indexKey,
-                                'projections',
-                            ],
-                        });
-                }
-        }
+    }
+    // validate entities
+    for (const [entityToken, { timestampProperty, uniqueProperty },] of Object.entries(data.entities)) {
+        // validate timestampProperty is a transcoded property.
+        if (!transcodedProperties.includes(timestampProperty))
+            ctx.addIssue({
+                code: z.ZodIssueCode.invalid_enum_value,
+                options: transcodedProperties,
+                path: ['entities', entityToken, 'timestampProperty'],
+                received: timestampProperty,
+            });
+        // validate uniqueProperty is a transcoded property.
+        if (!transcodedProperties.includes(uniqueProperty))
+            ctx.addIssue({
+                code: z.ZodIssueCode.invalid_enum_value,
+                options: transcodedProperties,
+                path: ['entities', entityToken, 'uniqueProperty'],
+                received: uniqueProperty,
+            });
     }
 });
 

package/dist/mjs/addKeys.js

@@ -5,11 +5,11 @@ import { updateItemRangeKey } from './updateItemRangeKey.js';
 import { validateEntityToken } from './validateEntityToken.js';
 
 /**
- * Update generated properties, hash key, and range key on an {@link ItemMap | `ItemMap`} object.
+ * Update generated properties, hash key, and range key on an {@link EntityItem | `EntityItem`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
- * @param item - {@link ItemMap | `ItemMap`} object.
+ * @param entityToken - {@link ConfigEntity.uniqueProperty | `this.config.entities`} key.
+ * @param item - {@link EntityItem | `EntityItem`} object.
  * @param overwrite - Overwrite existing properties (default `false`).
  *
  * @returns Shallow clone of `item` with updated properties.
@@ -25,10 +25,10 @@ function addKeys(entityManager, entityToken, item, overwrite = false) {
         // Update range key.
         newItem = updateItemRangeKey(entityManager, entityToken, newItem, overwrite);
         // Update generated properties.
-        for (const property in entityManager.config.entities[entityToken]
-            .generated) {
+        const { sharded, unsharded } = entityManager.config.generatedProperties;
+        for (const property in { ...sharded, ...unsharded }) {
             if (overwrite || isNil(item[property])) {
-                const encoded = encodeGeneratedProperty(entityManager, entityToken, property, newItem);
+                const encoded = encodeGeneratedProperty(entityManager, property, newItem);
                 if (encoded)
                     Object.assign(newItem, { [property]: encoded });
                 else

package/dist/{cjs/decodeEntityElement.js → mjs/decodeElement.js}

@@ -1,16 +1,13 @@
-'use strict';
-
-var validateEntityToken = require('./validateEntityToken.js');
+import { validateTranscodedProperty } from './validateTranscodedProperty.js';
 
 /**
- * Decode an {@link Entity | `Entity`} generated property element or ungenerated index component using the associated {@link Transcodes | Transcodes} `encode` function.
+ * Decode 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 value - Encoded entity element.
  *
@@ -18,17 +15,15 @@ var validateEntityToken = require('./validateEntityToken.js');
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function decodeEntityElement(entityManager, entityToken, element, value) {
+function decodeElement(entityManager, element, value) {
     try {
-        validateEntityToken.validateEntityToken(entityManager, entityToken);
-        const { entities, hashKey, rangeKey, transcodes } = entityManager.config;
+        // Validate params.
+        validateTranscodedProperty(entityManager, element);
         if (!value)
             return;
-        if ([hashKey, rangeKey].includes(element))
-            return value;
-        const decoded = transcodes[entities[entityToken].elementTranscodes[element]].decode(value);
+        const { propertyTranscodes, transcodes } = entityManager.config;
+        const decoded = transcodes[propertyTranscodes[element]].decode(value);
         entityManager.logger.debug('decoded entity element', {
-            entityToken,
             element,
             value,
             decoded,
@@ -38,7 +33,6 @@ function decodeEntityElement(entityManager, entityToken, element, value) {
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                entityToken,
                 element,
                 value,
             });
@@ -46,4 +40,4 @@ function decodeEntityElement(entityManager, entityToken, element, value) {
     }
 }
 
-exports.decodeEntityElement = decodeEntityElement;
+export { decodeElement };

package/dist/mjs/decodeGeneratedProperty.js

@@ -1,23 +1,20 @@
 import { objectify } from 'radash';
-import { decodeEntityElement } from './decodeEntityElement.js';
-import { validateEntityToken } from './validateEntityToken.js';
+import { decodeElement } from './decodeElement.js';
 
 /**
- * Decode a generated property value. Returns a partial ItemMap.
+ * Decode a generated property value. Returns an {@link EntityItem | `EntityItem`}.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
  * @param entityToken - `entityManager.config.entities` key.
  * @param encoded - Encoded generated property value.
  *
- * @returns Partial {@link ItemMap | `ItemMap`} object with updated properties decoded from `encoded`.
+ * @returns {@link EntityItem | `EntityItem`} object with updated properties decoded from `encoded`.
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function decodeGeneratedProperty(entityManager, entityToken, encoded) {
+function decodeGeneratedProperty(entityManager, encoded) {
     try {
         const { generatedKeyDelimiter, generatedValueDelimiter, hashKey, shardKeyDelimiter, } = entityManager.config;
-        // Validate params.
-        validateEntityToken(entityManager, entityToken);
         // Handle degenerate case.
         if (!encoded)
             return {};
@@ -35,9 +32,8 @@ function decodeGeneratedProperty(entityManager, entityToken, encoded) {
             return pair;
         });
         // Assign decoded properties.
-        Object.assign(decoded, objectify(values, ([key]) => key, ([key, value]) => decodeEntityElement(entityManager, entityToken, key, value)));
+        Object.assign(decoded, objectify(values, ([key]) => key, ([key, value]) => decodeElement(entityManager, key, value)));
         entityManager.logger.debug('decoded generated property', {
-            entityToken,
             encoded,
             decoded,
         });
@@ -45,7 +41,7 @@ function decodeGeneratedProperty(entityManager, entityToken, encoded) {
     }
     catch (error) {
         if (error instanceof Error)
-            entityManager.logger.error(error.message, { entityToken, encoded });
+            entityManager.logger.error(error.message, { encoded });
         throw error;
     }
 }

package/dist/mjs/dehydrateIndexItem.js

@@ -1,9 +1,10 @@
-import { encodeEntityElement } from './encodeEntityElement.js';
+import { encodeElement } from './encodeElement.js';
 import { unwrapIndex } from './unwrapIndex.js';
-import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { validateEntityToken } from './validateEntityToken.js';
+import { validateIndexToken } from './validateIndexToken.js';
 
 /**
- * Condense a partial {@link ItemMap | `ItemMap`} object into a delimited string representing the deduped, sorted, ungenerated component elements of an {@link ConfigEntity.indexes | Entity index}.
+ * Condense an {@link EntityItem | `EntityItem`} into a delimited string representing the deduped, sorted, ungenerated component elements of an {@link Config.indexes | index}, leaving out those of the index hash key.
  *
  * @remarks
  * Reverses {@link EntityManager.rehydrateIndexItem | `rehydrateIndexItem`}.
@@ -16,31 +17,31 @@ import { validateEntityIndexToken } from './validateEntityIndexToken.js';
  * `item` must be populated with all required index component elements!
  *
  * @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 item - Partial {@link ItemMap | `ItemMap`} object.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.indexes`} key.
+ * @param item - {@link EntityItem | `EntityItem`} object.
  *
  * @returns Dehydrated index value.
  *
- * @throws `Error` if `entityToken` is invalid.
  * @throws `Error` if `indexToken` is invalid.
  */
 function dehydrateIndexItem(entityManager, entityToken, indexToken, item) {
     try {
-        const { generatedKeyDelimiter } = entityManager.config;
         // Validate params.
-        validateEntityIndexToken(entityManager, entityToken, indexToken);
+        validateEntityToken(entityManager, entityToken);
+        validateIndexToken(entityManager, indexToken);
         // Handle degenerate case.
         if (!item)
             return '';
         // Unwrap index elements.
-        const { hashKey } = entityManager.config.entities[entityToken].indexes[indexToken];
+        const { hashKey } = entityManager.config.indexes[indexToken];
         const elements = unwrapIndex(entityManager, entityToken, indexToken, [
             hashKey,
         ]);
         // Join index element values.
+        const { generatedKeyDelimiter } = entityManager.config;
         const dehydrated = elements
-            .map((element) => encodeEntityElement(entityManager, entityToken, element, item))
+            .map((element) => encodeElement(entityManager, element, item))
             .join(generatedKeyDelimiter);
         entityManager.logger.debug('dehydrated index', {
             item,