jazz-tools 0.18.4 → 0.18.6

package/dist/{chunk-LHQQZH7I.js → chunk-45VKEOXG.js}

@@ -2677,7 +2677,9 @@ var Profile = class extends CoMap {
 };
 
 // src/tools/coValues/inbox.ts
-import { RawAccount as RawAccount2 } from "cojson";
+import {
+  RawAccount as RawAccount2
+} from "cojson";
 
 // src/tools/lib/id.ts
 function isCoValueId(id) {
@@ -2704,6 +2706,20 @@ function createInboxRoot(account) {
     inviteLink
   };
 }
+var IncrementalFeed = class {
+  constructor(feed) {
+    this.feed = feed;
+    this.sessions = {};
+  }
+  getNewItems() {
+    const items = this.feed.getValidTransactions({
+      ignorePrivateTransactions: false,
+      from: this.sessions
+    });
+    this.sessions = this.feed.knownState().sessions;
+    return items;
+  }
+};
 async function createInboxMessage(payload, inboxOwner) {
   const group = payload.$jazz.raw.group;
   if (group instanceof RawAccount2) {
@@ -2720,108 +2736,133 @@ async function createInboxMessage(payload, inboxOwner) {
   await message.core.waitForSync();
   return message;
 }
+var MessageQueue = class {
+  constructor(concurrencyLimit = 10, processMessage, handleError) {
+    this.processMessage = processMessage;
+    this.handleError = handleError;
+    this.queue = [];
+    this.processing = /* @__PURE__ */ new Set();
+    this.activeCount = 0;
+    this.concurrencyLimit = concurrencyLimit;
+  }
+  enqueue(txKey, messageId) {
+    this.queue.push({ txKey, messageId });
+    this.processNext();
+  }
+  async processNext() {
+    if (this.activeCount >= this.concurrencyLimit || this.queue.length === 0) {
+      return;
+    }
+    const { txKey, messageId } = this.queue.shift();
+    if (this.processing.has(txKey)) {
+      this.processNext();
+      return;
+    }
+    this.processing.add(txKey);
+    this.activeCount++;
+    try {
+      await this.processMessage(txKey, messageId);
+    } catch (error) {
+      this.handleError(txKey, messageId, error);
+    } finally {
+      this.processing.delete(txKey);
+      this.activeCount--;
+      this.processNext();
+    }
+  }
+};
 var Inbox = class _Inbox {
   constructor(account, root, messages, processed, failed) {
-    this.processing = /* @__PURE__ */ new Set();
     this.account = account;
     this.root = root;
     this.messages = messages;
     this.processed = processed;
     this.failed = failed;
   }
-  subscribe(Schema4, callback, options = {}) {
+  subscribe(Schema4, callback, options) {
     const processed = /* @__PURE__ */ new Set();
-    const failed = /* @__PURE__ */ new Map();
     const node = this.account.$jazz.localNode;
-    this.processed.subscribe((stream) => {
-      for (const items of Object.values(stream.items)) {
-        for (const item of items) {
-          processed.add(item.value);
-        }
+    const concurrencyLimit = options?.concurrencyLimit ?? 10;
+    const processedFeed = new IncrementalFeed(this.processed.core);
+    this.processed.subscribe(() => {
+      for (const { changes } of processedFeed.getNewItems()) {
+        processed.add(changes[0]);
       }
     });
     const { account } = this;
-    const { retries = 3 } = options;
-    let failTimer = void 0;
-    const clearFailTimer = () => {
-      clearTimeout(failTimer);
-      failTimer = void 0;
+    const messagesFeed = new IncrementalFeed(this.messages.core);
+    const processMessage = async (txKey, messageId) => {
+      const message = await node.load(messageId);
+      if (message === "unavailable") {
+        throw new Error(`Inbox: message ${messageId} is unavailable`);
+      }
+      const value = await loadCoValue(
+        coValueClassFromCoValueClassOrSchema(Schema4),
+        message.get("payload"),
+        {
+          loadAs: account
+        }
+      );
+      if (!value) {
+        throw new Error(
+          `Inbox: Unable to load the payload of message ${messageId}`
+        );
+      }
+      const accountID = getAccountIDfromSessionID(
+        txKey.split("/")[0]
+      );
+      if (!accountID) {
+        throw new Error(`Inbox: Unknown account for message ${messageId}`);
+      }
+      const result = await callback(value, accountID);
+      const inboxMessage = node.expectCoValueLoaded(messageId).getCurrentContent();
+      if (result) {
+        inboxMessage.set("result", result.$jazz.id);
+      }
+      inboxMessage.set("processed", true);
+      this.processed.push(txKey);
+    };
+    const handleError = (txKey, messageId, error) => {
+      console.error(error);
+      const stringifiedError = String(error);
+      this.processed.push(txKey);
+      this.failed.push({ errors: [stringifiedError], value: messageId });
+      try {
+        const inboxMessage = node.expectCoValueLoaded(messageId).getCurrentContent();
+        inboxMessage.set("error", stringifiedError);
+        inboxMessage.set("processed", true);
+      } catch (error2) {
+      }
     };
-    const handleNewMessages = (stream) => {
-      clearFailTimer();
-      for (const [sessionID, items] of Object.entries(stream.items)) {
-        const accountID = getAccountIDfromSessionID(sessionID);
+    const messageQueue = new MessageQueue(
+      concurrencyLimit,
+      processMessage,
+      handleError
+    );
+    const handleNewMessages = () => {
+      for (const tx of messagesFeed.getNewItems()) {
+        const accountID = getAccountIDfromSessionID(tx.txID.sessionID);
         if (!accountID) {
-          console.warn("Received message from unknown account", sessionID);
+          console.warn(
+            "Received message from unknown account",
+            tx.txID.sessionID
+          );
           continue;
         }
-        for (const item of items) {
-          const txKey = `${sessionID}/${item.tx.txIndex}`;
-          if (!processed.has(txKey) && !this.processing.has(txKey)) {
-            this.processing.add(txKey);
-            const id = item.value;
-            node.load(id).then((message) => {
-              if (message === "unavailable") {
-                return Promise.reject(
-                  new Error("Unable to load inbox message " + id)
-                );
-              }
-              return loadCoValue(
-                coValueClassFromCoValueClassOrSchema(Schema4),
-                message.get("payload"),
-                {
-                  loadAs: account
-                }
-              );
-            }).then((value) => {
-              if (!value) {
-                return Promise.reject(
-                  new Error("Unable to load inbox message " + id)
-                );
-              }
-              return callback(value, accountID);
-            }).then((result) => {
-              const inboxMessage = node.expectCoValueLoaded(item.value).getCurrentContent();
-              if (result) {
-                inboxMessage.set("result", result.$jazz.id);
-              }
-              inboxMessage.set("processed", true);
-              this.processed.push(txKey);
-              this.processing.delete(txKey);
-            }).catch((error) => {
-              console.error("Error processing inbox message", error);
-              this.processing.delete(txKey);
-              const errors = failed.get(txKey) ?? [];
-              const stringifiedError = String(error);
-              errors.push(stringifiedError);
-              let inboxMessage;
-              try {
-                inboxMessage = node.expectCoValueLoaded(item.value).getCurrentContent();
-                inboxMessage.set("error", stringifiedError);
-              } catch (error2) {
-              }
-              if (errors.length > retries) {
-                inboxMessage?.set("processed", true);
-                this.processed.push(txKey);
-                this.failed.push({ errors, value: item.value });
-              } else {
-                failed.set(txKey, errors);
-                if (!failTimer) {
-                  failTimer = setTimeout(
-                    () => handleNewMessages(stream),
-                    100
-                  );
-                }
-              }
-            });
-          }
+        const id = tx.changes[0];
+        if (!isCoValueId(id)) {
+          continue;
+        }
+        const txKey = `${tx.txID.sessionID}/${tx.txID.txIndex}`;
+        if (processed.has(txKey)) {
+          continue;
         }
+        messageQueue.enqueue(txKey, id);
       }
     };
     const unsubscribe = this.messages.subscribe(handleNewMessages);
     return () => {
       unsubscribe();
-      clearFailTimer();
     };
   }
   static async load(account) {
@@ -2845,6 +2886,7 @@ var Inbox = class _Inbox {
     if (messages === "unavailable" || processed === "unavailable" || failed === "unavailable") {
       throw new Error("Inbox not found");
     }
+    await processed.core.waitForFullStreaming();
     return new _Inbox(account, root, messages, processed, failed);
   }
 };
@@ -5816,4 +5858,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-LHQQZH7I.js.map
+//# sourceMappingURL=chunk-45VKEOXG.js.map