jararaca 0.3.12a14__py3-none-any.whl → 0.3.12a16__py3-none-any.whl

jararaca/__init__.py

@@ -165,7 +165,11 @@ if TYPE_CHECKING:
     from .presentation.websocket.websocket_interceptor import WebSocketInterceptor
     from .scheduler.decorators import ScheduledAction
     from .tools.app_config.interceptor import AppConfigurationInterceptor
-    from .tools.typescript.decorators import MutationEndpoint, QueryEndpoint
+    from .tools.typescript.decorators import (
+        MutationEndpoint,
+        QueryEndpoint,
+        SplitInputOutput,
+    )
 
     __all__ = [
         "SetMetadata",
@@ -272,6 +276,7 @@ if TYPE_CHECKING:
         "AppConfigurationInterceptor",
         "QueryEndpoint",
         "MutationEndpoint",
+        "SplitInputOutput",
         "UseMiddleware",
         "UseDependency",
         "GlobalHttpErrorHandler",
@@ -501,6 +506,7 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     ),
     "QueryEndpoint": (__SPEC_PARENT__, "tools.typescript.decorators", None),
     "MutationEndpoint": (__SPEC_PARENT__, "tools.typescript.decorators", None),
+    "SplitInputOutput": (__SPEC_PARENT__, "tools.typescript.decorators", None),
     "UseMiddleware": (__SPEC_PARENT__, "presentation.decorators", None),
     "UseDependency": (__SPEC_PARENT__, "presentation.decorators", None),
     "GlobalHttpErrorHandler": (__SPEC_PARENT__, "rpc.http.decorators", None),

jararaca/persistence/interceptors/aiosqa_interceptor.py

@@ -1,7 +1,7 @@
 from contextlib import asynccontextmanager, contextmanager, suppress
 from contextvars import ContextVar
 from dataclasses import dataclass
