openart-realtime-sdk 1.0.2 → 1.0.3

package/dist/client/index.cjs

@@ -86,77 +86,87 @@ function RealtimeProvider({
       connect();
     }, PING_TIMEOUT_MS);
   }, []);
-  const connect = react.useCallback((opts) => {
-    const { replayEventsSince } = opts ?? { replayEventsSince: Date.now() };
-    const channels = Array.from(getAllNeededChannels());
-    if (channels.length === 0) return;
-    if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
-      console.log("Max reconnection attempts reached.");
-      setStatus("error");
-      return;
-    }
-    if (visibilityTimeoutRef.current) {
-      clearTimeout(visibilityTimeoutRef.current);
-      visibilityTimeoutRef.current = null;
-    }
-    if (eventSourceRef.current) {
-      eventSourceRef.current.close();
-    }
-    setStatus("connecting");
-    try {
-      const channelsParam = channels.map((ch) => `channel=${encodeURIComponent(ch)}`).join("&");
-      const lastAckParam = channels.map((c) => {
-        const lastAck = lastAckRef.current.get(c) ?? String(replayEventsSince);
-        return `last_ack_${encodeURIComponent(c)}=${encodeURIComponent(lastAck)}`;
-      }).join("&");
-      const url = api.url + "?" + channelsParam + "&" + lastAckParam;
-      const eventSource = new EventSource(url, {
-        withCredentials: api.withCredentials ?? false
-      });
-      eventSourceRef.current = eventSource;
-      eventSource.onopen = () => {
-        reconnectAttemptsRef.current = 0;
-        setStatus("connected");
-        resetPingTimeout();
-      };
-      eventSource.onmessage = (evt) => {
-        try {
-          const payload = JSON.parse(evt.data);
+  const connect = react.useCallback(
+    (opts) => {
+      const { replayEventsSince } = opts ?? { replayEventsSince: Date.now() };
+      const channels = Array.from(getAllNeededChannels());
+      if (channels.length === 0) return;
+      if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
+        console.log("Max reconnection attempts reached.");
+        setStatus("error");
+        return;
+      }
+      if (visibilityTimeoutRef.current) {
+        clearTimeout(visibilityTimeoutRef.current);
+        visibilityTimeoutRef.current = null;
+      }
+      if (eventSourceRef.current) {
+        eventSourceRef.current.close();
+      }
+      setStatus("connecting");
+      try {
+        const channelsParam = channels.map((ch) => `channel=${encodeURIComponent(ch)}`).join("&");
+        const lastAckParam = channels.map((c) => {
+          const lastAck = lastAckRef.current.get(c) ?? String(replayEventsSince);
+          return `last_ack_${encodeURIComponent(c)}=${encodeURIComponent(
+            lastAck
+          )}`;
+        }).join("&");
+        const url = api.url + "?" + channelsParam + "&" + lastAckParam;
+        const eventSource = new EventSource(url, {
+          withCredentials: api.withCredentials ?? false
+        });
+        eventSourceRef.current = eventSource;
+        eventSource.onopen = () => {
+          reconnectAttemptsRef.current = 0;
+          setStatus("connected");
           resetPingTimeout();
-          handleMessage(payload);
-          const systemResult = systemEvent.safeParse(payload);
-          if (systemResult.success) {
-            if (systemResult.data.type === "reconnect") {
-              connect({ replayEventsSince: systemResult.data.timestamp });
+        };
+        eventSource.onmessage = (evt) => {
+          try {
+            const payload = JSON.parse(evt.data);
+            resetPingTimeout();
+            handleMessage(payload);
+            const systemResult = systemEvent.safeParse(payload);
+            if (systemResult.success) {
+              if (systemResult.data.type === "reconnect") {
+                connect({ replayEventsSince: systemResult.data.timestamp });
+              }
             }
+          } catch (error) {
+            console.warn("Error parsing message:", error);
           }
-        } catch (error) {
-          console.warn("Error parsing message:", error);
-        }
-      };
-      eventSource.onerror = () => {
-        if (eventSource !== eventSourceRef.current) return;
-        const readyState = eventSourceRef.current?.readyState;
-        if (readyState === EventSource.CONNECTING) return;
-        if (readyState === EventSource.CLOSED) {
-          console.log("Connection closed, reconnecting...");
-        }
-        setStatus("disconnected");
-        if (reconnectAttemptsRef.current < maxReconnectAttempts) {
-          reconnectAttemptsRef.current++;
-          const timeoutMs = Math.min(1e3 * Math.pow(2, reconnectAttemptsRef.current), 3e4);
-          console.log(`Reconnecting in ${timeoutMs}ms... (Attempt ${reconnectAttemptsRef.current})`);
-          reconnectTimeoutRef.current = setTimeout(() => {
-            connect();
-          }, timeoutMs);
-        } else {
-          setStatus("error");
-        }
-      };
-    } catch (error) {
-      setStatus("error");
-    }
-  }, [getAllNeededChannels, maxReconnectAttempts, api.url, api.withCredentials]);
+        };
+        eventSource.onerror = () => {
+          if (eventSource !== eventSourceRef.current) return;
+          const readyState = eventSourceRef.current?.readyState;
+          if (readyState === EventSource.CONNECTING) return;
+          if (readyState === EventSource.CLOSED) {
+            console.log("Connection closed, reconnecting...");
+          }
+          setStatus("disconnected");
+          if (reconnectAttemptsRef.current < maxReconnectAttempts) {
+            reconnectAttemptsRef.current++;
+            const timeoutMs = Math.min(
+              1e3 * Math.pow(2, reconnectAttemptsRef.current),
+              3e4
+            );
+            console.log(
+              `Reconnecting in ${timeoutMs}ms... (Attempt ${reconnectAttemptsRef.current})`
+            );
+            reconnectTimeoutRef.current = setTimeout(() => {
+              connect();
+            }, timeoutMs);
+          } else {
+            setStatus("error");
+          }
+        };
+      } catch (error) {
+        setStatus("error");
+      }
+    },
+    [getAllNeededChannels, maxReconnectAttempts, api.url, api.withCredentials]
+  );
   const debouncedConnect = react.useCallback(() => {
     if (debounceTimeoutRef.current) {
       clearTimeout(debounceTimeoutRef.current);
@@ -173,7 +183,8 @@ function RealtimeProvider({
     if (!disconnectOnWindowHidden || typeof document === "undefined") return;
     const handleVisibilityChange = () => {
       if (document.hidden) {
-        if (visibilityTimeoutRef.current) clearTimeout(visibilityTimeoutRef.current);
+        if (visibilityTimeoutRef.current)
+          clearTimeout(visibilityTimeoutRef.current);
         visibilityTimeoutRef.current = setTimeout(() => {
           console.log("Window hidden for too long, disconnecting...");
           cleanup();
@@ -192,7 +203,8 @@ function RealtimeProvider({
     document.addEventListener("visibilitychange", handleVisibilityChange);
     return () => {
       document.removeEventListener("visibilitychange", handleVisibilityChange);
-      if (visibilityTimeoutRef.current) clearTimeout(visibilityTimeoutRef.current);
+      if (visibilityTimeoutRef.current)
+        clearTimeout(visibilityTimeoutRef.current);
     };
   }, [disconnectOnWindowHidden, disconnectDelay, connect, status]);
   const handleMessage = (payload) => {
@@ -262,7 +274,9 @@ function RealtimeProvider({
 function useRealtimeContext() {
   const context = react.useContext(RealtimeContext);
   if (!context) {
-    throw new Error("useRealtimeContext must be used within a RealtimeProvider");
+    throw new Error(
+      "useRealtimeContext must be used within a RealtimeProvider"
+    );
   }
   return context;
 }
@@ -279,7 +293,9 @@ function useRealtime(opts) {
       "useRealtime: No RealtimeProvider found. Wrap your app in <RealtimeProvider> to use Realtime."
     );
   }
-  const registrationId = react.useRef(Math.random().toString(36).substring(2)).current;
+  const registrationId = react.useRef(
+    Math.random().toString(36).substring(2)
+  ).current;
   const onDataRef = react.useRef(onData);
   onDataRef.current = onData;
   react.useEffect(() => {
@@ -296,7 +312,11 @@ function useRealtime(opts) {
         if (events && events.length > 0 && !events.includes(event)) {
           return;
         }
-        const payload = { event, data, channel };
+        const payload = {
+          event,
+          data,
+          channel
+        };
         onDataRef.current?.(payload);
       }
     });

package/dist/client/index.d.cts

@@ -39,7 +39,7 @@ interface RealtimeProviderProps {
      */
     disconnectDelay?: number;
 }
-declare function RealtimeProvider({ children, api, maxReconnectAttempts, disconnectOnWindowHidden, disconnectDelay }: RealtimeProviderProps): react_jsx_runtime.JSX.Element;
+declare function RealtimeProvider({ children, api, maxReconnectAttempts, disconnectOnWindowHidden, disconnectDelay, }: RealtimeProviderProps): react_jsx_runtime.JSX.Element;
 declare function useRealtimeContext(): RealtimeContextValue;
 declare const createRealtime: <T extends Record<string, unknown>>() => {
     useRealtime: <const E extends EventPaths<T>>(opts: UseRealtimeOpts<T, E>) => {

package/dist/client/index.d.ts

@@ -39,7 +39,7 @@ interface RealtimeProviderProps {
      */
     disconnectDelay?: number;
 }
-declare function RealtimeProvider({ children, api, maxReconnectAttempts, disconnectOnWindowHidden, disconnectDelay }: RealtimeProviderProps): react_jsx_runtime.JSX.Element;
+declare function RealtimeProvider({ children, api, maxReconnectAttempts, disconnectOnWindowHidden, disconnectDelay, }: RealtimeProviderProps): react_jsx_runtime.JSX.Element;
 declare function useRealtimeContext(): RealtimeContextValue;
 declare const createRealtime: <T extends Record<string, unknown>>() => {
     useRealtime: <const E extends EventPaths<T>>(opts: UseRealtimeOpts<T, E>) => {

package/dist/client/index.js

@@ -80,77 +80,87 @@ function RealtimeProvider({
       connect();
     }, PING_TIMEOUT_MS);
   }, []);
-  const connect = useCallback((opts) => {
-    const { replayEventsSince } = opts ?? { replayEventsSince: Date.now() };
-    const channels = Array.from(getAllNeededChannels());
-    if (channels.length === 0) return;
-    if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
-      console.log("Max reconnection attempts reached.");
-      setStatus("error");
-      return;
-    }
-    if (visibilityTimeoutRef.current) {
-      clearTimeout(visibilityTimeoutRef.current);
-      visibilityTimeoutRef.current = null;
-    }
-    if (eventSourceRef.current) {
-      eventSourceRef.current.close();
-    }
-    setStatus("connecting");
-    try {
-      const channelsParam = channels.map((ch) => `channel=${encodeURIComponent(ch)}`).join("&");
-      const lastAckParam = channels.map((c) => {
-        const lastAck = lastAckRef.current.get(c) ?? String(replayEventsSince);
-        return `last_ack_${encodeURIComponent(c)}=${encodeURIComponent(lastAck)}`;
-      }).join("&");
-      const url = api.url + "?" + channelsParam + "&" + lastAckParam;
-      const eventSource = new EventSource(url, {
-        withCredentials: api.withCredentials ?? false
-      });
-      eventSourceRef.current = eventSource;
-      eventSource.onopen = () => {
-        reconnectAttemptsRef.current = 0;
-        setStatus("connected");
-        resetPingTimeout();
-      };
-      eventSource.onmessage = (evt) => {
-        try {
-          const payload = JSON.parse(evt.data);
+  const connect = useCallback(
+    (opts) => {
+      const { replayEventsSince } = opts ?? { replayEventsSince: Date.now() };
+      const channels = Array.from(getAllNeededChannels());
+      if (channels.length === 0) return;
+      if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
+        console.log("Max reconnection attempts reached.");
+        setStatus("error");
+        return;
+      }
+      if (visibilityTimeoutRef.current) {
+        clearTimeout(visibilityTimeoutRef.current);
+        visibilityTimeoutRef.current = null;
+      }
+      if (eventSourceRef.current) {
+        eventSourceRef.current.close();
+      }
+      setStatus("connecting");
+      try {
+        const channelsParam = channels.map((ch) => `channel=${encodeURIComponent(ch)}`).join("&");
+        const lastAckParam = channels.map((c) => {
+          const lastAck = lastAckRef.current.get(c) ?? String(replayEventsSince);
+          return `last_ack_${encodeURIComponent(c)}=${encodeURIComponent(
+            lastAck
+          )}`;
+        }).join("&");
+        const url = api.url + "?" + channelsParam + "&" + lastAckParam;
+        const eventSource = new EventSource(url, {
+          withCredentials: api.withCredentials ?? false
+        });
+        eventSourceRef.current = eventSource;
+        eventSource.onopen = () => {
+          reconnectAttemptsRef.current = 0;
+          setStatus("connected");
           resetPingTimeout();
-          handleMessage(payload);
-          const systemResult = systemEvent.safeParse(payload);
-          if (systemResult.success) {
-            if (systemResult.data.type === "reconnect") {
-              connect({ replayEventsSince: systemResult.data.timestamp });
+        };
+        eventSource.onmessage = (evt) => {
+          try {
+            const payload = JSON.parse(evt.data);
+            resetPingTimeout();
+            handleMessage(payload);
+            const systemResult = systemEvent.safeParse(payload);
+            if (systemResult.success) {
+              if (systemResult.data.type === "reconnect") {
+                connect({ replayEventsSince: systemResult.data.timestamp });
+              }
             }
+          } catch (error) {
+            console.warn("Error parsing message:", error);
           }
-        } catch (error) {
-          console.warn("Error parsing message:", error);
-        }
-      };
-      eventSource.onerror = () => {
-        if (eventSource !== eventSourceRef.current) return;
-        const readyState = eventSourceRef.current?.readyState;
-        if (readyState === EventSource.CONNECTING) return;
-        if (readyState === EventSource.CLOSED) {
-          console.log("Connection closed, reconnecting...");
-        }
-        setStatus("disconnected");
-        if (reconnectAttemptsRef.current < maxReconnectAttempts) {
-          reconnectAttemptsRef.current++;
-          const timeoutMs = Math.min(1e3 * Math.pow(2, reconnectAttemptsRef.current), 3e4);
-          console.log(`Reconnecting in ${timeoutMs}ms... (Attempt ${reconnectAttemptsRef.current})`);
-          reconnectTimeoutRef.current = setTimeout(() => {
-            connect();
-          }, timeoutMs);
-        } else {
-          setStatus("error");
-        }
-      };
-    } catch (error) {
-      setStatus("error");
-    }
-  }, [getAllNeededChannels, maxReconnectAttempts, api.url, api.withCredentials]);
+        };
+        eventSource.onerror = () => {
+          if (eventSource !== eventSourceRef.current) return;
+          const readyState = eventSourceRef.current?.readyState;
+          if (readyState === EventSource.CONNECTING) return;
+          if (readyState === EventSource.CLOSED) {
+            console.log("Connection closed, reconnecting...");
+          }
+          setStatus("disconnected");
+          if (reconnectAttemptsRef.current < maxReconnectAttempts) {
+            reconnectAttemptsRef.current++;
+            const timeoutMs = Math.min(
+              1e3 * Math.pow(2, reconnectAttemptsRef.current),
+              3e4
+            );
+            console.log(
+              `Reconnecting in ${timeoutMs}ms... (Attempt ${reconnectAttemptsRef.current})`
+            );
+            reconnectTimeoutRef.current = setTimeout(() => {
+              connect();
+            }, timeoutMs);
+          } else {
+            setStatus("error");
+          }
+        };
+      } catch (error) {
+        setStatus("error");
+      }
+    },
+    [getAllNeededChannels, maxReconnectAttempts, api.url, api.withCredentials]
+  );
   const debouncedConnect = useCallback(() => {
     if (debounceTimeoutRef.current) {
       clearTimeout(debounceTimeoutRef.current);
@@ -167,7 +177,8 @@ function RealtimeProvider({
     if (!disconnectOnWindowHidden || typeof document === "undefined") return;
     const handleVisibilityChange = () => {
       if (document.hidden) {
-        if (visibilityTimeoutRef.current) clearTimeout(visibilityTimeoutRef.current);
+        if (visibilityTimeoutRef.current)
+          clearTimeout(visibilityTimeoutRef.current);
         visibilityTimeoutRef.current = setTimeout(() => {
           console.log("Window hidden for too long, disconnecting...");
           cleanup();
@@ -186,7 +197,8 @@ function RealtimeProvider({
     document.addEventListener("visibilitychange", handleVisibilityChange);
     return () => {
       document.removeEventListener("visibilitychange", handleVisibilityChange);
-      if (visibilityTimeoutRef.current) clearTimeout(visibilityTimeoutRef.current);
+      if (visibilityTimeoutRef.current)
+        clearTimeout(visibilityTimeoutRef.current);
     };
   }, [disconnectOnWindowHidden, disconnectDelay, connect, status]);
   const handleMessage = (payload) => {
@@ -256,7 +268,9 @@ function RealtimeProvider({
 function useRealtimeContext() {
   const context = useContext(RealtimeContext);
   if (!context) {
-    throw new Error("useRealtimeContext must be used within a RealtimeProvider");
+    throw new Error(
+      "useRealtimeContext must be used within a RealtimeProvider"
+    );
   }
   return context;
 }
@@ -273,7 +287,9 @@ function useRealtime(opts) {
       "useRealtime: No RealtimeProvider found. Wrap your app in <RealtimeProvider> to use Realtime."
     );
   }
-  const registrationId = useRef(Math.random().toString(36).substring(2)).current;
+  const registrationId = useRef(
+    Math.random().toString(36).substring(2)
+  ).current;
   const onDataRef = useRef(onData);
   onDataRef.current = onData;
   useEffect(() => {
@@ -290,7 +306,11 @@ function useRealtime(opts) {
         if (events && events.length > 0 && !events.includes(event)) {
           return;
         }
-        const payload = { event, data, channel };
+        const payload = {
+          event,
+          data,
+          channel
+        };
         onDataRef.current?.(payload);
       }
     });

package/dist/server/index.cjs

@@ -132,6 +132,10 @@ function handle(config) {
         request.signal.addEventListener("abort", handleAbort);
         const safeEnqueue = (data) => {
           if (isClosed) return;
+          if (controller.desiredSize && controller.desiredSize <= 0) {
+            logger.warn?.("\u26A0\uFE0F Client too slow, dropping message to prevent OOM.");
+            return;
+          }
           try {
             controller.enqueue(data);
           } catch (err) {
@@ -152,15 +156,15 @@ function handle(config) {
         let buffer = [];
         let isHistoryReplayed = false;
         const lastHistoryIds = /* @__PURE__ */ new Map();
-        const onManagerMessage = (message) => {
+        const onManagerMessage = (message, encodedMessage) => {
           logger.debug?.("\u2B07\uFE0F  Received event:", message);
           if (!isHistoryReplayed) {
             buffer.push(message);
           } else {
-            safeEnqueue(json(message));
+            safeEnqueue(encodedMessage);
           }
         };
-        const fetchHistory = async () => {
+        const executeHistoryPipeline = async () => {
           const pipeline = redis.pipeline();
           const channelAcks = /* @__PURE__ */ new Map();
           for (const channel of channels) {
@@ -171,36 +175,53 @@ function handle(config) {
             safeEnqueue(json(connectedEvent));
             const lastAck = searchParams.get(`last_ack_${channel}`) ?? String(Date.now());
             channelAcks.set(channel, lastAck);
-            pipeline.xrange(channel, `(${lastAck}`, "+", "COUNT", maxRecoveryLimit);
+            pipeline.xrange(
+              channel,
+              `(${lastAck}`,
+              "+",
+              "COUNT",
+              maxRecoveryLimit
+            );
           }
           try {
-            const results = await pipeline.exec();
-            if (results) {
-              results.forEach((result, index) => {
-                const [err, rawMissing] = result;
-                const channel = channels[index];
-                if (!channel) return;
-                if (err) {
-                  logger.error(`Error fetching history for channel ${channel}:`, err);
-                  return;
-                }
-                const missingMessages = parseStreamResponse(rawMissing);
-                if (missingMessages.length > 0) {
-                  missingMessages.forEach((value) => {
-                    const eventWithId = value;
-                    const event = userEvent.safeParse(eventWithId);
-                    if (event.success) safeEnqueue(json(event.data));
-                  });
-                  lastHistoryIds.set(channel, missingMessages[missingMessages.length - 1]?.id ?? "");
-                }
-              });
-            }
+            return await pipeline.exec();
           } catch (error) {
             logger.error("Error executing history pipeline:", error);
+            return null;
           }
+        };
+        const processHistoryResults = (results) => {
+          if (!results) return;
+          results.forEach((result, index) => {
+            const [err, rawMissing] = result;
+            const channel = channels[index];
+            if (!channel) return;
+            if (err) {
+              logger.error(
+                `Error fetching history for channel ${channel}:`,
+                err
+              );
+              return;
+            }
+            const missingMessages = parseStreamResponse(rawMissing);
+            if (missingMessages.length > 0) {
+              missingMessages.forEach((value) => {
+                const eventWithId = value;
+                const event = userEvent.safeParse(eventWithId);
+                if (event.success) safeEnqueue(json(event.data));
+              });
+              lastHistoryIds.set(
+                channel,
+                missingMessages[missingMessages.length - 1]?.id ?? ""
+              );
+            }
+          });
+        };
+        const flushBuffer = () => {
           for (const msg of buffer) {
             const channelLastId = lastHistoryIds.get(msg.channel);
-            if (channelLastId && compareStreamIds(msg.id, channelLastId) <= 0) continue;
+            if (channelLastId && compareStreamIds(msg.id, channelLastId) <= 0)
+              continue;
             safeEnqueue(json(msg));
           }
           buffer = [];
@@ -208,11 +229,20 @@ function handle(config) {
           logger.info("\u2705 Subscription established:", { channels });
         };
         try {
-          await Promise.all(channels.map(async (channel) => {
-            const unsub = await subscriptionManager.subscribe(channel, onManagerMessage);
-            unsubs.push(unsub);
-          }));
-          await fetchHistory();
+          const [_, historyResults] = await Promise.all([
+            Promise.all(
+              channels.map(async (channel) => {
+                const unsub = await subscriptionManager.subscribe(
+                  channel,
+                  onManagerMessage
+                );
+                unsubs.push(unsub);
+              })
+            ),
+            executeHistoryPipeline()
+          ]);
+          processHistoryResults(historyResults);
+          flushBuffer();
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : "Unknown error";
           logger.error("\u26A0\uFE0F Redis subscriber error:", errorMessage);
@@ -238,8 +268,9 @@ function handle(config) {
     return new StreamingResponse(stream);
   };
 }
+var encoder = new TextEncoder();
 function json(data) {
-  return new TextEncoder().encode(`data: ${JSON.stringify(data)}
+  return encoder.encode(`data: ${JSON.stringify(data)}
 
 `);
 }
@@ -262,17 +293,18 @@ var StreamingResponse = class extends Response {
 };
 
 // src/server/subscription-manager.ts
+var encoder2 = new TextEncoder();
 var SubscriptionManager = class {
   redis;
   subRedis;
   // Map<ChannelName, Set<Listener>>
   listeners = /* @__PURE__ */ new Map();
   unsubscribeTimers = /* @__PURE__ */ new Map();
-  verbose;
-  constructor(redis, verbose = false) {
+  logger;
+  constructor(redis, logger) {
     this.redis = redis;
     this.subRedis = redis.duplicate();
-    this.verbose = verbose;
+    this.logger = logger;
     this.setupMessageListener();
   }
   setupMessageListener() {
@@ -292,34 +324,49 @@ var SubscriptionManager = class {
         }
         const result = userEvent.safeParse(payload);
         if (result.success) {
-          if (this.verbose) {
-            console.log(`[SubscriptionManager] Dispatching message to ${handlers.size} listeners on ${channel}`);
-          }
+          const encodedMessage = encoder2.encode(
+            `data: ${JSON.stringify(result.data)}
+
+`
+          );
+          this.logger.debug?.(
+            `[SubscriptionManager] Dispatching message to ${handlers.size} listeners on ${channel}`
+          );
           handlers.forEach((listener) => {
             try {
-              listener(result.data);
+              listener(result.data, encodedMessage);
             } catch (listenerErr) {
-              console.error(`[SubscriptionManager] Error in listener for ${channel}:`, listenerErr);
+              this.logger.error(
+                `[SubscriptionManager] Error in listener for ${channel}:`,
+                listenerErr
+              );
             }
           });
         }
       } catch (err) {
-        console.error(`[SubscriptionManager] Error processing message on ${channel}:`, err);
+        this.logger.error(
+          `[SubscriptionManager] Error processing message on ${channel}:`,
+          err
+        );
       }
     });
     this.subRedis.on("error", (err) => {
-      console.error("[SubscriptionManager] Redis subscription error:", err);
+      this.logger.error("[SubscriptionManager] Redis subscription error:", err);
     });
   }
   async subscribe(channel, listener) {
     if (this.unsubscribeTimers.has(channel)) {
       clearTimeout(this.unsubscribeTimers.get(channel));
       this.unsubscribeTimers.delete(channel);
-      if (this.verbose) console.log(`[SubscriptionManager] Cancelled pending unsubscribe for: ${channel}`);
+      this.logger.debug?.(
+        `[SubscriptionManager] Cancelled pending unsubscribe for: ${channel}`
+      );
     }
     if (!this.listeners.has(channel)) {
       this.listeners.set(channel, /* @__PURE__ */ new Set());
-      if (this.verbose) console.log(`[SubscriptionManager] Subscribing to Redis channel: ${channel}`);
+      this.logger.debug?.(
+        `[SubscriptionManager] Subscribing to Redis channel: ${channel}`
+      );
       await this.subRedis.subscribe(channel);
     }
     const channelListeners = this.listeners.get(channel);
@@ -335,9 +382,14 @@ var SubscriptionManager = class {
           const timer = setTimeout(() => {
             this.listeners.delete(channel);
             this.unsubscribeTimers.delete(channel);
-            if (this.verbose) console.log(`[SubscriptionManager] Unsubscribing from Redis channel: ${channel}`);
+            this.logger.debug?.(
+              `[SubscriptionManager] Unsubscribing from Redis channel: ${channel}`
+            );
             this.subRedis.unsubscribe(channel).catch((err) => {
-              console.error(`[SubscriptionManager] Error unsubscribing from ${channel}:`, err);
+              this.logger.error(
+                `[SubscriptionManager] Error unsubscribing from ${channel}:`,
+                err
+              );
             });
           }, 2e3);
           this.unsubscribeTimers.set(channel, timer);
@@ -387,7 +439,10 @@ var RealtimeBase = class {
       }
     };
     if (this._redis) {
-      this._subscriptionManager = new SubscriptionManager(this._redis, this._verbose);
+      this._subscriptionManager = new SubscriptionManager(
+        this._redis,
+        this._logger
+      );
     }
     Object.assign(this, this.createEventHandlers("default"));
   }
@@ -400,7 +455,10 @@ var RealtimeBase = class {
     let pingInterval = void 0;
     const startPingInterval = () => {
       pingInterval = setInterval(() => {
-        this._redis?.publish(channel, JSON.stringify({ type: "ping", timestamp: Date.now() }));
+        this._redis?.publish(
+          channel,
+          JSON.stringify({ type: "ping", timestamp: Date.now() })
+        );
       }, 6e4);
     };
     const stopPingInterval = () => {
@@ -412,7 +470,13 @@ var RealtimeBase = class {
       const start = args?.start ? String(args.start) : "-";
       const end = args?.end ? String(args.end) : "+";
       const limit = args?.limit ?? 1e3;
-      const rawHistory = await redis.xrange(channel, start, end, "COUNT", limit);
+      const rawHistory = await redis.xrange(
+        channel,
+        start,
+        end,
+        "COUNT",
+        limit
+      );
       const historyMessages = parseStreamResponse(rawHistory);
       return historyMessages.map((value) => {
         if (typeof value === "object" && value !== null) {
@@ -456,17 +520,26 @@ var RealtimeBase = class {
           const limit = typeof history === "object" ? history.limit : void 0;
           let rawMessages = [];
           if (limit) {
-            rawMessages = await redis.xrange(channel, start, end, "COUNT", limit);
+            rawMessages = await redis.xrange(
+              channel,
+              start,
+              end,
+              "COUNT",
+              limit
+            );
           } else {
             rawMessages = await redis.xrange(channel, start, end);
           }
           const messages = parseStreamResponse(rawMessages);
           for (const message of messages) {
             const typedMessage = message;
-            if (!typedMessage.event || events && !events.includes(typedMessage.event)) continue;
+            if (!typedMessage.event || events && !events.includes(typedMessage.event))
+              continue;
             const result = userEvent.safeParse(message);
             if (result.success) {
-              onData(result.data);
+              onData(
+                result.data
+              );
             }
           }
           if (messages.length > 0) {

package/dist/server/index.js

@@ -107,6 +107,10 @@ function handle(config) {
         request.signal.addEventListener("abort", handleAbort);
         const safeEnqueue = (data) => {
           if (isClosed) return;
+          if (controller.desiredSize && controller.desiredSize <= 0) {
+            logger.warn?.("\u26A0\uFE0F Client too slow, dropping message to prevent OOM.");
+            return;
+          }
           try {
             controller.enqueue(data);
           } catch (err) {
@@ -127,15 +131,15 @@ function handle(config) {
         let buffer = [];
         let isHistoryReplayed = false;
         const lastHistoryIds = /* @__PURE__ */ new Map();
-        const onManagerMessage = (message) => {
+        const onManagerMessage = (message, encodedMessage) => {
           logger.debug?.("\u2B07\uFE0F  Received event:", message);
           if (!isHistoryReplayed) {
             buffer.push(message);
           } else {
-            safeEnqueue(json(message));
+            safeEnqueue(encodedMessage);
           }
         };
-        const fetchHistory = async () => {
+        const executeHistoryPipeline = async () => {
           const pipeline = redis.pipeline();
           const channelAcks = /* @__PURE__ */ new Map();
           for (const channel of channels) {
@@ -146,36 +150,53 @@ function handle(config) {
             safeEnqueue(json(connectedEvent));
             const lastAck = searchParams.get(`last_ack_${channel}`) ?? String(Date.now());
             channelAcks.set(channel, lastAck);
-            pipeline.xrange(channel, `(${lastAck}`, "+", "COUNT", maxRecoveryLimit);
+            pipeline.xrange(
+              channel,
+              `(${lastAck}`,
+              "+",
+              "COUNT",
+              maxRecoveryLimit
+            );
           }
           try {
-            const results = await pipeline.exec();
-            if (results) {
-              results.forEach((result, index) => {
-                const [err, rawMissing] = result;
-                const channel = channels[index];
-                if (!channel) return;
-                if (err) {
-                  logger.error(`Error fetching history for channel ${channel}:`, err);
-                  return;
-                }
-                const missingMessages = parseStreamResponse(rawMissing);
-                if (missingMessages.length > 0) {
-                  missingMessages.forEach((value) => {
-                    const eventWithId = value;
-                    const event = userEvent.safeParse(eventWithId);
-                    if (event.success) safeEnqueue(json(event.data));
-                  });
-                  lastHistoryIds.set(channel, missingMessages[missingMessages.length - 1]?.id ?? "");
-                }
-              });
-            }
+            return await pipeline.exec();
           } catch (error) {
             logger.error("Error executing history pipeline:", error);
+            return null;
           }
+        };
+        const processHistoryResults = (results) => {
+          if (!results) return;
+          results.forEach((result, index) => {
+            const [err, rawMissing] = result;
+            const channel = channels[index];
+            if (!channel) return;
+            if (err) {
+              logger.error(
+                `Error fetching history for channel ${channel}:`,
+                err
+              );
+              return;
+            }
+            const missingMessages = parseStreamResponse(rawMissing);
+            if (missingMessages.length > 0) {
+              missingMessages.forEach((value) => {
+                const eventWithId = value;
+                const event = userEvent.safeParse(eventWithId);
+                if (event.success) safeEnqueue(json(event.data));
+              });
+              lastHistoryIds.set(
+                channel,
+                missingMessages[missingMessages.length - 1]?.id ?? ""
+              );
+            }
+          });
+        };
+        const flushBuffer = () => {
           for (const msg of buffer) {
             const channelLastId = lastHistoryIds.get(msg.channel);
-            if (channelLastId && compareStreamIds(msg.id, channelLastId) <= 0) continue;
+            if (channelLastId && compareStreamIds(msg.id, channelLastId) <= 0)
+              continue;
             safeEnqueue(json(msg));
           }
           buffer = [];
@@ -183,11 +204,20 @@ function handle(config) {
           logger.info("\u2705 Subscription established:", { channels });
         };
         try {
-          await Promise.all(channels.map(async (channel) => {
-            const unsub = await subscriptionManager.subscribe(channel, onManagerMessage);
-            unsubs.push(unsub);
-          }));
-          await fetchHistory();
+          const [_, historyResults] = await Promise.all([
+            Promise.all(
+              channels.map(async (channel) => {
+                const unsub = await subscriptionManager.subscribe(
+                  channel,
+                  onManagerMessage
+                );
+                unsubs.push(unsub);
+              })
+            ),
+            executeHistoryPipeline()
+          ]);
+          processHistoryResults(historyResults);
+          flushBuffer();
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : "Unknown error";
           logger.error("\u26A0\uFE0F Redis subscriber error:", errorMessage);
@@ -213,8 +243,9 @@ function handle(config) {
     return new StreamingResponse(stream);
   };
 }
+var encoder = new TextEncoder();
 function json(data) {
-  return new TextEncoder().encode(`data: ${JSON.stringify(data)}
+  return encoder.encode(`data: ${JSON.stringify(data)}
 
 `);
 }
@@ -237,17 +268,18 @@ var StreamingResponse = class extends Response {
 };
 
 // src/server/subscription-manager.ts
+var encoder2 = new TextEncoder();
 var SubscriptionManager = class {
   redis;
   subRedis;
   // Map<ChannelName, Set<Listener>>
   listeners = /* @__PURE__ */ new Map();
   unsubscribeTimers = /* @__PURE__ */ new Map();
-  verbose;
-  constructor(redis, verbose = false) {
+  logger;
+  constructor(redis, logger) {
     this.redis = redis;
     this.subRedis = redis.duplicate();
-    this.verbose = verbose;
+    this.logger = logger;
     this.setupMessageListener();
   }
   setupMessageListener() {
@@ -267,34 +299,49 @@ var SubscriptionManager = class {
         }
         const result = userEvent.safeParse(payload);
         if (result.success) {
-          if (this.verbose) {
-            console.log(`[SubscriptionManager] Dispatching message to ${handlers.size} listeners on ${channel}`);
-          }
+          const encodedMessage = encoder2.encode(
+            `data: ${JSON.stringify(result.data)}
+
+`
+          );
+          this.logger.debug?.(
+            `[SubscriptionManager] Dispatching message to ${handlers.size} listeners on ${channel}`
+          );
           handlers.forEach((listener) => {
             try {
-              listener(result.data);
+              listener(result.data, encodedMessage);
             } catch (listenerErr) {
-              console.error(`[SubscriptionManager] Error in listener for ${channel}:`, listenerErr);
+              this.logger.error(
+                `[SubscriptionManager] Error in listener for ${channel}:`,
+                listenerErr
+              );
             }
           });
         }
       } catch (err) {
-        console.error(`[SubscriptionManager] Error processing message on ${channel}:`, err);
+        this.logger.error(
+          `[SubscriptionManager] Error processing message on ${channel}:`,
+          err
+        );
       }
     });
     this.subRedis.on("error", (err) => {
-      console.error("[SubscriptionManager] Redis subscription error:", err);
+      this.logger.error("[SubscriptionManager] Redis subscription error:", err);
     });
   }
   async subscribe(channel, listener) {
     if (this.unsubscribeTimers.has(channel)) {
       clearTimeout(this.unsubscribeTimers.get(channel));
       this.unsubscribeTimers.delete(channel);
-      if (this.verbose) console.log(`[SubscriptionManager] Cancelled pending unsubscribe for: ${channel}`);
+      this.logger.debug?.(
+        `[SubscriptionManager] Cancelled pending unsubscribe for: ${channel}`
+      );
     }
     if (!this.listeners.has(channel)) {
       this.listeners.set(channel, /* @__PURE__ */ new Set());
-      if (this.verbose) console.log(`[SubscriptionManager] Subscribing to Redis channel: ${channel}`);
+      this.logger.debug?.(
+        `[SubscriptionManager] Subscribing to Redis channel: ${channel}`
+      );
       await this.subRedis.subscribe(channel);
     }
     const channelListeners = this.listeners.get(channel);
@@ -310,9 +357,14 @@ var SubscriptionManager = class {
           const timer = setTimeout(() => {
             this.listeners.delete(channel);
             this.unsubscribeTimers.delete(channel);
-            if (this.verbose) console.log(`[SubscriptionManager] Unsubscribing from Redis channel: ${channel}`);
+            this.logger.debug?.(
+              `[SubscriptionManager] Unsubscribing from Redis channel: ${channel}`
+            );
             this.subRedis.unsubscribe(channel).catch((err) => {
-              console.error(`[SubscriptionManager] Error unsubscribing from ${channel}:`, err);
+              this.logger.error(
+                `[SubscriptionManager] Error unsubscribing from ${channel}:`,
+                err
+              );
             });
           }, 2e3);
           this.unsubscribeTimers.set(channel, timer);
@@ -362,7 +414,10 @@ var RealtimeBase = class {
       }
     };
     if (this._redis) {
-      this._subscriptionManager = new SubscriptionManager(this._redis, this._verbose);
+      this._subscriptionManager = new SubscriptionManager(
+        this._redis,
+        this._logger
+      );
     }
     Object.assign(this, this.createEventHandlers("default"));
   }
@@ -375,7 +430,10 @@ var RealtimeBase = class {
     let pingInterval = void 0;
     const startPingInterval = () => {
       pingInterval = setInterval(() => {
-        this._redis?.publish(channel, JSON.stringify({ type: "ping", timestamp: Date.now() }));
+        this._redis?.publish(
+          channel,
+          JSON.stringify({ type: "ping", timestamp: Date.now() })
+        );
       }, 6e4);
     };
     const stopPingInterval = () => {
@@ -387,7 +445,13 @@ var RealtimeBase = class {
       const start = args?.start ? String(args.start) : "-";
       const end = args?.end ? String(args.end) : "+";
       const limit = args?.limit ?? 1e3;
-      const rawHistory = await redis.xrange(channel, start, end, "COUNT", limit);
+      const rawHistory = await redis.xrange(
+        channel,
+        start,
+        end,
+        "COUNT",
+        limit
+      );
       const historyMessages = parseStreamResponse(rawHistory);
       return historyMessages.map((value) => {
         if (typeof value === "object" && value !== null) {
@@ -431,17 +495,26 @@ var RealtimeBase = class {
           const limit = typeof history === "object" ? history.limit : void 0;
           let rawMessages = [];
           if (limit) {
-            rawMessages = await redis.xrange(channel, start, end, "COUNT", limit);
+            rawMessages = await redis.xrange(
+              channel,
+              start,
+              end,
+              "COUNT",
+              limit
+            );
           } else {
             rawMessages = await redis.xrange(channel, start, end);
           }
           const messages = parseStreamResponse(rawMessages);
           for (const message of messages) {
             const typedMessage = message;
-            if (!typedMessage.event || events && !events.includes(typedMessage.event)) continue;
+            if (!typedMessage.event || events && !events.includes(typedMessage.event))
+              continue;
             const result = userEvent.safeParse(message);
             if (result.success) {
-              onData(result.data);
+              onData(
+                result.data
+              );
             }
           }
           if (messages.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openart-realtime-sdk",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "author": "OpenArt",
   "repository": {
     "type": "git",