chore: buffered request with lane

Author: bang9

packages/uikit-utils/src/sendbird/channel.ts

@@ -22,13 +22,13 @@ export const getGroupChannelChatAvailableState = (channel: SendbirdGroupChannel)
 export const confirmAndMarkAsRead = async (channels: SendbirdBaseChannel[]) => {
   channels
     .filter((it): it is SendbirdGroupChannel => it.isGroupChannel() && it.unreadMessageCount > 0)
-    .forEach((it) => BufferedRequest.markAsRead.push(() => it.markAsRead()));
+    .forEach((it) => BufferedRequest.markAsRead.push(() => it.markAsRead(), it.url));
 };
 
 export const confirmAndMarkAsDelivered = async (channels: SendbirdBaseChannel[]) => {
   channels
     .filter((it): it is SendbirdGroupChannel => it.isGroupChannel() && it.unreadMessageCount > 0)
-    .forEach((it) => BufferedRequest.markAsDelivered.push(() => it.markAsDelivered()));
+    .forEach((it) => BufferedRequest.markAsDelivered.push(() => it.markAsDelivered(), it.url));
 };
 
 export function isDefaultCoverImage(coverUrl: string) {

packages/uikit-utils/src/shared/bufferedRequest.ts

@@ -5,10 +5,21 @@ let REQ_PER_TIMEOUT = 5;
 let TIMEOUT_MILLS = 1000;
 const SAFE_TIMEOUT_BUFFER = 100;
 
+function generateRandomId() {
+  return Math.random().toString(16).slice(2);
+}
+
 export class BufferedRequest {
   public static markAsRead = BufferedRequest.create();
   public static markAsDelivered = BufferedRequest.create();
 
+  public static updateMarkAsReadOptions(reqPerTimeout: number, timeoutMills: number) {
+    BufferedRequest.markAsRead = BufferedRequest.create(reqPerTimeout, timeoutMills);
+  }
+  public static updateMarkAsDeliveredOptions(reqPerTimeout: number, timeoutMills: number) {
+    BufferedRequest.markAsDelivered = BufferedRequest.create(reqPerTimeout, timeoutMills);
+  }
+
   public static get reqPerTimeout() {
     return REQ_PER_TIMEOUT;
   }
@@ -28,28 +39,33 @@ export class BufferedRequest {
   }
 
   public static create(reqPerTimeout = REQ_PER_TIMEOUT, timeoutMills = TIMEOUT_MILLS) {
-    const waitQueue: Func[] = [];
-    const nextQueue: Func[] = [];
+    const waitQueue = new Map<string, Func>();
+    const nextQueue = new Map<string, Func>();
 
     let state: State = 'idle';
     let timeout: NodeJS.Timeout | undefined;
 
     return {
-      push(func: Func) {
-        waitQueue.push(func);
+      push(func: Func, lane?: string) {
+        waitQueue.set(lane ?? generateRandomId(), func);
         this.invoke();
       },
       shift() {
-        if (nextQueue.length < reqPerTimeout) {
-          const nextRemains = Math.min(reqPerTimeout - nextQueue.length, waitQueue.length);
+        if (nextQueue.size < reqPerTimeout) {
+          const nextRemains = Math.min(reqPerTimeout - nextQueue.size, waitQueue.size);
+          const lanes = [...waitQueue.keys()];
           for (let n = 0; n < nextRemains; n++) {
-            const func = waitQueue.shift();
-            if (func) nextQueue.push(func);
+            const lane = lanes[n];
+            const func = waitQueue.get(lane);
+            if (func) {
+              waitQueue.delete(lane);
+              nextQueue.set(lane, func);
+            }
           }
         }
       },
       handleIdle() {
-        if (0 < nextQueue.length) {
+        if (0 < nextQueue.size) {
           state = 'processing';
           this.invoke();
         }
@@ -59,15 +75,21 @@ export class BufferedRequest {
 
         timeout = setTimeout(() => {
           timeout = undefined;
-          if (0 < nextQueue.length || 0 < waitQueue.length) {
+          if (0 < nextQueue.size || 0 < waitQueue.size) {
             this.invoke();
           } else {
             state = 'idle';
           }
         }, timeoutMills + SAFE_TIMEOUT_BUFFER);
 
-        nextQueue.forEach((func) => func());
-        nextQueue.length = 0;
+        nextQueue.forEach(async (func, lane) => {
+          try {
+            await func();
+          } catch (e) {
+            waitQueue.set(lane, func);
+          }
+        });
+        nextQueue.clear();
       },
       async invoke() {
         this.shift();