@kadoa/node-sdk 0.24.0 → 0.24.2

package/dist/index.mjs

@@ -6035,7 +6035,7 @@ var NotificationSetupService = class {
           (s) => s.eventType === eventType
         );
         if (existing?.id) {
-          const existingChannelIds = (existing.channels || []).map((c) => c.id).filter(Boolean);
+          const existingChannelIds = (existing.channels || []).map((channel) => channel.id).filter(Boolean);
           const mergedChannelIds = [
             .../* @__PURE__ */ new Set([...existingChannelIds, ...channelIds])
           ];
@@ -6201,7 +6201,7 @@ process.env.KADOA_WSS_NEO_API_URI ?? "wss://events.kadoa.com/events/ws";
 var REALTIME_API_URI = process.env.KADOA_REALTIME_API_URI ?? "https://realtime.kadoa.com";
 
 // src/version.ts
-var SDK_VERSION = "0.24.0";
+var SDK_VERSION = "0.24.2";
 var SDK_NAME = "kadoa-node-sdk";
 var SDK_LANGUAGE = "node";
 
@@ -6210,89 +6210,256 @@ var debug5 = logger.wss;
 if (typeof WebSocket === "undefined") {
   global.WebSocket = __require("ws");
 }
-var Realtime = class {
+var isDrainControlMessage = (message) => message.type === "control.draining";
+var isRealtimeEvent = (message) => message.type !== "heartbeat" && message.type !== "control.draining";
+var _Realtime = class _Realtime {
   constructor(config) {
+    this.drainingSockets = /* @__PURE__ */ new Set();
     this.lastHeartbeat = Date.now();
     this.isConnecting = false;
     this.eventListeners = /* @__PURE__ */ new Set();
     this.connectionListeners = /* @__PURE__ */ new Set();
     this.errorListeners = /* @__PURE__ */ new Set();
+    this.isClosed = false;
+    this.hasConnectedOnce = false;
+    this.recentEventIds = /* @__PURE__ */ new Set();
+    this.recentEventIdQueue = [];
+    this.maxRecentEventIds = 1e3;
     this.apiKey = config.apiKey;
     this.heartbeatInterval = config.heartbeatInterval || 1e4;
-    this.reconnectDelay = config.reconnectDelay || 5e3;
+    this.reconnectDelay = this.normalizeReconnectDelay(config.reconnectDelay);
     this.missedHeartbeatsLimit = config.missedHeartbeatsLimit || 3e4;
   }
   async connect() {
-    if (this.isConnecting) return;
+    if (this.isClosed || this.isConnecting || this.activeSocket) {
+      return;
+    }
     this.isConnecting = true;
     try {
-      const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": `${this.apiKey}`,
-          "x-sdk-version": SDK_VERSION
+      const { access_token, team_id } = await this.getOAuthToken();
+      await this.openSocket(access_token, team_id, "active");
+      this.hasConnectedOnce = true;
+    } catch (err) {
+      debug5("Failed to connect: %O", err);
+      this.isConnecting = false;
+      this.notifyErrorListeners(err);
+      if (!this.hasConnectedOnce) {
+        throw err;
+      }
+      this.scheduleReconnect();
+    }
+  }
+  async getOAuthToken() {
+    const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": `${this.apiKey}`,
+        "x-sdk-version": SDK_VERSION
+      }
+    });
+    return await response.json();
+  }
+  async openSocket(accessToken, teamId, role) {
+    await new Promise((resolve, reject) => {
+      const socket = new WebSocket(
+        `${WSS_API_URI}?access_token=${accessToken}`
+      );
+      let settled = false;
+      socket.onopen = () => {
+        const subscribeMessage = {
+          action: "subscribe",
+          channel: teamId
+        };
+        if (this.lastCursor) {
+          subscribeMessage.lastCursor = this.lastCursor;
         }
-      });
-      const { access_token, team_id } = await response.json();
-      await new Promise((resolve, reject) => {
-        this.socket = new WebSocket(
-          `${WSS_API_URI}?access_token=${access_token}`
-        );
-        this.socket.onopen = () => {
-          this.isConnecting = false;
-          this.lastHeartbeat = Date.now();
-          if (this.socket?.readyState === WebSocket.OPEN) {
-            this.socket.send(
-              JSON.stringify({
-                action: "subscribe",
-                channel: team_id
-              })
-            );
-            debug5("Connected to WebSocket");
-            this.notifyConnectionListeners(true);
-          }
-          this.startHeartbeatCheck();
+        socket.send(JSON.stringify(subscribeMessage));
+        this.promoteSocket(socket, role);
+        this.isConnecting = false;
+        this.lastHeartbeat = Date.now();
+        this.startHeartbeatCheck();
+        debug5("Connected to WebSocket");
+        if (!settled) {
+          settled = true;
           resolve();
-        };
-        this.socket.onmessage = (event) => {
-          try {
-            const data = JSON.parse(event.data);
-            if (data.type === "heartbeat") {
-              this.handleHeartbeat();
-            } else {
-              if (data?.id) {
-                fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
-                  method: "POST",
-                  headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({ id: data.id })
-                });
-              }
-              this.notifyEventListeners(data);
-            }
-          } catch (err) {
-            debug5("Failed to parse incoming message: %O", err);
-          }
-        };
-        this.socket.onclose = () => {
-          debug5("WebSocket disconnected. Attempting to reconnect...");
-          this.isConnecting = false;
-          this.stopHeartbeatCheck();
-          this.notifyConnectionListeners(false, "Connection closed");
-          setTimeout(() => this.connect(), this.reconnectDelay);
-        };
-        this.socket.onerror = (error) => {
-          debug5("WebSocket error: %O", error);
-          this.isConnecting = false;
-          this.notifyErrorListeners(error);
+        }
+      };
+      socket.onmessage = (event) => {
+        this.handleSocketMessage(socket, event.data);
+      };
+      socket.onclose = () => {
+        this.handleSocketClose(socket);
+        if (!settled) {
+          settled = true;
+          reject(new Error("WebSocket closed before opening"));
+        }
+      };
+      socket.onerror = (error) => {
+        this.notifyErrorListeners(error);
+        if (!settled) {
+          settled = true;
           reject(error);
-        };
-      });
+          return;
+        }
+        if (socket === this.activeSocket) {
+          this.handleUnexpectedDisconnect("Socket error");
+        }
+      };
+    });
+  }
+  promoteSocket(socket, role) {
+    if (role === "replacement" && this.activeSocket && this.activeSocket !== socket) {
+      this.drainingSockets.add(this.activeSocket);
+    }
+    this.activeSocket = socket;
+    this.drainingSockets.delete(socket);
+    if (role === "active" || !this.hasConnectedOnce) {
+      this.notifyConnectionListeners(true);
+    }
+  }
+  handleSocketMessage(socket, rawData) {
+    try {
+      const payload = typeof rawData === "string" ? rawData : rawData.toString?.() ?? "";
+      const data = JSON.parse(payload);
+      if (data.type === "heartbeat") {
+        if (socket === this.activeSocket) {
+          this.handleHeartbeat();
+        }
+        return;
+      }
+      if (isDrainControlMessage(data)) {
+        this.handleDrainSignal(socket, data);
+        return;
+      }
+      if (!isRealtimeEvent(data)) {
+        return;
+      }
+      if (typeof data._cursor === "string") {
+        this.lastCursor = data._cursor;
+      }
+      if (typeof data.id === "string") {
+        fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ id: data.id })
+        }).catch((error) => {
+          debug5("Failed to acknowledge event %s: %O", data.id, error);
+        });
+      }
+      if (this.isDuplicateEvent(data.id)) {
+        return;
+      }
+      this.notifyEventListeners(data);
     } catch (err) {
-      debug5("Failed to connect: %O", err);
-      this.isConnecting = false;
-      setTimeout(() => this.connect(), this.reconnectDelay);
+      debug5("Failed to parse incoming message: %O", err);
+    }
+  }
+  handleDrainSignal(socket, message) {
+    if (socket !== this.activeSocket || this.isClosed) {
+      return;
+    }
+    debug5("Received drain signal, preparing replacement socket");
+    this.drainingSockets.add(socket);
+    this.scheduleDrainReconnect(message.retryAfterMs);
+  }
+  handleSocketClose(socket) {
+    const wasActiveSocket = socket === this.activeSocket;
+    this.drainingSockets.delete(socket);
+    if (!wasActiveSocket) {
+      return;
+    }
+    this.activeSocket = void 0;
+    this.stopHeartbeatCheck();
+    if (this.isClosed) {
+      return;
+    }
+    if (this.drainingSockets.size > 0) {
+      debug5("Draining socket closed after replacement was scheduled");
+      return;
+    }
+    this.handleUnexpectedDisconnect("Connection closed");
+  }
+  handleUnexpectedDisconnect(reason) {
+    this.isConnecting = false;
+    this.notifyConnectionListeners(false, reason);
+    this.scheduleReconnect();
+  }
+  scheduleReconnect(replacement = false) {
+    if (this.isClosed || this.reconnectTimer) {
+      return;
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = void 0;
+      if (this.isClosed || this.isConnecting || !replacement && this.activeSocket) {
+        return;
+      }
+      this.isConnecting = true;
+      try {
+        const { access_token, team_id } = await this.getOAuthToken();
+        await this.openSocket(
+          access_token,
+          team_id,
+          replacement ? "replacement" : "active"
+        );
+      } catch (err) {
+        debug5("Reconnect failed: %O", err);
+        this.isConnecting = false;
+        this.notifyErrorListeners(err);
+        this.scheduleReconnect(replacement);
+      }
+    }, this.reconnectDelay);
+  }
+  scheduleDrainReconnect(retryAfterMs) {
+    if (this.isClosed || this.reconnectTimer) {
+      return;
     }
+    let safeDelayMs = this.reconnectDelay;
+    if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs >= 0 && retryAfterMs <= _Realtime.MAX_RECONNECT_DELAY_MS) {
+      safeDelayMs = Math.trunc(retryAfterMs);
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = void 0;
+      if (this.isClosed || this.isConnecting) {
+        return;
+      }
+      this.isConnecting = true;
+      try {
+        const { access_token, team_id } = await this.getOAuthToken();
+        await this.openSocket(access_token, team_id, "replacement");
+      } catch (err) {
+        debug5("Reconnect failed: %O", err);
+        this.isConnecting = false;
+        this.notifyErrorListeners(err);
+        this.scheduleReconnect(true);
+      }
+    }, safeDelayMs);
+  }
+  normalizeReconnectDelay(delay) {
+    if (typeof delay !== "number" || !Number.isFinite(delay)) {
+      return _Realtime.DEFAULT_RECONNECT_DELAY_MS;
+    }
+    return Math.min(
+      Math.max(0, Math.trunc(delay)),
+      _Realtime.MAX_RECONNECT_DELAY_MS
+    );
+  }
+  isDuplicateEvent(eventId) {
+    if (!eventId) {
+      return false;
+    }
+    if (this.recentEventIds.has(eventId)) {
+      return true;
+    }
+    this.recentEventIds.add(eventId);
+    this.recentEventIdQueue.push(eventId);
+    if (this.recentEventIdQueue.length > this.maxRecentEventIds) {
+      const expiredId = this.recentEventIdQueue.shift();
+      if (expiredId) {
+        this.recentEventIds.delete(expiredId);
+      }
+    }
+    return false;
   }
   handleHeartbeat() {
     debug5("Heartbeat received");
@@ -6320,22 +6487,24 @@ var Realtime = class {
     this.errorListeners.forEach((listener) => {
       try {
         listener(error);
-      } catch (error2) {
-        debug5("Error in error listener: %O", error2);
+      } catch (listenerError) {
+        debug5("Error in error listener: %O", listenerError);
       }
     });
   }
   startHeartbeatCheck() {
+    this.stopHeartbeatCheck();
     this.missedHeartbeatCheckTimer = setInterval(() => {
-      if (Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
+      if (this.activeSocket && Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
         debug5("No heartbeat received in 30 seconds! Closing connection.");
-        this.socket?.close();
+        this.activeSocket.close();
       }
     }, this.heartbeatInterval);
   }
   stopHeartbeatCheck() {
     if (this.missedHeartbeatCheckTimer) {
       clearInterval(this.missedHeartbeatCheckTimer);
+      this.missedHeartbeatCheckTimer = void 0;
     }
   }
   /**
@@ -6356,6 +6525,9 @@ var Realtime = class {
    */
   onConnection(listener) {
     this.connectionListeners.add(listener);
+    if (this.isConnected()) {
+      listener(true);
+    }
     return () => {
       this.connectionListeners.delete(listener);
     };
@@ -6372,19 +6544,30 @@ var Realtime = class {
     };
   }
   close() {
-    if (this.socket) {
-      this.stopHeartbeatCheck();
-      this.socket.close();
-      this.socket = void 0;
+    this.isClosed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
     }
+    this.stopHeartbeatCheck();
+    this.activeSocket?.close();
+    this.activeSocket = void 0;
+    this.drainingSockets.forEach((socket) => {
+      socket.close();
+    });
+    this.drainingSockets.clear();
+    this.isConnecting = false;
     this.eventListeners.clear();
     this.connectionListeners.clear();
     this.errorListeners.clear();
   }
   isConnected() {
-    return this.socket?.readyState === WebSocket.OPEN;
+    return this.activeSocket?.readyState === WebSocket.OPEN;
   }
 };
+_Realtime.DEFAULT_RECONNECT_DELAY_MS = 5e3;
+_Realtime.MAX_RECONNECT_DELAY_MS = 6e4;
+var Realtime = _Realtime;
 
 // src/domains/user/user.service.ts
 var UserService = class {