@karmaniverous/entity-manager 6.7.4 → 6.8.0

package/dist/cjs/dehydratePageKeyMap.js

@@ -2,8 +2,8 @@
 
 var decodeGeneratedProperty = require('./decodeGeneratedProperty.js');
 var dehydrateIndexItem = require('./dehydrateIndexItem.js');
-var validateEntityIndexToken = require('./validateEntityIndexToken.js');
 var validateEntityToken = require('./validateEntityToken.js');
+var validateIndexToken = require('./validateIndexToken.js');
 
 /**
  * Dehydrate a {@link PageKeyMap | `PageKeyMap`} object into an array of dehydrated page keys.
@@ -11,7 +11,7 @@ var validateEntityToken = require('./validateEntityToken.js');
  * Reverses {@link EntityManager.rehydratePageKeyMap | `rehydratePageKeyMap`}.
  *
  * @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 pageKeyMap - {@link PageKeyMap | `PageKeyMap`} object to dehydrate.
  *
  * @returns  Array of dehydrated page keys.
@@ -40,7 +40,7 @@ function dehydratePageKeyMap(entityManager, entityToken, pageKeyMap) {
         }
         // Extract, sort & validate indexs.
         const indexes = Object.keys(pageKeyMap).sort();
-        indexes.map((index) => validateEntityIndexToken.validateEntityIndexToken(entityManager, entityToken, index));
+        indexes.map((index) => validateIndexToken.validateIndexToken(entityManager, index));
         // Extract & sort hash keys.
         const hashKeys = Object.keys(pageKeyMap[indexes[0]]);
         // Dehydrate page keys.
@@ -54,13 +54,16 @@ function dehydratePageKeyMap(entityManager, entityToken, pageKeyMap) {
                 }
                 // Compose item from page key
                 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, entityToken, value));
+                    if (property === entityManager.config.rangeKey ||
+                        property in entityManager.config.generatedProperties.sharded ||
+                        property in entityManager.config.generatedProperties.unsharded)
+                        Object.assign(item, decodeGeneratedProperty.decodeGeneratedProperty(entityManager, value));
                     else
                         Object.assign(item, { [property]: value });
                     return item;
-                }, {});
+                }, 
+                // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
+                {});
                 // Dehydrate index from item.
                 dehydrated.push(dehydrateIndexItem.dehydrateIndexItem(entityManager, entityToken, index, item));
             }

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

@@ -1,14 +1,13 @@
-import { validateEntityToken } from './validateEntityToken.js';
+'use strict';
 
 /**
- * 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.
  *
@@ -16,16 +15,15 @@ import { validateEntityToken } from './validateEntityToken.js';
  *
  * @throws `Error` if `entityToken` is invalid.
  */
