exguard-backend 1.0.32 → 1.0.34

package/README.md

@@ -355,11 +355,28 @@ EXGUARD_REALTIME_ENABLED=false
 EXGUARD_API_URL=https://api.your-domain.com
 EXGUARD_CACHE_ENABLED=true
 EXGUARD_CACHE_TTL=300000
-EXGUARD_REALTIME_ENABLED=true
-EXGUARD_REALTIME_URL=wss://api.your-domain.com/realtime
-EXGUARD_SERVICE_TOKEN=${SERVICE_JWT_TOKEN}
+# Optional: Enable realtime for automatic cache invalidation
+# EXGUARD_REALTIME_ENABLED=true
+# EXGUARD_REALTIME_URL=wss://api.your-domain.com/realtime
+# EXGUARD_SERVICE_TOKEN=your-service-token
 ```
 
+### ⚠️ Troubleshooting
+
+**502 WebSocket Error:**
+- This means the realtime server is not running or the URL is incorrect
+- **Solution:** Set `EXGUARD_REALTIME_ENABLED=false` in your .env file
+- The SDK will work without realtime (cache invalidation will be manual)
+
+```env
+EXGUARD_REALTIME_ENABLED=false
+```
+
+**To enable realtime later:**
+1. Make sure your WebSocket server is running
+2. Set correct URL: `EXGUARD_REALTIME_URL=ws://your-server:3000/realtime`
+3. Enable: `EXGUARD_REALTIME_ENABLED=true`
+
 ## 📊 Performance Benefits
 
 | Operation | Without Cache | With Cache | Improvement |

package/dist/index.cjs

