django-cfg 1.4.11__py3-none-any.whl → 1.4.14__py3-none-any.whl

django_cfg/modules/django_client/core/generator/typescript/models_generator.py

@@ -0,0 +1,245 @@
+"""
+TypeScript Models Generator - Generates TypeScript interfaces and enums.
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+from ...ir import IRSchemaObject
+from ..base import GeneratedFile
+
+
+class ModelsGenerator:
+    """Generates TypeScript interfaces and enums."""
+
+    def __init__(self, jinja_env: Environment, context, base):
+        self.jinja_env = jinja_env
+        self.context = context
+        self.base = base
+
+    def generate_models_file(self):
+        """Generate models.ts with all TypeScript interfaces."""
+
+        # Generate all schemas
+        schema_codes = []
+
+        # Response models first
+        for name, schema in self.base.get_response_schemas().items():
+            schema_codes.append(self.generate_schema(schema))
+
+        # Request models
+        for name, schema in self.base.get_request_schemas().items():
+            schema_codes.append(self.generate_schema(schema))
+
+        # Patch models
+        for name, schema in self.base.get_patch_schemas().items():
+            schema_codes.append(self.generate_schema(schema))
+
+        template = self.jinja_env.get_template('models/models.ts.jinja')
+        content = template.render(
+            has_enums=bool(self.base.get_enum_schemas()),
+            schemas=schema_codes
+        )
+
+        return GeneratedFile(
+            path="models.ts",
+            content=content,
+            description="TypeScript interfaces (Request/Response/Patch)",
+        )
+
+    def generate_enums_file(self):
+        """Generate enums.ts with all enum types (flat structure)."""
+
+        enum_codes = []
+        for name, schema in self.base.get_enum_schemas().items():
+            enum_codes.append(self.generate_enum(schema))
+
+        template = self.jinja_env.get_template('models/enums.ts.jinja')
+        content = template.render(enums=enum_codes)
+
+        return GeneratedFile(
+            path="enums.ts",
+            content=content,
+            description="Enum types from x-enum-varnames",
+        )
+
+    def generate_shared_enums_file(self, enums: dict[str, IRSchemaObject]):
+        """Generate shared enums.ts for namespaced structure (Variant 2)."""
+
+        enum_codes = []
+        for name, schema in enums.items():
+            enum_codes.append(self.generate_enum(schema))
+
+        template = self.jinja_env.get_template('models/enums.ts.jinja')
+        content = template.render(enums=enum_codes)
+
+        return GeneratedFile(
+            path="enums.ts",
+            content=content,
+            description="Shared enum types from x-enum-varnames",
+        )
+
+    def generate_schema(self, schema: IRSchemaObject) -> str:
+        """Generate TypeScript interface for schema."""
+        if schema.type != "object":
+            # For primitive types, skip (they'll be inlined)
+            return ""
+
+        # Interface comment
+        comment_lines = []
+        if schema.description:
+            comment_lines.extend(self.base.wrap_comment(schema.description, 76))
+
+        # Add metadata about model type
+        if schema.is_request_model:
+            comment_lines.append("")
+            comment_lines.append("Request model (no read-only fields).")
+        elif schema.is_patch_model:
+            comment_lines.append("")
+            comment_lines.append("PATCH model (all fields optional).")
+        elif schema.is_response_model:
+            comment_lines.append("")
+            comment_lines.append("Response model (includes read-only fields).")
+
+        comment = "/**\n * " + "\n * ".join(comment_lines) + "\n */" if comment_lines else None
+
+        # Fields
+        field_lines = []
+
+        for prop_name, prop_schema in schema.properties.items():
+            field_lines.append(self._generate_field(prop_name, prop_schema, schema.required))
+
+        # Build interface
+        lines = []
+
+        if comment:
+            lines.append(comment)
+
+        lines.append(f"export interface {schema.name} {{")
+
+        if field_lines:
+            for field_line in field_lines:
+                lines.append(self.base.indent(field_line, 2))
+        else:
+            # Empty interface
+            pass
+
+        lines.append("}")
+
+        return "\n".join(lines)
+
+    def _generate_field(
+        self,
+        name: str,
+        schema: IRSchemaObject,
+        required_fields: list[str],
+    ) -> str:
+        """
+        Generate TypeScript field definition.
+
+        Examples:
+            id: number;
+            username: string;
+            email?: string | null;
+            status: Enums.StatusEnum;
+        """
+        # Check if this field is an enum
+        if schema.enum and schema.name:
+            # Use enum type from shared enums (sanitized)
+            ts_type = f"Enums.{self.base.sanitize_enum_name(schema.name)}"
+            if schema.nullable:
+                ts_type = f"{ts_type} | null"
+        # Check if this field is a reference to an enum (via $ref)
+        elif schema.ref and schema.ref in self.context.schemas:
+            ref_schema = self.context.schemas[schema.ref]
+            if ref_schema.enum:
+                # This is a reference to an enum component (sanitized to PascalCase)
+                ts_type = f"Enums.{self.base.sanitize_enum_name(schema.ref)}"
+                if schema.nullable:
+                    ts_type = f"{ts_type} | null"
+            else:
+                # Regular reference
+                ts_type = schema.typescript_type
+        else:
+            # Get TypeScript type
+            ts_type = schema.typescript_type
+
+        # Check if required
+        is_required = name in required_fields
+
+        # Optional marker
+        optional_marker = "" if is_required else "?"
+
+        # Comment
+        if schema.description:
+            return f"/** {schema.description} */\n{name}{optional_marker}: {ts_type};"
+
+        return f"{name}{optional_marker}: {ts_type};"
+
+    def generate_enum(self, schema: IRSchemaObject) -> str:
+        """Generate TypeScript enum from x-enum-varnames."""
+        # Sanitize enum name (convert to PascalCase)
+        # "OrderDetail.status" → "OrderDetailStatus"
+        # "Currency.currency_type" → "CurrencyCurrencyType"
+        enum_name = self.base.sanitize_enum_name(schema.name)
+
+        # Enum comment
+        comment = None
+        if schema.description:
+            # Format enum description to split bullet points
+            formatted_desc = self.base.format_enum_description(schema.description)
+            # Split into lines and format as JSDoc comment
+            desc_lines = formatted_desc.split('\n')
+            comment = "/**\n * " + "\n * ".join(desc_lines) + "\n */"
+
+        # Enum members
+        member_lines = []
+        for var_name, value in zip(schema.enum_var_names, schema.enum):
+            # Skip empty values (from blank=True in Django)
+            if not var_name or (isinstance(value, str) and value == ''):
+                continue
+
+            if isinstance(value, str):
+                member_lines.append(f'{var_name} = "{value}",')
+            else:
+                member_lines.append(f"{var_name} = {value},")
+
+        # Build enum
+        lines = []
+
+        if comment:
+            lines.append(comment)
+
+        lines.append(f"export enum {enum_name} {{")
+
+        for member_line in member_lines:
+            lines.append(self.base.indent(member_line, 2))
+
+        lines.append("}")
+
+        return "\n".join(lines)
+
+    def generate_app_models_file(self, tag: str, schemas: dict[str, IRSchemaObject], operations: list):
+        """Generate models.ts for a specific app."""
+
+        # Check if we have enums in schemas
+        app_enums = self.base._collect_enums_from_schemas(schemas)
+        has_enums = len(app_enums) > 0
+
+        # Generate schemas
+        schema_codes = []
+        for name, schema in schemas.items():
+            schema_codes.append(self.generate_schema(schema))
+
+        template = self.jinja_env.get_template('models/app_models.ts.jinja')
+        content = template.render(
+            has_enums=has_enums,
+            schemas=schema_codes
+        )
+
+        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
+        return GeneratedFile(
+            path=f"{folder_name}/models.ts",
+            content=content,
+            description=f"TypeScript interfaces for {tag}",
+        )

django_cfg/modules/django_client/core/generator/typescript/operations_generator.py

@@ -0,0 +1,298 @@
+"""
+TypeScript Operations Generator - Generates TypeScript async operation methods.
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+from ...ir import IROperationObject
+
+
+class OperationsGenerator:
+    """Generates TypeScript async operation methods."""
+
+    def __init__(self, jinja_env: Environment, context, base):
+        self.jinja_env = jinja_env
+        self.context = context
+        self.base = base
+
+    def generate_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False, in_subclient: bool = False) -> str:
+        """Generate async method for operation."""
+        # Get method name
+        operation_id = operation.operation_id
+        if remove_tag_prefix and operation.tags:
+            # Remove tag prefix using base class method
+            tag = operation.tags[0]
+            operation_id = self.base.remove_tag_prefix(operation_id, tag)
+
+        # Convert snake_case to camelCase
+        method_name = self._to_camel_case(operation_id)
+
+        # Request method prefix
+        request_prefix = "this.client" if in_subclient else "this"
+
+        # Method parameters
+        params = []
+
+        # Add path parameters
+        for param in operation.path_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            params.append(f"{param.name}: {param_type}")
+
+        # Check if this is a file upload operation
+        is_multipart = (
+            operation.request_body
+            and operation.request_body.content_type == "multipart/form-data"
+        )
+
+        # Add request body parameter
+        if operation.request_body:
+            if is_multipart:
+                # For multipart, get schema properties and add as individual File parameters
+                schema_name = operation.request_body.schema_name
+                if schema_name and schema_name in self.context.schemas:
+                    schema = self.context.schemas[schema_name]
+                    for prop_name, prop in schema.properties.items():
+                        # Check if it's a file field (format: binary)
+                        if prop.format == "binary":
+                            params.append(f"{prop_name}: File | Blob")
+                        else:
+                            # Regular field in multipart
+                            prop_type = self._map_param_type(prop.type)
+                            if prop_name in schema.required:
+                                params.append(f"{prop_name}: {prop_type}")
+                            else:
+                                params.append(f"{prop_name}?: {prop_type}")
+                else:
+                    # Inline schema - use FormData
+                    params.append("data: FormData")
+            else:
+                # JSON request body
+                schema_name = operation.request_body.schema_name
+                if schema_name and schema_name in self.context.schemas:
+                    params.append(f"data: Models.{schema_name}")
+                else:
+                    # Inline schema - use any
+                    params.append("data: any")
+        elif operation.patch_request_body:
+            schema_name = operation.patch_request_body.schema_name
+            if schema_name and schema_name in self.context.schemas:
+                params.append(f"data?: Models.{schema_name}")
+            else:
+                params.append("data?: any")
+
+        # Add query parameters (old style - separate params)
+        query_params_list = []
+        for param in operation.query_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            if not param.required:
+                params.append(f"{param.name}?: {param_type}")
+            else:
+                params.append(f"{param.name}: {param_type}")
+            query_params_list.append((param.name, param_type, param.required))
+
+        # Return type
+        primary_response = operation.primary_success_response
+        if primary_response and primary_response.schema_name:
+            if operation.is_list_operation:
+                return_type = f"Models.{primary_response.schema_name}[]"
+            else:
+                return_type = f"Models.{primary_response.schema_name}"
+        else:
+            return_type = "void"
+
+        # Build overload signatures if has query params
+        overload_signatures = []
+        use_rest_params = False
+
+        if query_params_list:
+            # Overload 1: separate parameters (current/backward compatible style)
+            overload_signatures.append(f"async {method_name}({', '.join(params)}): Promise<{return_type}>")
+
+            # Overload 2: params object (new style)
+            # Build params object signature
+            params_obj = [p for p in params if not any(p.startswith(f"{pn}:") or p.startswith(f"{pn}?:") for pn, _, _ in query_params_list)]
+            query_fields = []
+            for param_name, param_type, required in query_params_list:
+                optional = "?" if not required else ""
+                query_fields.append(f"{param_name}{optional}: {param_type}")
+            if query_fields:
+                params_obj.append(f"params?: {{ {'; '.join(query_fields)} }}")
+            overload_signatures.append(f"async {method_name}({', '.join(params_obj)}): Promise<{return_type}>")
+
+            # Implementation signature - use rest params for compatibility
+            use_rest_params = True
+
+        # Build implementation signature
+        if use_rest_params:
+            signature = f"async {method_name}(...args: any[]): Promise<{return_type}> {{"
+        else:
+            signature = f"async {method_name}({', '.join(params)}): Promise<{return_type}> {{"
+
+        # Comment
+        comment_lines = []
+        if operation.summary:
+            comment_lines.append(operation.summary)
+        if operation.description:
+            if comment_lines:
+                comment_lines.append("")
+            comment_lines.extend(self.base.wrap_comment(operation.description, 72))
+
+        comment = "/**\n * " + "\n * ".join(comment_lines) + "\n */" if comment_lines else None
+
+        # Method body
+        body_lines = []
+
+        # Handle overloaded parameters if has query params (using rest params)
+        if use_rest_params and query_params_list:
+            # Extract parameters from args array
+            path_params_count = len(operation.path_parameters)
+            body_params_count = 1 if (operation.request_body or operation.patch_request_body) else 0
+            first_query_pos = path_params_count + body_params_count
+
+            # Extract path parameters
+            for i, param in enumerate(operation.path_parameters):
+                body_lines.append(f"const {param.name} = args[{i}];")
+
+            # Extract body/data parameter
+            if operation.request_body or operation.patch_request_body:
+                body_lines.append(f"const data = args[{path_params_count}];")
+
+            # Check if first query arg is object (params style) or primitive (old style)
+            body_lines.append(f"const isParamsObject = args.length === {first_query_pos + 1} && typeof args[{first_query_pos}] === 'object' && args[{first_query_pos}] !== null && !Array.isArray(args[{first_query_pos}]);")
+            body_lines.append("")
+
+        # Build path
+        path_expr = f'"{operation.path}"'
+        if operation.path_parameters:
+            # Replace {id} with ${id}
+            path_with_vars = operation.path
+            for param in operation.path_parameters:
+                path_with_vars = path_with_vars.replace(f"{{{param.name}}}", f"${{{param.name}}}")
+            path_expr = f'`{path_with_vars}`'
+
+        # Build request options
+        request_opts = []
+
+        # Query params
+        if query_params_list:
+            param_names = [param_name for param_name, _, _ in query_params_list]
+
+            if use_rest_params:
+                # Extract params from args array - handle both calling styles
+                path_params_count = len(operation.path_parameters)
+                body_params_count = 1 if (operation.request_body or operation.patch_request_body) else 0
+                first_query_pos = path_params_count + body_params_count
+
+                body_lines.append("let params;")
+                body_lines.append("if (isParamsObject) {")
+                # Params object style
+                body_lines.append(f"  params = args[{first_query_pos}];")
+                body_lines.append("} else {")
+                # Separate params style - collect from individual args
+                param_extractions = []
+                for i, param_name in enumerate(param_names):
+                    param_extractions.append(f"{param_name}: args[{first_query_pos + i}]")
+                body_lines.append(f"  params = {{ {', '.join(param_extractions)} }};")
+                body_lines.append("}")
+            else:
+                # No overloads - standard query params
+                query_items = ", ".join(param_names)
+                body_lines.append(f"const params = {{ {query_items} }};")
+
+            request_opts.append("params")
+
+        # Body / FormData
+        if operation.request_body or operation.patch_request_body:
+            if is_multipart and operation.request_body:
+                # Build FormData for multipart upload
+                schema_name = operation.request_body.schema_name
+                if schema_name and schema_name in self.context.schemas:
+                    schema = self.context.schemas[schema_name]
+                    body_lines.append("const formData = new FormData();")
+                    for prop_name, prop in schema.properties.items():
+                        if prop.format == "binary":
+                            # Append file
+                            body_lines.append(f"formData.append('{prop_name}', {prop_name});")
+                        elif prop_name in schema.required or True:  # Append all non-undefined fields
+                            # Append other fields (wrap in if check for optional)
+                            if prop_name not in schema.required:
+                                body_lines.append(f"if ({prop_name} !== undefined) formData.append('{prop_name}', String({prop_name}));")
+                            else:
+                                body_lines.append(f"formData.append('{prop_name}', String({prop_name}));")
+                    request_opts.append("formData")
+                else:
+                    # Inline schema - data is already FormData
+                    request_opts.append("body: data")
+            else:
+                # JSON body
+                request_opts.append("body: data")
+
+        # Make request (no type argument when client is 'any')
+        if request_opts:
+            request_line = f"const response = await {request_prefix}.request('{operation.http_method}', {path_expr}, {{ {', '.join(request_opts)} }});"
+        else:
+            request_line = f"const response = await {request_prefix}.request('{operation.http_method}', {path_expr});"
+
+        body_lines.append(request_line)
+
+        # Handle response
+        if operation.is_list_operation and primary_response:
+            # Extract results from paginated response
+            body_lines.append("return (response as any).results || [];")
+        elif return_type != "void":
+            body_lines.append("return response;")
+        else:
+            body_lines.append("return;")
+
+        # Build method with proper class-level indentation (2 spaces)
+        lines = []
+
+        # Add overload signatures first (if any)
+        if overload_signatures:
+            for overload_sig in overload_signatures:
+                lines.append("  " + overload_sig + ";")
+            lines.append("")  # Empty line between overloads and implementation
+
+        # Add comment with indentation
+        if comment:
+            comment_lines_formatted = []
+            for line in comment.split('\n'):
+                comment_lines_formatted.append("  " + line)
+            lines.extend(comment_lines_formatted)
+
+        # Add signature with indentation
+        lines.append("  " + signature)
+
+        # Add body with indentation (4 spaces total: 2 for class + 2 for method body)
+        for line in body_lines:
+            lines.append("    " + line)
+
+        # Add closing brace with indentation
+        lines.append("  " + "}")
+
+        return "\n".join(lines)
+
+    def _map_param_type(self, schema_type: str) -> str:
+        """Map parameter schema type to TypeScript type."""
+        type_map = {
+            "string": "string",
+            "integer": "number",
+            "number": "number",
+            "boolean": "boolean",
+            "array": "any[]",
+        }
+        return type_map.get(schema_type, "any")
+
+    def _to_camel_case(self, snake_str: str) -> str:
+        """
+        Convert snake_case to camelCase.
+
+        Examples:
+            >>> self._to_camel_case("users_list")
+            'usersList'
+            >>> self._to_camel_case("users_partial_update")
+            'usersPartialUpdate'
+        """
+        components = snake_str.split("_")
+        return components[0] + "".join(x.title() for x in components[1:])