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

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

@@ -19,7 +19,7 @@ from __future__ import annotations
 from jinja2 import Environment
 from ..base import BaseGenerator, GeneratedFile
 from ...ir import IROperationObject, IRContext
-
+from .naming import operation_to_method_name
 
 class HooksGenerator:
     """
@@ -39,7 +39,7 @@ class HooksGenerator:
 
     def generate_query_hook(self, operation: IROperationObject) -> str:
         """
-        Generate useSWR hook for GET operation.
+        Generate useSWR hook for GET operation using Jinja2 template.
 
         Examples:
             >>> generate_query_hook(users_list)
@@ -65,44 +65,21 @@ class HooksGenerator:
         # Get SWR key
         swr_key = self._generate_swr_key(operation)
 
-        # Build hook
-        lines = []
-
-        # JSDoc
-        lines.append("/**")
-        if operation.summary:
-            lines.append(f" * {operation.summary}")
-        lines.append(" *")
-        lines.append(f" * @method {operation.http_method}")
-        lines.append(f" * @path {operation.path}")
-        lines.append(" */")
-
-        # Hook signature
-        if param_info['func_params']:
-            lines.append(f"export function {hook_name}({param_info['func_params']}) {{")
-        else:
-            lines.append(f"export function {hook_name}() {{")
-
-        # useSWR call
-        fetcher_params = param_info['fetcher_params']
-        if fetcher_params:
-            lines.append(f"  return useSWR<{response_type}>(")
-            lines.append(f"    {swr_key},")
-            lines.append(f"    () => Fetchers.{fetcher_name}({fetcher_params})")
-            lines.append("  )")
-        else:
-            lines.append(f"  return useSWR<{response_type}>(")
-            lines.append(f"    {swr_key},")
-            lines.append(f"    () => Fetchers.{fetcher_name}()")
-            lines.append("  )")
-
-        lines.append("}")
-
-        return "\n".join(lines)
+        # Render template
+        template = self.jinja_env.get_template('hooks/query_hook.ts.jinja')
+        return template.render(
+            operation=operation,
+            hook_name=hook_name,
+            fetcher_name=fetcher_name,
+            func_params=param_info['func_params'],
+            fetcher_params=param_info['fetcher_params'],
+            response_type=response_type,
+            swr_key=swr_key
+        )
 
     def generate_mutation_hook(self, operation: IROperationObject) -> str:
         """
-        Generate mutation hook for POST/PUT/PATCH/DELETE.
+        Generate mutation hook for POST/PUT/PATCH/DELETE using Jinja2 template.
 
         Examples:
             >>> generate_mutation_hook(users_create)
@@ -131,114 +108,84 @@ class HooksGenerator:
         # Get revalidation keys
         revalidation_keys = self._get_revalidation_keys(operation)
 
-        # Build hook
-        lines = []
-
-        # JSDoc
-        lines.append("/**")
-        if operation.summary:
-            lines.append(f" * {operation.summary}")
-        lines.append(" *")
-        lines.append(f" * @method {operation.http_method}")
-        lines.append(f" * @path {operation.path}")
-        lines.append(" */")
-
-        # Hook signature
-        lines.append(f"export function {hook_name}() {{")
-        lines.append("  const { mutate } = useSWRConfig()")
-        lines.append("")
-
-        # Return async function
-        if param_info['func_params']:
-            lines.append(f"  return async ({param_info['func_params']}): Promise<{response_type}> => {{")
-        else:
-            lines.append(f"  return async (): Promise<{response_type}> => {{")
-
-        # Call fetcher
-        fetcher_params = param_info['fetcher_params']
-        if fetcher_params:
-            lines.append(f"    const result = await Fetchers.{fetcher_name}({fetcher_params})")
-        else:
-            lines.append(f"    const result = await Fetchers.{fetcher_name}()")
-
-        # Revalidate
-        if revalidation_keys:
-            lines.append("")
-            lines.append("    // Revalidate related queries")
-            for key in revalidation_keys:
-                lines.append(f"    mutate('{key}')")
-
-        lines.append("")
-        lines.append("    return result")
-        lines.append("  }")
-        lines.append("}")
-
-        return "\n".join(lines)
+        # Render template
+        template = self.jinja_env.get_template('hooks/mutation_hook.ts.jinja')
+        return template.render(
+            operation=operation,
+            hook_name=hook_name,
+            fetcher_name=fetcher_name,
+            func_params=param_info['func_params'],
+            fetcher_params=param_info['fetcher_params'],
+            response_type=response_type,
+            revalidation_keys=revalidation_keys
+        )
 
     def _operation_to_hook_name(self, operation: IROperationObject) -> str:
         """
         Convert operation to hook name.
