@karmaniverous/entity-manager 6.5.0 → 6.6.0

package/dist/cjs/EntityManager.js

@@ -44,29 +44,29 @@ class EntityManager {
     /**
      * Update generated properties, hash key, and range key on an {@link ItemMap | `ItemMap`} object.
      *
-     * @param item - {@link ItemMap | `ItemMap`} object.
      * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+     * @param item - {@link ItemMap | `ItemMap`} object.
      * @param overwrite - Overwrite existing properties (default `false`).
      *
      * @returns Shallow clone of `item` with updated properties.
      *
      * @throws `Error` if `entityToken` is invalid.
      */
-    addKeys(item, entityToken, overwrite = false) {
-        return addKeys.addKeys(this, item, entityToken, overwrite);
+    addKeys(entityToken, item, overwrite = false) {
+        return addKeys.addKeys(this, entityToken, item, overwrite);
     }
     /**
      * Strips generated properties, hash key, and range key from an {@link ItemMap | `ItemMap`} object.
      *
-     * @param item - {@link ItemMap | `ItemMap`} object.
      * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+     * @param item - {@link ItemMap | `ItemMap`} object.
      *
      * @returns Shallow clone of `item` without generated properties, hash key or range key.
      *
      * @throws `Error` if `entityToken` is invalid.
      */
-    removeKeys(item, entityToken) {
-        return removeKeys.removeKeys(this, item, entityToken);
+    removeKeys(entityToken, item) {
+        return removeKeys.removeKeys(this, entityToken, item);
     }
     /**
      * Query a database entity across shards in a provider-generic fashion.

package/dist/cjs/ParsedConfig.js

@@ -59,7 +59,8 @@ const configSchema = zod.z
         elementTranscodes: zod.z.record(zod.z.string()).optional().default({}),
         indexes: zod.z
             .record(zod.z.object({
-            components: componentArray,
+            hashKey: zod.z.string().min(1),
+            rangeKey: zod.z.string().min(1),
             projections: componentArray.optional(),
         }))
             .optional()
@@ -212,9 +213,23 @@ const configSchema = zod.z
                     });
         // validate indexes.
         const generatedProperties = Object.keys(entity.generated);
-        for (const [indexKey, index] of Object.entries(entity.indexes)) {
+        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: zod.z.ZodIssueCode.custom,
+                    message: 'index hash key is not sharded',
+                    path: ['entities', entityToken, 'indexes', indexKey, 'hashKey'],
+                });
+            // validate index range key is unsharded
+            if (rangeKey !== data.rangeKey && entity.generated[rangeKey]?.sharded)
+                ctx.addIssue({
+                    code: zod.z.ZodIssueCode.custom,
+                    message: 'index range key is sharded',
+                    path: ['entities', entityToken, 'indexes', indexKey, 'rangeKey'],
+                });
             // validate all ungenerated entity index components have a corresponding entity element type
-            for (const component of index.components)
+            for (const component of [hashKey, rangeKey])
                 if (![data.hashKey, data.rangeKey, ...generatedProperties].includes(component) &&
                     !typedElements.includes(component))
                     ctx.addIssue({
@@ -230,9 +245,9 @@ const configSchema = zod.z
                         received: component,
                     });
             // validate no index projections are index components, hashKey, or rangeKey
-            if (index.projections)
-                for (const projection of index.projections) {
-                    if ([data.hashKey, data.rangeKey, ...index.components].includes(projection))
+            if (projections)
+                for (const projection of projections) {
+                    if ([data.hashKey, data.rangeKey, hashKey, rangeKey].includes(projection))
                         ctx.addIssue({
                             code: zod.z.ZodIssueCode.custom,
                             message: 'index projection is an index component, hash key, or range key',

package/dist/cjs/addKeys.js

@@ -10,27 +10,27 @@ var validateEntityToken = require('./validateEntityToken.js');
  * Update generated properties, hash key, and range key on an {@link ItemMap | `ItemMap`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param item - {@link ItemMap | `ItemMap`} object.
  * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param item - {@link ItemMap | `ItemMap`} object.
  * @param overwrite - Overwrite existing properties (default `false`).
  *
  * @returns Shallow clone of `item` with updated properties.
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function addKeys(entityManager, item, entityToken, overwrite = false) {
+function addKeys(entityManager, entityToken, item, overwrite = false) {
     try {
         // Validate params.
         validateEntityToken.validateEntityToken(entityManager, entityToken);
         // Update hash key.
-        let newItem = updateItemHashKey.updateItemHashKey(entityManager, item, entityToken, overwrite);
+        let newItem = updateItemHashKey.updateItemHashKey(entityManager, entityToken, item, overwrite);
         // Update range key.
-        newItem = updateItemRangeKey.updateItemRangeKey(entityManager, newItem, entityToken, overwrite);
+        newItem = updateItemRangeKey.updateItemRangeKey(entityManager, entityToken, newItem, overwrite);
         // Update generated properties.
         for (const property in entityManager.config.entities[entityToken]
             .generated) {
             if (overwrite || entityTools.isNil(item[property])) {
-                const encoded = encodeGeneratedProperty.encodeGeneratedProperty(entityManager, newItem, entityToken, property);
+                const encoded = encodeGeneratedProperty.encodeGeneratedProperty(entityManager, entityToken, property, newItem);
                 if (encoded)
                     Object.assign(newItem, { [property]: encoded });
                 else

package/dist/cjs/decodeEntityElement.js

@@ -10,15 +10,15 @@ var validateEntityToken = require('./validateEntityToken.js');
  * 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 item - Partial {@link ItemMap | `ItemMap`} object.
  * @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.
  *
  * @returns Decoded value.
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function decodeEntityElement(entityManager, value, entityToken, element) {
+function decodeEntityElement(entityManager, entityToken, element, value) {
     try {
         validateEntityToken.validateEntityToken(entityManager, entityToken);
         const { entities, hashKey, rangeKey, transcodes } = entityManager.config;
@@ -28,9 +28,9 @@ function decodeEntityElement(entityManager, value, entityToken, element) {
             return value;
         const decoded = transcodes[entities[entityToken].elementTranscodes[element]].decode(value);
         entityManager.logger.debug('decoded entity element', {
-            value,
             entityToken,
             element,
+            value,
             decoded,
         });
         return decoded;
@@ -38,9 +38,9 @@ function decodeEntityElement(entityManager, value, entityToken, element) {
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                value,
                 entityToken,
                 element,
+                value,
             });
         throw error;
     }

package/dist/cjs/decodeGeneratedProperty.js

@@ -8,14 +8,14 @@ var validateEntityToken = require('./validateEntityToken.js');
  * Decode a generated property value. Returns a partial ItemMap.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param encoded - Encoded generated property value.
  * @param entityToken - `entityManager.config.entities` key.
+ * @param encoded - Encoded generated property value.
  *
  * @returns Partial {@link ItemMap | `ItemMap`} object with updated properties decoded from `encoded`.
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function decodeGeneratedProperty(entityManager, encoded, entityToken) {
+function decodeGeneratedProperty(entityManager, entityToken, encoded) {
     try {
         const { generatedKeyDelimiter, generatedValueDelimiter, hashKey, shardKeyDelimiter, } = entityManager.config;
         // Validate params.
@@ -37,17 +37,17 @@ function decodeGeneratedProperty(entityManager, encoded, entityToken) {
             return pair;
         });
         // Assign decoded properties.
-        Object.assign(decoded, radash.objectify(values, ([key]) => key, ([key, value]) => decodeEntityElement.decodeEntityElement(entityManager, value, entityToken, key)));
+        Object.assign(decoded, radash.objectify(values, ([key]) => key, ([key, value]) => decodeEntityElement.decodeEntityElement(entityManager, entityToken, key, value)));
         entityManager.logger.debug('decoded generated property', {
-            encoded,
             entityToken,
+            encoded,
             decoded,
         });
         return decoded;
     }
     catch (error) {
         if (error instanceof Error)
-            entityManager.logger.error(error.message, { encoded, entityToken });
+            entityManager.logger.error(error.message, { entityToken, encoded });
         throw error;
     }
 }

package/dist/cjs/dehydrateIndexItem.js

@@ -18,9 +18,9 @@ var validateEntityIndexToken = require('./validateEntityIndexToken.js');
  * `item` must be populated with all required index component elements!
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param item - Partial {@link ItemMap | `ItemMap`} object.
  * @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 omit - Array of index components to omit from the output value.
  *
  * @returns Dehydrated index value.
@@ -28,7 +28,7 @@ var validateEntityIndexToken = require('./validateEntityIndexToken.js');
  * @throws `Error` if `entityToken` is invalid.
  * @throws `Error` if `indexToken` is invalid.
  */
-function dehydrateIndexItem(entityManager, item, entityToken, indexToken, omit = []) {
+function dehydrateIndexItem(entityManager, entityToken, indexToken, item, omit = []) {
     try {
         const { generatedKeyDelimiter } = entityManager.config;
         // Validate params.
@@ -40,7 +40,7 @@ function dehydrateIndexItem(entityManager, item, entityToken, indexToken, omit =
         const elements = unwrapIndex.unwrapIndex(entityManager, entityToken, indexToken).filter((element) => !omit.includes(element));
         // Join index element values.
         const dehydrated = elements
-            .map((element) => encodeEntityElement.encodeEntityElement(entityManager, item, entityToken, element))
+            .map((element) => encodeEntityElement.encodeEntityElement(entityManager, entityToken, element, item))
             .join(generatedKeyDelimiter);
         entityManager.logger.debug('dehydrated index', {
             item,

package/dist/cjs/dehydratePageKeyMap.js

@@ -11,8 +11,8 @@ var validateEntityToken = require('./validateEntityToken.js');
  * Reverses {@link EntityManager.rehydratePageKeyMap | `rehydratePageKeyMap`}.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param pageKeyMap - {@link PageKeyMap | `PageKeyMap`} object to dehydrate.
  * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param pageKeyMap - {@link PageKeyMap | `PageKeyMap`} object to dehydrate.
  *
  * @returns  Array of dehydrated page keys.
  *
@@ -24,7 +24,7 @@ var validateEntityToken = require('./validateEntityToken.js');
  *
  * An empty returned array indicates all page keys are `undefined`.
  */
-function dehydratePageKeyMap(entityManager, pageKeyMap, entityToken) {
+function dehydratePageKeyMap(entityManager, entityToken, pageKeyMap) {
     try {
         // Validate params.
         validateEntityToken.validateEntityToken(entityManager, entityToken);
@@ -32,8 +32,8 @@ function dehydratePageKeyMap(entityManager, pageKeyMap, entityToken) {
         if (!Object.keys(pageKeyMap).length) {
             const dehydrated = [];
             entityManager.logger.debug('dehydrated empty page key map', {
-                pageKeyMap,
                 entityToken,
+                pageKeyMap,
                 dehydrated,
             });
             return dehydrated;
@@ -56,13 +56,13 @@ function dehydratePageKeyMap(entityManager, pageKeyMap, entityToken) {
                 const item = Object.entries(pageKeyMap[index][hashKey]).reduce((item, [property, value]) => {
                     if (property in entityManager.config.entities[entityToken].generated ||
                         property === entityManager.config.rangeKey)
-                        Object.assign(item, decodeGeneratedProperty.decodeGeneratedProperty(entityManager, value, entityToken));
+                        Object.assign(item, decodeGeneratedProperty.decodeGeneratedProperty(entityManager, entityToken, value));
                     else
                         Object.assign(item, { [property]: value });
                     return item;
                 }, {});
                 // Dehydrate index from item.
-                dehydrated.push(dehydrateIndexItem.dehydrateIndexItem(entityManager, item, entityToken, index, [
+                dehydrated.push(dehydrateIndexItem.dehydrateIndexItem(entityManager, entityToken, index, item, [
                     entityManager.config.hashKey,
                 ]));
             }
@@ -71,8 +71,8 @@ function dehydratePageKeyMap(entityManager, pageKeyMap, entityToken) {
         if (dehydrated.every((pageKey) => pageKey === ''))
             dehydrated = [];
         entityManager.logger.debug('dehydrated page key map', {
-            pageKeyMap,
             entityToken,
+            pageKeyMap,
             indexes,
             hashKeys,
             dehydrated,

package/dist/cjs/encodeEntityElement.js

@@ -10,15 +10,15 @@ var validateEntityToken = require('./validateEntityToken.js');
  * 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 item - Partial {@link ItemMap | `ItemMap`} object.
  * @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.
  *
  * @returns Encoded value.
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function encodeEntityElement(entityManager, item, entityToken, element) {
+function encodeEntityElement(entityManager, entityToken, element, item) {
     try {
         validateEntityToken.validateEntityToken(entityManager, entityToken);
         const { entities, hashKey, rangeKey, transcodes } = entityManager.config;
@@ -27,16 +27,16 @@ function encodeEntityElement(entityManager, item, entityToken, element) {
             return value;
         const encoded = transcodes[entities[entityToken].elementTranscodes[element]].encode(item[element]) || undefined;
         entityManager.logger.debug('encoded entity element', {
-            item,
             entityToken,
             element,
+            item,
             encoded,
         });
         return encoded;
     }
     catch (error) {
         if (error instanceof Error)
-            entityManager.logger.error(error.message, { item, entityToken, element });
+            entityManager.logger.error(error.message, { entityToken, element, item });
         throw error;
     }
 }

package/dist/cjs/encodeGeneratedProperty.js

@@ -7,16 +7,16 @@ var validateEntityGeneratedProperty = require('./validateEntityGeneratedProperty
  * Encode a generated property value. Returns a string or undefined if atomicity requirement not met.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param item - Partial {@link ItemMap | `ItemMap`} object.
  * @param entityToken - `entityManager.config.entities` key.
  * @param property - {@link ConfigEntityGenerated | `entityManager.config.entities.<entityToken>.generated`} 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.
  */
-function encodeGeneratedProperty(entityManager, item, entityToken, property) {
+function encodeGeneratedProperty(entityManager, entityToken, property, item) {
     try {
         // Validate params.
         validateEntityGeneratedProperty.validateEntityGeneratedProperty(entityManager, entityToken, property);
@@ -35,9 +35,9 @@ function encodeGeneratedProperty(entityManager, item, entityToken, property) {
             ...elementMap.map(([element, value]) => [element, (value ?? '').toString()].join(entityManager.config.generatedValueDelimiter)),
         ].join(entityManager.config.generatedKeyDelimiter);
         entityManager.logger.debug('encoded generated property', {
-            item,
             entityToken,
             property,
+            item,
             encoded,
         });
         return encoded;
@@ -45,9 +45,9 @@ function encodeGeneratedProperty(entityManager, item, entityToken, property) {
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                item,
                 entityToken,
                 property,
+                item,
             });
         throw error;
     }

package/dist/cjs/getIndexComponents.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var radash = require('radash');
+var validateEntityIndexToken = require('./validateEntityIndexToken.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.
+ *
+ * @returns Array of index components.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `indexToken` is invalid.
+ */
+function getIndexComponents(entityManager, entityToken, indexToken) {
+    validateEntityIndexToken.validateEntityIndexToken(entityManager, entityToken, indexToken);
+    const { hashKey, rangeKey, entities } = entityManager.config;
+    const { hashKey: indexHashKey, rangeKey: indexRangeKey } = entities[entityToken].indexes[indexToken];
+    return radash.unique([hashKey, rangeKey, indexHashKey, indexRangeKey]);
+}
+
+exports.getIndexComponents = getIndexComponents;

package/dist/cjs/query.js

@@ -40,9 +40,9 @@ async function query(entityManager, { entityToken, hashKey, limit, pageKeyMap, p
         if (!(radash.isInt(pageSize) && pageSize >= 1))
             throw new Error('pageSize must be a positive integer');
         // Rehydrate pageKeyMap.
-        const rehydratedPageKeyMap = rehydratePageKeyMap.rehydratePageKeyMap(entityManager, pageKeyMap
+        const rehydratedPageKeyMap = rehydratePageKeyMap.rehydratePageKeyMap(entityManager, entityToken, Object.keys(shardQueryMap), pageKeyMap
             ? JSON.parse(decompressFromEncodedURIComponent(pageKeyMap))
-            : undefined, entityToken, Object.keys(shardQueryMap), timestampFrom, timestampTo);
+            : undefined, timestampFrom, timestampTo);
         // Shortcut if pageKeyMap is empty.
         if (!Object.keys(rehydratedPageKeyMap).length)
             return {
@@ -90,7 +90,7 @@ async function query(entityManager, { entityToken, hashKey, limit, pageKeyMap, p
         const result = {
             count: workingResult.items.length,
             items: workingResult.items,
-            pageKeyMap: compressToEncodedURIComponent(JSON.stringify(dehydratePageKeyMap.dehydratePageKeyMap(entityManager, workingResult.pageKeyMap, entityToken))),
+            pageKeyMap: compressToEncodedURIComponent(JSON.stringify(dehydratePageKeyMap.dehydratePageKeyMap(entityManager, entityToken, workingResult.pageKeyMap))),
         };
         entityManager.logger.debug('queried entityToken across shards', {
             entityToken,

package/dist/cjs/rehydrateIndexItem.js

@@ -14,9 +14,9 @@ var validateEntityIndexToken = require('./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 dehydrated - Dehydrated index value.
  * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
  * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} key.
+ * @param dehydrated - Dehydrated index value.
  * @param omit - Array of index components omitted from `dehydrated`.
  *
  * @returns Partial {@link ItemMap | `ItemMap`} object containing rehydrated index component elements.
@@ -24,7 +24,7 @@ var validateEntityIndexToken = require('./validateEntityIndexToken.js');
  * @throws `Error` if `entityToken` is invalid.
  * @throws `Error` if `indexToken` is invalid.
  */
-function rehydrateIndexItem(entityManager, dehydrated, entityToken, indexToken, omit = []) {
+function rehydrateIndexItem(entityManager, entityToken, indexToken, dehydrated, omit = []) {
     try {
         const { generatedKeyDelimiter } = entityManager.config;
         // Validate params.
@@ -36,11 +36,11 @@ function rehydrateIndexItem(entityManager, dehydrated, entityToken, indexToken,
         if (elements.length !== values.length)
             throw new Error('index rehydration key-value mismatch');
         // Assign values to elements.
-        const rehydrated = radash.shake(radash.zipToObject(elements, values.map((value, i) => decodeEntityElement.decodeEntityElement(entityManager, value, entityToken, elements[i]))));
+        const rehydrated = radash.shake(radash.zipToObject(elements, values.map((value, i) => decodeEntityElement.decodeEntityElement(entityManager, entityToken, elements[i], value))));
         entityManager.logger.debug('rehydrated index', {
-            dehydrated,
             entityToken,
             indexToken,
+            dehydrated,
             elements,
             values,
             rehydrated,
@@ -50,9 +50,9 @@ function rehydrateIndexItem(entityManager, dehydrated, entityToken, indexToken,
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                dehydrated,
                 entityToken,
                 indexToken,
+                dehydrated,
             });
         throw error;
     }

package/dist/cjs/rehydratePageKeyMap.js

@@ -3,6 +3,7 @@
 var radash = require('radash');
 var encodeGeneratedProperty = require('./encodeGeneratedProperty.js');
 var getHashKeySpace = require('./getHashKeySpace.js');
+var getIndexComponents = require('./getIndexComponents.js');
 var rehydrateIndexItem = require('./rehydrateIndexItem.js');
 var updateItemRangeKey = require('./updateItemRangeKey.js');
 var validateEntityIndexToken = require('./validateEntityIndexToken.js');
@@ -13,9 +14,9 @@ var validateEntityIndexToken = require('./validateEntityIndexToken.js');
  * Reverses the {@link EntityManager.dehydratePageKeyMap | `dehydratePageKeyMap`} method.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param dehydrated - Array of dehydrated page keys or undefined if new query.
  * @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 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`.
  * @param timestampTo - Upper timestamp limit used to generate the original {@link PageKeyMap | `PageKeyMap`}. Defaults to `Date.now()`.
  *
@@ -26,7 +27,7 @@ var validateEntityIndexToken = require('./validateEntityIndexToken.js');
  * @throws `Error` if any `indexTokens` are invalid.
  * @throws `Error` if `dehydrated` has invalid length.
  */
-function rehydratePageKeyMap(entityManager, dehydrated, entityToken, indexTokens, timestampFrom = 0, timestampTo = Date.now()) {
+function rehydratePageKeyMap(entityManager, entityToken, indexTokens, dehydrated, timestampFrom = 0, timestampTo = Date.now()) {
     try {
         // Validate params.
         if (!indexTokens.length)
@@ -48,18 +49,17 @@ function rehydratePageKeyMap(entityManager, dehydrated, entityToken, indexTokens
                 return;
             let item = {
                 [entityManager.config.hashKey]: hashKey,
-                ...rehydrateIndexItem.rehydrateIndexItem(entityManager, dehydratedIndexPageKeyMaps[i], entityToken, index, [entityManager.config.hashKey]),
+                ...rehydrateIndexItem.rehydrateIndexItem(entityManager, entityToken, index, dehydratedIndexPageKeyMaps[i], [entityManager.config.hashKey]),
             };
-            item = updateItemRangeKey.updateItemRangeKey(entityManager, item, entityToken);
-            return radash.zipToObject(entityManager.config.entities[entityToken].indexes[index]
-                .components, (component) => entityManager.config.entities[entityToken].generated[component]
-                ? encodeGeneratedProperty.encodeGeneratedProperty(entityManager, item, entityToken, component)
+            item = updateItemRangeKey.updateItemRangeKey(entityManager, entityToken, item);
+            return radash.zipToObject(getIndexComponents.getIndexComponents(entityManager, entityToken, index), (component) => entityManager.config.entities[entityToken].generated[component]
+                ? encodeGeneratedProperty.encodeGeneratedProperty(entityManager, entityToken, component, item)
                 : item[component]);
         }));
         entityManager.logger.debug('rehydrated page key map', {
-            dehydrated,
             entityToken,
             indexTokens,
+            dehydrated,
             rehydrated,
         });
         return rehydrated;
@@ -67,9 +67,9 @@ function rehydratePageKeyMap(entityManager, dehydrated, entityToken, indexTokens
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                dehydrated,
                 entityToken,
                 indexTokens,
+                dehydrated,
             });
         throw error;
     }

package/dist/cjs/removeKeys.js

@@ -6,14 +6,14 @@ var validateEntityToken = require('./validateEntityToken.js');
  * Strips generated properties, hash key, and range key from an {@link ItemMap | `ItemMap`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param item - {@link ItemMap | `ItemMap`} object.
  * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param item - {@link ItemMap | `ItemMap`} object.
  *
  * @returns Shallow clone of `item` without generated properties, hash key or range key.
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function removeKeys(entityManager, item, entityToken) {
+function removeKeys(entityManager, entityToken, item) {
     try {
         // Validate params.
         validateEntityToken.validateEntityToken(entityManager, entityToken);
@@ -25,15 +25,15 @@ function removeKeys(entityManager, item, entityToken) {
         for (const property in entityManager.config.entities[entityToken].generated)
             delete newItem[property];
         entityManager.logger.debug('stripped entity item generated properties', {
-            item,
             entityToken,
+            item,
             newItem,
         });
         return newItem;
     }
     catch (error) {
         if (error instanceof Error)
-            entityManager.logger.error(error.message, { item, entityToken });
+            entityManager.logger.error(error.message, { entityToken, item });
         throw error;
     }
 }

package/dist/cjs/unwrapIndex.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var radash = require('radash');
+var getIndexComponents = require('./getIndexComponents.js');
 var validateEntityIndexToken = require('./validateEntityIndexToken.js');
 
 /**
@@ -21,7 +22,7 @@ function unwrapIndex(entityManager, entityToken, indexToken) {
         validateEntityIndexToken.validateEntityIndexToken(entityManager, entityToken, indexToken);
         const generated = entityManager.config.entities[entityToken].generated;
         const generatedKeys = Object.keys(radash.shake(generated));
-        return entityManager.config.entities[entityToken].indexes[indexToken].components
+        return getIndexComponents.getIndexComponents(entityManager, entityToken, indexToken)
             .map((component) => component === entityManager.config.hashKey
             ? entityManager.config.hashKey
             : component === entityManager.config.rangeKey

package/dist/cjs/updateItemHashKey.js

@@ -9,15 +9,15 @@ var validateEntityToken = require('./validateEntityToken.js');
  * Update the hash key on a partial {@link ItemMap | `ItemMap`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param item - Partial {@link ItemMap | `ItemMap`} object.
  * @param entityToken - {@link ConfigKeys.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`).
  *
  * @returns Shallow clone of `item` with updated hash key.
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function updateItemHashKey(entityManager, item, entityToken, overwrite = false) {
+function updateItemHashKey(entityManager, entityToken, item, overwrite = false) {
     try {
         // Validate params.
         validateEntityToken.validateEntityToken(entityManager, entityToken);
@@ -61,8 +61,8 @@ function updateItemHashKey(entityManager, item, entityToken, overwrite = false)
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                item,
                 entityToken,
+                item,
                 overwrite,
             });
         throw error;

package/dist/cjs/updateItemRangeKey.js

@@ -7,8 +7,8 @@ var validateEntityToken = require('./validateEntityToken.js');
  * Update the range key on a partial {@link ItemMap | `ItemMap`} object.
  *
  * @param entityManager - {@link EntityManager | `EntityManager`} instance.
- * @param item - Partial {@link ItemMap | `ItemMap`} object.
  * @param entityToken - {@link ConfigKeys.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.
@@ -16,15 +16,15 @@ var validateEntityToken = require('./validateEntityToken.js');
  * @throws `Error` if `entityToken` is invalid.
  * @throws `Error` if `item` {@link ConfigEntity.uniqueProperty | `this.config.entities<entityToken>.uniqueProperty`} property value is missing.
  */
-function updateItemRangeKey(entityManager, item, entityToken, overwrite = false) {
+function updateItemRangeKey(entityManager, entityToken, item, overwrite = false) {
     try {
         // Validate params.
         validateEntityToken.validateEntityToken(entityManager, entityToken);
         // Return current item if rangeKey exists and overwrite is false.
         if (item[entityManager.config.rangeKey] && !overwrite) {
             entityManager.logger.debug('did not overwrite existing entity item range key', {
-                item,
                 entityToken,
+                item,
                 overwrite,
             });
             return { ...item };
@@ -51,8 +51,8 @@ function updateItemRangeKey(entityManager, item, entityToken, overwrite = false)
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                item,
                 entityToken,
+                item,
                 overwrite,
             });
         throw error;