@djangocfg/centrifugo 2.1.26 → 2.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/centrifugo",
-  "version": "2.1.26",
+  "version": "2.1.27",
   "description": "Production-ready Centrifugo WebSocket client for React with real-time subscriptions, RPC patterns, and connection state management",
   "keywords": [
     "centrifugo",
@@ -51,9 +51,9 @@
     "centrifuge": "^5.2.2"
   },
   "peerDependencies": {
-    "@djangocfg/api": "^2.1.26",
-    "@djangocfg/ui-nextjs": "^2.1.26",
-    "@djangocfg/layouts": "^2.1.26",
+    "@djangocfg/api": "^2.1.27",
+    "@djangocfg/ui-nextjs": "^2.1.27",
+    "@djangocfg/layouts": "^2.1.27",
     "consola": "^3.4.2",
     "lucide-react": "^0.545.0",
     "moment": "^2.30.1",
@@ -61,7 +61,7 @@
     "react-dom": "^19.1.0"
   },
   "devDependencies": {
-    "@djangocfg/typescript-config": "^2.1.26",
+    "@djangocfg/typescript-config": "^2.1.27",
     "@types/react": "^19.1.0",
     "@types/react-dom": "^19.1.0",
     "moment": "^2.30.1",

package/src/core/client/CentrifugoRPCClient.ts

@@ -9,6 +9,19 @@ import { Centrifuge } from 'centrifuge';
 import type { Logger } from '../logger';
 import { createLogger } from '../logger';
 
+export interface CentrifugoClientOptions {
+  url: string;
+  token: string;
+  userId: string;
+  timeout?: number;
+  logger?: Logger;
+  /**
+   * Callback to get fresh token when current token expires.
+   * Centrifuge-js calls this automatically on token expiration.
+   */
+  getToken?: () => Promise<string>;
+}
+
 export class CentrifugoRPCClient {
   private centrifuge: Centrifuge;
   private subscription: any;
@@ -19,21 +32,73 @@ export class CentrifugoRPCClient {
   private readonly timeout: number;
   private readonly logger: Logger;
 
+  constructor(options: CentrifugoClientOptions);
+  /** @deprecated Use options object instead */
   constructor(
     url: string,
     token: string,
     userId: string,
+    timeout?: number,
+    logger?: Logger
+  );
+  constructor(
+    urlOrOptions: string | CentrifugoClientOptions,
+    token?: string,
+    userId?: string,
     timeout: number = 30000,
     logger?: Logger
   ) {
-    this.userId = userId;
-    this.replyChannel = `user#${userId}`;
-    this.timeout = timeout;
-    this.logger = logger || createLogger({ source: 'client' });
+    // Handle both old and new API
+    let url: string;
+    let actualToken: string;
+    let actualUserId: string;
+    let actualTimeout: number;
+    let actualLogger: Logger | undefined;
+    let getToken: (() => Promise<string>) | undefined;
+
+    if (typeof urlOrOptions === 'object') {
+      // New options-based API
+      url = urlOrOptions.url;
+      actualToken = urlOrOptions.token;
+      actualUserId = urlOrOptions.userId;
+      actualTimeout = urlOrOptions.timeout ?? 30000;
+      actualLogger = urlOrOptions.logger;
+      getToken = urlOrOptions.getToken;
+    } else {
+      // Legacy positional arguments API
+      url = urlOrOptions;
+      actualToken = token!;
+      actualUserId = userId!;
+      actualTimeout = timeout;
+      actualLogger = logger;
+    }
 
-    this.centrifuge = new Centrifuge(url, {
-      token,
-    });
+    this.userId = actualUserId;
+    this.replyChannel = `user#${actualUserId}`;
+    this.timeout = actualTimeout;
+    this.logger = actualLogger || createLogger({ source: 'client' });
+
+    // Build Centrifuge options
+    const centrifugeOptions: any = {
+      token: actualToken,
+    };
+
+    // Add getToken callback for automatic token refresh
+    if (getToken) {
+      centrifugeOptions.getToken = async () => {
+        this.logger.info('Token expired, refreshing...');
+        try {
+          const newToken = await getToken();
+          this.logger.success('Token refreshed successfully');
+          return newToken;
+        } catch (error) {
+          this.logger.error('Failed to refresh token', error);
+          throw error;
+        }
+      };
+    }
+
+    this.centrifuge = new Centrifuge(url, centrifugeOptions);
 
     this.centrifuge.on('disconnected', (ctx) => {
       // Reject all pending requests

package/src/core/client/index.ts

@@ -3,3 +3,4 @@
  */
 
 export { CentrifugoRPCClient } from './CentrifugoRPCClient';
+export type { CentrifugoClientOptions } from './CentrifugoRPCClient';

package/src/providers/CentrifugoProvider/CentrifugoProvider.tsx

@@ -56,6 +56,18 @@ export interface CentrifugoProviderProps {
   enabled?: boolean;
   url?: string;
   autoConnect?: boolean;
+  /**
+   * Callback to refresh the Centrifugo token when it expires.
+   * If provided, centrifuge-js will automatically call this when token expires.
+   * Should return a fresh JWT token string.
+   *
+   * @example
+   * onTokenRefresh={async () => {
+   *   const response = await getCentrifugoAuthTokenRetrieve();
+   *   return response.token;
+   * }}
+   */
+  onTokenRefresh?: () => Promise<string>;
 }
 
 // ─────────────────────────────────────────────────────────────────────────
@@ -67,6 +79,7 @@ function CentrifugoProviderInner({
   enabled = false,
   url,
   autoConnect: autoConnectProp = true,
+  onTokenRefresh,
 }: CentrifugoProviderProps) {
   const { isAuthenticated, isLoading, user } = useAuth();
 
@@ -215,7 +228,14 @@ function CentrifugoProviderInner({
         }
       }
 
-      const rpcClient = new CentrifugoRPCClient(wsUrl, token, userId, 30000, logger);
+      const rpcClient = new CentrifugoRPCClient({
+        url: wsUrl,
+        token,
+        userId,
+        timeout: 30000,
+        logger,
+        getToken: onTokenRefresh,
+      });
       await rpcClient.connect();
 
       if (!isMountedRef.current) {
@@ -304,7 +324,7 @@ function CentrifugoProviderInner({
     } finally {
       setIsConnecting(false);
     }
-  }, [wsUrl, centrifugoToken, user, logger, isConnecting, isConnected, getReconnectDelay]);
+  }, [wsUrl, centrifugoToken, user, logger, isConnecting, isConnected, getReconnectDelay, onTokenRefresh]);
 
   // Disconnect function
   const disconnect = useCallback(() => {