-
+        
+        Hooks are organized into tag-specific files but also exported globally,
+        so we include the tag in the name to avoid collisions.
+        
         Examples:
-            users_list (GET) -> useUsersList
-            users_retrieve (GET) -> useUsersById
-            users_create (POST) -> useCreateUsers
-            users_update (PUT) -> useUpdateUsers
-            users_partial_update (PATCH) -> usePartialUpdateUsers
-            users_destroy (DELETE) -> useDeleteUsers
+            cfg_support_tickets_list -> useSupportTicketsList
+            cfg_health_drf_retrieve -> useHealthDrf
+            cfg_accounts_otp_request_create -> useCreateAccountsOtpRequest
         """
-        op_id = operation.operation_id
-
-        # Keep full resource name and add suffixes for uniqueness
-        if op_id.endswith("_list"):
-            resource = op_id.removesuffix("_list")
-            return f"use{self._to_pascal_case(resource)}List"
-        elif op_id.endswith("_retrieve"):
-            resource = op_id.removesuffix("_retrieve")
-            # Add ById suffix to distinguish from list
-            return f"use{self._to_pascal_case(resource)}ById"
-        elif op_id.endswith("_create"):
-            resource = op_id.removesuffix("_create")
-            return f"useCreate{self._to_pascal_case(resource)}"
-        elif op_id.endswith("_partial_update"):
-            resource = op_id.removesuffix("_partial_update")
-            return f"usePartialUpdate{self._to_pascal_case(resource)}"
-        elif op_id.endswith("_update"):
-            resource = op_id.removesuffix("_update")
-            return f"useUpdate{self._to_pascal_case(resource)}"
-        elif op_id.endswith("_destroy"):
-            resource = op_id.removesuffix("_destroy")
-            return f"useDelete{self._to_pascal_case(resource)}"
+        
+        # Remove cfg_ prefix but keep tag + resource for uniqueness (same as fetchers)
+        operation_id = operation.operation_id
+        if operation_id.startswith('django_cfg_'):
+            operation_id = operation_id.replace('django_cfg_', '', 1)
+        elif operation_id.startswith('cfg_'):
+            operation_id = operation_id.replace('cfg_', '', 1)
+        
+        # Determine prefix based on HTTP method
+        if operation.http_method == 'GET':
+            prefix = 'use'
+        elif operation.http_method == 'POST':
+            prefix = 'useCreate'
+        elif operation.http_method in ('PUT', 'PATCH'):
+            if '_partial_update' in operation_id:
+                prefix = 'usePartialUpdate'
+            else:
+                prefix = 'useUpdate'
+        elif operation.http_method == 'DELETE':
+            prefix = 'useDelete'
         else:
-            # Custom action
-            return f"use{self._to_pascal_case(op_id)}"
+            prefix = 'use'
+        
+        # For hooks, path is not critical but pass for consistency
+        return operation_to_method_name(operation_id, operation.http_method, prefix, self.base, operation.path)
 
     def _operation_to_fetcher_name(self, operation: IROperationObject) -> str:
         """Get corresponding fetcher function name (must match fetchers_generator logic)."""
-        op_id = operation.operation_id
-
-        # Must match fetchers_generator._operation_to_function_name() exactly
-        if op_id.endswith("_list"):
-            resource = op_id.removesuffix("_list")
-            return f"get{self._to_pascal_case(resource)}List"
-        elif op_id.endswith("_retrieve"):
-            resource = op_id.removesuffix("_retrieve")
-            # Add ById suffix to match fetchers_generator
-            return f"get{self._to_pascal_case(resource)}ById"
-        elif op_id.endswith("_create"):
-            resource = op_id.removesuffix("_create")
-            return f"create{self._to_pascal_case(resource)}"
-        elif op_id.endswith("_partial_update"):
-            resource = op_id.removesuffix("_partial_update")
-            return f"partialUpdate{self._to_pascal_case(resource)}"
-        elif op_id.endswith("_update"):
-            resource = op_id.removesuffix("_update")
-            return f"update{self._to_pascal_case(resource)}"
-        elif op_id.endswith("_destroy"):
-            resource = op_id.removesuffix("_destroy")
-            return f"delete{self._to_pascal_case(resource)}"
+        
+        
+        # Remove cfg_ prefix but keep tag + resource (must match fetchers_generator exactly)
+        operation_id = operation.operation_id
+        if operation_id.startswith('django_cfg_'):
+            operation_id = operation_id.replace('django_cfg_', '', 1)
+        elif operation_id.startswith('cfg_'):
+            operation_id = operation_id.replace('cfg_', '', 1)
+        
+        # Determine prefix (must match fetchers_generator exactly)
+        if operation.http_method == 'GET':
+            prefix = 'get'
+        elif operation.http_method == 'POST':
+            prefix = 'create'
+        elif operation.http_method in ('PUT', 'PATCH'):
+            if '_partial_update' in operation_id:
+                prefix = 'partialUpdate'
+            else:
+                prefix = 'update'
+        elif operation.http_method == 'DELETE':
+            prefix = 'delete'
         else:
-            return self._to_camel_case(op_id)
+            prefix = ''
+        
+        # Must match fetchers exactly, including path
+        return operation_to_method_name(operation_id, operation.http_method, prefix, self.base, operation.path)
 
     def _get_param_info(self, operation: IROperationObject) -> dict:
         """
