exguard-backend 1.0.29 → 1.0.31

package/dist/index.cjs

@@ -283,6 +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 ExGuardRealtime = class {
   handlers = /* @__PURE__ */ new Map();
   websocket = null;
@@ -291,6 +301,7 @@ var ExGuardRealtime = class {
   currentUrl = null;
   currentToken = null;
   shouldReconnect = true;
+  isNode = typeof window === "undefined";
   constructor(config = {}) {
     this.config = {
       autoReconnect: config.autoReconnect ?? true,
@@ -301,15 +312,33 @@ var ExGuardRealtime = class {
       }),
       onDisconnect: config.onDisconnect ?? (() => {
       }),
-      onError: config.onError ?? ((error) => console.error("[ExGuardRealtime] Error:", error))
+      onError: config.onError ?? ((error) => console.error("[ExGuardRealtime] Error:", error)),
+      autoConnect: config.autoConnect ?? false
     };
   }
+  /**
+   * Initialize and optionally connect to realtime server
+   */
+  async init(url, accessToken) {
+    if (url) {
+      this.currentUrl = url;
+      this.currentToken = accessToken ?? null;
+      if (this.config.autoConnect) {
+        try {
+          await this.connect(url, accessToken);
+        } catch (error) {
+          console.warn("[ExGuardRealtime] Auto-connect failed, will retry on demand:", error);
+        }
+      }
+    }
+  }
   /**
    * 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(url, auth) {
+  connect(url, auth, silent = false) {
     let authToken;
     let authType = null;
     if (typeof auth === "string") {
@@ -329,6 +358,12 @@ var ExGuardRealtime = class {
       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;
+      }
       try {
         let wsUrl = url;
         if (authToken && authType) {
@@ -338,43 +373,90 @@ var ExGuardRealtime = class {
             wsUrl = `${url}?${authType}=${encodeURIComponent(authToken)}`;
           }
         }
-        this.websocket = new WebSocket(wsUrl);
-        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);
-          reject(err);
-        };
+        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);
+        }
       } 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);
+      }
+    });
+  }
   /**
    * Disconnect from realtime server
    */
@@ -466,16 +548,33 @@ var ExGuardRealtime = class {
     return Promise.reject(new Error("No URL configured"));
   }
   /**
-   * Check if connected
-   */
+  * Check if connected
+  */
   isConnected() {
-    return this.websocket?.readyState === WebSocket.OPEN;
+    if (!this.websocket) return false;
+    if (this.isNode) {
+      return this.websocket.readyState === 1;
+    }
+    return this.websocket.readyState === WebSocket.OPEN;
   }
   /**
    * 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";
@@ -505,6 +604,17 @@ var ExGuardRealtime = class {
       ...config
     };
   }
+  /**
+   * 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) {
+    try {
+      await this.connect(url, accessToken, true);
+    } catch (error) {
+      console.warn("[ExGuardRealtime] Failed to connect with user token:", error);
+    }
+  }
 };
 function createRealtime(config) {
   return new ExGuardRealtime(config);
@@ -567,10 +677,13 @@ var ExGuardBackendEnhanced = class {
     }, 6e4);
   }
   async setupRealtime() {
+    if (!this.config.realtime?.url) {
+      return;
+    }
     try {
       await this.realtime.connect(
         this.config.realtime.url,
-        this.config.realtime.token
+        this.config.realtime.accessToken
       );
       this.realtime.subscribe("rbac_update", (event) => {
         console.log("[ExGuardBackend] RBAC update received:", event);
@@ -605,15 +718,15 @@ var ExGuardBackendEnhanced = class {
         }
       });
     } catch (error) {
-      console.error("[ExGuardBackend] Failed to setup realtime:", error);
+      console.warn("[ExGuardBackend] Realtime connection failed (will retry on demand):", error);
     }
   }
   /**
    * Manually connect to realtime server
    */
-  async connectRealtime(url, token) {
+  async connectRealtime(url, accessToken) {
     const wsUrl = url || this.config.realtime?.url;
-    const wsToken = token || this.config.realtime?.token;
+    const wsToken = accessToken || this.config.realtime?.accessToken;
     if (!wsUrl) {
       throw new Error("WebSocket URL is required");
     }