dynamodb-reactive 0.2.1 → 0.2.2

package/dist/server.js

@@ -2068,7 +2068,7 @@ async function mapWithConcurrency(values, concurrency, mapper) {
   await Promise.all(workers);
   return results;
 }
-async function processRecord(record, utils) {
+function extractRecordAffectedKeys(record) {
   const tableName = extractTableName(record);
   if (!tableName || !record.dynamodb) {
     throw new Error("Malformed DynamoDB stream record");
@@ -2079,53 +2079,84 @@ async function processRecord(record, utils) {
     const item = unmarshall(image);
     for (const key of extractAffectedKeys(tableName, item)) affectedKeys.add(key);
   }
-  const subscriptions = /* @__PURE__ */ new Map();
-  const lookupResults = await mapWithConcurrency(
-    [...affectedKeys],
-    MAX_FANOUT_CONCURRENCY,
-    (key) => utils.findAffectedSubscriptions(key)
-  );
-  for (const result of lookupResults) {
-    for (const subscription of result) {
-      subscriptions.set(
-        `${subscription.connectionId}\0${subscription.subscriptionId}`,
-        subscription
-      );
+  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(
-    [...subscriptions.values()],
+    [...dependencies],
     MAX_FANOUT_CONCURRENCY,
-    ({ connectionId, subscriptionId }) => utils.processSubscription(connectionId, subscriptionId)
+    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);
+        }
+      }
+    }
   );
-}
-async function processStreamEvent(event, utils) {
-  const results = await mapWithConcurrency(
-    event.Records,
+  await mapWithConcurrency(
+    [...subscriptions.values()],
     MAX_FANOUT_CONCURRENCY,
-    async (record) => {
+    async ({ connectionId, subscriptionId, recordIndexes }) => {
       try {
-        await processRecord(record, utils);
-        return null;
+        await utils.processSubscription(connectionId, subscriptionId);
       } catch (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 }
-          );
+        error("[stream] Subscription refresh failed:", error2);
+        for (const recordIndex of recordIndexes) {
+          failures.set(recordIndex, error2);
         }
-        return {
-          itemIdentifier
-        };
       }
     }
   );
   return {
-    batchItemFailures: results.filter(
-      (failure) => failure !== null
-    )
+    batchItemFailures: event.Records.flatMap((record, recordIndex) => {
+      if (!failures.has(recordIndex)) return [];
+      const cause = failures.get(recordIndex);
+      return [{ itemIdentifier: failureIdentifier(record, cause) }];
+    })
   };
 }
 function clients(config) {