jararaca 0.3.12a18__tar.gz → 0.3.12a20__tar.gz

{jararaca-0.3.12a18 → jararaca-0.3.12a20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jararaca
-Version: 0.3.12a18
+Version: 0.3.12a20
 Summary: A simple and fast API framework for Python
 Home-page: https://github.com/LuscasLeo/jararaca
 Author: Lucas S

{jararaca-0.3.12a18 → jararaca-0.3.12a20}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.3.12a18"
+version = "0.3.12a20"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"

{jararaca-0.3.12a18 → jararaca-0.3.12a20}/src/jararaca/tools/typescript/interface_parser.py

@@ -24,7 +24,7 @@ from typing import (
 from uuid import UUID
 
 from fastapi import Request, Response, UploadFile
-from fastapi.params import Body, Cookie, Depends, Header, Path, Query
+from fastapi.params import Body, Cookie, Depends, Form, Header, Path, Query
 from fastapi.security.http import HTTPBase
 from pydantic import BaseModel, PlainValidator
 from pydantic_core import PydanticUndefined
@@ -48,6 +48,58 @@ def is_constant(name: str) -> bool:
     return CONSTANT_PATTERN.match(name) is not None
 
 
+def unwrap_annotated_type(field_type: Any) -> tuple[Any, list[Any]]:
+    """
+    Recursively unwrap Annotated types to find the real underlying type.
+
+    Args:
+        field_type: The type to unwrap, which may be deeply nested Annotated types
+
+    Returns:
+        A tuple of (unwrapped_type, all_metadata) where:
+        - unwrapped_type is the final non-Annotated type
+        - all_metadata is a list of all metadata from all Annotated layers
+    """
+    all_metadata = []
+    current_type = field_type
+
+    while get_origin(current_type) == Annotated:
+        # Collect metadata from current layer
+        if hasattr(current_type, "__metadata__"):
+            all_metadata.extend(current_type.__metadata__)
+
+        # Move to the next inner type
+        if hasattr(current_type, "__args__") and len(current_type.__args__) > 0:
+            current_type = current_type.__args__[0]
+        else:
+            break
+
+    return current_type, all_metadata
+
+
+def is_upload_file_type(field_type: Any) -> bool:
+    """
+    Check if a type is UploadFile or a list/array of UploadFile.
+
+    Args:
+        field_type: The type to check
+
+    Returns:
+        True if it's UploadFile or list[UploadFile], False otherwise
+    """
+    if field_type == UploadFile:
+        return True
+
+    # Check for list[UploadFile], List[UploadFile], etc.
+    origin = get_origin(field_type)
+    if origin in (list, frozenset, set):
+        args = getattr(field_type, "__args__", ())
+        if args and args[0] == UploadFile:
+            return True
+
+    return False
+
+
 def should_exclude_field(
     field_name: str, field_type: Any, basemodel_type: Type[Any]
 ) -> bool:
@@ -87,7 +139,8 @@ def should_exclude_field(
 
     # Check for Annotated types with Field metadata
     if get_origin(field_type) == Annotated:
-        for metadata in field_type.__metadata__:
+        unwrapped_type, all_metadata = unwrap_annotated_type(field_type)
+        for metadata in all_metadata:
             # Check if this is a Pydantic Field by looking for expected attributes
             if hasattr(metadata, "exclude") or hasattr(metadata, "alias"):
                 # Check if Field has exclude=True
@@ -182,7 +235,8 @@ def has_default_value(
 
     # Check for Annotated types with Field metadata that have defaults
     if get_origin(field_type) == Annotated:
-        for metadata in field_type.__metadata__:
+        unwrapped_type, all_metadata = unwrap_annotated_type(field_type)
+        for metadata in all_metadata:
             # Check if this is a Pydantic Field with a default
             if hasattr(metadata, "default") and hasattr(
                 metadata, "exclude"
@@ -333,16 +387,18 @@ def get_field_type_for_ts(field_type: Any, context_suffix: str = "") -> Any:
             [get_field_type_for_ts(x, context_suffix) for x in field_type.__args__]
         )
     if (get_origin(field_type) == Annotated) and (len(field_type.__args__) > 0):
+        unwrapped_type, all_metadata = unwrap_annotated_type(field_type)
+
         if (
             plain_validator := next(
-                (x for x in field_type.__metadata__ if isinstance(x, PlainValidator)),
+                (x for x in all_metadata if isinstance(x, PlainValidator)),
                 None,
             )
         ) is not None:
             return get_field_type_for_ts(
                 plain_validator.json_schema_input_type, context_suffix
             )
-        return get_field_type_for_ts(field_type.__args__[0], context_suffix)
+        return get_field_type_for_ts(unwrapped_type, context_suffix)
     return "unknown"
 
 
@@ -625,6 +681,21 @@ def write_microservice_to_typescript_interface(
 // noinspection JSUnusedGlobalSymbols
 
 import { HttpService, HttpBackend, HttpBackendRequest, ResponseType, createClassQueryHooks , createClassMutationHooks, createClassInfiniteQueryHooks, paginationModelByFirstArgPaginationFilter } from "@jararaca/core";
+
+function makeFormData(data: Record<string, any>): FormData {
+  const formData = new FormData();
+  for (const key in data) {
+    if (Array.isArray(data[key])) {
+      data[key].forEach((item: any) => {
+        formData.append(key, item);
+      });
+    } else {
+      formData.append(key, data[key]);
+    }
+  }
+  return formData;
+}
+
 export type WebSocketMessageMap = {
 %s
 }
@@ -768,10 +839,21 @@ def write_rest_controller_to_typescript_interface(
             class_buffer.write(f'\t\t\tmethod: "{mapping.method}",\n')
 
             endpoint_path = parse_path_with_params(mapping.path, arg_params_spec)
-            final_path = "/".join(
-                s.strip("/") for s in [rest_controller.path, endpoint_path]
-            )
-            class_buffer.write(f"\t\t\tpath: `/{final_path}`,\n")
+
+            # Properly handle path joining to avoid double slashes
+            controller_path = rest_controller.path or ""
+            path_parts = []
+
+            if controller_path and controller_path.strip("/"):
+                path_parts.append(controller_path.strip("/"))
+            if endpoint_path and endpoint_path.strip("/"):
+                path_parts.append(endpoint_path.strip("/"))
+
+            final_path = "/".join(path_parts) if path_parts else ""
+            # Ensure the path starts with a single slash
+            formatted_path = f"/{final_path}" if final_path else "/"
+
+            class_buffer.write(f"\t\t\tpath: `{formatted_path}`,\n")
 
             # Sort path params
             path_params = sorted(
@@ -803,10 +885,25 @@ def write_rest_controller_to_typescript_interface(
                 class_buffer.write(f'\t\t\t\t"{param.name}": {param.name},\n')
             class_buffer.write("\t\t\t},\n")
 
-            if (
-                body := next((x for x in arg_params_spec if x.type_ == "body"), None)
-            ) is not None:
-                class_buffer.write(f"\t\t\tbody: {body.name}\n")
+            # Check if we need to use FormData (for file uploads or form parameters)
+            form_params = [param for param in arg_params_spec if param.type_ == "form"]
+            body_param = next((x for x in arg_params_spec if x.type_ == "body"), None)
+
+            if form_params:
+                # Use FormData for file uploads and form parameters
+                class_buffer.write("\t\t\tbody: makeFormData({\n")
+
+                # Add form parameters (including file uploads)
+                for param in form_params:
+                    class_buffer.write(f'\t\t\t\t"{param.name}": {param.name},\n')
+
+                # Add body parameter if it exists alongside form params
+                if body_param:
+                    class_buffer.write(f"\t\t\t\t...{body_param.name},\n")
+
+                class_buffer.write("\t\t\t})\n")
+            elif body_param is not None:
+                class_buffer.write(f"\t\t\tbody: {body_param.name}\n")
             else:
                 class_buffer.write("\t\t\tbody: undefined\n")
 
@@ -862,7 +959,7 @@ EXCLUDED_REQUESTS_TYPES = [Request, Response]
 
 @dataclass
 class HttpParemeterSpec:
-    type_: Literal["query", "path", "body", "header", "cookie"]
+    type_: Literal["query", "path", "body", "header", "cookie", "form"]
     name: str
     required: bool
     argument_type_str: str
@@ -910,15 +1007,16 @@ def extract_parameters(
     if is_primitive(member):
 
         if get_origin(member) is Annotated:
+            unwrapped_type, all_metadata = unwrap_annotated_type(member)
             if (
                 plain_validator := next(
-                    (x for x in member.__metadata__ if isinstance(x, PlainValidator)),
+                    (x for x in all_metadata if isinstance(x, PlainValidator)),
                     None,
                 )
             ) is not None:
                 mapped_types.add(plain_validator.json_schema_input_type)
                 return parameters_list, mapped_types
-            return extract_parameters(member.__args__[0], controller, mapping)
+            return extract_parameters(unwrapped_type, controller, mapping)
         return parameters_list, mapped_types
 
     if hasattr(member, "__bases__"):
@@ -938,8 +1036,21 @@ def extract_parameters(
                 continue
 
             if get_origin(parameter_type) == Annotated:
-                annotated_type_hook = parameter_type.__metadata__[0]
-                annotated_type = parameter_type.__args__[0]
+                unwrapped_type, all_metadata = unwrap_annotated_type(parameter_type)
+                # Look for FastAPI parameter annotations in all metadata layers
+                annotated_type_hook = None
+                for metadata in all_metadata:
+                    if isinstance(
+                        metadata, (Header, Cookie, Form, Body, Query, Path, Depends)
+                    ):
+                        annotated_type_hook = metadata
+                        break
+
+                if annotated_type_hook is None and all_metadata:
+                    # Fallback to first metadata if no FastAPI annotation found
+                    annotated_type_hook = all_metadata[0]
+
+                annotated_type = unwrapped_type
                 if isinstance(annotated_type_hook, Header):
                     mapped_types.add(str)
                     parameters_list.append(
@@ -960,6 +1071,16 @@ def extract_parameters(
                             argument_type_str=get_field_type_for_ts(str),
                         )
                     )
+                elif isinstance(annotated_type_hook, Form):
+                    mapped_types.add(annotated_type)
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="form",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(annotated_type),
+                        )
+                    )
                 elif isinstance(annotated_type_hook, Body):
                     mapped_types.update(extract_all_envolved_types(parameter_type))
                     # For body parameters, use Input suffix if it's a split model
@@ -1067,11 +1188,11 @@ def extract_parameters(
                     )
                 else:
                     mapped_types.add(annotated_type)
-                    # Special handling for UploadFile - should go to body, not query
-                    if annotated_type == UploadFile:
+                    # Special handling for UploadFile and list[UploadFile] - should be treated as form data
+                    if is_upload_file_type(annotated_type):
                         parameters_list.append(
                             HttpParemeterSpec(
-                                type_="body",
+                                type_="form",
                                 name=parameter_name,
                                 required=True,
                                 argument_type_str=get_field_type_for_ts(annotated_type),
@@ -1117,12 +1238,12 @@ def extract_parameters(
                         ),
                     )
                 )
-            elif parameter_type == UploadFile:
-                # UploadFile should always go to body, not query parameters
+            elif parameter_type == UploadFile or is_upload_file_type(parameter_type):
+                # UploadFile and list[UploadFile] should be treated as form data
                 mapped_types.add(parameter_type)
                 parameters_list.append(
                     HttpParemeterSpec(
-                        type_="body",
+                        type_="form",
                         name=parameter_name,
                         required=True,
                         argument_type_str=get_field_type_for_ts(parameter_type),
@@ -1156,11 +1277,11 @@ def extract_parameters(
                 )
             else:
                 mapped_types.add(parameter_type)
-                # Special handling for UploadFile - should go to body, not query
-                if parameter_type == UploadFile:
+                # Special handling for UploadFile and list[UploadFile] - should be treated as form data
+                if is_upload_file_type(parameter_type):
                     parameters_list.append(
                         HttpParemeterSpec(
-                            type_="body",
+                            type_="form",
                             name=parameter_name,
                             required=True,
                             argument_type_str=get_field_type_for_ts(parameter_type),
@@ -1196,21 +1317,22 @@ def extract_parameters(
                 for _, parameter_type in parameter_members.items():
                     if is_primitive(parameter_type.annotation):
                         if get_origin(parameter_type.annotation) is not None:
-                            if (
-                                get_origin(parameter_type.annotation) == Annotated
-                                and (
-                                    plain_validator := next(
-                                        (
-                                            x
-                                            for x in parameter_type.annotation.__metadata__
-                                            if isinstance(x, PlainValidator)
-                                        ),
-                                        None,
-                                    )
+                            if get_origin(parameter_type.annotation) == Annotated:
+                                unwrapped_type, all_metadata = unwrap_annotated_type(
+                                    parameter_type.annotation
                                 )
-                                is not None
-                            ):
-                                mapped_types.add(plain_validator.json_schema_input_type)
+                                plain_validator = next(
+                                    (
+                                        x
+                                        for x in all_metadata
+                                        if isinstance(x, PlainValidator)
+                                    ),
+                                    None,
+                                )
+                                if plain_validator is not None:
+                                    mapped_types.add(
+                                        plain_validator.json_schema_input_type
+                                    )
                             else:
                                 args = parameter_type.annotation.__args__
                                 mapped_types.update(args)
@@ -1241,22 +1363,15 @@ def extract_all_envolved_types(field_type: Any) -> set[Any]:
 
     if is_primitive(field_type):
         if get_origin(field_type) is not None:
-            if (
-                get_origin(field_type) == Annotated
-                and (
-                    plain_validator := next(
-                        (
-                            x
-                            for x in field_type.__metadata__
-                            if isinstance(x, PlainValidator)
-                        ),
-                        None,
-                    )
+            if get_origin(field_type) == Annotated:
+                unwrapped_type, all_metadata = unwrap_annotated_type(field_type)
+                plain_validator = next(
+                    (x for x in all_metadata if isinstance(x, PlainValidator)),
+                    None,
                 )
-                is not None
-            ):
-                mapped_types.add(plain_validator.json_schema_input_type)
-                return mapped_types
+                if plain_validator is not None:
+                    mapped_types.add(plain_validator.json_schema_input_type)
+                    return mapped_types
             else:
                 mapped_types.update(
                     *[extract_all_envolved_types(arg) for arg in field_type.__args__]