django-cfg 1.5.14__py3-none-any.whl → 1.5.20__py3-none-any.whl

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.5.14"
+__version__ = "1.5.20"
 __license__ = "MIT"
 
 # Setup warnings debug early (checks env var only at this point)

django_cfg/apps/business/accounts/serializers/profile.py

@@ -4,6 +4,24 @@ from rest_framework import serializers
 from ..models import CustomUser, RegistrationSource, UserRegistrationSource
 
 
+class CentrifugoTokenSerializer(serializers.Serializer):
+    """Nested serializer for Centrifugo WebSocket connection token."""
+
+    token = serializers.CharField(
+        help_text="JWT token for Centrifugo WebSocket connection"
+    )
+    centrifugo_url = serializers.URLField(
+        help_text="Centrifugo WebSocket URL"
+    )
+    expires_at = serializers.DateTimeField(
+        help_text="Token expiration time (ISO 8601)"
+    )
+    channels = serializers.ListField(
+        child=serializers.CharField(),
+        help_text="List of allowed channels for this user"
+    )
+
+
 class UserSerializer(serializers.ModelSerializer):
     """Serializer for user details."""
 
@@ -11,6 +29,7 @@ class UserSerializer(serializers.ModelSerializer):
     initials = serializers.ReadOnlyField()
     display_username = serializers.ReadOnlyField()
     avatar = serializers.SerializerMethodField()
+    centrifugo = serializers.SerializerMethodField()
 
     class Meta:
         model = CustomUser
@@ -31,6 +50,7 @@ class UserSerializer(serializers.ModelSerializer):
             "date_joined",
             "last_login",
             "unanswered_messages_count",