-from typing import Any, AsyncGenerator, Generator
+from typing import Any, AsyncGenerator, Generator, Protocol
 
 from sqlalchemy.ext.asyncio import (
     AsyncSession,
@@ -18,6 +18,42 @@ from jararaca.persistence.interceptors.decorators import (
 )
 from jararaca.reflect.metadata import get_metadata_value
 
+
+class SessionManager(Protocol):
+    def spawn_session(self, connection_name: str | None = None) -> AsyncSession: ...
+
+
+ctx_session_manager: ContextVar[SessionManager | None] = ContextVar(
+    "ctx_session_manager", default=None
+)
+
+
+@contextmanager
+def providing_session_manager(
+    session_manager: SessionManager,
+) -> Generator[None, Any, None]:
+    """
+    Context manager to provide a session manager for the current context.
+    """
+    token = ctx_session_manager.set(session_manager)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            ctx_session_manager.reset(token)
+
+
+def use_session_manager() -> SessionManager:
+    """
+    Retrieve the current session manager from the context variable.
+    Raises ValueError if no session manager is set.
+    """
+    session_manager = ctx_session_manager.get()
+    if session_manager is None:
+        raise ValueError("No session manager set in the context.")
+    return session_manager
+
+
 ctx_default_connection_name: ContextVar[str] = ContextVar(
     "ctx_default_connection_name", default=DEFAULT_CONNECTION_NAME
 )
@@ -71,7 +107,8 @@ async def providing_new_session(
     connection_name: str | None = None,
 ) -> AsyncGenerator[AsyncSession, None]:
 
-    current_session = use_session(connection_name)
+    session_manager = use_session_manager()
+    current_session = session_manager.spawn_session(connection_name)
 
     async with AsyncSession(
         current_session.bind,
@@ -131,7 +168,7 @@ class AIOSQAConfig:
         self.inject_default = inject_default
 
 
-class AIOSqlAlchemySessionInterceptor(AppInterceptor):
+class AIOSqlAlchemySessionInterceptor(AppInterceptor, SessionManager):
 
     def __init__(self, config: AIOSQAConfig):
         self.config = config
@@ -148,27 +185,33 @@ class AIOSqlAlchemySessionInterceptor(AppInterceptor):
         self, app_context: AppTransactionContext
     ) -> AsyncGenerator[None, None]:
 
-        uses_connection_metadata = get_metadata_value(
-            INJECT_PERSISTENCE_SESSION_METADATA_TEMPLATE.format(
-                connection_name=self.config.connection_name
-            ),
-            self.config.inject_default,
-        )
-
-        if not uses_connection_metadata:
-            yield
-            return
-
-        async with self.sessionmaker() as session, session.begin() as tx:
-            token = ctx_default_connection_name.set(self.config.connection_name)
-            with providing_session(session, tx, self.config.connection_name):
-                try:
-                    yield
-                    if tx.is_active:
-                        await tx.commit()
-                except Exception as e:
-                    await tx.rollback()
-                    raise e
-                finally:
-                    with suppress(ValueError):
-                        ctx_default_connection_name.reset(token)
+        with providing_session_manager(self):
+            uses_connection_metadata = get_metadata_value(
+                INJECT_PERSISTENCE_SESSION_METADATA_TEMPLATE.format(
+                    connection_name=self.config.connection_name
+                ),
+                self.config.inject_default,
+            )
+
+            if not uses_connection_metadata:
+                yield
+                return
+
+            async with self.sessionmaker() as session, session.begin() as tx:
+                token = ctx_default_connection_name.set(self.config.connection_name)
+                with providing_session(session, tx, self.config.connection_name):
+                    try:
+                        yield
+                        if tx.is_active:
+                            await tx.commit()
+                    except Exception as e:
+                        await tx.rollback()
+                        raise e
+                    finally:
+                        with suppress(ValueError):
+                            ctx_default_connection_name.reset(token)
+
+    def spawn_session(self, connection_name: str | None = None) -> AsyncSession:
+        connection_name = ensure_name(connection_name)
+        session = self.sessionmaker()
+        return session

jararaca/tools/typescript/decorators.py

@@ -1,5 +1,7 @@
 from typing import Any, Callable, TypeVar, cast
 
+from pydantic import BaseModel
+
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
 
 
@@ -60,3 +62,34 @@ class MutationEndpoint:
         Check if the function is marked as a mutation endpoint.
         """
         return getattr(func, MutationEndpoint.METADATA_KEY, False)
+
+
+BASEMODEL_T = TypeVar("BASEMODEL_T", bound=BaseModel)
+
+
+class SplitInputOutput:
+    """
+    Decorator to mark a Pydantic model to generate separate Input and Output TypeScript interfaces.
+
+    Input interface: Used for API inputs (mutations/queries), handles optional fields with defaults
+    Output interface: Used for API outputs, represents the complete object structure
+    """
+
+    METADATA_KEY = "__jararaca_split_input_output__"
+
+    def __init__(self) -> None:
+        pass
+
+    def __call__(self, cls: type[BASEMODEL_T]) -> type[BASEMODEL_T]:
+        """
+        Decorate the Pydantic model class to mark it for split interface generation.
+        """
+        setattr(cls, self.METADATA_KEY, True)
+        return cls
+
+    @staticmethod
+    def is_split_model(cls: type) -> bool:
+        """
+        Check if the Pydantic model is marked for split interface generation.
+        """
+        return getattr(cls, SplitInputOutput.METADATA_KEY, False)

jararaca/tools/typescript/interface_parser.py

@@ -27,7 +27,7 @@ from fastapi import Request, Response, UploadFile
 from fastapi.params import Body, Cookie, Depends, Header, Path, Query
 from fastapi.security.http import HTTPBase
 from pydantic import BaseModel, PlainValidator
-from pydantic_core import PydanticUndefinedType
+from pydantic_core import PydanticUndefined
 
 from jararaca.microservice import Microservice
 from jararaca.presentation.decorators import HttpMapping, RestController
@@ -35,7 +35,11 @@ from jararaca.presentation.websocket.decorators import RegisterWebSocketMessage
 from jararaca.presentation.websocket.websocket_interceptor import (
     WebSocketMessageWrapper,
 )
-from jararaca.tools.typescript.decorators import MutationEndpoint, QueryEndpoint
+from jararaca.tools.typescript.decorators import (
+    MutationEndpoint,
+    QueryEndpoint,
+    SplitInputOutput,
+)
 
 CONSTANT_PATTERN = re.compile(r"^[A-Z_]+$")
 
@@ -44,6 +48,152 @@ def is_constant(name: str) -> bool:
     return CONSTANT_PATTERN.match(name) is not None
 
 
+def should_exclude_field(
+    field_name: str, field_type: Any, basemodel_type: Type[Any]
+) -> bool:
+    """
+    Check if a field should be excluded from TypeScript interface generation.
+
+    Args:
+        field_name: The name of the field
+        field_type: The type annotation of the field
+        basemodel_type: The BaseModel class containing the field
+
+    Returns:
+        True if the field should be excluded, False otherwise
+    """
+    # Check if field is private (starts with underscore)
+    if field_name.startswith("_"):
+        return True
+
+    # Check if field has Pydantic Field annotation and is excluded via model_fields
+    if (
+        hasattr(basemodel_type, "model_fields")
+        and field_name in basemodel_type.model_fields
+    ):
+        field_info = basemodel_type.model_fields[field_name]
+
+        # Check if field is excluded via Field(exclude=True)
+        if hasattr(field_info, "exclude") and field_info.exclude:
+            return True
+
+        # Check if field is marked as private via Field(..., alias=None) pattern
+        if (
+            hasattr(field_info, "alias")
+            and field_info.alias is None
+            and field_name.startswith("_")
+        ):
+            return True
+
+    # Check for Annotated types with Field metadata
+    if get_origin(field_type) == Annotated:
+        for metadata in field_type.__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
+                if hasattr(metadata, "exclude") and metadata.exclude:
+                    return True
+                # Check for private fields with alias=None
+                if (
+                    hasattr(metadata, "alias")
+                    and metadata.alias is None
+                    and field_name.startswith("_")
+                ):
+                    return True
+
+    # Check for Field instances assigned as default values
+    # This handles cases like: field_name: str = Field(exclude=True)
+    if (
+        hasattr(basemodel_type, "__annotations__")
+        and field_name in basemodel_type.__annotations__
+    ):
+        # Check if there's a default value that's a Field instance
+        if hasattr(basemodel_type, field_name):
+            default_value = getattr(basemodel_type, field_name, None)
+            # Check if default value has Field-like attributes (duck typing approach)
+            if default_value is not None and hasattr(default_value, "exclude"):
+                if getattr(default_value, "exclude", False):
+                    return True
+            # Check for private fields with alias=None in default Field
+            if (
+                default_value is not None
+                and hasattr(default_value, "alias")
+                and getattr(default_value, "alias", None) is None
+                and field_name.startswith("_")
+            ):
+                return True
+
+    return False
+
+
+def has_default_value(
+    field_name: str, field_type: Any, basemodel_type: Type[Any]
+) -> bool:
+    """
+    Check if a field has a default value (making it optional in TypeScript).
+
+    Args:
+        field_name: The name of the field
+        field_type: The type annotation of the field
+        basemodel_type: The BaseModel class containing the field
+
+    Returns:
+        True if the field has a default value, False otherwise
+    """
+    # Skip literal types as they don't have defaults in the traditional sense
+    if get_origin(field_type) is Literal:
+        return False
+
+    # Check if field has default in model_fields (standard Pydantic way)
+    if (
+        hasattr(basemodel_type, "model_fields")
+        and field_name in basemodel_type.model_fields
+    ):
+        field_info = basemodel_type.model_fields[field_name]
+        if field_info.default is not PydanticUndefined:
+            return True
+
+    # Check for Field instances assigned as default values
+    # This handles cases like: field_name: str = Field(default="value")
+    if (
+        hasattr(basemodel_type, "__annotations__")
+        and field_name in basemodel_type.__annotations__
+    ):
+        if hasattr(basemodel_type, field_name):
+            default_value = getattr(basemodel_type, field_name, None)
+            # Check if it's a Field instance with a default
+            if default_value is not None and hasattr(default_value, "default"):
+                # Check if the Field has a default value set
+                field_default = getattr(default_value, "default", PydanticUndefined)
+                if field_default is not PydanticUndefined:
+                    return True
+
+    # Check for non-Field default values assigned directly to class attributes
+    # This handles cases like: field_name: str = "default_value"
+    if hasattr(basemodel_type, field_name):
+        default_value = getattr(basemodel_type, field_name, None)
+        # If it's not a Field instance but has a value, it's a default
+        if (
+            default_value is not None
+            and not hasattr(default_value, "exclude")  # Not a Field instance
+            and not hasattr(default_value, "alias")
+        ):  # Not a Field instance
+            return True
+
+    # Check for Annotated types with Field metadata that have defaults
+    if get_origin(field_type) == Annotated:
+        for metadata in field_type.__metadata__:
+            # Check if this is a Pydantic Field with a default
+            if hasattr(metadata, "default") and hasattr(
+                metadata, "exclude"
+            ):  # Ensure it's a Field
+                field_default = getattr(metadata, "default", PydanticUndefined)
+                if field_default is not PydanticUndefined:
+                    return True
+
+    return False
+
+
 class ParseContext:
     def __init__(self) -> None:
         self.mapped_types: set[Any] = set()
@@ -102,7 +252,14 @@ def parse_literal_value(value: Any) -> str:
     return "unknown"
 
 
-def get_field_type_for_ts(field_type: Any) -> Any:
+def get_field_type_for_ts(field_type: Any, context_suffix: str = "") -> Any:
+    """
+    Convert a Python type to its TypeScript equivalent.
+
+    Args:
+        field_type: The Python type to convert
+        context_suffix: Suffix for split models (e.g., "Input", "Output")
+    """
     if field_type is Response:
         return "unknown"
     if field_type is Any:
@@ -130,17 +287,20 @@ def get_field_type_for_ts(field_type: Any) -> Any:
     if field_type == Decimal:
         return "number"
     if get_origin(field_type) == ClassVar:
-        return get_field_type_for_ts(field_type.__args__[0])
+        return get_field_type_for_ts(field_type.__args__[0], context_suffix)
     if get_origin(field_type) == tuple:
-        return f"[{', '.join([get_field_type_for_ts(field) for field in field_type.__args__])}]"
+        return f"[{', '.join([get_field_type_for_ts(field, context_suffix) for field in field_type.__args__])}]"
     if get_origin(field_type) == list or get_origin(field_type) == frozenset:
-        return f"Array<{get_field_type_for_ts(field_type.__args__[0])}>"
+        return f"Array<{get_field_type_for_ts(field_type.__args__[0], context_suffix)}>"
     if get_origin(field_type) == set:
-        return f"Array<{get_field_type_for_ts(field_type.__args__[0])}> // Set"
+        return f"Array<{get_field_type_for_ts(field_type.__args__[0], context_suffix)}> // Set"
     if get_origin(field_type) == dict:
-        return f"{{[key: {get_field_type_for_ts(field_type.__args__[0])}]: {get_field_type_for_ts(field_type.__args__[1])}}}"
+        return f"{{[key: {get_field_type_for_ts(field_type.__args__[0], context_suffix)}]: {get_field_type_for_ts(field_type.__args__[1], context_suffix)}}}"
     if inspect.isclass(field_type):
         if not hasattr(field_type, "__pydantic_generic_metadata__"):
+            # Check if this is a split model and use appropriate suffix
+            if SplitInputOutput.is_split_model(field_type) and context_suffix:
+                return f"{field_type.__name__}{context_suffix}"
             return field_type.__name__
         pydantic_metadata = getattr(field_type, "__pydantic_generic_metadata__")
 
@@ -149,12 +309,17 @@ def get_field_type_for_ts(field_type: Any) -> Any:
             if pydantic_metadata.get("origin") is not None
             else field_type.__name__
         )
+
+        # Check if this is a split model and use appropriate suffix
+        if SplitInputOutput.is_split_model(field_type) and context_suffix:
+            name = f"{field_type.__name__}{context_suffix}"
+
         args = pydantic_metadata.get("args")
 
         if len(args) > 0:
             return "%s<%s>" % (
                 name,
-                ", ".join([get_field_type_for_ts(arg) for arg in args]),
+                ", ".join([get_field_type_for_ts(arg, context_suffix) for arg in args]),
             )
 
         return name
@@ -164,7 +329,9 @@ def get_field_type_for_ts(field_type: Any) -> Any:
     if get_origin(field_type) == Literal:
         return " | ".join([parse_literal_value(x) for x in field_type.__args__])
     if get_origin(field_type) == UnionType or get_origin(field_type) == typing.Union:
-        return " | ".join([get_field_type_for_ts(x) for x in field_type.__args__])
+        return " | ".join(
+            [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):
         if (
             plain_validator := next(
@@ -172,8 +339,10 @@ def get_field_type_for_ts(field_type: Any) -> Any:
                 None,
             )
         ) is not None:
-            return get_field_type_for_ts(plain_validator.json_schema_input_type)
-        return get_field_type_for_ts(field_type.__args__[0])
+            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 "unknown"
 
 
@@ -188,6 +357,59 @@ def get_generic_args(field_type: Any) -> Any:
 def parse_type_to_typescript_interface(
     basemodel_type: Type[Any],
 ) -> tuple[set[type], str]:
+    """
+    Parse a Pydantic model into TypeScript interface(s).
+
+    If the model is decorated with @SplitInputOutput, it generates both Input and Output interfaces.
+    Otherwise, it generates a single interface.
+    """
+    # Check if this model should be split into Input/Output interfaces
+    if SplitInputOutput.is_split_model(basemodel_type):
+        return parse_split_input_output_interfaces(basemodel_type)
+
+    return parse_single_typescript_interface(basemodel_type)
+
+
+def parse_split_input_output_interfaces(
+    basemodel_type: Type[Any],
+) -> tuple[set[type], str]:
+    """
+    Generate both Input and Output TypeScript interfaces for a split model.
+    """
+    mapped_types: set[type] = set()
+    combined_output = StringIO()
+
+    # Generate Input interface (with optional fields)
+    input_mapped_types, input_interface = parse_single_typescript_interface(
+        basemodel_type, interface_suffix="Input", force_optional_defaults=True
+    )
+    mapped_types.update(input_mapped_types)
+    combined_output.write(input_interface)
+
+    # Generate Output interface (all fields required as they come from the backend)
+    output_mapped_types, output_interface = parse_single_typescript_interface(
+        basemodel_type, interface_suffix="Output", force_optional_defaults=False
+    )
+    mapped_types.update(output_mapped_types)
+    combined_output.write(output_interface)
+
+    return mapped_types, combined_output.getvalue()
+
+
+def parse_single_typescript_interface(
+    basemodel_type: Type[Any],
+    interface_suffix: str = "",
+    force_optional_defaults: bool | None = None,
+) -> tuple[set[type], str]:
+    """
+    Generate a single TypeScript interface for a Pydantic model.
+
+    Args:
+        basemodel_type: The Pydantic model class
+        interface_suffix: Suffix to add to the interface name (e.g., "Input", "Output")
+        force_optional_defaults: If True, fields with defaults are optional. If False, all fields are required.
+                                If None, uses the default behavior (fields with defaults are optional).
+    """
     string_builder = StringIO()
     mapped_types: set[type] = set()
 
@@ -214,7 +436,7 @@ def parse_type_to_typescript_interface(
         enum_values = sorted([(x._name_, x.value) for x in basemodel_type])
         return (
             set(),
-            f"export enum {basemodel_type.__name__} {{\n"
+            f"export enum {basemodel_type.__name__}{interface_suffix} {{\n"
             + "\n ".join([f'\t{name} = "{value}",' for name, value in enum_values])
             + "\n}\n",
         )
@@ -238,46 +460,46 @@ def parse_type_to_typescript_interface(
         for inherited_class in valid_inherited_classes
     }
 
-    extends_expression = (
-        " extends %s"
-        % ", ".join(
-            sorted(
-                [
-                    (
-                        "%s" % get_field_type_for_ts(inherited_class)
-                        if not inherited_classes_consts_conflict[inherited_class]
-                        else "Omit<%s, %s>"
-                        % (
-                            get_field_type_for_ts(inherited_class),
-                            " | ".join(
-                                sorted(
-                                    [
-                                        '"%s"' % field_name
-                                        for field_name in inherited_classes_consts_conflict[
-                                            inherited_class
-                                        ]
-                                    ]
-                                )
-                            ),
+    # Modify inheritance for split interfaces
+    extends_expression = ""
+    if len(valid_inherited_classes) > 0:
+        extends_base_names = []
+        for inherited_class in valid_inherited_classes:
+            base_name = get_field_type_for_ts(inherited_class, interface_suffix)
+            # If the inherited class is also a split model, use the appropriate suffix
+            if SplitInputOutput.is_split_model(inherited_class) and interface_suffix:
+                base_name = f"{inherited_class.__name__}{interface_suffix}"
+
+            if inherited_classes_consts_conflict[inherited_class]:
+                base_name = "Omit<%s, %s>" % (
+                    base_name,
+                    " | ".join(
+                        sorted(
+                            [
+                                '"%s"' % field_name
+                                for field_name in inherited_classes_consts_conflict[
+                                    inherited_class
+                                ]
+                            ]
                         )
-                    )
-                    for inherited_class in valid_inherited_classes
-                ],
-                key=lambda x: str(x),
-            )
+                    ),
+                )
+            extends_base_names.append(base_name)
+
+        extends_expression = " extends %s" % ", ".join(
+            sorted(extends_base_names, key=lambda x: str(x))
         )
-        if len(valid_inherited_classes) > 0
-        else ""
-    )
+
+    interface_name = f"{basemodel_type.__name__}{interface_suffix}"
 
     if is_generic_type(basemodel_type):
         generic_args = get_generic_args(basemodel_type)
         string_builder.write(
-            f"export interface {basemodel_type.__name__}<{', '.join(sorted([arg.__name__ for arg in generic_args]))}>{extends_expression} {{\n"
+            f"export interface {interface_name}<{', '.join(sorted([arg.__name__ for arg in generic_args]))}>{extends_expression} {{\n"
         )
     else:
         string_builder.write(
-            f"export interface {basemodel_type.__name__}{extends_expression} {{\n"
+            f"export interface {interface_name}{extends_expression} {{\n"
         )
 
     if hasattr(basemodel_type, "__annotations__"):
@@ -290,16 +512,23 @@ def parse_type_to_typescript_interface(
             if field_name in cls_consts:
                 continue
 
-            has_default_value = (
-                get_origin(field) is not Literal
-                and field_name in basemodel_type.model_fields
-                and not isinstance(
-                    basemodel_type.model_fields[field_name].default,
-                    PydanticUndefinedType,
-                )
-            )
+            # Check if field should be excluded (private or excluded via Field)
+            if should_exclude_field(field_name, field, basemodel_type):
+                continue
+
+            # Determine if field is optional based on the force_optional_defaults parameter
+            if force_optional_defaults is True:
+                # Input interface: fields with defaults are optional
+                is_optional = has_default_value(field_name, field, basemodel_type)
+            elif force_optional_defaults is False:
+                # Output interface: all fields are required (backend provides complete data)
+                is_optional = False
+            else:
+                # Default behavior: fields with defaults are optional
+                is_optional = has_default_value(field_name, field, basemodel_type)
+
             string_builder.write(
-                f"  {snake_to_camel(field_name) if not is_constant(field_name) else field_name}{'?' if has_default_value else ''}: {get_field_type_for_ts(field)};\n"
+                f"  {snake_to_camel(field_name) if not is_constant(field_name) else field_name}{'?' if is_optional else ''}: {get_field_type_for_ts(field, interface_suffix)};\n"
             )
             mapped_types.update(extract_all_envolved_types(field))
             mapped_types.add(field)
@@ -326,7 +555,7 @@ def parse_type_to_typescript_interface(
                     return_type = NoneType
 
                 string_builder.write(
-                    f"  {snake_to_camel(field_name)}: {get_field_type_for_ts(return_type)};\n"
+                    f"  {snake_to_camel(field_name)}: {get_field_type_for_ts(return_type, interface_suffix)};\n"
                 )
                 mapped_types.update(extract_all_envolved_types(return_type))
                 mapped_types.add(return_type)
@@ -515,7 +744,8 @@ def write_rest_controller_to_typescript_interface(
 
             mapped_types.update(extract_all_envolved_types(return_type))
 
-            return_value_repr = get_field_type_for_ts(return_type)
+            # For return types, use Output suffix if it's a split model
+            return_value_repr = get_field_type_for_ts(return_type, "Output")
 
             arg_params_spec, parametes_mapped_types = extract_parameters(
                 member, rest_controller, mapping
@@ -732,32 +962,68 @@ def extract_parameters(
                     )
                 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
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(parameter_type)
+                            and hasattr(parameter_type, "__dict__")
+                            and SplitInputOutput.is_split_model(parameter_type)
+                        )
+                        else ""
+                    )
                     parameters_list.append(
                         HttpParemeterSpec(
                             type_="body",
                             name=parameter_name,
                             required=True,
-                            argument_type_str=get_field_type_for_ts(parameter_type),
+                            argument_type_str=get_field_type_for_ts(
+                                parameter_type, context_suffix
+                            ),
                         )
                     )
                 elif isinstance(annotated_type_hook, Query):
                     mapped_types.add(parameter_type)
+                    # For query parameters, use Input suffix if it's a split model
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(parameter_type)
+                            and hasattr(parameter_type, "__dict__")
+                            and SplitInputOutput.is_split_model(parameter_type)
+                        )
+                        else ""
+                    )
                     parameters_list.append(
                         HttpParemeterSpec(
                             type_="query",
                             name=parameter_name,
                             required=True,
-                            argument_type_str=get_field_type_for_ts(parameter_type),
+                            argument_type_str=get_field_type_for_ts(
+                                parameter_type, context_suffix
+                            ),
                         )
                     )
                 elif isinstance(annotated_type_hook, Path):
                     mapped_types.add(parameter_type)
+                    # For path parameters, use Input suffix if it's a split model
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(parameter_type)
+                            and hasattr(parameter_type, "__dict__")
+                            and SplitInputOutput.is_split_model(parameter_type)
+                        )
+                        else ""
+                    )
                     parameters_list.append(
                         HttpParemeterSpec(
                             type_="path",
                             name=parameter_name,
                             required=True,
-                            argument_type_str=get_field_type_for_ts(parameter_type),
+                            argument_type_str=get_field_type_for_ts(
+                                parameter_type, context_suffix
+                            ),
                         )
                     )
 
@@ -779,22 +1045,46 @@ def extract_parameters(
                     re.search(f":{parameter_name}(?:/|$)", controller.path) is not None
                 ):
                     mapped_types.add(annotated_type)
+                    # For path parameters, use Input suffix if it's a split model
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(annotated_type)
+                            and hasattr(annotated_type, "__dict__")
+                            and SplitInputOutput.is_split_model(annotated_type)
+                        )
+                        else ""
+                    )
                     parameters_list.append(
                         HttpParemeterSpec(
                             type_="path",
                             name=parameter_name,
                             required=True,
-                            argument_type_str=get_field_type_for_ts(annotated_type),
+                            argument_type_str=get_field_type_for_ts(
+                                annotated_type, context_suffix
+                            ),
                         )
                     )
                 else:
                     mapped_types.add(annotated_type)
+                    # For default parameters (treated as query), use Input suffix if it's a split model
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(annotated_type)
+                            and hasattr(annotated_type, "__dict__")
+                            and SplitInputOutput.is_split_model(annotated_type)
+                        )
+                        else ""
+                    )
                     parameters_list.append(
                         HttpParemeterSpec(
                             type_="query",
                             name=parameter_name,
                             required=True,
-                            argument_type_str=get_field_type_for_ts(annotated_type),
+                            argument_type_str=get_field_type_for_ts(
+                                annotated_type, context_suffix
+                            ),
                         )
                     )
 
@@ -802,12 +1092,18 @@ def extract_parameters(
                 parameter_type, BaseModel
             ):
                 mapped_types.update(extract_all_envolved_types(parameter_type))
+                # For BaseModel parameters, use Input suffix if it's a split model
+                context_suffix = (
+                    "Input" if SplitInputOutput.is_split_model(parameter_type) else ""
+                )
                 parameters_list.append(
                     HttpParemeterSpec(
                         type_="body",
                         name=parameter_name,
                         required=True,
-                        argument_type_str=get_field_type_for_ts(parameter_type),
+                        argument_type_str=get_field_type_for_ts(
+                            parameter_type, context_suffix
+                        ),
                     )
                 )
             elif (
@@ -816,22 +1112,46 @@ def extract_parameters(
                 or re.search(f"{{{parameter_name}(:.*?)?}}", mapping.path) is not None
             ):
                 mapped_types.add(parameter_type)
+                # For path parameters, use Input suffix if it's a split model
+                context_suffix = (
+                    "Input"
+                    if (
+                        inspect.isclass(parameter_type)
+                        and hasattr(parameter_type, "__dict__")
+                        and SplitInputOutput.is_split_model(parameter_type)
+                    )
+                    else ""
+                )
                 parameters_list.append(
                     HttpParemeterSpec(
                         type_="path",
                         name=parameter_name,
                         required=True,
-                        argument_type_str=get_field_type_for_ts(parameter_type),
+                        argument_type_str=get_field_type_for_ts(
+                            parameter_type, context_suffix
+                        ),
                     )
                 )
             else:
                 mapped_types.add(parameter_type)
+                # For default parameters (treated as query), use Input suffix if it's a split model
+                context_suffix = (
+                    "Input"
+                    if (
+                        inspect.isclass(parameter_type)
+                        and hasattr(parameter_type, "__dict__")
+                        and SplitInputOutput.is_split_model(parameter_type)
+                    )
+                    else ""
+                )
                 parameters_list.append(
                     HttpParemeterSpec(
                         type_="query",
                         name=parameter_name,
                         required=True,
-                        argument_type_str=get_field_type_for_ts(parameter_type),
+                        argument_type_str=get_field_type_for_ts(
+                            parameter_type, context_suffix
+                        ),
                     )
                 )
 

{jararaca-0.3.12a14.dist-info → jararaca-0.3.12a16.dist-info}/METADATA

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

{jararaca-0.3.12a14.dist-info → jararaca-0.3.12a16.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 README.md,sha256=2qMM__t_MoLKZr4IY9tXjo-Jn6LKjuHMb1qbyXpgL08,3401
-pyproject.toml,sha256=3QVWSJEkvEp1kWJ7e8UU9gvW6RtQRqMPvGq7-u2cjiU,2041
-jararaca/__init__.py,sha256=h3MkFZ9xNllb-YTB-M1WH2HnSJbkev6t1c984Nn6G1w,21887
+pyproject.toml,sha256=CJhUE0Llc5_AlQo4FUo5kjI7cblJBlzu4-YmrIZ0QCQ,2041
+jararaca/__init__.py,sha256=vK3zyIVLckwZgj1FPX6jzSbzaSWmSy3wQ2KMwmpJnmg,22046
 jararaca/__main__.py,sha256=-O3vsB5lHdqNFjUtoELDF81IYFtR-DSiiFMzRaiSsv4,67
 jararaca/broker_backend/__init__.py,sha256=GzEIuHR1xzgCJD4FE3harNjoaYzxHMHoEL0_clUaC-k,3528
 jararaca/broker_backend/mapper.py,sha256=vTsi7sWpNvlga1PWPFg0rCJ5joJ0cdzykkIc2Tuvenc,696
@@ -32,7 +32,7 @@ jararaca/observability/providers/otel.py,sha256=8N1F32W43t7c8cwmtTh6Yz9b7HyfGFSR
 jararaca/persistence/base.py,sha256=xnGUbsLNz3gO-9iJt-Sn5NY13Yc9-misP8wLwQuGGoM,1024
 jararaca/persistence/exports.py,sha256=Ghx4yoFaB4QVTb9WxrFYgmcSATXMNvrOvT8ybPNKXCA,62
 jararaca/persistence/interceptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/persistence/interceptors/aiosqa_interceptor.py,sha256=_qhTONCtusGIvQg3FOHVnsxWXGi77gsNi1fH0Cv6kxg,5301
+jararaca/persistence/interceptors/aiosqa_interceptor.py,sha256=Cvr8wtCpRHE1Ddy9NvlZvXE2EVV0jBIibHCqj4pRkvc,6689
 jararaca/persistence/interceptors/constants.py,sha256=o8g5RxDX9dSSnM9eXYlTJalGPfWxYm6-CAA8-FooUzE,36
 jararaca/persistence/interceptors/decorators.py,sha256=p37r9ux5w_bvn8xPNPhScl3fjCc2enqTR0cJYLxMsrI,1627
 jararaca/persistence/session.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -69,13 +69,13 @@ jararaca/tools/app_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 jararaca/tools/app_config/decorators.py,sha256=-ckkMZ1dswOmECdo1rFrZ15UAku--txaNXMp8fd1Ndk,941
 jararaca/tools/app_config/interceptor.py,sha256=HV8h4AxqUc_ACs5do4BSVlyxlRXzx7HqJtoVO9tfRnQ,2611
 jararaca/tools/typescript/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/tools/typescript/decorators.py,sha256=DbwZADDzzo3cbMfNcY6ldILy_80N4x25ChyQoX1q56s,1956
-jararaca/tools/typescript/interface_parser.py,sha256=SsTgYUWhX79e2rvcu5A5kvs7bJ31J05VQUushj9tudk,33689
+jararaca/tools/typescript/decorators.py,sha256=y1zBq8mBZ8CBXlZ0nKy2RyIgCvP9kp4elACbaC6dptQ,2946
+jararaca/tools/typescript/interface_parser.py,sha256=OMvz4vcsKD0eYPwH1hd3PJpLP2Bc_Ex0CefIhsJArf4,47306
 jararaca/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/utils/rabbitmq_utils.py,sha256=ytdAFUyv-OBkaVnxezuJaJoLrmN7giZgtKeet_IsMBs,10918
 jararaca/utils/retry.py,sha256=DzPX_fXUvTqej6BQ8Mt2dvLo9nNlTBm7Kx2pFZ26P2Q,4668
-jararaca-0.3.12a14.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.3.12a14.dist-info/METADATA,sha256=tlstrP3vETc9kcSVacSbX6rYO6j1VBTX2AoMSwdH1Ok,4996
-jararaca-0.3.12a14.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-jararaca-0.3.12a14.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.3.12a14.dist-info/RECORD,,
+jararaca-0.3.12a16.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.3.12a16.dist-info/METADATA,sha256=d5M-tdj2etlzLG_d1OofoaoDIFYwLqgyhHda36VMTJU,4996
+jararaca-0.3.12a16.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+jararaca-0.3.12a16.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.3.12a16.dist-info/RECORD,,

pyproject.toml

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