@@ -283,25 +283,16 @@ var ExGuardCache = class {
 var cache = new ExGuardCache();
 
 // src/realtime.ts
-var WebSocketImpl;
-if (typeof window === "undefined") {
-  try {
-    WebSocketImpl = require("ws");
-  } catch {
-    WebSocketImpl = null;
-  }
-} else {
-  WebSocketImpl = WebSocket;
-}
+var import_socket = require("socket.io-client");
 var ExGuardRealtime = class {
   handlers = /* @__PURE__ */ new Map();
-  websocket = null;
+  socket = null;
   reconnectAttempts = 0;
   config;
   currentUrl = null;
   currentToken = null;
+  currentUserId = null;
   shouldReconnect = true;
-  isNode = typeof window === "undefined";
   constructor(config = {}) {
     this.config = {
       autoReconnect: config.autoReconnect ?? true,
@@ -319,13 +310,14 @@ var ExGuardRealtime = class {
   /**
    * Initialize and optionally connect to realtime server
    */
-  async init(url, accessToken) {
+  async init(url, accessToken, userId) {
     if (url) {
       this.currentUrl = url;
       this.currentToken = accessToken ?? null;
+      this.currentUserId = userId ?? null;
       if (this.config.autoConnect) {
         try {
-          await this.connect(url, accessToken);
+          await this.connect(url, accessToken, userId);
         } catch (error) {
           console.warn("[ExGuardRealtime] Auto-connect failed, will retry on demand:", error);
         }
@@ -333,138 +325,126 @@ var ExGuardRealtime = class {
     }
   }
   /**
-   * Connect to realtime server
-   * @param url - WebSocket URL (e.g., wss://api.example.com/realtime)
-   * @param auth - Authentication options (accessToken, apiKey, bearerToken) - optional
-   * @param silent - If true, won't throw error on connection failure
+   * Connect to realtime server using Socket.IO
+   * @param url - Server URL (e.g., https://api.example.com)
+   * @param auth - Authentication options (accessToken, apiKey, bearerToken, userId)
    */
-  connect(url, auth, silent = false) {
+  connect(url, auth, userId) {
     let authToken;
-    let authType = null;
+    let authUserId;
     if (typeof auth === "string") {
       authToken = auth;
-      authType = "access_token";
-    } else if (auth?.accessToken) {
-      authToken = auth.accessToken;
-      authType = "access_token";
-    } else if (auth?.apiKey) {
-      authToken = auth.apiKey;
-      authType = "api_key";
-    } else if (auth?.bearerToken) {
-      authToken = auth.bearerToken;
-      authType = "bearer";
+      authUserId = userId || "unknown";
+    } else if (typeof auth === "object") {
+      authToken = auth.accessToken || auth.bearerToken || auth.apiKey;
+      authUserId = auth.userId || userId || "unknown";
     }
     return new Promise((resolve, reject) => {
       this.shouldReconnect = true;
       this.currentUrl = url;
       this.currentToken = authToken ?? null;
-      if (!WebSocketImpl) {
-        const err = new Error('WebSocket is not available. Install "ws" package for Node.js: npm install ws');
-        this.config.onError(err);
-        if (!silent) reject(err);
-        return;
-      }
+      this.currentUserId = authUserId ?? null;
       try {
-        let wsUrl = url;
-        if (authToken && authType) {
-          if (authType === "bearer") {
-            wsUrl = `${url}?bearer=${encodeURIComponent(authToken)}`;
-          } else {
-            wsUrl = `${url}?${authType}=${encodeURIComponent(authToken)}`;
-          }
-        }
-        if (this.isNode && WebSocketImpl === require("ws")) {
-          this.websocket = new WebSocketImpl(wsUrl);
-          this.setupNodeWebSocket(resolve, reject);
-        } else {
-          this.websocket = new WebSocketImpl(wsUrl);
-          this.setupBrowserWebSocket(resolve, reject);
+        if (this.socket) {
+          this.socket.disconnect();
+          this.socket = null;
         }
+        const socketUrl = `${url}/realtime`;
+        console.log("[ExGuardRealtime] Connecting to:", socketUrl);
+        this.socket = (0, import_socket.io)(socketUrl, {
+          auth: {
+            token: authToken,
+            userId: authUserId
+          },
+          transports: ["websocket", "polling"],
+          reconnection: this.config.autoReconnect,
+          reconnectionDelay: this.config.reconnectDelay,
+          reconnectionDelayMax: this.config.reconnectMaxDelay,
+          reconnectionAttempts: this.config.maxReconnectAttempts,
+          timeout: 2e4
+        });
+        this.socket.on("connect", () => {
+          this.reconnectAttempts = 0;
+          console.log("[ExGuardRealtime] Connected! Socket ID:", this.socket?.id);
+          this.config.onConnect();
+          resolve();
+        });
+        this.socket.on("disconnect", (reason) => {
+          console.log("[ExGuardRealtime] Disconnected:", reason);
+          this.config.onDisconnect();
+          if (this.shouldReconnect && this.config.autoReconnect) {
+            this.handleReconnect();
+          }
+        });
+        this.socket.on("connect_error", (error) => {
+          console.error("[ExGuardRealtime] Connection error:", error.message);
+          const err = new Error(`Connection error: ${error.message}`);
+          this.config.onError(err);
+          if (!this.shouldReconnect || this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+            reject(err);
+          }
+        });
+        this.socket.on("error", (error) => {
+          console.error("[ExGuardRealtime] Socket error:", error);
+          const err = new Error(`Socket error: ${error}`);
+          this.config.onError(err);
+        });
+        this.socket.on("reconnect_attempt", (attempt) => {
+          this.reconnectAttempts = attempt;
+          console.log(`[ExGuardRealtime] Reconnecting... (attempt ${attempt})`);
+        });
+        this.socket.on("reconnect", () => {
+          console.log("[ExGuardRealtime] Reconnected!");
+        });
+        this.socket.on("reconnect_failed", () => {
+          console.error("[ExGuardRealtime] Reconnection failed after max attempts");
+          const err = new Error("Reconnection failed after maximum attempts");
+          this.config.onError(err);
+          reject(err);
+        });
+        this.socket.onAny((eventName, payload) => {
+          try {
+            const realtimeEvent = {
+              type: eventName,
+              timestamp: payload?.timestamp || Date.now(),
+              data: payload?.data || payload,
+              userId: payload?.userId
+            };
+            this.handleEvent(realtimeEvent);
+          } catch (error) {
+            console.error("[ExGuardRealtime] Failed to handle event:", error);
+          }
+        });
+        setTimeout(() => {
+          if (!this.socket?.connected) {
+            const err = new Error("Connection timeout");
+            this.config.onError(err);
+            this.socket?.disconnect();
+            reject(err);
+          }
+        }, 2e4);
       } catch (error) {
         reject(error);
       }
     });
   }
-  setupBrowserWebSocket(resolve, reject) {
-    const timeout = setTimeout(() => {
-      reject(new Error("Connection timeout"));
-    }, 1e4);
-    this.websocket.onopen = () => {
-      clearTimeout(timeout);
-      this.reconnectAttempts = 0;
-      console.log("[ExGuardRealtime] Connected to realtime server");
-      this.config.onConnect();
-      resolve();
-    };
-    this.websocket.onmessage = (event) => {
-      try {
-        const realtimeEvent = JSON.parse(event.data);
-        this.handleEvent(realtimeEvent);
-      } catch (error) {
-        console.error("[ExGuardRealtime] Failed to parse event:", error);
-      }
-    };
-    this.websocket.onclose = () => {
-      clearTimeout(timeout);
-      console.log("[ExGuardRealtime] Disconnected from realtime server");
-      this.config.onDisconnect();
-      this.handleReconnect();
-    };
-    this.websocket.onerror = (error) => {
-      clearTimeout(timeout);
-      console.error("[ExGuardRealtime] WebSocket error:", error);
-      const err = new Error("WebSocket connection error");
-      this.config.onError(err);
-      if (!this.shouldReconnect) {
-        reject(err);
-      }
-    };
-  }
-  setupNodeWebSocket(resolve, reject) {
-    const timeout = setTimeout(() => {
-      reject(new Error("Connection timeout"));
-    }, 1e4);
-    this.websocket.on("open", () => {
-      clearTimeout(timeout);
-      this.reconnectAttempts = 0;
-      console.log("[ExGuardRealtime] Connected to realtime server (Node.js)");
-      this.config.onConnect();
-      resolve();
-    });
-    this.websocket.on("message", (data) => {
-      try {
-        const realtimeEvent = JSON.parse(data.toString());
-        this.handleEvent(realtimeEvent);
-      } catch (error) {
-        console.error("[ExGuardRealtime] Failed to parse event:", error);
-      }
-    });
-    this.websocket.on("close", () => {
-      clearTimeout(timeout);
-      console.log("[ExGuardRealtime] Disconnected from realtime server");
-      this.config.onDisconnect();
-      this.handleReconnect();
-    });
-    this.websocket.on("error", (error) => {
-      clearTimeout(timeout);
-      console.error("[ExGuardRealtime] WebSocket error:", error);
-      const err = new Error("WebSocket connection error: " + (error?.message || error));
-      this.config.onError(err);
-      if (this.shouldReconnect) {
-        this.handleReconnect();
-      } else {
-        reject(err);
-      }
-    });
+  /**
+   * Subscribe to channels
+   */
+  subscribeToChannel(channel) {
+    if (this.socket?.connected) {
+      this.socket.emit(`subscribe:${channel}`);
+      console.log(`[ExGuardRealtime] Subscribed to channel: ${channel}`);
+    }
   }
   /**
    * Disconnect from realtime server
    */
   disconnect() {
     this.shouldReconnect = false;
-    if (this.websocket) {
-      this.websocket.close();
-      this.websocket = null;
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
     }
   }
   /**
@@ -526,7 +506,7 @@ var ExGuardRealtime = class {
       );
       console.log(`[ExGuardRealtime] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
       setTimeout(() => {
-        this.connect(this.currentUrl, this.currentToken).catch((error) => {
+        this.connect(this.currentUrl, this.currentToken, this.currentUserId).catch((error) => {
           console.error("[ExGuardRealtime] Reconnection failed:", error);
         });
       }, delay);
@@ -540,7 +520,7 @@ var ExGuardRealtime = class {
   reconnect() {
     if (this.currentUrl && this.currentToken) {
       this.reconnectAttempts = 0;
-      return this.connect(this.currentUrl, this.currentToken);
+      return this.connect(this.currentUrl, this.currentToken, this.currentUserId || void 0);
     } else if (this.currentUrl) {
       this.reconnectAttempts = 0;
       return this.connect(this.currentUrl);
@@ -548,51 +528,25 @@ var ExGuardRealtime = class {
     return Promise.reject(new Error("No URL configured"));
   }
   /**
-  * Check if connected
-  */
+   * Check if connected
+   */
   isConnected() {
-    if (!this.websocket) return false;
-    if (this.isNode) {
-      return this.websocket.readyState === 1;
-    }
-    return this.websocket.readyState === WebSocket.OPEN;
+    return this.socket?.connected ?? false;
   }
   /**
    * Get connection status
    */
   getStatus() {
-    if (!this.websocket) return "disconnected";
-    if (this.isNode) {
-      switch (this.websocket.readyState) {
-        case 0:
-          return "connecting";
-        case 1:
-          return "connected";
-        case 2:
-        case 3:
-          return "disconnected";
-        default:
-          return "disconnected";
-      }
-    }
-    switch (this.websocket.readyState) {
-      case WebSocket.CONNECTING:
-        return "connecting";
-      case WebSocket.OPEN:
-        return "connected";
-      case WebSocket.CLOSING:
-      case WebSocket.CLOSED:
-        return "disconnected";
-      default:
-        return "disconnected";
-    }
+    if (!this.socket) return "disconnected";
+    if (this.socket.connected) return "connected";
+    return "disconnected";
   }
   /**
    * Send a message to the server
    */
-  send(event) {
-    if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
-      this.websocket.send(JSON.stringify(event));
+  send(event, data) {
+    if (this.socket?.connected) {
+      this.socket.emit(event, data);
     }
   }
   /**
@@ -608,9 +562,9 @@ var ExGuardRealtime = class {
    * Connect on-demand with user's access token from request
    * Call this in your guard or middleware with the user's token
    */
-  async connectWithUserToken(url, accessToken) {
+  async connectWithUserToken(url, accessToken, userId) {
     try {
-      await this.connect(url, accessToken, true);
+      await this.connect(url, accessToken, userId);
     } catch (error) {
       console.warn("[ExGuardRealtime] Failed to connect with user token:", error);
     }
@@ -677,7 +631,7 @@ var ExGuardBackendEnhanced = class {
     }, 6e4);
   }
   async setupRealtime() {
-    if (!this.config.realtime?.url) {
+    if (!this.config.realtime?.enabled || !this.config.realtime?.url) {
       return;
     }
     try {