django-cfg 1.4.72__py3-none-any.whl → 1.4.74__py3-none-any.whl

django_cfg/modules/django_client/core/generator/proto/messages_generator.py

@@ -0,0 +1,260 @@
+"""
+Proto Messages Generator - Generates Protocol Buffer message definitions from IR schemas.
+
+Converts IRSchemaObject instances into proto3 message definitions.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .type_mapper import ProtoTypeMapper
+
+if TYPE_CHECKING:
+    from django_cfg.modules.django_client.core.ir.schema import IRSchemaObject
+
+
+class ProtoMessagesGenerator:
+    """
+    Generates Protocol Buffer message definitions from IR schemas.
+
+    Handles:
+    - Basic message structure with fields
+    - Nested message definitions
+    - Enums (from string enums in OpenAPI)
+    - Field numbering
+    - Proper indentation and formatting
+    """
+
+    def __init__(self, type_mapper: ProtoTypeMapper):
+        self.type_mapper = type_mapper
+        self.generated_messages: set[str] = set()  # Track what we've generated
+        self.message_definitions: list[str] = []  # Ordered list of definitions
+
+    def generate_message(
+        self, schema: IRSchemaObject, message_name: str | None = None
+    ) -> str:
+        """
+        Generate a proto message from an IR schema.
+
+        Args:
+            schema: IR schema object to convert
+            message_name: Override message name (uses schema.name if not provided)
+
+        Returns:
+            Proto message definition string
+        """
+        if message_name is None:
+            message_name = self.type_mapper.get_message_name(schema.name or "Message")
+
+        # Skip if already generated
+        if message_name in self.generated_messages:
+            return ""
+
+        self.generated_messages.add(message_name)
+
+        # Handle different schema types
+        if schema.type == "object":
+            return self._generate_object_message(schema, message_name)
+        elif schema.type == "array":
+            # Arrays are handled as repeated fields, not separate messages
+            return ""
+        elif schema.enum:
+            return self._generate_enum(schema, message_name)
+        else:
+            # Scalar types don't need messages
+            return ""
+
+    def _generate_object_message(self, schema: IRSchemaObject, message_name: str) -> str:
+        """Generate a message for an object schema."""
+        lines = [f"message {message_name} {{"]
+
+        # Generate nested enums first
+        for prop_name, prop_schema in (schema.properties or {}).items():
+            if prop_schema.enum:
+                enum_name = self.type_mapper.get_message_name(prop_name)
+                nested_enum = self._generate_enum(prop_schema, enum_name, indent=2)
+                if nested_enum:
+                    lines.append("")
+                    lines.extend(f"  {line}" for line in nested_enum.split("\n"))
+
+        # Generate nested messages (only if not already defined at top level)
+        for prop_name, prop_schema in (schema.properties or {}).items():
+            if prop_schema.type == "object" and not prop_schema.enum:
+                nested_name = self.type_mapper.get_message_name(prop_name)
+                # Skip if this message is already generated (it's a top-level schema)
+                if nested_name not in self.generated_messages:
+                    self.generated_messages.add(nested_name)
+                    nested_msg = self._generate_object_message(prop_schema, nested_name)
+                    if nested_msg:
+                        lines.append("")
+                        lines.extend(f"  {line}" for line in nested_msg.split("\n"))
+
+        # Generate fields
+        field_number = 1
+        if schema.properties:
+            lines.append("")
+            for prop_name, prop_schema in schema.properties.items():
+                field_def = self._generate_field(
+                    prop_name, prop_schema, field_number, schema.required or []
+                )
+                lines.append(f"  {field_def}")
+                field_number += 1
+
+        lines.append("}")
+
+        definition = "\n".join(lines)
+        self.message_definitions.append(definition)
+        return definition
+
+    def _generate_field(
+        self,
+        field_name: str,
+        field_schema: IRSchemaObject,
+        field_number: int,
+        required_fields: list[str],
+    ) -> str:
+        """
+        Generate a single field definition.
+
+        Args:
+            field_name: Original field name
+            field_schema: Field schema
+            field_number: Proto field number
+            required_fields: List of required field names
+
+        Returns:
+            Field definition line (e.g., "optional string name = 1;")
+        """
+        # Sanitize field name
+        proto_field_name = self.type_mapper.sanitize_field_name(field_name)
+
+        # Determine if field is required/nullable
+        is_required = field_name in required_fields
+        is_nullable = field_schema.nullable or False
+        is_repeated = field_schema.type == "array"
+
+        # Get field type
+        if is_repeated:
+            # Array field - use items type
+            if field_schema.items:
+                if field_schema.items.type == "object":
+                    # Nested object array
+                    item_type = self.type_mapper.get_message_name(field_name + "Item")
+                    # Generate the nested message
+                    self.generate_message(field_schema.items, item_type)
+                elif field_schema.items.enum:
+                    # Enum array - generate the enum definition
+                    item_type = self.type_mapper.get_message_name(field_name)
+                    # Generate the enum if not already generated
+                    if item_type not in self.generated_messages:
+                        self.generated_messages.add(item_type)
+                        enum_def = self._generate_enum(field_schema.items, item_type)
+                        if enum_def:
+                            self.message_definitions.append(enum_def)
+                else:
+                    # Scalar array
+                    item_type = self.type_mapper.map_type(
+                        field_schema.items.type or "string",
+                        field_schema.items.format,
+                    )
+            else:
+                item_type = "string"  # Fallback
+            field_type = item_type
+        elif field_schema.type == "object":
+            # Nested object
+            field_type = self.type_mapper.get_message_name(field_name)
+        elif field_schema.enum:
+            # Enum field
+            field_type = self.type_mapper.get_message_name(field_name)
+        else:
+            # Scalar field
+            field_type = self.type_mapper.map_type(
+                field_schema.type or "string",
+                field_schema.format,
+            )
+
+        # Get field label
+        label = self.type_mapper.get_field_label(is_required, is_nullable, is_repeated)
+
+        # Build field definition
+        if label:
+            return f"{label} {field_type} {proto_field_name} = {field_number};"
+        else:
+            return f"{field_type} {proto_field_name} = {field_number};"
+
+    def _generate_enum(
+        self, schema: IRSchemaObject, enum_name: str, indent: int = 0
+    ) -> str:
+        """
+        Generate an enum definition.
+
+        Args:
+            schema: Schema with enum values
+            enum_name: Enum name
+            indent: Indentation level for nested enums
+
+        Returns:
+            Enum definition string
+        """
+        if not schema.enum:
+            return ""
+
+        indent_str = " " * indent
+        lines = [f"{indent_str}enum {enum_name} {{"]
+
+        # Proto enums must start with 0
+        # Add UNKNOWN/UNSPECIFIED as first value if not present
+        enum_values = list(schema.enum)
+        if not any(
+            v.upper() in ("UNKNOWN", "UNSPECIFIED", f"{enum_name}_UNKNOWN")
+            for v in enum_values
+        ):
+            lines.append(f"{indent_str}  {enum_name.upper()}_UNKNOWN = 0;")
+            start_index = 1
+        else:
+            start_index = 0
+
+        # Generate enum values
+        for idx, value in enumerate(enum_values, start=start_index):
+            # Convert to UPPER_SNAKE_CASE
+            enum_value_name = (
+                str(value).replace("-", "_").replace(" ", "_").replace(".", "_").upper()
+            )
+            # Add enum name prefix if not already present
+            if not enum_value_name.startswith(enum_name.upper()):
+                enum_value_name = f"{enum_name.upper()}_{enum_value_name}"
+
+            lines.append(f"{indent_str}  {enum_value_name} = {idx};")
+
+        lines.append(f"{indent_str}}}")
+
+        return "\n".join(lines)
+
+    def generate_all_messages(self, schemas: dict[str, IRSchemaObject]) -> list[str]:
+        """
+        Generate all message definitions from a collection of schemas.
+
+        Args:
+            schemas: Dictionary of schema_name -> IRSchemaObject
+
+        Returns:
+            List of proto message definition strings
+        """
+        self.generated_messages.clear()
+        self.message_definitions.clear()
+
+        for schema_name, schema in schemas.items():
+            message_name = self.type_mapper.get_message_name(schema_name)
+            self.generate_message(schema, message_name)
+
+        return self.message_definitions
+
+    def get_all_definitions(self) -> str:
+        """
+        Get all generated message definitions as a single string.
+
+        Returns:
+            Combined proto definitions separated by blank lines
+        """
+        return "\n\n".join(self.message_definitions)

django_cfg/modules/django_client/core/generator/proto/services_generator.py

@@ -0,0 +1,295 @@
+"""
+Proto Services Generator - Generates gRPC service definitions from IR operations.
+
+Converts IROperationObject instances into proto3 service and rpc definitions.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .type_mapper import ProtoTypeMapper
+
+if TYPE_CHECKING:
+    from django_cfg.modules.django_client.core.ir.operation import IROperationObject
+    from django_cfg.modules.django_client.core.ir.schema import IRSchemaObject
+
+
+class ProtoServicesGenerator:
+    """
+    Generates gRPC service definitions from IR operations.
+
+    Handles:
+    - Service grouping by tags
+    - RPC method definitions
+    - Request/Response message generation
+    - Empty responses (google.protobuf.Empty)
+    - Stream annotations (if needed in future)
+    """
+
+    def __init__(self, type_mapper: ProtoTypeMapper, context: IRContext | None = None):
+        self.type_mapper = type_mapper
+        self.context = context  # Need context to resolve schema references
+        self.services: dict[str, list[str]] = {}  # service_name -> [rpc_definitions]
+        self.request_messages: dict[str, str] = {}  # Track generated request messages
+
+    def generate_rpc(self, operation: IROperationObject) -> tuple[str, list[str]]:
+        """
+        Generate an RPC definition from an IR operation.
+
+        Args:
+            operation: IR operation object
+
+        Returns:
+            Tuple of (service_name, [request_message_defs, response_message_defs, rpc_def])
+        """
+        # Determine service name from tags (first tag or "Default")
+        service_name = self._get_service_name(operation)
+
+        # Generate RPC method name
+        rpc_name = self._get_rpc_name(operation)
+
+        # Generate request message
+        request_message_name, request_msg_def = self._generate_request_message(
+            operation, rpc_name
+        )
+
+        # Generate response message
+        response_message_name, response_msg_def = self._generate_response_message(
+            operation, rpc_name
+        )
+
+        # Generate RPC definition
+        rpc_def = f"  rpc {rpc_name}({request_message_name}) returns ({response_message_name});"
+
+        # Add comment if operation has description
+        if operation.description:
+            # Sanitize description for proto comment
+            desc = operation.description.strip().replace("\n", "\n  // ")
+            rpc_def = f"  // {desc}\n{rpc_def}"
+
+        # Collect all definitions
+        definitions = []
+        if request_msg_def:
+            definitions.append(request_msg_def)
+        if response_msg_def:
+            definitions.append(response_msg_def)
+        definitions.append(rpc_def)
+
+        return service_name, definitions
+
+    def _get_service_name(self, operation: IROperationObject) -> str:
+        """Get service name from operation tags."""
+        if operation.tags and len(operation.tags) > 0:
+            service_name = operation.tags[0]
+        else:
+            service_name = "Default"
+
+        # Convert to PascalCase and add "Service" suffix
+        return self.type_mapper.get_message_name(service_name) + "Service"
+
+    def _get_rpc_name(self, operation: IROperationObject) -> str:
+        """Get RPC method name from operation."""
+        if operation.operation_id:
+            # Use operation_id (already should be camelCase from OpenAPI)
+            name = operation.operation_id
+        else:
+            # Fallback: method + path
+            path_parts = [p for p in operation.path.split("/") if p and not p.startswith("{")]
+            name = operation.method + "_" + "_".join(path_parts)
+
+        # Ensure PascalCase for RPC method name
+        return self.type_mapper.get_message_name(name)
+
+    def _generate_request_message(
+        self, operation: IROperationObject, rpc_name: str
+    ) -> tuple[str, str]:
+        """
+        Generate request message for an RPC.
+
+        Args:
+            operation: IR operation
+            rpc_name: RPC method name
+
+        Returns:
+            Tuple of (message_name, message_definition)
+        """
+        message_name = f"{rpc_name}Request"
+
+        # Check if we need a request message at all
+        has_patch_body = hasattr(operation, 'patch_request_body') and operation.patch_request_body
+        has_params = bool(
+            operation.parameters
+            or operation.request_body
+            or has_patch_body
+        )
+
+        if not has_params:
+            # No parameters - use empty message or google.protobuf.Empty
+            self.type_mapper.imported_types.add("google.protobuf.Empty")
+            return "google.protobuf.Empty", ""
+
+        # Build request message
+        lines = [f"message {message_name} {{"]
+        field_number = 1
+
+        # Add path/query parameters
+        if operation.parameters:
+            for param in operation.parameters:
+                if param.location in ("path", "query"):
+                    field_name = self.type_mapper.sanitize_field_name(param.name)
+                    field_type = self.type_mapper.map_type(
+                        param.schema_type,
+                        None,  # IRParameterObject doesn't have format
+                    )
+                    is_required = param.required
+                    is_nullable = False  # Parameters don't have nullable in IR
+
+                    label = self.type_mapper.get_field_label(
+                        is_required, is_nullable, False
+                    )
+
+                    if label:
+                        lines.append(
+                            f"  {label} {field_type} {field_name} = {field_number};"
+                        )
+                    else:
+                        lines.append(f"  {field_type} {field_name} = {field_number};")
+
+                    field_number += 1
+
+        # Add request body as a single field referencing the schema
+        if operation.request_body:
+            # Check if this is multipart/form-data (file upload)
+            is_multipart = operation.request_body.content_type and "multipart" in operation.request_body.content_type
+
+            if is_multipart:
+                # For file uploads, use bytes type directly
+                # Note: In real gRPC, file uploads should use streaming (not implemented here)
+                field_name = "file_data"
+                field_type = "bytes"
+                is_required = operation.request_body.required
+                label = self.type_mapper.get_field_label(is_required, False, False)
+
+                if label:
+                    lines.append(f"  {label} {field_type} {field_name} = {field_number};")
+                else:
+                    lines.append(f"  {field_type} {field_name} = {field_number};")
+            else:
+                # Use schema_name to reference the request body schema
+                schema_name = operation.request_body.schema_name
+                field_name = "body"
+                field_type = self.type_mapper.get_message_name(schema_name)
+
+                is_required = operation.request_body.required
+                label = self.type_mapper.get_field_label(is_required, False, False)
+
+                if label:
+                    lines.append(f"  {label} {field_type} {field_name} = {field_number};")
+                else:
+                    lines.append(f"  {field_type} {field_name} = {field_number};")
+        elif has_patch_body:
+            # PATCH operations have optional body
+            schema_name = operation.patch_request_body.schema_name
+            field_name = "body"
+            field_type = self.type_mapper.get_message_name(schema_name)
+
+            # PATCH body is always optional
+            label = "optional"
+            lines.append(f"  {label} {field_type} {field_name} = {field_number};")
+
+        lines.append("}")
+
+        return message_name, "\n".join(lines)
+
+    def _generate_response_message(
+        self, operation: IROperationObject, rpc_name: str
+    ) -> tuple[str, str]:
+        """
+        Generate response message for an RPC.
+
+        Args:
+            operation: IR operation
+            rpc_name: RPC method name
+
+        Returns:
+            Tuple of (message_name, message_definition)
+        """
+        message_name = f"{rpc_name}Response"
+
+        # Get successful response (200, 201, etc.)
+        response_schema_name = None
+        for status_code, response in operation.responses.items():
+            if isinstance(status_code, int) and 200 <= status_code < 300:
+                # Found successful response
+                if response.schema_name:
+                    response_schema_name = response.schema_name
+                    break
+
+        # No response body - use Empty
+        if not response_schema_name:
+            self.type_mapper.imported_types.add("google.protobuf.Empty")
+            return "google.protobuf.Empty", ""
+
+        # Build response message - simply reference the schema
+        lines = [f"message {message_name} {{"]
+
+        # Reference the response schema as a single field
+        field_type = self.type_mapper.get_message_name(response_schema_name)
+        lines.append(f"  {field_type} data = 1;")
+
+        lines.append("}")
+
+        return message_name, "\n".join(lines)
+
+    def generate_all_services(
+        self, operations: list[IROperationObject]
+    ) -> dict[str, str]:
+        """
+        Generate all service definitions from operations.
+
+        Args:
+            operations: List of IR operations
+
+        Returns:
+            Dictionary of service_name -> service_definition
+        """
+        self.services.clear()
+        self.request_messages.clear()
+
+        # Group operations by service
+        messages_by_service: dict[str, list[str]] = {}
+        rpcs_by_service: dict[str, list[str]] = {}
+
+        for operation in operations:
+            service_name, definitions = self.generate_rpc(operation)
+
+            if service_name not in messages_by_service:
+                messages_by_service[service_name] = []
+                rpcs_by_service[service_name] = []
+
+            # Separate messages from RPC definitions
+            for definition in definitions:
+                if definition.startswith("message "):
+                    messages_by_service[service_name].append(definition)
+                elif definition.strip().startswith("rpc ") or definition.strip().startswith("//"):
+                    rpcs_by_service[service_name].append(definition)
+
+        # Build service definitions
+        service_definitions = {}
+        for service_name in rpcs_by_service:
+            lines = []
+
+            # Add messages first
+            if service_name in messages_by_service:
+                lines.extend(messages_by_service[service_name])
+                lines.append("")  # Blank line between messages and service
+
+            # Add service definition
+            lines.append(f"service {service_name} {{")
+            lines.extend(rpcs_by_service[service_name])
+            lines.append("}")
+
+            service_definitions[service_name] = "\n".join(lines)
+
+        return service_definitions