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

django_cfg/apps/integrations/grpc/views/charts.py

@@ -72,8 +72,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_server_uptime_data(hours)
-            serializer = ServerUptimeChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ServerUptimeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Server uptime chart error: {e}", exc_info=True)
             return Response(
@@ -94,8 +95,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_request_volume_data(hours)
-            serializer = RequestVolumeChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = RequestVolumeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Request volume chart error: {e}", exc_info=True)
             return Response(
@@ -116,8 +118,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_response_time_data(hours)
-            serializer = ResponseTimeChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ResponseTimeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Response time chart error: {e}", exc_info=True)
             return Response(
@@ -138,8 +141,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_service_activity_data(hours)
-            serializer = ServiceActivityChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ServiceActivityChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Service activity chart error: {e}", exc_info=True)
             return Response(
@@ -160,8 +164,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_server_lifecycle_data(hours)
-            serializer = ServerLifecycleChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ServerLifecycleChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Server lifecycle chart error: {e}", exc_info=True)
             return Response(
@@ -182,8 +187,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_error_distribution_data(hours)
-            serializer = ErrorDistributionChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ErrorDistributionChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Error distribution chart error: {e}", exc_info=True)
             return Response(
@@ -204,8 +210,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_dashboard_data(hours)
-            serializer = DashboardChartsSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = DashboardChartsSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Dashboard charts error: {e}", exc_info=True)
             return Response(

django_cfg/apps/integrations/grpc/views/config.py

@@ -67,7 +67,7 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                     "host": grpc_config.server.host,
                     "port": grpc_config.server.port,
                     "enabled": grpc_config.server.enabled,
-                    "max_workers": grpc_config.server.max_workers,
+                    "max_concurrent_streams": grpc_config.server.max_concurrent_streams,
                     "max_concurrent_rpcs": None,  # Not in current config
                 },
                 "framework": {
@@ -77,7 +77,7 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                     "interceptors": grpc_config.server.interceptors,
                 },
                 "features": {
-                    "jwt_auth": grpc_config.auth.enabled,
+                    "api_key_auth": grpc_config.auth.enabled,
                     "request_logging": True,  # Always on
                     "metrics": True,  # Always on
                     "reflection": grpc_config.server.enable_reflection,
@@ -86,8 +86,9 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                 "total_methods": methods_count,
             }
 
-            serializer = GRPCConfigSerializer(**config_data)
-            return Response(serializer.model_dump())
+            serializer = GRPCConfigSerializer(data=config_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Config fetch error: {e}", exc_info=True)
@@ -177,8 +178,9 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                 },
             }
 
-            serializer = GRPCServerInfoSerializer(**server_info_data)
-            return Response(serializer.model_dump())
+            serializer = GRPCServerInfoSerializer(data=server_info_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Server info error: {e}", exc_info=True)

django_cfg/apps/integrations/grpc/views/monitoring.py

@@ -11,6 +11,7 @@ from django.db import models
 from django.db.models import Avg, Count, Max
 from django.db.models.functions import TruncDay, TruncHour
 from django_cfg.mixins import AdminAPIMixin
+from django_cfg.middleware.pagination import DefaultPagination
 from django_cfg.modules.django_logging import get_logger
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, extend_schema
@@ -24,8 +25,6 @@ from ..serializers import (
     GRPCOverviewStatsSerializer,
     MethodListSerializer,
     MethodStatsSerializer,
-    MonitoringServiceStatsSerializer,
-    ServiceListSerializer,
 )
 from ..serializers.service_registry import RecentRequestSerializer
 from ..services import MonitoringService
@@ -48,6 +47,8 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     Requires admin authentication (JWT, Session, or Basic Auth).
     """
 
+    pagination_class = DefaultPagination
+
     # Required for GenericViewSet
     queryset = GRPCRequestLog.objects.none()  # Placeholder, actual queries in actions
     serializer_class = RecentRequestSerializer  # Default serializer for schema
@@ -67,7 +68,9 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
         try:
             service = MonitoringService()
             health_data = service.get_health_status()
-            return Response(health_data)
+            serializer = GRPCHealthCheckSerializer(data=health_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except ValueError as e:
             return Response(
@@ -107,7 +110,9 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
 
             service = MonitoringService()
             stats = service.get_overview_statistics(hours=hours)
-            return Response(stats)
+            serializer = GRPCOverviewStatsSerializer(data=stats)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except ValueError as e:
             logger.warning(f"Overview stats validation error: {e}")
@@ -149,7 +154,7 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
             ),
         ],
         responses={
-            200: RecentRequestSerializer,
+            200: RecentRequestSerializer(many=True),  # Use many=True for paginated list
             400: {"description": "Invalid parameters"},
         },
     )
@@ -174,37 +179,49 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 # Serialize paginated data
                 requests_list = []
                 for req in page:
-                    req_serializer = RecentRequestSerializer(
-                        id=req.id,
-                        request_id=req.request_id,
-                        service_name=req.service_name,
-                        method_name=req.method_name,
-                        status=req.status,
-                        duration_ms=req.duration_ms or 0,
-                        grpc_status_code=req.grpc_status_code or "",
-                        error_message=req.error_message or "",
-                        created_at=req.created_at.isoformat(),
-                        client_ip=req.client_ip or "",
-                    )
-                    requests_list.append(req_serializer.model_dump())
+                    requests_list.append({
+                        "id": req.id,
+                        "request_id": req.request_id,
+                        "service_name": req.service_name,
+                        "method_name": req.method_name,
+                        "status": req.status,
+                        "duration_ms": req.duration_ms or 0,
+                        "grpc_status_code": req.grpc_status_code or "",
+                        "error_message": req.error_message or "",
+                        "created_at": req.created_at.isoformat(),
+                        "client_ip": req.client_ip or "",
+                        # User information
+                        "user_id": req.user.id if req.user else None,
+                        "username": req.user.username if req.user else "",
+                        "is_authenticated": req.is_authenticated,
+                        # API Key information
+                        "api_key_id": req.api_key.id if req.api_key else None,
+                        "api_key_name": req.api_key.name if req.api_key else "",
+                    })
                 return self.get_paginated_response(requests_list)
 
             # No pagination fallback
             requests_list = []
             for req in queryset[:100]:
-                req_serializer = RecentRequestSerializer(
-                    id=req.id,
-                    request_id=req.request_id,
-                    service_name=req.service_name,
-                    method_name=req.method_name,
-                    status=req.status,
-                    duration_ms=req.duration_ms or 0,
-                    grpc_status_code=req.grpc_status_code or "",
-                    error_message=req.error_message or "",
-                    created_at=req.created_at.isoformat(),
-                    client_ip=req.client_ip or "",
-                )
-                requests_list.append(req_serializer.model_dump())
+                requests_list.append({
+                    "id": req.id,
+                    "request_id": req.request_id,
+                    "service_name": req.service_name,
+                    "method_name": req.method_name,
+                    "status": req.status,
+                    "duration_ms": req.duration_ms or 0,
+                    "grpc_status_code": req.grpc_status_code or "",
+                    "error_message": req.error_message or "",
+                    "created_at": req.created_at.isoformat(),
+                    "client_ip": req.client_ip or "",
+                    # User information
+                    "user_id": req.user.id if req.user else None,
+                    "username": req.user.username if req.user else "",
+                    "is_authenticated": req.is_authenticated,
+                    # API Key information
+                    "api_key_id": req.api_key.id if req.api_key else None,
+                    "api_key_name": req.api_key.name if req.api_key else "",
+                })
             return Response({"requests": requests_list, "count": len(requests_list)})
 
         except ValueError as e:
@@ -219,52 +236,6 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
-    @extend_schema(
-        tags=["gRPC Monitoring"],
-        summary="Get service statistics",
-        description="Returns statistics grouped by service.",
-        parameters=[
-            OpenApiParameter(
-                name="hours",
-                type=OpenApiTypes.INT,
-                location=OpenApiParameter.QUERY,
-                description="Statistics period in hours (default: 24)",
-                required=False,
-            ),
-        ],
-        responses={
-            200: ServiceListSerializer,
-            400: {"description": "Invalid parameters"},
-        },
-    )
-    @action(detail=False, methods=["get"], url_path="services", pagination_class=None)
-    def services(self, request):
-        """Get statistics per service."""
-        try:
-            hours = int(request.GET.get("hours", 24))
-
-            service = MonitoringService()
-            services_list = service.get_service_statistics(hours=hours)
-
-            response_data = {
-                "services": services_list,
-                "total_services": len(services_list),
-            }
-
-            return Response(response_data)
-
-        except ValueError as e:
-            logger.warning(f"Service stats validation error: {e}")
-            return Response(
-                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            logger.error(f"Service stats error: {e}", exc_info=True)
-            return Response(
-                {"error": "Internal server error"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
     @extend_schema(
         tags=["gRPC Monitoring"],
         summary="Get method statistics",
@@ -308,8 +279,9 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 "total_methods": len(methods_list),
             }
 
-            serializer = MethodListSerializer(**response_data)
-            return Response(serializer.model_dump())
+            serializer = MethodListSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except ValueError as e:
             logger.warning(f"Method stats validation error: {e}")

django_cfg/apps/integrations/grpc/views/proto_files.py

@@ -0,0 +1,214 @@
+"""
+gRPC Proto Files ViewSet.
+
+Provides REST API endpoints for downloading proto files generated from Django models.
+"""
+
+from django.http import FileResponse, HttpResponse
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.modules.django_logging import get_logger
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..serializers.proto_files import (
+    ProtoFileListSerializer,
+    ProtoGenerateRequestSerializer,
+    ProtoGenerateResponseSerializer,
+)
+from ..services import ProtoFilesManager
+
+logger = get_logger("grpc.proto_files")
+
+
+class GRPCProtoFilesViewSet(AdminAPIMixin, viewsets.ViewSet):
+    """
+    ViewSet for gRPC proto files management.
+
+    Provides endpoints for:
+    - List all available proto files
+    - Download specific proto file
+    - Download all proto files as .zip
+    - Trigger proto generation
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    lookup_value_regex = r'[^/]+'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.manager = ProtoFilesManager()
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="List all proto files",
+        description="Returns list of all available proto files with metadata.",
+        responses={
+            200: ProtoFileListSerializer,
+        },
+    )
+    def list(self, request):
+        """List all available proto files."""
+        try:
+            from django.urls import reverse
+            from django_cfg.core.state import get_current_config
+
+            proto_files = self.manager.scan_proto_files(request=request)
+
+            config = get_current_config()
+
+            # Build download-all URL
+            # Use api_url from config (respects HTTPS behind reverse proxy)
+            # Falls back to request.build_absolute_uri if config not available
+            if config and hasattr(config, 'api_url'):
+                path = reverse('django_cfg_grpc:proto-files-download-all')
+                download_all_url = f"{config.api_url}{path}"
+            else:
+                download_all_url = request.build_absolute_uri(
+                    reverse('django_cfg_grpc:proto-files-download-all')
+                )
+
+            response_data = {
+                "files": proto_files,
+                "total_files": len(proto_files),
+                "proto_dir": str(self.manager.get_proto_dir()),
+                "download_all_url": download_all_url,
+            }
+
+            serializer = ProtoFileListSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"Proto files list error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="Download proto file",
+        description="Download specific proto file by app label.",
+        parameters=[
+            OpenApiParameter(
+                name="pk",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.PATH,
+                description="App label (e.g., 'crypto')",
+                required=True,
+            ),
+        ],
+        responses={
+            200: {
+                "description": "Proto file content",
+                "content": {"text/plain": {}},
+            },
+            404: {"description": "Proto file not found"},
+        },
+    )
+    def retrieve(self, request, pk=None):
+        """Download specific proto file."""
+        try:
+            app_label = pk
+            proto_file = self.manager.get_proto_file(app_label)
+
+            if not proto_file:
+                return Response(
+                    {"error": f"Proto file for app '{app_label}' not found"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Return proto file content
+            response = FileResponse(
+                open(proto_file, "rb"),
+                content_type="text/plain; charset=utf-8",
+            )
+            response["Content-Disposition"] = f'attachment; filename="{proto_file.name}"'
+            return response
+
+        except Exception as e:
+            logger.error(f"Proto file download error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="Download all proto files",
+        description="Download all proto files as a .zip archive.",
+        responses={
+            200: {
+                "description": "Zip archive with all proto files",
+                "content": {"application/zip": {}},
+            },
+            404: {"description": "No proto files found"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="download-all")
+    def download_all(self, request):
+        """Download all proto files as .zip archive."""
+        try:
+            zip_data = self.manager.create_zip_archive()
+
+            if not zip_data:
+                return Response(
+                    {"error": "No proto files found"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Return zip file
+            response = HttpResponse(zip_data, content_type="application/zip")
+            response["Content-Disposition"] = 'attachment; filename="protos.zip"'
+            return response
+
+        except Exception as e:
+            logger.error(f"Proto files zip error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="Generate proto files",
+        description="Trigger proto file generation for specified apps.",
+        request=ProtoGenerateRequestSerializer,
+        responses={
+            200: ProtoGenerateResponseSerializer,
+            400: {"description": "Bad request"},
+        },
+    )
+    @action(detail=False, methods=["post"], url_path="generate")
+    def generate(self, request):
+        """Trigger proto generation for specified apps."""
+        try:
+            serializer = ProtoGenerateRequestSerializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+
+            apps = serializer.validated_data.get("apps")
+            force = serializer.validated_data.get("force", False)
+
+            # Generate protos via service
+            result = self.manager.generate_protos(apps=apps, force=force)
+
+            # Add proto_dir to response
+            result["proto_dir"] = str(self.manager.get_proto_dir())
+
+            response_serializer = ProtoGenerateResponseSerializer(data=result)
+            response_serializer.is_valid(raise_exception=True)
+            return Response(response_serializer.data)
+
+        except Exception as e:
+            logger.error(f"Proto generation error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCProtoFilesViewSet"]

django_cfg/apps/integrations/grpc/views/services.py

@@ -6,6 +6,7 @@ Provides REST API endpoints for viewing registered gRPC services and their metho
 
 from django.db import models
 from django.db.models import Avg, Count, Max, Min
+from django_cfg.middleware.pagination import DefaultPagination
 from django_cfg.mixins import AdminAPIMixin
 from django_cfg.modules.django_logging import get_logger
 from drf_spectacular.types import OpenApiTypes
@@ -20,13 +21,14 @@ from ..serializers.service_registry import (
     ServiceDetailSerializer,
     ServiceListSerializer,
     ServiceMethodsSerializer,
+    ServiceSummarySerializer,
 )
 from ..services import ServiceRegistryManager
 
 logger = get_logger("grpc.services")
 
 
-class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
+class GRPCServiceViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     """
     ViewSet for gRPC service registry and management.
 
@@ -39,13 +41,20 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
     Requires admin authentication (JWT, Session, or Basic Auth).
     """
 
+    # Pagination for list endpoint
+    pagination_class = DefaultPagination
+
+    # Required for GenericViewSet
+    queryset = GRPCRequestLog.objects.none()  # Placeholder
+    serializer_class = ServiceSummarySerializer
+
     # Allow dots in service names (e.g., apps.CryptoService)
     lookup_value_regex = r'[^/]+'
 
     @extend_schema(
         tags=["gRPC Services"],
         summary="List all services",
-        description="Returns list of all registered gRPC services with basic statistics.",
+        description="Returns paginated list of all registered gRPC services with basic statistics.",
         parameters=[
             OpenApiParameter(
                 name="hours",
@@ -54,13 +63,14 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
                 description="Statistics period in hours (default: 24)",
                 required=False,
             ),
+            # Note: page, page_size added automatically by pagination_class
         ],
         responses={
-            200: ServiceListSerializer,
+            200: ServiceSummarySerializer(many=True),
         },
     )
     def list(self, request):
-        """List all registered gRPC services."""
+        """List all registered gRPC services with pagination."""
         try:
             hours = int(request.GET.get("hours", 24))
             hours = min(max(hours, 1), 168)
@@ -68,23 +78,20 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
             # Use service registry manager
             registry = ServiceRegistryManager()
 
-            if not registry.is_server_running():
-                # No running server - return empty list
-                return Response({
-                    "services": [],
-                    "total_services": 0,
-                })
-
             # Get services with stats from service layer
+            # Note: This will return empty list if server is not running,
+            # but that's expected - services are only known when server is started
             services_list = registry.get_all_services_with_stats(hours=hours)
 
-            response_data = {
-                "services": services_list,
-                "total_services": len(services_list),
-            }
+            # Paginate the services list (works with empty list too)
+            page = self.paginate_queryset(services_list)
+            if page is not None:
+                serializer = ServiceSummarySerializer(page, many=True)
+                return self.get_paginated_response(serializer.data)
 
-            serializer = ServiceListSerializer(**response_data)
-            return Response(serializer.model_dump())
+            # Fallback (no pagination)
+            serializer = ServiceSummarySerializer(services_list, many=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Service list error: {e}", exc_info=True)
@@ -216,8 +223,9 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
                 ],
             }
 
-            serializer = ServiceDetailSerializer(**service_detail)
-            return Response(serializer.model_dump())
+            serializer = ServiceDetailSerializer(data=service_detail)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Service detail error: {e}", exc_info=True)
@@ -275,8 +283,9 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
                 "total_methods": len(methods_list),
             }
 
-            serializer = ServiceMethodsSerializer(**response_data)
-            return Response(serializer.model_dump())
+            serializer = ServiceMethodsSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Service methods error: {e}", exc_info=True)