@@ -385,22 +332,13 @@ class HooksGenerator:
 
         return keys
 
-    def _to_pascal_case(self, snake_str: str) -> str:
-        """Convert snake_case to PascalCase."""
-        return ''.join(word.capitalize() for word in snake_str.split('_'))
-
-    def _to_camel_case(self, snake_str: str) -> str:
-        """Convert snake_case to camelCase."""
-        components = snake_str.split('_')
-        return components[0] + ''.join(x.capitalize() for x in components[1:])
-
     def generate_tag_hooks_file(
         self,
         tag: str,
         operations: list[IROperationObject],
     ) -> GeneratedFile:
         """
-        Generate hooks file for a specific tag/resource.
+        Generate hooks file for a specific tag/resource using Jinja2 template.
 
         Args:
             tag: Tag name (e.g., "shop_products")
@@ -410,8 +348,7 @@ class HooksGenerator:
             GeneratedFile with hooks
         """
         # Separate queries and mutations & collect schema names
-        query_hooks = []
-        mutation_hooks = []
+        hooks = []
         schema_names = set()
 
         for operation in operations:
@@ -430,69 +367,28 @@ class HooksGenerator:
 
             # Generate hook
             if operation.http_method == "GET":
-                query_hooks.append(self.generate_query_hook(operation))
+                hooks.append(self.generate_query_hook(operation))
             else:
-                mutation_hooks.append(self.generate_mutation_hook(operation))
+                hooks.append(self.generate_mutation_hook(operation))
 
         # Get display name for documentation
         tag_display_name = self.base.tag_to_display_name(tag)