+            "centrifugo",
         ]
         read_only_fields = [
             "id",
@@ -52,6 +72,28 @@ class UserSerializer(serializers.ModelSerializer):
             return obj.avatar.url
         return None
 
+    @extend_schema_field(CentrifugoTokenSerializer(allow_null=True))
+    def get_centrifugo(self, obj):
+        """
+        Generate Centrifugo WebSocket connection token if enabled.
+
+        Returns None if Centrifugo is disabled in config.
+        """
+        try:
+            # Import here to avoid circular imports
+            from django_cfg.apps.integrations.centrifugo.services import generate_centrifugo_token
+
+            # Generate token with user's channels
+            token_data = generate_centrifugo_token(obj)
+            return token_data
+
+        except ValueError:
+            # Centrifugo not configured or disabled
+            return None
+        except Exception:
+            # If token generation fails, return None (don't break profile response)
+            return None
+
 
 
 class UserProfileUpdateSerializer(serializers.ModelSerializer):

django_cfg/apps/business/support/serializers.py

@@ -8,13 +8,14 @@ from .models import Message, Ticket
 User = get_user_model()
 
 class SenderSerializer(serializers.ModelSerializer):
-    avatar = serializers.SerializerMethodField()
+    avatar = serializers.SerializerMethodField(allow_null=True)
     initials = serializers.ReadOnlyField()
 
     class Meta:
         model = User
         fields = ['id', 'display_username', 'email', 'avatar', 'initials', 'is_staff', 'is_superuser']
-        read_only_fields = fields
+        # Don't include avatar in read_only_fields to make it optional in OpenAPI schema
+        read_only_fields = ['id', 'display_username', 'email', 'initials', 'is_staff', 'is_superuser']
 
     def get_avatar(self, obj) -> Optional[str]:
         if obj.avatar:

django_cfg/apps/integrations/centrifugo/apps.py

@@ -32,6 +32,7 @@ class CentrifugoConfig(AppConfig):
         Initialize app when Django starts.
 
         Validates that all required Centrifugo dependencies are installed.
+        Registers signal handlers for JWT token customization.
         """
         from django_cfg.modules.django_logging import get_logger
 
@@ -40,7 +41,7 @@ class CentrifugoConfig(AppConfig):
         # Check dependencies if needed (only when using Centrifugo features)
         self._check_dependencies_if_needed()
 
-        logger.info("Centrifugo app initialized")
+        logger.info("Centrifugo app initialized (middleware will inject JWT tokens)")
 
     def _check_dependencies_if_needed(self):
         """

django_cfg/apps/integrations/centrifugo/codegen/generators/typescript_thin/templates/rpc-client.ts.j2

@@ -10,6 +10,7 @@ import { Centrifuge } from 'centrifuge';
 export class CentrifugoRPCClient {
   private centrifuge: Centrifuge;
   private subscription: any;
+  private channelSubscriptions: Map<string, any> = new Map();
   private pendingRequests: Map<string, { resolve: Function; reject: Function }> = new Map();
   private readonly replyChannel: string;
   private readonly timeout: number;
@@ -27,12 +28,7 @@ export class CentrifugoRPCClient {
       token,
     });
 
-    this.centrifuge.on('connected', (ctx) => {
-      console.log('✅ Connected to Centrifugo');
-    });
-
     this.centrifuge.on('disconnected', (ctx) => {
-      console.warn('Disconnected:', ctx);
       // Reject all pending requests
       this.pendingRequests.forEach(({ reject }) => {
         reject(new Error('Disconnected from Centrifugo'));
@@ -43,6 +39,27 @@ export class CentrifugoRPCClient {
 
   async connect(): Promise<void> {
     return new Promise((resolve, reject) => {
+      let resolved = false;
+
+      // Listen to Centrifuge connection events
+      const onConnected = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+
+      const onError = (ctx: any) => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(ctx.message || 'Connection error'));
+        }
+      };
+
+      this.centrifuge.on('connected', onConnected);
+      this.centrifuge.on('error', onError);
+
+      // Start connection
       this.centrifuge.connect();
 
       // Subscribe to reply channel
@@ -53,11 +70,17 @@ export class CentrifugoRPCClient {
       });
 
       this.subscription.on('subscribed', () => {
-        resolve();
+        // Subscription successful (optional, we already resolved on 'connected')
       });
 
       this.subscription.on('error', (ctx: any) => {
-        reject(new Error(ctx.error?.message || 'Subscription error'));
+        // Error code 105 = "already subscribed" (server-side subscription from JWT)
+        // This is not an error - the channel is already active via server-side subscription
+        if (ctx.error?.code === 105) {
+          // This is fine, server-side subscription exists
+        } else {
+          console.error(`Subscription error for ${this.replyChannel}:`, ctx.error);
+        }
       });
 
       this.subscription.subscribe();
@@ -65,9 +88,14 @@ export class CentrifugoRPCClient {
   }
 
   async disconnect(): Promise<void> {
+    // Unsubscribe from all event channels
+    this.unsubscribeAll();
+
+    // Unsubscribe from RPC reply channel
     if (this.subscription) {
       this.subscription.unsubscribe();
     }
+
     this.centrifuge.disconnect();
   }
 
@@ -103,21 +131,17 @@ export class CentrifugoRPCClient {
     // Publish request
     await this.centrifuge.publish('rpc.requests', message);
 
-    console.log(`📤 RPC call: ${method} (${correlationId})`);
-
     return promise;
   }
 
   private handleResponse(data: any): void {
     const correlationId = data.correlation_id;
     if (!correlationId) {
-      console.warn('Received response without correlation_id');
       return;
     }
 
     const pending = this.pendingRequests.get(correlationId);
     if (!pending) {
-      console.warn(`Received response for unknown correlation_id: ${correlationId}`);
       return;
     }
 
@@ -126,7 +150,6 @@ export class CentrifugoRPCClient {
     if (data.error) {
       pending.reject(new Error(data.error.message || 'RPC error'));
     } else {
-      console.log(`📥 RPC response: ${correlationId}`);
       pending.resolve(data.result);
     }
   }
@@ -134,4 +157,120 @@ export class CentrifugoRPCClient {
   private generateCorrelationId(): string {
     return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
   }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Channel Subscription API (for gRPC events)
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Subscribe to a Centrifugo channel for real-time events.
+   *
+   * @param channel - Channel name (e.g., 'bot#bot-123#heartbeat')
+   * @param callback - Callback for received messages
+   * @returns Unsubscribe function
+   *
+   * @example
+   * const unsubscribe = client.subscribe('bot#bot-123#heartbeat', (data) => {
+   *   console.log('Heartbeat:', data);
+   * });
+   *
+   * // Later: unsubscribe when done
+   * unsubscribe();
+   */
+  subscribe(channel: string, callback: (data: any) => void): () => void {
+    // Check if already subscribed
+    if (this.channelSubscriptions.has(channel)) {
+      return () => {}; // Return no-op unsubscribe
+    }
+
+    // Create new subscription
+    const sub = this.centrifuge.newSubscription(channel);
+
+    // Handle publications
+    sub.on('publication', (ctx: any) => {
+      callback(ctx.data);
+    });
+
+    // Handle subscription lifecycle
+    sub.on('subscribed', () => {
+      // Subscription successful
+    });
+
+    sub.on('error', (ctx: any) => {
+      console.error(`Subscription error for ${channel}:`, ctx.error);
+    });
+
+    // Start subscription
+    sub.subscribe();
+
+    // Store subscription
+    this.channelSubscriptions.set(channel, sub);
+
+    // Return unsubscribe function
+    return () => this.unsubscribe(channel);
+  }
+
+  /**
+   * Unsubscribe from a channel.
+   *
+   * @param channel - Channel name
+   */
+  unsubscribe(channel: string): void {
+    const sub = this.channelSubscriptions.get(channel);
+    if (!sub) {
+      return;
+    }
+
+    sub.unsubscribe();
+    this.channelSubscriptions.delete(channel);
+  }
+
+  /**
+   * Unsubscribe from all channels.
+   */
+  unsubscribeAll(): void {
+    if (this.channelSubscriptions.size === 0) {
+      return;
+    }
+
+    this.channelSubscriptions.forEach((sub, channel) => {
+      sub.unsubscribe();
+    });
+    this.channelSubscriptions.clear();
+  }
+
+  /**
+   * Get list of active client-side subscriptions.
+   */
+  getActiveSubscriptions(): string[] {
+    return Array.from(this.channelSubscriptions.keys());
+  }
+
+  /**
+   * Get list of server-side subscriptions (from JWT token).
+   *
+   * These are channels automatically subscribed by Centrifugo server
+   * based on the 'channels' claim in the JWT token.
+   */
+  getServerSideSubscriptions(): string[] {
+    try {
+      // Access Centrifuge.js internal state for server-side subs
+      // @ts-ignore - accessing internal property
+      const serverSubs = this.centrifuge._serverSubs || {};
+      return Object.keys(serverSubs);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Get all active subscriptions (both client-side and server-side).
+   */
+  getAllSubscriptions(): string[] {
+    const clientSubs = this.getActiveSubscriptions();
+    const serverSubs = this.getServerSideSubscriptions();
+
+    // Combine and deduplicate
+    return Array.from(new Set([...clientSubs, ...serverSubs]));
+  }
 }

django_cfg/apps/integrations/centrifugo/management/commands/generate_centrifugo_clients.py

@@ -6,6 +6,7 @@ Usage:
     python manage.py generate_centrifugo_clients -o ./clients --python --verbose
 """
 
+import logging
 from pathlib import Path
 from typing import List
 
@@ -131,11 +132,10 @@ class Command(AdminCommand):
         if not methods:
             self.stdout.write(
                 colorize(
-                    "No RPC methods found. Did you register handlers with @websocket_rpc?",
+                    "⚠️  No RPC methods found. Will generate base RPC client without API methods.",
                     fg="yellow",
                 )
             )
-            return
 
         # Create output directory
         output_dir.mkdir(parents=True, exist_ok=True)

django_cfg/apps/integrations/centrifugo/services/__init__.py

@@ -5,8 +5,14 @@ Business logic layer for Centrifugo integration.
 """
 
 from .config_helper import get_centrifugo_config, get_centrifugo_config_or_default
+from .publisher import CentrifugoPublisher, get_centrifugo_publisher
+from .token_generator import get_user_channels, generate_centrifugo_token
 
 __all__ = [
     "get_centrifugo_config",
     "get_centrifugo_config_or_default",
+    "CentrifugoPublisher",
+    "get_centrifugo_publisher",
+    "get_user_channels",
+    "generate_centrifugo_token",
 ]

django_cfg/apps/integrations/centrifugo/services/client/__init__.py

@@ -1,11 +1,14 @@
 """
 Centrifugo Client.
 
-Django client for publishing messages to Centrifugo via Python Wrapper.
+Two client implementations:
+- CentrifugoClient: Via wrapper (for external API, with auth & logging)
+- DirectCentrifugoClient: Direct to Centrifugo (for internal use, lightweight)
 """
 
 from .client import CentrifugoClient, PublishResponse, get_centrifugo_client
 from .config import DjangoCfgCentrifugoConfig
+from .direct_client import DirectCentrifugoClient, get_direct_centrifugo_client
 from .exceptions import (
     CentrifugoBaseException,
     CentrifugoConfigurationError,
@@ -19,6 +22,8 @@ __all__ = [
     "DjangoCfgCentrifugoConfig",
     "CentrifugoClient",
     "get_centrifugo_client",
+    "DirectCentrifugoClient",
+    "get_direct_centrifugo_client",
     "PublishResponse",
     "CentrifugoBaseException",
     "CentrifugoTimeoutError",

django_cfg/apps/integrations/centrifugo/services/client/direct_client.py

@@ -0,0 +1,282 @@
+"""
+Direct Centrifugo Client.
+
+Lightweight client for internal Django-to-Centrifugo communication.
+Bypasses wrapper and connects directly to Centrifugo HTTP API.
+
+Use this for:
+- Internal gRPC events
+- Demo/test events
+- Background tasks
+- Any server-side publishing
+
+Use CentrifugoClient (with wrapper) for:
+- External API calls (from Next.js frontend)
+- When you need Django authorization
+- When you need wrapper-level logging
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+from uuid import uuid4
+
+import httpx
+from django_cfg.modules.django_logging import get_logger
+
+from .exceptions import (
+    CentrifugoConfigurationError,
+    CentrifugoConnectionError,
+    CentrifugoPublishError,
+)
+
+logger = get_logger("centrifugo.direct_client")
+
+
+class PublishResponse:
+    """Response from direct publish operation."""
+
+    def __init__(self, message_id: str, published: bool):
+        self.message_id = message_id
+        self.published = published
+        self.delivered = published  # For compatibility
+
+
+class DirectCentrifugoClient:
+    """
+    Direct Centrifugo HTTP API client.
+
+    Connects directly to Centrifugo without going through Django wrapper.
+    Uses Centrifugo JSON-RPC format: POST /api with {method, params}.
+
+    Features:
+    - No database logging (lightweight)
+    - No wrapper overhead
+    - Direct API key authentication
+    - Minimal latency for internal calls
+
+    Example:
+        >>> from django_cfg.apps.integrations.centrifugo.services.client import DirectCentrifugoClient
+        >>>
+        >>> client = DirectCentrifugoClient(
+        ...     api_url="http://localhost:7120/api",
+        ...     api_key="your-api-key"
+        ... )
+        >>>
+        >>> result = await client.publish(
+        ...     channel="grpc#bot#123",
+        ...     data={"status": "running"}
+        ... )
+    """
+
+    def __init__(
+        self,
+        api_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        http_timeout: int = 10,
+        max_retries: int = 3,
+        retry_delay: float = 0.5,
+        verify_ssl: bool = False,
+    ):
+        """
+        Initialize direct Centrifugo client.
+
+        Args:
+            api_url: Centrifugo HTTP API URL (e.g., "http://localhost:8000/api")
+            api_key: Centrifugo API key for authentication
+            http_timeout: HTTP request timeout (seconds)
+            max_retries: Maximum retry attempts
+            retry_delay: Delay between retries (seconds)
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self.api_url = api_url or self._get_api_url_from_settings()
+        self.api_key = api_key or self._get_api_key_from_settings()
+        self.http_timeout = http_timeout
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+        self.verify_ssl = verify_ssl
+
+        # Create HTTP client
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"apikey {self.api_key}"
+
+        self._http_client = httpx.AsyncClient(
+            base_url=self.api_url.rstrip("/api"),  # Remove /api from base
+            headers=headers,
+            timeout=httpx.Timeout(self.http_timeout),
+            limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
+            verify=self.verify_ssl,
+        )
+
+        logger.info(f"DirectCentrifugoClient initialized: {self.api_url}")
+
+    def _get_api_url_from_settings(self) -> str:
+        """Get Centrifugo API URL from django-cfg config."""
+        from ..config_helper import get_centrifugo_config
+
+        config = get_centrifugo_config()
+
+        if config and config.centrifugo_api_url:
+            return config.centrifugo_api_url
+
+        raise CentrifugoConfigurationError(
+            "Centrifugo API URL not configured",
+            config_key="centrifugo.centrifugo_api_url",
+        )
+
+    def _get_api_key_from_settings(self) -> str:
+        """Get Centrifugo API key from django-cfg config."""
+        from ..config_helper import get_centrifugo_config
+
+        config = get_centrifugo_config()
+
+        if config and config.centrifugo_api_key:
+            return config.centrifugo_api_key
+
+        raise CentrifugoConfigurationError(
+            "Centrifugo API key not configured",
+            config_key="centrifugo.centrifugo_api_key",
+        )
+
+    async def publish(
+        self,
+        channel: str,
+        data: Dict[str, Any],
+    ) -> PublishResponse:
+        """
+        Publish message to Centrifugo channel.
+
+        Args:
+            channel: Centrifugo channel name
+            data: Message data dict
+
+        Returns:
+            PublishResponse with result
+
+        Raises:
+            CentrifugoPublishError: If publish fails
+            CentrifugoConnectionError: If connection fails
+
+        Example:
+            >>> result = await client.publish(
+            ...     channel="grpc#bot#123#status",
+            ...     data={"status": "running", "timestamp": "2025-11-05T09:00:00Z"}
+            ... )
+        """
+        message_id = str(uuid4())
+        start_time = time.time()
+
+        # Centrifugo JSON-RPC format
+        payload = {
+            "method": "publish",
+            "params": {
+                "channel": channel,
+                "data": data,
+            },
+        }
+
+        last_error = None
+
+        for attempt in range(self.max_retries):
+            try:
+                response = await self._http_client.post("/api", json=payload)
+
+                if response.status_code == 200:
+                    result = response.json()
+
+                    # Check for Centrifugo error
+                    if "error" in result and result["error"]:
+                        error_msg = result["error"].get("message", "Unknown error")
+                        raise CentrifugoPublishError(
+                            f"Centrifugo API error: {error_msg}",
+                            channel=channel,
+                        )
+
+                    duration_ms = int((time.time() - start_time) * 1000)
+                    logger.debug(
+                        f"Published to {channel} (message_id={message_id}, {duration_ms}ms)"
+                    )
+
+                    return PublishResponse(message_id=message_id, published=True)
+
+                else:
+                    raise CentrifugoPublishError(
+                        f"HTTP {response.status_code}: {response.text}",
+                        channel=channel,
+                    )
+
+            except httpx.ConnectError as e:
+                last_error = CentrifugoConnectionError(
+                    f"Failed to connect to Centrifugo: {e}",
+                    url=self.api_url,
+                )
+                logger.warning(
+                    f"Connection attempt {attempt + 1}/{self.max_retries} failed: {e}"
+                )
+
+            except Exception as e:
+                last_error = CentrifugoPublishError(
+                    f"Publish failed: {e}",
+                    channel=channel,
+                )
+                logger.error(f"Publish attempt {attempt + 1}/{self.max_retries} failed: {e}")
+
+            # Retry delay
+            if attempt < self.max_retries - 1:
+                import asyncio
+                await asyncio.sleep(self.retry_delay)
+
+        # All retries failed
+        if last_error:
+            raise last_error
+        else:
+            raise CentrifugoPublishError(
+                f"Failed to publish after {self.max_retries} attempts",
+                channel=channel,
+            )
+
+    async def close(self):
+        """Close HTTP client connection."""
+        await self._http_client.aclose()
+        logger.debug("DirectCentrifugoClient closed")
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+
+
+# Singleton instance
+_direct_client_instance: Optional[DirectCentrifugoClient] = None
+
+
+def get_direct_centrifugo_client() -> DirectCentrifugoClient:
+    """
+    Get singleton DirectCentrifugoClient instance.
+
+    Returns:
+        DirectCentrifugoClient instance
+
+    Example:
+        >>> from django_cfg.apps.integrations.centrifugo.services.client import get_direct_centrifugo_client
+        >>> client = get_direct_centrifugo_client()
+        >>> await client.publish(channel="test", data={"foo": "bar"})
+    """
+    global _direct_client_instance
+
+    if _direct_client_instance is None:
+        _direct_client_instance = DirectCentrifugoClient()
+
+    return _direct_client_instance
+
+
+__all__ = [
+    "DirectCentrifugoClient",
+    "get_direct_centrifugo_client",
+    "PublishResponse",
+]