@djangocfg/centrifugo 1.0.1 → 1.0.3

package/src/context/CentrifugoProvider.tsx

@@ -1,228 +0,0 @@
-/**
- * Base Centrifugo Provider
- *
- * Generic WebSocket RPC provider that can be used in any app.
- * Automatically accesses auth context from @djangocfg/layouts.
- */
-
-'use client';
-
-import { createContext, useContext, useState, useEffect, useCallback, useRef, useMemo } from 'react';
-import { useAuth } from '@djangocfg/layouts';
-import type { CentrifugoProviderProps, CentrifugoContextValue } from '../types';
-import { useCentrifugoLogger } from '../hooks';
-import { CentrifugoDebug } from '../components';
-
-const CentrifugoContext = createContext<CentrifugoContextValue | undefined>(undefined);
-
-export function CentrifugoProvider({
-  children,
-  enabled = false,
-  RPCClientClass,
-  APIClientClass,
-  url,
-  autoConnect: autoConnectProp = true,
-}: CentrifugoProviderProps) {
-  const { isAuthenticated, isLoading, user } = useAuth();
-
-  const [client, setClient] = useState<any>(null);
-  const [baseClient, setBaseClient] = useState<any>(null);
-  const [isConnected, setIsConnected] = useState(false);
-  const [isConnecting, setIsConnecting] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  const logger = useCentrifugoLogger();
-
-  const reconnectTimeoutRef = useRef<NodeJS.Timeout | null>(null);
-  const hasConnectedRef = useRef(false);
-  const isConnectingRef = useRef(false);
-  const isMountedRef = useRef(true);
-
-  const centrifugoToken = user?.centrifugo;
-  const hasCentrifugoToken = !!centrifugoToken?.token;
-
-  const wsUrl = useMemo(() => {
-    if (url) return url;
-    if (centrifugoToken?.centrifugo_url) return centrifugoToken.centrifugo_url;
-    return '';
-  }, [url, centrifugoToken?.centrifugo_url]);
-
-  const autoConnect = autoConnectProp &&
-                      (isAuthenticated && !isLoading) &&
-                      enabled &&
-                      hasCentrifugoToken;
-
-  useEffect(() => {
-    if (!isLoading) {
-      logger.info(`[RPC] Auto-connect decision: ${autoConnect ? 'YES' : 'NO'}`);
-      logger.info(`[RPC]   - Authenticated: ${isAuthenticated}`);
-      logger.info(`[RPC]   - Auth loading: ${isLoading}`);
-      logger.info(`[RPC]   - Centrifugo enabled: ${enabled}`);
-      logger.info(`[RPC]   - Centrifugo token from profile: ${hasCentrifugoToken}`);
-      logger.info(`[RPC]   - WebSocket URL: ${wsUrl}`);
-
-      if (hasCentrifugoToken && centrifugoToken) {
-        logger.info(`[RPC]   - Channels: ${centrifugoToken.channels?.join(', ')}`);
-      }
-    }
-  }, [autoConnect, isAuthenticated, isLoading, enabled, hasCentrifugoToken, centrifugoToken, logger, wsUrl]);
-
-  const connect = useCallback(async () => {
-    if (hasConnectedRef.current || isConnectingRef.current) return;
-    if (isConnecting || isConnected) return;
-
-    isConnectingRef.current = true;
-    setIsConnecting(true);
-    setError(null);
-
-    try {
-      logger.info('Connecting to WebSocket RPC server...');
-
-      if (!centrifugoToken?.token) {
-        throw new Error('No Centrifugo token available in user profile. Please refresh the page.');
-      }
-
-      const token = centrifugoToken.token;
-      let userId = user?.id?.toString() || '1';
-
-      if (!user?.id) {
-        try {
-          const tokenPayload = JSON.parse(atob(token.split('.')[1]));
-          userId = tokenPayload.user_id?.toString() || tokenPayload.sub?.toString() || '1';
-        } catch (err) {
-          // Silently fallback
-        }
-      }
-
-      const baseRPC = new RPCClientClass(wsUrl, token, userId);
-      await baseRPC.connect();
-
-      if (!isMountedRef.current) {
-        baseRPC.disconnect();
-        isConnectingRef.current = false;
-        return;
-      }
-
-      const rpcClient = new APIClientClass(baseRPC);
-
-      hasConnectedRef.current = true;
-      isConnectingRef.current = false;
-
-      setBaseClient(baseRPC);
-      setClient(rpcClient);
-      setIsConnected(true);
-      setError(null);
-
-      logger.success('WebSocket RPC connected successfully');
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error('Connection failed');
-      setError(error);
-      setBaseClient(null);
-      setClient(null);
-      setIsConnected(false);
-      hasConnectedRef.current = false;
-      isConnectingRef.current = false;
-
-      const isAuthError = error.message.includes('token') ||
-                          error.message.includes('auth') ||
-                          error.message.includes('expired');
-
-      if (isAuthError) {
-        logger.error('WebSocket RPC authentication failed', error);
-      } else {
-        logger.error('WebSocket RPC connection failed', error);
-        reconnectTimeoutRef.current = setTimeout(() => {
-          logger.info('Attempting to reconnect...');
-          connect();
-        }, 5000);
-      }
-    } finally {
-      setIsConnecting(false);
-    }
-  }, [wsUrl, centrifugoToken, user, logger, RPCClientClass, APIClientClass, isConnecting, isConnected]);
-
-  const disconnect = useCallback(() => {
-    if (isConnectingRef.current) return;
-
-    if (reconnectTimeoutRef.current) {
-      clearTimeout(reconnectTimeoutRef.current);
-      reconnectTimeoutRef.current = null;
-    }
-
-    if (baseClient) {
-      logger.info('Disconnecting from WebSocket RPC server...');
-      baseClient.disconnect();
-      setBaseClient(null);
-      setClient(null);
-      setIsConnected(false);
-      setError(null);
-    }
-
-    hasConnectedRef.current = false;
-    isConnectingRef.current = false;
-  }, [baseClient, logger]);
-
-  const reconnect = useCallback(async () => {
-    disconnect();
-    await connect();
-  }, [connect, disconnect]);
-
-  useEffect(() => {
-    isMountedRef.current = true;
-
-    if (autoConnect && !hasConnectedRef.current) {
-      connect();
-    }
-
-    return () => {
-      if (isConnectingRef.current && !hasConnectedRef.current) {
-        return;
-      }
-
-      if (!hasConnectedRef.current) {
-        return;
-      }
-
-      isMountedRef.current = false;
-      disconnect();
-    };
-  }, [autoConnect, connect, disconnect]);
-
-  const connectionState = isConnected
-    ? 'connected'
-    : isConnecting
-    ? 'connecting'
-    : error
-    ? 'error'
-    : 'disconnected';
-
-  const value: CentrifugoContextValue = {
-    client,
-    baseClient,
-    isConnected,
-    isConnecting,
-    error,
-    connectionState,
-    enabled,
-    connect,
-    disconnect,
-    reconnect,
-  };
-
-  return (
-    <CentrifugoContext.Provider value={value}>
-      {children}
-      <CentrifugoDebug />
-    </CentrifugoContext.Provider>
-  );
-}
-
-export function useCentrifugo(): CentrifugoContextValue {
-  const context = useContext(CentrifugoContext);
-
-  if (context === undefined) {
-    throw new Error('useCentrifugo must be used within a CentrifugoProvider');
-  }
-
-  return context;
-}

