@karmaniverous/entity-manager 6.14.0 → 6.14.2

package/dist/cjs/EntityManager/getHashKeySpace.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var radash = require('radash');
+var stringHash = require('string-hash');
 var encodeGeneratedProperty = require('./encodeGeneratedProperty.js');
 var validateGeneratedProperty = require('./validateGeneratedProperty.js');
 
@@ -24,6 +25,9 @@ function getHashKeySpace(entityManager, entityToken, hashKeyToken, item, timesta
         if (hashKeyToken !== entityManager.config.hashKey)
             validateGeneratedProperty.validateGeneratedProperty(entityManager, hashKeyToken, true);
         const { shardBumps } = entityManager.config.entities[entityToken];
+        // Detect presence of the entity's unique property on the item.
+        const uniqueProp = entityManager.config.entities[entityToken].uniqueProperty;
+        const uniqueValue = item[uniqueProp];
         const hashKeySpace = shardBumps
             // Filter shard bumps by timestamp range.
             .filter((bump, i) => (i === shardBumps.length - 1 ||
@@ -32,9 +36,18 @@ function getHashKeySpace(entityManager, entityToken, hashKeyToken, item, timesta
             // Generate shard key space.
             .flatMap(({ charBits, chars }) => {
             const radix = 2 ** charBits;
-            return chars
-                ? [...radash.range(0, radix ** chars - 1)].map((char) => char.toString(radix).padStart(chars, '0'))
-                : '';
+            // If the item's unique property is present, deterministically
+            // compute exactly one shard suffix for this bump. Otherwise,
+            // enumerate the full shard space for the bump.
+            if (chars) {
+                if (uniqueValue) {
+                    const space = radix ** chars;
+                    const mod = stringHash(uniqueValue) % space;
+                    return mod.toString(radix).padStart(chars, '0');
+                }
+                return [...radash.range(0, radix ** chars - 1)].map((char) => char.toString(radix).padStart(chars, '0'));
+            }
+            return '';
         })
             // Map shard keys to hash keys.
             .map((shardKey) => {

package/dist/cjs/EntityManager/rehydratePageKeyMap.js

@@ -47,7 +47,9 @@ function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehy
         if (hashKeys.length > 1)
             throw new Error('inconsistent hashKeys');
         const [hashKeyToken] = hashKeys;
-        indexTokens.map((index) => validateIndexToken.validateIndexToken(entityManager, index));
+        indexTokens.map((index) => {
+            validateIndexToken.validateIndexToken(entityManager, index);
+        });
         // Shortcut empty dehydrated.
         if (dehydrated && !dehydrated.length)
             return [hashKeyToken, {}];

package/dist/cjs/EntityManager/removeKeys.js

@@ -17,14 +17,16 @@ function removeKeys(entityManager, entityToken, item) {
     try {
         // Validate params.
         validateEntityToken.validateEntityToken(entityManager, entityToken);
-        // Delete hash & range keys.
-        const newItem = { ...item };
-        delete newItem[entityManager.config.hashKey];
-        delete newItem[entityManager.config.rangeKey];
-        // Delete generated properties.
-        const { sharded, unsharded } = entityManager.config.generatedProperties;
-        for (const property in { ...sharded, ...unsharded })
-            delete newItem[property];
+        // Build a set of keys to strip (hash, range, and all generated properties).
+        const { hashKey, rangeKey, generatedProperties: { sharded, unsharded }, } = entityManager.config;
+        const keysToStrip = new Set([
+            hashKey,
+            rangeKey,
+            ...Object.keys(sharded),
+            ...Object.keys(unsharded),
+        ]);
+        // Create a shallow copy of item omitting the keys above (no delete operator).
+        const newItem = Object.fromEntries(Object.entries(item).filter(([key]) => !keysToStrip.has(key)));
         entityManager.logger.debug('stripped entity item generated properties', {
             entityToken,
             item,

package/dist/cjs/EntityManager/updateItemHashKey.js

@@ -42,12 +42,15 @@ function updateItemHashKey(entityManager, entityToken, item, overwrite = false)
         if (chars) {
             // Radix is the numerical base of the shardKey.
             const radix = 2 ** charBits;
+            // Compute the full shard space for this bump. Use radix ** chars to ensure
+            // all placeholders are utilized (e.g., chars=2, charBits=2 => 16 combos).
+            const space = radix ** chars;
             // Get item unique property & validate.
             const uniqueId = item[entityManager.config.entities[entityToken]
                 .uniqueProperty];
             if (entityTools.isNil(uniqueId))
                 throw new Error(`missing item unique property`);
-            hashKey += (stringHash(uniqueId.toString()) % (chars * radix))
+            hashKey += (stringHash(uniqueId) % space)
                 .toString(radix)
                 .padStart(chars, '0');
         }

package/dist/index.d.ts

@@ -157,31 +157,15 @@ type EntityRecord<C extends BaseConfigMap> = EntityItem<C> & EntityKey<C>;
  */
 type EntityToken<C extends BaseConfigMap> = keyof Exactify<C['EntityMap']> & string;
 
-declare const configSchema: z.ZodEffects<z.ZodObject<{
+declare const configSchema: z.ZodObject<{
     entities: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         defaultLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         defaultPageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        shardBumps: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        shardBumps: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
             timestamp: z.ZodNumber;
             charBits: z.ZodNumber;
             chars: z.ZodNumber;
-        }, "strict", z.ZodTypeAny, {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }, {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }>, "many">>>, {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[], {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[] | undefined>, {
+        }, z.core.$strict>>>>, z.ZodTransform<{
             timestamp: number;
             charBits: number;
             chars: number;
@@ -189,62 +173,20 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
             timestamp: number;
             charBits: number;
             chars: number;
-        }[] | undefined>, {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[], {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[] | undefined>;
+        }[]>>;
         timestampProperty: z.ZodString;
         uniqueProperty: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        defaultLimit: number;
-        defaultPageSize: number;
-        shardBumps: {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[];
-        timestampProperty: string;
-        uniqueProperty: string;
-    }, {
-        timestampProperty: string;
-        uniqueProperty: string;
-        defaultLimit?: number | undefined;
-        defaultPageSize?: number | undefined;
-        shardBumps?: {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[] | undefined;
-    }>>>>;
+    }, z.core.$strict>>>>;
     generatedProperties: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        sharded: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "atleastone">, [string, ...string[]], [string, ...string[]]>>>>;
-        unsharded: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "atleastone">, [string, ...string[]], [string, ...string[]]>>>>;
-    }, "strip", z.ZodTypeAny, {
-        sharded: Record<string, [string, ...string[]]>;
-        unsharded: Record<string, [string, ...string[]]>;
-    }, {
-        sharded?: Record<string, [string, ...string[]]> | undefined;
-        unsharded?: Record<string, [string, ...string[]]> | undefined;
-    }>>>;
+        sharded: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+        unsharded: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+    }, z.core.$strip>>>;
     hashKey: z.ZodString;
     indexes: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         hashKey: z.ZodString;
         rangeKey: z.ZodString;
-        projections: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
-    }, "strip", z.ZodTypeAny, {
-        hashKey: string;
-        rangeKey: string;
-        projections?: string[] | undefined;
-    }, {
-        hashKey: string;
-        rangeKey: string;
-        projections?: string[] | undefined;
-    }>>>>;
+        projections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>>;
     generatedKeyDelimiter: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     generatedValueDelimiter: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     propertyTranscodes: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
@@ -252,144 +194,10 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     shardKeyDelimiter: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     throttle: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     transcodes: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        encode: z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodString>;
-        decode: z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodAny>;
-    }, "strict", z.ZodTypeAny, {
-        encode: (args_0: any, ...args: unknown[]) => string;
-        decode: (args_0: string, ...args: unknown[]) => any;
-    }, {
-        encode: (args_0: any, ...args: unknown[]) => string;
-        decode: (args_0: string, ...args: unknown[]) => any;
-    }>>>>;
-}, "strict", z.ZodTypeAny, {
-    hashKey: string;
-    rangeKey: string;
-    entities: Record<string, {
-        defaultLimit: number;
-        defaultPageSize: number;
-        shardBumps: {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[];
-        timestampProperty: string;
-        uniqueProperty: string;
-    }>;
-    generatedProperties: {
-        sharded: Record<string, [string, ...string[]]>;
-        unsharded: Record<string, [string, ...string[]]>;
-    };
-    propertyTranscodes: Record<string, string>;
-    transcodes: Record<string, {
-        encode: (args_0: any, ...args: unknown[]) => string;
-        decode: (args_0: string, ...args: unknown[]) => any;
-    }>;
-    indexes: Record<string, {
-        hashKey: string;
-        rangeKey: string;
-        projections?: string[] | undefined;
-    }>;
-    generatedKeyDelimiter: string;
-    generatedValueDelimiter: string;
-    shardKeyDelimiter: string;
-    throttle: number;
-}, {
-    hashKey: string;
-    rangeKey: string;
-    entities?: Record<string, {
-        timestampProperty: string;
-        uniqueProperty: string;
-        defaultLimit?: number | undefined;
-        defaultPageSize?: number | undefined;
-        shardBumps?: {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[] | undefined;
-    }> | undefined;
-    generatedProperties?: {
-        sharded?: Record<string, [string, ...string[]]> | undefined;
-        unsharded?: Record<string, [string, ...string[]]> | undefined;
-    } | undefined;
-    propertyTranscodes?: Record<string, string> | undefined;
-    transcodes?: Record<string, {
-        encode: (args_0: any, ...args: unknown[]) => string;
-        decode: (args_0: string, ...args: unknown[]) => any;
-    }> | undefined;
-    indexes?: Record<string, {
-        hashKey: string;
-        rangeKey: string;
-        projections?: string[] | undefined;
-    }> | undefined;
-    generatedKeyDelimiter?: string | undefined;
-    generatedValueDelimiter?: string | undefined;
-    shardKeyDelimiter?: string | undefined;
-    throttle?: number | undefined;
-}>, {
-    hashKey: string;
-    rangeKey: string;
-    entities: Record<string, {
-        defaultLimit: number;
-        defaultPageSize: number;
-        shardBumps: {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[];
-        timestampProperty: string;
-        uniqueProperty: string;
-    }>;
-    generatedProperties: {
-        sharded: Record<string, [string, ...string[]]>;
-        unsharded: Record<string, [string, ...string[]]>;
-    };
-    propertyTranscodes: Record<string, string>;
-    transcodes: Record<string, {
-        encode: (args_0: any, ...args: unknown[]) => string;
-        decode: (args_0: string, ...args: unknown[]) => any;
-    }>;
-    indexes: Record<string, {
-        hashKey: string;
-        rangeKey: string;
-        projections?: string[] | undefined;
-    }>;
-    generatedKeyDelimiter: string;
-    generatedValueDelimiter: string;
-    shardKeyDelimiter: string;
-    throttle: number;
-}, {
-    hashKey: string;
-    rangeKey: string;
-    entities?: Record<string, {
-        timestampProperty: string;
-        uniqueProperty: string;
-        defaultLimit?: number | undefined;
-        defaultPageSize?: number | undefined;
-        shardBumps?: {
-            timestamp: number;
-            charBits: number;
-            chars: number;
-        }[] | undefined;
-    }> | undefined;
-    generatedProperties?: {
-        sharded?: Record<string, [string, ...string[]]> | undefined;
-        unsharded?: Record<string, [string, ...string[]]> | undefined;
-    } | undefined;
-    propertyTranscodes?: Record<string, string> | undefined;
-    transcodes?: Record<string, {
-        encode: (args_0: any, ...args: unknown[]) => string;
-        decode: (args_0: string, ...args: unknown[]) => any;
-    }> | undefined;
-    indexes?: Record<string, {
-        hashKey: string;
-        rangeKey: string;
-        projections?: string[] | undefined;
-    }> | undefined;
-    generatedKeyDelimiter?: string | undefined;
-    generatedValueDelimiter?: string | undefined;
-    shardKeyDelimiter?: string | undefined;
-    throttle?: number | undefined;
-}>;
+        encode: z.ZodCustom<unknown, unknown>;
+        decode: z.ZodCustom<unknown, unknown>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
 /**
  * Simplified type taken on by a {@link Config | `Config`} object after parsing in the {@link EntityManager | `EntityManager`} constructor.
  *
@@ -612,7 +420,7 @@ declare class EntityManager<C extends BaseConfigMap> {
      * Update generated properties, hash key, and range key on an array of {@link EntityItem | `EntityItem`} objects.
      *
      * @param entityToken - {@link Config | `Config`} `entities` key.
-     * @param items - Array of {@link EntityItem | `EntityItem`} objects.
+     * @param item - Array of {@link EntityItem | `EntityItem`} objects.
      * @param overwrite - Overwrite existing properties (default `false`).
      *
      * @returns An array of {@link EntityRecord | `EntityRecord`} objects with updated properties.
@@ -817,4 +625,5 @@ declare abstract class BaseQueryBuilder<C extends BaseConfigMap, EntityClient ex
     query(options: QueryBuilderQueryOptions<C>): Promise<QueryResult<C>>;
 }
 
-export { type BaseConfigMap, BaseEntityClient, type BaseEntityClientOptions, BaseQueryBuilder, type BaseQueryBuilderOptions, type Config, type ConfigMap, type EntityItem, type EntityKey, EntityManager, type EntityRecord, type EntityToken, type PageKey, type ParsedConfig, type QueryBuilderQueryOptions, type QueryOptions, type QueryResult, type ShardBump, type ShardQueryFunction, type ShardQueryMap, type ShardQueryResult, type ValidateConfigMap, configSchema };
+export { BaseEntityClient, BaseQueryBuilder, EntityManager, configSchema };
+export type { BaseConfigMap, BaseEntityClientOptions, BaseQueryBuilderOptions, Config, ConfigMap, EntityItem, EntityKey, EntityRecord, EntityToken, PageKey, ParsedConfig, QueryBuilderQueryOptions, QueryOptions, QueryResult, ShardBump, ShardQueryFunction, ShardQueryMap, ShardQueryResult, ValidateConfigMap };

package/dist/mjs/EntityManager/ParsedConfig.js

@@ -8,7 +8,7 @@ const validateArrayUnique = (arr, ctx, identity = (item) => item, path = []) =>
     for (const [element, count] of Object.entries(counts)) {
         if (count > 1)
             ctx.addIssue({
-                code: z.ZodIssueCode.custom,
+                code: 'custom',
                 message: `duplicate array element`,
                 params: { element },
                 path,
@@ -19,7 +19,7 @@ const validateKeysExclusive = (keys, label, ref, ctx) => {
     const intersection = keys.filter((key) => ref.includes(key));
     if (intersection.length)
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: `${label} key collision: ${intersection.toString()}`,
         });
 };
@@ -30,26 +30,14 @@ const componentArray = z
 const configSchema = z
     .object({
     entities: z
-        .record(z
+        .record(z.string(), z
         .object({
-        defaultLimit: z
-            .number()
-            .int()
-            .positive()
-            .safe()
-            .optional()
-            .default(10),
-        defaultPageSize: z
-            .number()
-            .int()
-            .positive()
-            .safe()
-            .optional()
-            .default(10),
+        defaultLimit: z.number().int().positive().optional().default(10),
+        defaultPageSize: z.number().int().positive().optional().default(10),
         shardBumps: z
             .array(z
             .object({
-            timestamp: z.number().nonnegative().safe(),
+            timestamp: z.number().int().nonnegative(),
             charBits: z.number().int().min(1).max(5),
             chars: z.number().int().min(0).max(40),
         })
@@ -77,7 +65,7 @@ const configSchema = z
                 for (let i = 1; i < val.length; i++)
                     if (val[i].chars <= val[i - 1].chars)
                         ctx.addIssue({
-                            code: z.ZodIssueCode.custom,
+                            code: 'custom',
                             message: `shardBump chars do not monotonically increase at timestamp ${val[i].timestamp.toString()}`,
                             path: [i],
                         });
@@ -91,14 +79,14 @@ const configSchema = z
         .default({}),
     generatedProperties: z
         .object({
-        sharded: z.record(componentArray).optional().default({}),
-        unsharded: z.record(componentArray).optional().default({}),
+        sharded: z.record(z.string(), componentArray).optional().default({}),
+        unsharded: z.record(z.string(), componentArray).optional().default({}),
     })
         .optional()
         .default({ sharded: {}, unsharded: {} }),
     hashKey: z.string(),
     indexes: z
-        .record(z.object({
+        .record(z.string(), z.object({
         hashKey: z.string().min(1),
         rangeKey: z.string().min(1),
         projections: z
@@ -110,15 +98,18 @@ const configSchema = z
         .default({}),
     generatedKeyDelimiter: z.string().regex(/\W+/).optional().default('|'),
     generatedValueDelimiter: z.string().regex(/\W+/).optional().default('#'),
-    propertyTranscodes: z.record(z.string()).optional().default({}),
+    propertyTranscodes: z.record(z.string(), z.string()).optional().default({}),
     rangeKey: z.string(),
     shardKeyDelimiter: z.string().regex(/\W+/).optional().default('!'),
-    throttle: z.number().int().positive().safe().optional().default(10),
+    throttle: z.number().int().positive().optional().default(10),
     transcodes: z
-        .record(z
+        .record(z.string(), z
         .object({
-        encode: z.function().args(z.any()).returns(z.string()),
-        decode: z.function().args(z.string()).returns(z.any()),
+        // Accept function shapes without relying on z.function()
+        // to avoid TS inference conflicts across Zod versions and
+        // to remain compatible with narrower parameter types.
+        encode: z.custom((fn) => typeof fn === 'function'),
+        decode: z.custom((fn) => typeof fn === 'function'),
     })
         .strict())
         .optional()
@@ -129,7 +120,7 @@ const configSchema = z
     // validate no generated key delimiter collision
     if (data.generatedKeyDelimiter.includes(data.generatedValueDelimiter))
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedKeyDelimiter contains generatedValueDelimiter',
             params: {
                 generatedKeyDelimiter: data.generatedKeyDelimiter,
@@ -139,7 +130,7 @@ const configSchema = z
         });
     if (data.generatedKeyDelimiter.includes(data.shardKeyDelimiter))
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedKeyDelimiter contains shardKeyDelimiter',
             params: {
                 generatedKeyDelimiter: data.generatedKeyDelimiter,
@@ -150,7 +141,7 @@ const configSchema = z
     // validate no generated value delimiter collision
     if (data.generatedValueDelimiter.includes(data.generatedKeyDelimiter))
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedValueDelimiter contains generatedKeyDelimiter',
             params: {
                 generatedValueDelimiter: data.generatedValueDelimiter,
@@ -160,7 +151,7 @@ const configSchema = z
         });
     if (data.generatedValueDelimiter.includes(data.shardKeyDelimiter))
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedValueDelimiter contains shardKeyDelimiter',
             params: {
                 generatedValueDelimiter: data.generatedValueDelimiter,
@@ -171,7 +162,7 @@ const configSchema = z
     // validate no shard key delimiter collision
     if (data.shardKeyDelimiter.includes(data.generatedKeyDelimiter))
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'shardKeyDelimiter contains generatedKeyDelimiter',
             params: {
                 generatedKeyDelimiter: data.generatedKeyDelimiter,
@@ -181,7 +172,7 @@ const configSchema = z
         });
     if (data.shardKeyDelimiter.includes(data.generatedValueDelimiter))
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'shardKeyDelimiter contains generatedValueDelimiter',
             params: {
                 generatedValueDelimiter: data.generatedValueDelimiter,
@@ -211,19 +202,17 @@ const configSchema = z
     for (const [property, transcode] of Object.entries(data.propertyTranscodes))
         if (!transcodes.includes(transcode))
             ctx.addIssue({
-                code: z.ZodIssueCode.invalid_enum_value,
-                options: transcodes,
+                code: 'custom',
+                message: `propertyTranscodes['${property}'] references unknown transcode '${transcode}'`,
                 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: transcodedProperties,
-                    received: element,
+                    code: 'custom',
+                    message: `generatedProperties.sharded['${property}'] contains non-transcoded element '${element}'`,
                     path: ['generatedProperties', 'sharded', property],
                 });
     // Validate all unsharded property elements are transcoded properties.
@@ -231,9 +220,8 @@ const configSchema = z
         for (const element of elements)
             if (!transcodedProperties.includes(element))
                 ctx.addIssue({
-                    code: z.ZodIssueCode.invalid_enum_value,
-                    options: transcodedProperties,
-                    received: element,
+                    code: 'custom',
+                    message: `generatedProperties.unsharded['${property}'] contains non-transcoded element '${element}'`,
                     path: ['generatedProperties', 'unsharded', property],
                 });
     // Validate indexes.
@@ -242,19 +230,24 @@ const configSchema = z
         // Validate hash key is sharded.
         if (![data.hashKey, ...shardedKeys].includes(hashKey)) {
             ctx.addIssue({
-                code: z.ZodIssueCode.invalid_enum_value,
-                options: [data.hashKey, ...shardedKeys],
+                code: 'custom',
+                message: `index '${indexKey}' hashKey '${hashKey}' must be one of [${[
+                    data.hashKey,
+                    ...shardedKeys,
+                ].join(', ')}]`,
                 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],
+                code: 'custom',
+                message: `index '${indexKey}' rangeKey '${rangeKey}' must be one of [${[
+                    data.rangeKey,
+                    ...unshardedKeys,
+                    ...transcodedProperties,
+                ].join(', ')}]`,
                 path: ['indexes', indexKey, 'rangeKey'],
-                received: rangeKey,
             });
         }
         // Validate no index projections are keys.
@@ -269,7 +262,7 @@ const configSchema = z
                     ...unshardedKeys,
                 ].includes(projection))
                     ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
+                        code: 'custom',
                         message: 'index projection is a key',
                         params: { projection },
                         path: ['indexes', indexKey, 'projections'],
@@ -280,18 +273,16 @@ const configSchema = z
         // validate timestampProperty is a transcoded property.
         if (!transcodedProperties.includes(timestampProperty))
             ctx.addIssue({
-                code: z.ZodIssueCode.invalid_enum_value,
-                options: transcodedProperties,
+                code: 'custom',
+                message: `entities['${entityToken}'].timestampProperty '${timestampProperty}' must be one of [${transcodedProperties.join(', ')}]`,
                 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,
+                code: 'custom',
+                message: `entities['${entityToken}'].uniqueProperty '${uniqueProperty}' must be one of [${transcodedProperties.join(', ')}]`,
                 path: ['entities', entityToken, 'uniqueProperty'],
-                received: uniqueProperty,
             });
     }
 });

package/dist/mjs/EntityManager/addKeys.js

@@ -32,6 +32,7 @@ function addKeys(entityManager, entityToken, item, overwrite = false) {
                 if (encoded)
                     Object.assign(newItem, { [property]: encoded });
                 else
+                    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                     delete newItem[property];
             }
         }

package/dist/mjs/EntityManager/decodeElement.js

@@ -22,7 +22,8 @@ function decodeElement(entityManager, element, value) {
         if (!value)
             return;
         const { propertyTranscodes, transcodes } = entityManager.config;
-        const decoded = transcodes[propertyTranscodes[element]].decode(value);
+        const decodeFn = transcodes[propertyTranscodes[element]].decode;
+        const decoded = decodeFn(value);
         entityManager.logger.debug('decoded entity element', {
             element,
             value,

package/dist/mjs/EntityManager/dehydratePageKeyMap.js

@@ -38,7 +38,9 @@ function dehydratePageKeyMap(entityManager, entityToken, pageKeyMap) {
         }
         // Extract, sort & validate indexs.
         const indexes = Object.keys(pageKeyMap).sort();
-        indexes.map((index) => validateIndexToken(entityManager, index));
+        indexes.map((index) => {
+            validateIndexToken(entityManager, index);
+        });
         // Extract & sort hash keys.
         const hashKeys = Object.keys(pageKeyMap[indexes[0]]);
         // Dehydrate page keys.

package/dist/mjs/EntityManager/encodeElement.js

@@ -19,8 +19,8 @@ function encodeElement(entityManager, element, item) {
         const value = item[element];
         if (value === undefined || [hashKey, rangeKey].includes(element))
             return value;
-        const encoded = transcodes[propertyTranscodes[element]].encode(item[element]) ||
-            undefined;
+        const encodeFn = transcodes[propertyTranscodes[element]].encode;
+        const encoded = encodeFn(item[element]) || undefined;
         entityManager.logger.debug('encoded entity element', {
             element,
             item,