dynamodb-reactive 0.2.2 → 0.2.3

package/dist/server.cjs

@@ -2074,7 +2074,7 @@ async function mapWithConcurrency(values, concurrency, mapper) {
   await Promise.all(workers);
   return results;
 }
-function extractRecordAffectedKeys(record) {
+async function processRecord(record, utils) {
   const tableName = extractTableName(record);
   if (!tableName || !record.dynamodb) {
     throw new Error("Malformed DynamoDB stream record");
@@ -2085,84 +2085,53 @@ function extractRecordAffectedKeys(record) {
     const item = utilDynamodb.unmarshall(image);
     for (const key of extractAffectedKeys(tableName, item)) affectedKeys.add(key);
   }
-  return affectedKeys;
-}
-function subscriptionKey(subscription) {
-  return JSON.stringify([
-    subscription.connectionId,
-    subscription.subscriptionId
-  ]);
-}
-function failureIdentifier(record, cause) {
-  const itemIdentifier = record.dynamodb?.SequenceNumber;
-  if (!itemIdentifier) {
-    throw new Error("Failed DynamoDB stream record has no sequence number", {
-      cause
-    });
-  }
-  return itemIdentifier;
-}
-async function processStreamEvent(event, utils) {
-  const failures = /* @__PURE__ */ new Map();
-  const dependencies = /* @__PURE__ */ new Map();
-  for (const [recordIndex, record] of event.Records.entries()) {
-    try {
-      for (const dependencyKey of extractRecordAffectedKeys(record)) {
-        const recordIndexes = dependencies.get(dependencyKey) ?? /* @__PURE__ */ new Set();
-        recordIndexes.add(recordIndex);
-        dependencies.set(dependencyKey, recordIndexes);
-      }
-    } catch (error2) {
-      error("[stream] Record dependency extraction failed:", error2);
-      failures.set(recordIndex, error2);
-    }
-  }
   const subscriptions = /* @__PURE__ */ new Map();
-  await mapWithConcurrency(
-    [...dependencies],
+  const lookupResults = await mapWithConcurrency(
+    [...affectedKeys],
     MAX_FANOUT_CONCURRENCY,
-    async ([dependencyKey, recordIndexes]) => {
-      try {
-        const affectedSubscriptions = await utils.findAffectedSubscriptions(dependencyKey);
-        for (const subscription of affectedSubscriptions) {
-          const key = subscriptionKey(subscription);
-          const work = subscriptions.get(key) ?? {
-            ...subscription,
-            recordIndexes: /* @__PURE__ */ new Set()
-          };
-          for (const recordIndex of recordIndexes) {
-            work.recordIndexes.add(recordIndex);
-          }
-          subscriptions.set(key, work);
-        }
-      } catch (error2) {
-        error("[stream] Subscription dependency lookup failed:", error2);
-        for (const recordIndex of recordIndexes) {
-          failures.set(recordIndex, error2);
-        }
-      }
-    }
+    (key) => utils.findAffectedSubscriptions(key)
   );
+  for (const result of lookupResults) {
+    for (const subscription of result) {
+      subscriptions.set(
+        `${subscription.connectionId}\0${subscription.subscriptionId}`,
+        subscription
+      );
+    }
+  }
   await mapWithConcurrency(
     [...subscriptions.values()],
     MAX_FANOUT_CONCURRENCY,
-    async ({ connectionId, subscriptionId, recordIndexes }) => {
+    ({ connectionId, subscriptionId }) => utils.processSubscription(connectionId, subscriptionId)
+  );
+}
+async function processStreamEvent(event, utils) {
+  const results = await mapWithConcurrency(
+    event.Records,
+    MAX_FANOUT_CONCURRENCY,
+    async (record) => {
       try {
-        await utils.processSubscription(connectionId, subscriptionId);
+        await processRecord(record, utils);
+        return null;
       } catch (error2) {
-        error("[stream] Subscription refresh failed:", error2);
-        for (const recordIndex of recordIndexes) {
-          failures.set(recordIndex, error2);
+        error("[stream] Record failed:", error2);
+        const itemIdentifier = record.dynamodb?.SequenceNumber;
+        if (!itemIdentifier) {
+          throw new Error(
+            "Failed DynamoDB stream record has no sequence number",
+            { cause: error2 }
+          );
         }
+        return {
+          itemIdentifier
+        };
       }
     }
   );
   return {
-    batchItemFailures: event.Records.flatMap((record, recordIndex) => {
-      if (!failures.has(recordIndex)) return [];
-      const cause = failures.get(recordIndex);
-      return [{ itemIdentifier: failureIdentifier(record, cause) }];
-    })
+    batchItemFailures: results.filter(
+      (failure) => failure !== null
+    )
   };
 }
 function clients(config) {