exguard-backend 1.0.33 → 1.0.35

package/dist/index.cjs

@@ -210,16 +210,20 @@ var ExGuardCache = class {
     keys.forEach((key) => this.notifySubscribers(key));
   }
   /**
-   * Clear cache for a specific user
+   * Clear cache for a specific user - clears ALL caches related to this user
    */
   clearUserCache(userId) {
     const keysToDelete = Array.from(this.cache.keys()).filter(
-      (key) => key.startsWith(`user:${userId}:`)
+      (key) => key.includes(userId)
     );
+    console.log(`[ExGuardCache] Clearing cache for user ${userId}, found ${keysToDelete.length} keys:`, keysToDelete);
     keysToDelete.forEach((key) => {
       this.cache.delete(key);
       this.notifySubscribers(key);
     });
+    if (keysToDelete.length === 0) {
+      console.log(`[ExGuardCache] No cache entries found for user ${userId}`);
+    }
   }
   /**
    * Subscribe to cache changes
@@ -283,25 +287,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 +314,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,142 +329,131 @@ 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;
     }
   }
   /**
    * Subscribe to realtime events
+   * Use '*' as eventType to receive ALL events
    */
   subscribe(eventType, handler) {
     if (!this.handlers.has(eventType)) {
@@ -486,14 +471,10 @@ var ExGuardRealtime = class {
     };
   }
   /**
-   * Subscribe to all realtime events
+   * Subscribe to ALL realtime events (wildcard)
    */
   subscribeAll(handler) {
-    const eventTypes = ["rbac_update", "user_update", "role_update", "permission_update"];
-    const unsubscribes = eventTypes.map((type) => this.subscribe(type, handler));
-    return () => {
-      unsubscribes.forEach((unsub) => unsub());
-    };
+    return this.subscribe("*", handler);
   }
   /**
    * Handle incoming realtime events
@@ -510,6 +491,16 @@ var ExGuardRealtime = class {
         }
       });
     }
+    const wildcardHandlers = this.handlers.get("*");
+    if (wildcardHandlers) {
+      wildcardHandlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error("[ExGuardRealtime] Wildcard handler error:", error);
+        }
+      });
+    }
   }
   /**
    * Handle reconnection logic
@@ -526,7 +517,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 +531,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 +539,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 +573,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);
     }
@@ -683,40 +648,42 @@ var ExGuardBackendEnhanced = class {
     try {
       await this.realtime.connect(
         this.config.realtime.url,
-        this.config.realtime.accessToken,
-        true
-        // silent mode - won't throw on connection failure
+        this.config.realtime.accessToken
       );
-      this.realtime.subscribe("rbac_update", (event) => {
-        console.log("[ExGuardBackend] RBAC update received:", event);
-        this.config.realtime?.onRBACUpdate?.(event);
-        if (event.userId) {
-          this.cache.clearUserCache(event.userId);
-        } else {
-          this.cache.clear();
+      this.realtime.subscribeToChannel("rbac");
+      this.realtime.subscribeToChannel("roles");
+      this.realtime.subscribeToChannel("permissions");
+      this.realtime.subscribe("*", (event) => {
+        console.log("[ExGuardBackend] Realtime event received:", event);
+        if (event.type.includes("rbac") || event.type === "rbac_update") {
+          this.config.realtime?.onRBACUpdate?.(event);
+          if (event.userId) {
+            this.cache.clearUserCache(event.userId);
+          } else {
+            this.cache.clear();
+          }
         }
-      });
-      this.realtime.subscribe("user_update", (event) => {
-        console.log("[ExGuardBackend] User update received:", event);
-        this.config.realtime?.onUserUpdate?.(event);
-        if (event.userId) {
-          this.cache.clearUserCache(event.userId);
+        if (event.type.includes("user") || event.type === "user_update") {
+          this.config.realtime?.onUserUpdate?.(event);
+          if (event.userId) {
+            this.cache.clearUserCache(event.userId);
+          } else {
+            this.cache.clear();
+          }
         }
-      });
-      this.realtime.subscribe("role_update", (event) => {
-        console.log("[ExGuardBackend] Role update received:", event);
-        if (event.userId) {
-          this.cache.clearUserCache(event.userId);
-        } else {
-          this.cache.clear();
+        if (event.type.includes("role") || event.type === "role_update") {
+          if (event.userId) {
+            this.cache.clearUserCache(event.userId);
+          } else {
+            this.cache.clear();
+          }
         }
-      });
-      this.realtime.subscribe("permission_update", (event) => {
-        console.log("[ExGuardBackend] Permission update received:", event);
-        if (event.userId) {
-          this.cache.clearUserCache(event.userId);
-        } else {
-          this.cache.clear();
+        if (event.type.includes("permission") || event.type === "permission_update") {
+          if (event.userId) {
+            this.cache.clearUserCache(event.userId);
+          } else {
+            this.cache.clear();
+          }
         }
       });
     } catch (error) {