@karmaniverous/entity-manager 6.14.2 → 7.0.0

package/dist/cjs/EntityManager/dehydratePageKeyMap.js

@@ -40,8 +40,8 @@ function dehydratePageKeyMap(entityManager, entityToken, pageKeyMap) {
         }
         // Extract, sort & validate indexs.
         const indexes = Object.keys(pageKeyMap).sort();
-        indexes.map((index) => {
-            validateIndexToken.validateIndexToken(entityManager, index);
+        indexes.map((indexToken) => {
+            validateIndexToken.validateIndexToken(entityManager, indexToken);
         });
         // Extract & sort hash keys.
         const hashKeys = Object.keys(pageKeyMap[indexes[0]]);
@@ -55,11 +55,12 @@ function dehydratePageKeyMap(entityManager, entityToken, pageKeyMap) {
                     continue;
                 }
                 // Compose item from page key
-                const item = Object.entries(pageKeyMap[index][hashKey]).reduce((item, [property, value]) => {
+                const pk = pageKeyMap[index][hashKey];
+                const item = Object.entries(pk).reduce((item, [property, 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));
+                        Object.assign(item, decodeGeneratedProperty.decodeGeneratedProperty(entityManager, entityToken, value));
                     else
                         Object.assign(item, { [property]: value });
                     return item;

package/dist/cjs/EntityManager/getIndexComponents.js

@@ -17,7 +17,12 @@ 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]);
+    return radash.unique([
+        hashKey,
+        rangeKey,
+        indexHashKey,
+        indexRangeKey,
+    ]);
 }
 
 exports.getIndexComponents = getIndexComponents;

package/dist/cjs/EntityManager/getPrimaryKey.js

@@ -1,25 +1,69 @@
 'use strict';
 
-var radash = require('radash');
-var addKeys = require('./addKeys.js');
+var getHashKeySpace = require('./getHashKeySpace.js');
+var updateItemHashKey = require('./updateItemHashKey.js');
+var updateItemRangeKey = require('./updateItemRangeKey.js');
 
 /**
- * Convert an {@link EntityItem | `EntityItem`} into an {@link EntityKey | `EntityKey`}.
+ * Convert an {@link EntityItem | `EntityItem`} into one or more {@link EntityKey | `EntityKey`} values.
+ *
+ * Behavior:
+ * - Always returns an array of keys.
+ * - If `overwrite` is false and the item already has both hash and range keys, returns exactly that pair.
+ * - Otherwise, computes the range key. Then:
+ *   - If the timestampProperty is present, computes exactly one hash key and returns a single key.
+ *   - If the timestampProperty is missing, enumerates the hash-key space across all shard bumps
+ *     (with uniqueProperty present → one suffix per bump) and returns one key per bump.
  *
  * @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.
+ * @returns Array of {@link EntityKey | `EntityKey`} values derived from `item`.
  *
  * @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]);
+    // If both keys are present and we're not overwriting, return the exact pair.
+    if (!overwrite && item[hashKey] && item[rangeKey]) {
+        return [
+            {
+                [hashKey]: item[hashKey],
+                [rangeKey]: item[rangeKey],
+            },
+        ];
+    }
+    // Compute/refresh the range key (throws if uniqueProperty missing).
+    const withRangeKey = updateItemRangeKey.updateItemRangeKey(entityManager, entityToken, item, true);
+    // If timestamp present, compute exactly one hash key and return single pair.
+    const tsProp = entityManager.config.entities[entityToken].timestampProperty;
+    if (withRangeKey[tsProp] !== undefined) {
+        const withHashKey = updateItemHashKey.updateItemHashKey(entityManager, entityToken, withRangeKey, true);
+        return [
+            {
+                [hashKey]: withHashKey[hashKey],
+                [rangeKey]: withHashKey[rangeKey],
+            },
+        ];
+    }
+    // No timestamp: enumerate hash-key space across all shard bumps (0..Infinity).
+    const hashKeys = getHashKeySpace.getHashKeySpace(entityManager, entityToken, hashKey, withRangeKey, 0, Infinity);
+    // Map to keys and de-duplicate.
+    const rk = withRangeKey[rangeKey];
+    const seen = new Set();
+    const keys = hashKeys
+        .map((hk) => {
+        const key = { [hashKey]: hk, [rangeKey]: rk };
+        const sig = `${hk}|${rk}`;
+        if (seen.has(sig))
+            return undefined;
+        seen.add(sig);
+        return key;
+    })
+        .filter((k) => !!k);
+    return keys;
 }
 
 exports.getPrimaryKey = getPrimaryKey;

package/dist/cjs/EntityManager/query.js

@@ -58,17 +58,20 @@ async function query(entityManager, options) {
             // items, which may be >> limit. Probably the way to fix entityManager is to limit the number of shards queried per
             // iteration in order to keep shardsQueried * pageSize > (limit - items.length) but only just.
             // TODO: Test for invalid characters (path delimiters) in index keys & shard key values.
+            // Build typed tasks (indexToken, hashKey, pageKey).
+            const tasks = [];
+            for (const [indexToken, indexPageKeys] of Object.entries(rehydratedPageKeyMap)) {
+                for (const [hashKey, pk] of Object.entries(indexPageKeys)) {
+                    tasks.push([indexToken, hashKey, pk]);
+                }
+            }
             // Query every shard on every index in pageKeyMap.
-            const shardQueryResults = await radash.parallel(throttle, Object.entries(rehydratedPageKeyMap).flatMap(([indexToken, indexPageKeys]) => Object.entries(indexPageKeys).map(([hashKey, pageKey]) => [
-                indexToken,
-                hashKey,
-                pageKey,
-            ])), async ([indexToken, hashKey, pageKey]) => ({
+            const shardQueryResults = await radash.parallel(throttle, tasks, async ([indexToken, hashKey, pageKey]) => ({
                 indexToken,
                 queryResult: await shardQueryMap[indexToken](hashKey, pageKey, pageSize),
                 hashKey,
             }));
-            // Reduce shardQueryResults & updateworkingRresult.
+            // Reduce shardQueryResults & update working result.
             workingResult = shardQueryResults.reduce(({ items, pageKeyMap }, { indexToken, queryResult, hashKey }) => {
                 Object.assign(rehydratedPageKeyMap[indexToken], {
                     [hashKey]: queryResult.pageKey,
@@ -78,12 +81,24 @@ async function query(entityManager, options) {
                     pageKeyMap,
                 };
             }, workingResult);
-        } while (
-        // Repeat while pages remain & limit is not reached.
-        Object.values(workingResult.pageKeyMap).some((indexPageKeys) => Object.values(indexPageKeys).some((pageKey) => pageKey !== undefined)) &&
-            workingResult.items.length < limit);
+            // Repeat while pages remain & limit is not reached.
+            let pagesRemain = false;
+            for (const idx of Object.keys(workingResult.pageKeyMap)) {
+                const inner = workingResult.pageKeyMap[idx];
+                for (const h of Object.keys(inner)) {
+                    if (inner[h] !== undefined) {
+                        pagesRemain = true;
+                        break;
+                    }
+                }
+                if (pagesRemain)
+                    break;
+            }
+            if (!pagesRemain)
+                break;
+        } while (workingResult.items.length < limit);
         // Dedupe & sort working result.
-        workingResult.items = entityTools.sort(radash.unique(workingResult.items, (item) => item[entityManager.config.entities[entityToken]
+        workingResult.items = entityTools.sort(radash.unique(workingResult.items, (i) => i[entityManager.config.entities[entityToken]
             .uniqueProperty].toString()), sortOrder);
         const result = {
             count: workingResult.items.length,

package/dist/cjs/EntityManager/rehydratePageKeyMap.js

@@ -38,7 +38,7 @@ function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehy
         // Validate indexTokens populated.
         if (!indexTokens.length)
             throw new Error('indexTokens empty');
-        // Validate indexTokens exist.
+        // Validate indexTokens exist and capture hashKeys.
         const hashKeys = radash.unique(indexTokens.map((indexToken) => {
             validateIndexToken.validateIndexToken(entityManager, indexToken);
             return entityManager.config.indexes[indexToken].hashKey;
@@ -52,7 +52,10 @@ function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehy
         });
         // Shortcut empty dehydrated.
         if (dehydrated && !dehydrated.length)
-            return [hashKeyToken, {}];
+            return [
+                hashKeyToken,
+                {},
+            ];
         // Get hash key space.
         const hashKeySpace = getHashKeySpace.getHashKeySpace(entityManager, entityToken, hashKeyToken, item, timestampFrom, timestampTo);
         // Default dehydrated.
@@ -68,7 +71,7 @@ function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehy
             if (!dehydratedIndexPageKeyMaps[i])
                 return;
             let pageKeyItem = {
-                ...decodeGeneratedProperty.decodeGeneratedProperty(entityManager, hashKey),
+                ...decodeGeneratedProperty.decodeGeneratedProperty(entityManager, entityToken, hashKey),
                 ...rehydrateIndexItem.rehydrateIndexItem(entityManager, entityToken, index, dehydratedIndexPageKeyMaps[i]),
             };
             pageKeyItem = updateItemRangeKey.updateItemRangeKey(entityManager, entityToken, pageKeyItem);

package/dist/cjs/index.js

@@ -2,6 +2,7 @@
 
 var BaseEntityClient = require('./BaseEntityClient/BaseEntityClient.js');
 var BaseQueryBuilder = require('./BaseQueryBuilder/BaseQueryBuilder.js');
+var createEntityManager = require('./EntityManager/createEntityManager.js');
 var EntityManager = require('./EntityManager/EntityManager.js');
 var ParsedConfig = require('./EntityManager/ParsedConfig.js');
 
@@ -9,5 +10,6 @@ var ParsedConfig = require('./EntityManager/ParsedConfig.js');
 
 exports.BaseEntityClient = BaseEntityClient.BaseEntityClient;
 exports.BaseQueryBuilder = BaseQueryBuilder.BaseQueryBuilder;
+exports.createEntityManager = createEntityManager.createEntityManager;
 exports.EntityManager = EntityManager.EntityManager;
 exports.configSchema = ParsedConfig.configSchema;