-function encodeEntityElement(entityManager, entityToken, element, item) {
+function encodeElement(entityManager, element, item) {
     try {
-        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,
@@ -34,9 +32,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;
     }
 }
 
-export { encodeEntityElement };
+exports.encodeElement = encodeElement;

package/dist/cjs/encodeGeneratedProperty.js

@@ -1,41 +1,41 @@
 'use strict';
 
 var entityTools = require('@karmaniverous/entity-tools');
-var validateEntityGeneratedProperty = require('./validateEntityGeneratedProperty.js');
+var validateGeneratedProperty = require('./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.validateEntityGeneratedProperty(entityManager, entityToken, property);
-        const { atomic, elements, sharded } = entityManager.config.entities[entityToken].generated[property];
+        validateGeneratedProperty.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]) => entityTools.isNil(value)))
+        // Return undefined if sharded & atomicity requirement fails.
+        if (sharded && elementMap.some(([, value]) => entityTools.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,
@@ -45,7 +45,6 @@ function encodeGeneratedProperty(entityManager, entityToken, property, item) {
     catch (error) {
         if (error instanceof Error)
             entityManager.logger.error(error.message, {
-                entityToken,
                 property,
                 item,
             });

package/dist/cjs/getHashKeySpace.js

@@ -2,15 +2,15 @@
 
 var radash = require('radash');
 var encodeGeneratedProperty = require('./encodeGeneratedProperty.js');
-var validateEntityGeneratedProperty = require('./validateEntityGeneratedProperty.js');
+var validateGeneratedProperty = require('./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()`.
  *
@@ -22,7 +22,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.validateEntityGeneratedProperty(entityManager, entityToken, hashKeyToken, true);
+            validateGeneratedProperty.validateGeneratedProperty(entityManager, hashKeyToken, true);
         const { shardBumps } = entityManager.config.entities[entityToken];
         const hashKeySpace = shardBumps
             // Filter shard bumps by timestamp range.
@@ -42,7 +42,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.encodeGeneratedProperty(entityManager, entityToken, hashKeyToken, {
+                hashKey = encodeGeneratedProperty.encodeGeneratedProperty(entityManager, hashKeyToken, {
                     ...item,
                     [entityManager.config.hashKey]: hashKey,
                 });

package/dist/cjs/getIndexComponents.js

@@ -1,24 +1,22 @@
 'use strict';
 
 var radash = require('radash');
-var validateEntityIndexToken = require('./validateEntityIndexToken.js');
+var validateIndexToken = require('./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.validateEntityIndexToken(entityManager, entityToken, indexToken);
-    const { hashKey, rangeKey, entities } = entityManager.config;
-    const { hashKey: indexHashKey, rangeKey: indexRangeKey } = entities[entityToken].indexes[indexToken];
+function getIndexComponents(entityManager, indexToken) {
+    validateIndexToken.validateIndexToken(entityManager, indexToken);
+    const { hashKey, rangeKey, indexes } = entityManager.config;
+    const { hashKey: indexHashKey, rangeKey: indexRangeKey } = indexes[indexToken];
     return radash.unique([hashKey, rangeKey, indexHashKey, indexRangeKey]);
 }
 

package/dist/cjs/getShardBump.js

@@ -6,7 +6,7 @@ var validateEntityToken = require('./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/cjs/index.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var BaseEntityClient = require('./BaseEntityClient.js');
-var BaseShardQueryMapBuilder = require('./BaseShardQueryMapBuilder.js');
+var BaseQueryBuilder = require('./BaseQueryBuilder.js');
 var conditionalize = require('./conditionalize.js');
 var EntityManager = require('./EntityManager.js');
 
 
 
 exports.BaseEntityClient = BaseEntityClient.BaseEntityClient;
-exports.BaseShardQueryMapBuilder = BaseShardQueryMapBuilder.BaseShardQueryMapBuilder;
+exports.BaseQueryBuilder = BaseQueryBuilder.BaseQueryBuilder;
 exports.conditionalize = conditionalize.conditionalize;
 exports.EntityManager = EntityManager.EntityManager;

package/dist/cjs/query.js

@@ -13,7 +13,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/cjs/rehydrateIndexItem.js

@@ -1,12 +1,13 @@
 'use strict';
 
 var radash = require('radash');
-var decodeEntityElement = require('./decodeEntityElement.js');
+var decodeElement = require('./decodeElement.js');
 var unwrapIndex = require('./unwrapIndex.js');
-var validateEntityIndexToken = require('./validateEntityIndexToken.js');
+var validateEntityToken = require('./validateEntityToken.js');
+var validateIndexToken = require('./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`}.
@@ -14,31 +15,32 @@ 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 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.validateEntityIndexToken(entityManager, entityToken, indexToken);
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        validateIndexToken.validateIndexToken(entityManager, indexToken);
         // Unwrap index elements.
-        const { hashKey } = entityManager.config.entities[entityToken].indexes[indexToken];
+        const { hashKey } = entityManager.config.indexes[indexToken];
         const elements = unwrapIndex.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 = radash.shake(radash.zipToObject(elements, values.map((value, i) => decodeEntityElement.decodeEntityElement(entityManager, entityToken, elements[i], value))));
+        const rehydrated = radash.shake(radash.zipToObject(elements, values.map((value, i) => decodeElement.decodeElement(entityManager, elements[i], value))));
         entityManager.logger.debug('rehydrated index', {
             entityToken,
             indexToken,

package/dist/cjs/rehydratePageKeyMap.js

@@ -7,7 +7,8 @@ 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');
+var validateEntityToken = require('./validateEntityToken.js');
+var validateIndexToken = require('./validateIndexToken.js');
 
 /**
  * Rehydrate an array of dehydrated page keys into a {@link PageKeyMap | `PageKeyMap`} object.
@@ -15,8 +16,8 @@ var validateEntityIndexToken = require('./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`.
@@ -32,20 +33,21 @@ var validateEntityIndexToken = require('./validateEntityIndexToken.js');
  */
 function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehydrated, timestampFrom = 0, timestampTo = Date.now()) {
     try {
+        // Validate params.
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
         // Validate indexTokens populated.
         if (!indexTokens.length)
             throw new Error('indexTokens empty');
         // Validate indexTokens exist.
         const hashKeys = radash.unique(indexTokens.map((indexToken) => {
-            validateEntityIndexToken.validateEntityIndexToken(entityManager, entityToken, indexToken);
-            return entityManager.config.entities[entityToken].indexes[indexToken]
-                .hashKey;
+            validateIndexToken.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.validateEntityIndexToken(entityManager, entityToken, index));
+        indexTokens.map((index) => validateIndexToken.validateIndexToken(entityManager, index));
         // Shortcut empty dehydrated.
         if (dehydrated && !dehydrated.length)
             return [hashKeyToken, {}];
@@ -57,17 +59,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 = radash.mapValues(radash.zipToObject(indexTokens, radash.cluster(dehydrated, hashKeySpace.length)), (dehydratedIndexPageKeyMaps, index) => radash.zipToObject(hashKeySpace, (hashKey, i) => {
             if (!dehydratedIndexPageKeyMaps[i])
                 return;
             let pageKeyItem = {
-                ...decodeGeneratedProperty.decodeGeneratedProperty(entityManager, entityToken, hashKey),
+                ...decodeGeneratedProperty.decodeGeneratedProperty(entityManager, hashKey),
                 ...rehydrateIndexItem.rehydrateIndexItem(entityManager, entityToken, index, dehydratedIndexPageKeyMaps[i]),
             };
             pageKeyItem = updateItemRangeKey.updateItemRangeKey(entityManager, entityToken, pageKeyItem);
-            return radash.zipToObject(getIndexComponents.getIndexComponents(entityManager, entityToken, index), (component) => entityManager.config.entities[entityToken].generated[component]
-                ? encodeGeneratedProperty.encodeGeneratedProperty(entityManager, entityToken, component, pageKeyItem)
-                : pageKeyItem[component]);
+            return radash.zipToObject(getIndexComponents.getIndexComponents(entityManager, index), (component) => component === entityManager.config.rangeKey
+                ? [uniqueProperty, pageKeyItem[uniqueProperty]].join(entityManager.config.generatedValueDelimiter)
+                : component in sharded || component in unsharded
+                    ? encodeGeneratedProperty.encodeGeneratedProperty(entityManager, component, pageKeyItem)
+                    : pageKeyItem[component]);
         }));
         entityManager.logger.debug('rehydrated page key map', {
             entityToken,

package/dist/cjs/removeKeys.js

@@ -6,7 +6,7 @@ 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 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.
@@ -22,7 +22,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/cjs/unwrapIndex.js

@@ -2,13 +2,14 @@
 
 var radash = require('radash');
 var getIndexComponents = require('./getIndexComponents.js');
-var validateEntityIndexToken = require('./validateEntityIndexToken.js');
+var validateEntityToken = require('./validateEntityToken.js');
+var validateIndexToken = require('./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.
  *
@@ -20,24 +21,37 @@ var validateEntityIndexToken = require('./validateEntityIndexToken.js');
 function unwrapIndex(entityManager, entityToken, indexToken, omit = []) {
     try {
         // Validate params.
-        validateEntityIndexToken.validateEntityIndexToken(entityManager, entityToken, indexToken);
-        const generated = entityManager.config.entities[entityToken].generated;
-        const generatedKeys = Object.keys(radash.shake(generated));
-        return radash.unique(getIndexComponents.getIndexComponents(entityManager, entityToken, indexToken)
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        validateIndexToken.validateIndexToken(entityManager, indexToken);
+        const { sharded, unsharded } = entityManager.config.generatedProperties;
+        const unwrapped = radash.unique(getIndexComponents.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/cjs/updateItemHashKey.js

@@ -9,7 +9,7 @@ var validateEntityToken = require('./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`).
  *
@@ -22,7 +22,8 @@ function updateItemHashKey(entityManager, entityToken, item, overwrite = false)
         // Validate params.
         validateEntityToken.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,
@@ -31,7 +32,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 (entityTools.isNil(timestamp))
             throw new Error(`missing item timestamp property`);
         // Find first entity sharding bump before timestamp.

package/dist/cjs/updateItemRangeKey.js

@@ -7,21 +7,22 @@ var validateEntityToken = require('./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.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,
@@ -30,7 +31,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 (entityTools.isNil(uniqueProperty))
             throw new Error(`missing item unique property`);
         // Update range key.

package/dist/cjs/validateGeneratedProperty.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * 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`);
+}
+
+exports.validateGeneratedProperty = validateGeneratedProperty;

package/dist/cjs/validateIndexToken.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * 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');
+}
+
+exports.validateIndexToken = validateIndexToken;

package/dist/cjs/validateTranscodedProperty.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * 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');
+}
+
+exports.validateTranscodedProperty = validateTranscodedProperty;