-
-        # Build file content
-        lines = []
-
-        # Header
-        lines.append("/**")
-        lines.append(f" * SWR Hooks for {tag_display_name}")
-        lines.append(" *")
-        lines.append(" * Auto-generated React hooks for data fetching with SWR.")
-        lines.append(" *")
-        lines.append(" * Setup:")
-        lines.append(" * ```typescript")
-        lines.append(" * // Configure API once (in your app root)")
-        lines.append(" * import { configureAPI } from '../../api-instance'")
-        lines.append(" * configureAPI({ baseUrl: 'https://api.example.com' })")
-        lines.append(" * ```")
-        lines.append(" *")
-        lines.append(" * Usage:")
-        lines.append(" * ```typescript")
-        lines.append(" * // Query hook")
-        lines.append(" * const { data, error, mutate } = useShopProducts({ page: 1 })")
-        lines.append(" *")
-        lines.append(" * // Mutation hook")
-        lines.append(" * const createProduct = useCreateShopProduct()")
-        lines.append(" * await createProduct({ name: 'Product', price: 99 })")
-        lines.append(" * ```")
-        lines.append(" */")
-
-        # Import types from schemas
-        for schema_name in sorted(schema_names):
-            lines.append(f"import type {{ {schema_name} }} from '../schemas/{schema_name}.schema'")
-
-        lines.append("import useSWR from 'swr'")
-        lines.append("import { useSWRConfig } from 'swr'")
-        lines.append("import * as Fetchers from '../fetchers'")
-        lines.append("")
-
-        # Query hooks
-        if query_hooks:
-            lines.append("// ===== Query Hooks (GET) =====")
-            lines.append("")
-            for hook in query_hooks:
-                lines.append(hook)
-                lines.append("")
-
-        # Mutation hooks
-        if mutation_hooks:
-            lines.append("// ===== Mutation Hooks (POST/PUT/PATCH/DELETE) =====")
-            lines.append("")
-            for hook in mutation_hooks:
-                lines.append(hook)
-                lines.append("")
-
-        content = "\n".join(lines)
+        
+        # Get tag file name for fetchers import
+        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
+        tag_file = folder_name
+
+        # Render template
+        template = self.jinja_env.get_template('hooks/hooks.ts.jinja')
+        content = template.render(
+            tag_display_name=tag_display_name,
+            tag_file=tag_file,
+            has_schemas=bool(schema_names),
+            schema_names=sorted(schema_names),
+            hooks=hooks
+        )
 
         # Get file path (use same naming as APIClient)
-        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
         file_path = f"_utils/hooks/{folder_name}.ts"
 
         return GeneratedFile(
@@ -502,35 +398,9 @@ class HooksGenerator:
         )
 
     def generate_hooks_index_file(self, module_names: list[str]) -> GeneratedFile:
