@karmaniverous/entity-manager 6.13.3 → 6.14.1

package/dist/cjs/{ParsedConfig.js → EntityManager/ParsedConfig.js}

@@ -10,7 +10,7 @@ const validateArrayUnique = (arr, ctx, identity = (item) => item, path = []) =>
     for (const [element, count] of Object.entries(counts)) {
         if (count > 1)
             ctx.addIssue({
-                code: zod.z.ZodIssueCode.custom,
+                code: 'custom',
                 message: `duplicate array element`,
                 params: { element },
                 path,
@@ -21,7 +21,7 @@ const validateKeysExclusive = (keys, label, ref, ctx) => {
     const intersection = keys.filter((key) => ref.includes(key));
     if (intersection.length)
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: `${label} key collision: ${intersection.toString()}`,
         });
 };
@@ -32,26 +32,14 @@ const componentArray = zod.z
 const configSchema = zod.z
     .object({
     entities: zod.z
-        .record(zod.z
+        .record(zod.z.string(), zod.z
         .object({
-        defaultLimit: zod.z
-            .number()
-            .int()
-            .positive()
-            .safe()
-            .optional()
-            .default(10),
-        defaultPageSize: zod.z
-            .number()
-            .int()
-            .positive()
-            .safe()
-            .optional()
-            .default(10),
+        defaultLimit: zod.z.number().int().positive().optional().default(10),
+        defaultPageSize: zod.z.number().int().positive().optional().default(10),
         shardBumps: zod.z
             .array(zod.z
             .object({
-            timestamp: zod.z.number().nonnegative().safe(),
+            timestamp: zod.z.number().int().nonnegative(),
             charBits: zod.z.number().int().min(1).max(5),
             chars: zod.z.number().int().min(0).max(40),
         })
@@ -79,7 +67,7 @@ const configSchema = zod.z
                 for (let i = 1; i < val.length; i++)
                     if (val[i].chars <= val[i - 1].chars)
                         ctx.addIssue({
-                            code: zod.z.ZodIssueCode.custom,
+                            code: 'custom',
                             message: `shardBump chars do not monotonically increase at timestamp ${val[i].timestamp.toString()}`,
                             path: [i],
                         });
@@ -93,14 +81,14 @@ const configSchema = zod.z
         .default({}),
     generatedProperties: zod.z
         .object({
-        sharded: zod.z.record(componentArray).optional().default({}),
-        unsharded: zod.z.record(componentArray).optional().default({}),
+        sharded: zod.z.record(zod.z.string(), componentArray).optional().default({}),
+        unsharded: zod.z.record(zod.z.string(), componentArray).optional().default({}),
     })
         .optional()
         .default({ sharded: {}, unsharded: {} }),
     hashKey: zod.z.string(),
     indexes: zod.z
-        .record(zod.z.object({
+        .record(zod.z.string(), zod.z.object({
         hashKey: zod.z.string().min(1),
         rangeKey: zod.z.string().min(1),
         projections: zod.z
@@ -112,15 +100,18 @@ const configSchema = zod.z
         .default({}),
     generatedKeyDelimiter: zod.z.string().regex(/\W+/).optional().default('|'),
     generatedValueDelimiter: zod.z.string().regex(/\W+/).optional().default('#'),
-    propertyTranscodes: zod.z.record(zod.z.string()).optional().default({}),
+    propertyTranscodes: zod.z.record(zod.z.string(), zod.z.string()).optional().default({}),
     rangeKey: zod.z.string(),
     shardKeyDelimiter: zod.z.string().regex(/\W+/).optional().default('!'),
-    throttle: zod.z.number().int().positive().safe().optional().default(10),
+    throttle: zod.z.number().int().positive().optional().default(10),
     transcodes: zod.z
-        .record(zod.z
+        .record(zod.z.string(), zod.z
         .object({
-        encode: zod.z.function().args(zod.z.any()).returns(zod.z.string()),
-        decode: zod.z.function().args(zod.z.string()).returns(zod.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: zod.z.custom((fn) => typeof fn === 'function'),
+        decode: zod.z.custom((fn) => typeof fn === 'function'),
     })
         .strict())
         .optional()
@@ -131,7 +122,7 @@ const configSchema = zod.z
     // validate no generated key delimiter collision
     if (data.generatedKeyDelimiter.includes(data.generatedValueDelimiter))
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedKeyDelimiter contains generatedValueDelimiter',
             params: {
                 generatedKeyDelimiter: data.generatedKeyDelimiter,
@@ -141,7 +132,7 @@ const configSchema = zod.z
         });
     if (data.generatedKeyDelimiter.includes(data.shardKeyDelimiter))
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedKeyDelimiter contains shardKeyDelimiter',
             params: {
                 generatedKeyDelimiter: data.generatedKeyDelimiter,
@@ -152,7 +143,7 @@ const configSchema = zod.z
     // validate no generated value delimiter collision
     if (data.generatedValueDelimiter.includes(data.generatedKeyDelimiter))
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedValueDelimiter contains generatedKeyDelimiter',
             params: {
                 generatedValueDelimiter: data.generatedValueDelimiter,
@@ -162,7 +153,7 @@ const configSchema = zod.z
         });
     if (data.generatedValueDelimiter.includes(data.shardKeyDelimiter))
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'generatedValueDelimiter contains shardKeyDelimiter',
             params: {
                 generatedValueDelimiter: data.generatedValueDelimiter,
@@ -173,7 +164,7 @@ const configSchema = zod.z
     // validate no shard key delimiter collision
     if (data.shardKeyDelimiter.includes(data.generatedKeyDelimiter))
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'shardKeyDelimiter contains generatedKeyDelimiter',
             params: {
                 generatedKeyDelimiter: data.generatedKeyDelimiter,
@@ -183,7 +174,7 @@ const configSchema = zod.z
         });
     if (data.shardKeyDelimiter.includes(data.generatedValueDelimiter))
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'shardKeyDelimiter contains generatedValueDelimiter',
             params: {
                 generatedValueDelimiter: data.generatedValueDelimiter,
@@ -213,19 +204,17 @@ const configSchema = zod.z
     for (const [property, transcode] of Object.entries(data.propertyTranscodes))
         if (!transcodes.includes(transcode))
             ctx.addIssue({
-                code: zod.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: zod.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.
@@ -233,9 +222,8 @@ const configSchema = zod.z
         for (const element of elements)
             if (!transcodedProperties.includes(element))
                 ctx.addIssue({
-                    code: zod.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.
@@ -244,19 +232,24 @@ const configSchema = zod.z
         // Validate hash key is sharded.
         if (![data.hashKey, ...shardedKeys].includes(hashKey)) {
             ctx.addIssue({
-                code: zod.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: zod.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.
@@ -271,7 +264,7 @@ const configSchema = zod.z
                     ...unshardedKeys,
                 ].includes(projection))
                     ctx.addIssue({
-                        code: zod.z.ZodIssueCode.custom,
+                        code: 'custom',
                         message: 'index projection is a key',
                         params: { projection },
                         path: ['indexes', indexKey, 'projections'],
@@ -282,18 +275,16 @@ const configSchema = zod.z
         // validate timestampProperty is a transcoded property.
         if (!transcodedProperties.includes(timestampProperty))
             ctx.addIssue({
-                code: zod.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: zod.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/cjs/{addKeys.js → EntityManager/addKeys.js}

@@ -34,6 +34,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/cjs/{decodeElement.js → EntityManager/decodeElement.js}

@@ -24,7 +24,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/cjs/{dehydratePageKeyMap.js → EntityManager/dehydratePageKeyMap.js}

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

package/dist/cjs/{encodeElement.js → EntityManager/encodeElement.js}

@@ -21,8 +21,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,

package/dist/cjs/{encodeGeneratedProperty.js → EntityManager/encodeGeneratedProperty.js}

@@ -30,7 +30,7 @@ function encodeGeneratedProperty(entityManager, property, item) {
             ...(sharded
                 ? [item[entityManager.config.hashKey]]
                 : []),
-            ...elementMap.map(([element, value]) => [element, (value ?? '').toString()].join(entityManager.config.generatedValueDelimiter)),
+            ...elementMap.map(([element, value]) => [element, `${value ?? ''}`].join(entityManager.config.generatedValueDelimiter)),
         ].join(entityManager.config.generatedKeyDelimiter);
         entityManager.logger.debug('encoded generated property', {
             property,

package/dist/cjs/EntityManager/getPrimaryKey.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var radash = require('radash');
+var addKeys = require('./addKeys.js');
+
+/**
+ * Convert an {@link EntityItem | `EntityItem`} into an {@link EntityKey | `EntityKey`}.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link Config | `Config`} `entities` key.
+ * @param item - {@link EntityItem | `EntityItem`} object.
+ * @param overwrite - Overwrite existing properties (default `false`).
+ *
+ * @returns {@link EntityKey | `EntityKey`} extracted from shallow clone of `item` with updated properties.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function getPrimaryKey(entityManager, entityToken, item, overwrite = false) {
+    const { hashKey, rangeKey } = entityManager.config;
+    return radash.pick(!overwrite && item[hashKey] && item[rangeKey]
+        ? item
+        : addKeys.addKeys(entityManager, entityToken, item, overwrite), [entityManager.config.hashKey, entityManager.config.rangeKey]);
+}
+
+exports.getPrimaryKey = getPrimaryKey;

package/dist/cjs/{rehydratePageKeyMap.js → 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/{removeKeys.js → 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/{updateItemHashKey.js → 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/cjs/index.js

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