package/src/context/index.ts

@@ -1,5 +0,0 @@
-/**
- * Centrifugo Providers
- */
-
-export { CentrifugoProvider, useCentrifugo } from './CentrifugoProvider';

package/src/hooks/useLogger.ts

@@ -1,69 +0,0 @@
-/**
- * Centrifugo Logger Hook
- *
- * React hook for Centrifugo logging using consola library.
- */
-
-'use client';
-
-import { useMemo } from 'react';
-import { createConsola, type ConsolaInstance } from 'consola';
-
-export interface CentrifugoLogger {
-  info: (message: string) => void;
-  debug: (message: string) => void;
-  warning: (message: string) => void;
-  error: (message: string, error?: Error) => void;
-  success: (message: string) => void;
-}
-
-/**
- * React hook for Centrifugo logger with consola
- *
- * @param isDevelopment - Enable debug logging (optional)
- * @returns Centrifugo logger instance
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const logger = useCentrifugoLogger();
- *   logger.info('Connected to Centrifugo server');
- * }
- * ```
- */
-export function useCentrifugoLogger(isDevelopment = process.env.NODE_ENV === 'development'): CentrifugoLogger {
-  const logger = useMemo(() => {
-    const consola = createConsola({
-      level: isDevelopment ? 4 : 3, // debug in dev, info in prod
-      formatOptions: {
-        colors: true,
-        date: false,
-        compact: !isDevelopment,
-      },
-    }).withTag('Centrifugo');
-
-    return {
-      info: (message: string) => {
-        if (isDevelopment) consola.info(message);
-      },
-      debug: (message: string) => {
-        if (isDevelopment) consola.debug(message);
-      },
-      warning: (message: string) => {
-        if (isDevelopment) consola.warn(message);
-      },
-      error: (message: string, error?: Error) => {
-        consola.error(message, error || '');
-      },
-      success: (message: string) => {
-        if (isDevelopment) consola.success(message);
-      },
-    };
-  }, [isDevelopment]);
-
-  return logger;
-}
-
-// Alias for backward compatibility
-export const useRPCLogger = useCentrifugoLogger;
-export type RPCLogger = CentrifugoLogger;

package/src/types/index.ts

@@ -1,45 +0,0 @@
-/**
- * Centrifugo Package Types
- */
-
-export interface CentrifugoToken {
-  token: string;
-  centrifugo_url: string;
-  channels: string[];
-  expires_at: string;
-}
-
-export interface User {
-  id: number;
-  centrifugo?: CentrifugoToken;
-}
-
-export interface CentrifugoProviderProps {
-  children: React.ReactNode;
-  /** Is Centrifugo enabled */
-  enabled?: boolean;
-  /** Base RPC client class */
-  RPCClientClass: any;
-  /** API client wrapper class */
-  APIClientClass: any;
-  /** Custom WebSocket URL (defaults to user profile URL) */
-  url?: string;
-  /** Auto-connect on mount (default: true) */
-  autoConnect?: boolean;
-}
-
-export interface CentrifugoContextValue {
-  // Connection State
-  client: any;
-  baseClient: any;
-  isConnected: boolean;
-  isConnecting: boolean;
-  error: Error | null;
-  connectionState: string;
-  enabled: boolean;
-
-  // Connection Methods
-  connect: () => Promise<void>;
-  disconnect: () => void;
-  reconnect: () => Promise<void>;
-}