-        """Generate index.ts for hooks folder."""
-        lines = []
-
-        lines.append("/**")
-        lines.append(" * SWR Hooks - React hooks for data fetching")
-        lines.append(" *")
-        lines.append(" * Auto-generated from OpenAPI specification.")
-        lines.append(" * These hooks use SWR for data fetching and caching.")
-        lines.append(" *")
-        lines.append(" * Usage:")
-        lines.append(" * ```typescript")
-        lines.append(" * import { useShopProducts } from './_utils/hooks'")
-        lines.append(" *")
-        lines.append(" * function ProductsPage() {")
-        lines.append(" *   const { data, error } = useShopProducts({ page: 1 })")
-        lines.append(" *   if (error) return <Error />")
-        lines.append(" *   if (!data) return <Loading />")
-        lines.append(" *   return <ProductList products={data.results} />")
-        lines.append(" * }")
-        lines.append(" * ```")
-        lines.append(" */")
-        lines.append("")
-
-        for module_name in module_names:
-            lines.append(f"export * from './{module_name}'")
-
-        lines.append("")
-
-        content = "\n".join(lines)
+        """Generate index.ts for hooks folder using Jinja2 template."""
+        template = self.jinja_env.get_template('hooks/index.ts.jinja')
+        content = template.render(modules=module_names)
 
         return GeneratedFile(
             path="_utils/hooks/index.ts",

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

@@ -140,35 +140,39 @@ class ModelsGenerator:
         Examples:
             id: number;
             username: string;
-            email?: string | null;
+            email?: string;
             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"
+            # Don't add | null for nullable - use optional marker instead
         # 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"
+                # Don't add | null for nullable - use optional marker instead
             else:
-                # Regular reference
+                # Regular reference - get base type without | null
                 ts_type = schema.typescript_type
+                # Remove | null suffix if present (we'll use optional marker instead)
+                if ts_type.endswith(" | null"):
+                    ts_type = ts_type[:-7]  # Remove " | null"
         else:
-            # Get TypeScript type
+            # Get TypeScript type and remove | null suffix if present
             ts_type = schema.typescript_type
+            if ts_type.endswith(" | null"):
+                ts_type = ts_type[:-7]  # Remove " | null"
 
         # Check if required
         is_required = name in required_fields
 
-        # Optional marker
-        optional_marker = "" if is_required else "?"
+        # Optional marker - use for both non-required AND nullable fields
+        # This converts Django's nullable=True to TypeScript's optional (undefined)
+        optional_marker = "" if is_required and not schema.nullable else "?"
 
         # Comment
         if schema.description:

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

@@ -0,0 +1,83 @@
+"""
+Simple naming strategy for TypeScript code generation.
+
+Strategy: Use full operation_id, remove tag prefix, convert to camelCase/PascalCase.
+"""
+
+import re
+
+
+def to_camel_case(s: str) -> str:
+    """Convert snake_case or kebab-case to camelCase."""
+    s = s.replace('-', '_')
+    parts = s.split('_')
+    if not parts:
+        return ''
+    return parts[0].lower() + ''.join(p.capitalize() for p in parts[1:])
+
+
+def to_pascal_case(s: str) -> str:
+    """Convert snake_case or kebab-case to PascalCase."""
+    s = s.replace('-', '_')
+    return ''.join(p.capitalize() for p in s.split('_'))
+
+
+def remove_tag_prefix(operation_id: str) -> str:
+    """
+    Remove common tag prefixes from operation_id.
+    
+    Examples:
+        cfg_newsletter_campaigns_list -> newsletter_campaigns_list
+        django_cfg_accounts_login -> accounts_login
+        newsletter_campaigns_send_create -> newsletter_campaigns_send_create
+    """
+    # Remove cfg_ or django_cfg_ prefix
+    if operation_id.startswith('django_cfg_'):
+        return operation_id[11:]  # len('django_cfg_')
+    elif operation_id.startswith('cfg_'):
+        return operation_id[4:]   # len('cfg_')
+    return operation_id
+
+
+def operation_to_method_name(
+    operation_id: str,
+    http_method: str,
+    prefix: str,
+    base_generator,
+    path: str = ''
+) -> str:
+    """
+    Simple naming: remove tag prefix, convert to camelCase/PascalCase.
+    
+    Args:
+        operation_id: Full operation ID from OpenAPI
+        http_method: HTTP method (GET, POST, PUT, PATCH, DELETE)
+        prefix: Function prefix ('', 'get', 'create', 'use', etc.)
+        base_generator: Base generator instance (unused)
+        path: URL path (unused)
+        
+    Returns:
+        Method name in camelCase (for client) or PascalCase (for fetchers/hooks)
+        
+    Examples:
+        # Client methods (prefix='')
+        cfg_newsletter_campaigns_list -> newsletterCampaignsList
+        cfg_newsletter_campaigns_send_create -> newsletterCampaignsSendCreate
+        cfg_accounts_otp_request_create -> accountsOtpRequestCreate
+        
+        # Fetchers (prefix='get')
+        cfg_newsletter_campaigns_list -> getNewsletterCampaignsList
+        
+        # Hooks (prefix='use')
+        cfg_newsletter_campaigns_list -> useNewsletterCampaignsList
+    """
+    # Remove tag prefix
+    clean_id = remove_tag_prefix(operation_id)
+    
+    # For client methods (no prefix): camelCase
+    if not prefix:
+        return to_camel_case(clean_id)
+    
+    # For fetchers/hooks (with prefix): prefix + PascalCase
+    return f"{prefix}{to_pascal_case(clean_id)}"
+

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

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from jinja2 import Environment
 from ...ir import IROperationObject
-
+from .naming import operation_to_method_name 
 
 class OperationsGenerator:
     """Generates TypeScript async operation methods."""
@@ -18,15 +18,19 @@ class OperationsGenerator:
 
     def generate_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False, in_subclient: bool = False) -> str:
         """Generate async method for operation."""
-        # Get method name
+        
+        
+        # Get method name using universal logic
+        # For client methods, we use empty prefix to get short names: list, create, retrieve
         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)
+        # Use universal naming function with empty prefix for client methods
+        # Pass path to distinguish custom actions
+        method_name = operation_to_method_name(operation_id, operation.http_method, '', self.base, operation.path)
 
         # Request method prefix
         request_prefix = "this.client" if in_subclient else "this"

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

@@ -117,14 +117,11 @@ class SchemasGenerator:
         # Check if required
         is_required = name in required_fields
 
-        # Handle optional fields
-        if not is_required:
+        # Handle optional fields - use .optional() for both non-required AND nullable
+        # This converts Django's nullable=True to TypeScript's optional (undefined)
+        if not is_required or schema.nullable:
             zod_type = f"{zod_type}.optional()"
 
-        # Handle nullable fields
-        if schema.nullable:
-            zod_type = f"{zod_type}.nullable()"
-
         return f"{name}: {zod_type}"
 
     def _map_type_to_zod(self, schema: IRSchemaObject) -> str:

django_cfg/modules/django_client/core/generator/typescript/templates/fetchers/function.ts.jinja

@@ -0,0 +1,25 @@
+/**
+ * {{ operation.summary or 'API operation' }}
+ *
+ * @method {{ operation.http_method }}
+ * @path {{ operation.path }}
+ */
+export async function {{ func_name }}(
+{%- if func_params %}
+  {{ func_params }},
+{%- endif %}
+  client?: API
+): Promise<{{ response_type }}> {
+  const api = client || getAPIInstance()
+{% if api_call_params %}
+  const response = await {{ api_call }}({{ api_call_params }})
+{% else %}
+  const response = await {{ api_call }}()
+{% endif %}
+{% if response_schema %}
+  return {{ response_schema }}.parse(response)
+{% else %}
+  return response
+{% endif %}
+}
+

django_cfg/modules/django_client/core/generator/typescript/templates/hooks/hooks.ts.jinja

@@ -0,0 +1,30 @@
+/**
+ * SWR Hooks for {{ tag_display_name }}
+ *
+ * React hooks powered by SWR for data fetching with automatic caching,
+ * revalidation, and optimistic updates.
+ *
+ * Usage:
+ * ```typescript
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = useCreateUser()
+ * await createUser({ name: 'John', email: 'john@example.com' })
+ * ```
+ */
+import useSWR from 'swr'
+import { useSWRConfig } from 'swr'
+import * as Fetchers from '../fetchers/{{ tag_file }}'
+{% if has_schemas %}
+{% for schema_name in schema_names %}
+import type { {{ schema_name }} } from '../schemas/{{ schema_name }}.schema'
+{% endfor %}
+{% endif %}
+
+{% for hook in hooks %}
+{{ hook }}
+
+{% endfor %}
+