jararaca 0.3.12a5__tar.gz → 0.3.12a7__tar.gz

{jararaca-0.3.12a5 → jararaca-0.3.12a7}/PKG-INFO

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

{jararaca-0.3.12a5 → jararaca-0.3.12a7}/pyproject.toml

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

{jararaca-0.3.12a5 → jararaca-0.3.12a7}/src/jararaca/__init__.py

@@ -160,6 +160,7 @@ 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
 
     __all__ = [
         "SetMetadata",
@@ -261,6 +262,8 @@ if TYPE_CHECKING:
         "MessageBusPublisherInterceptor",
         "RedisWebSocketConnectionBackend",
         "AppConfigurationInterceptor",
+        "QueryEndpoint",
+        "MutationEndpoint",
         "UseMiddleware",
         "UseDependency",
         "GlobalHttpErrorHandler",
@@ -473,6 +476,8 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
         "tools.app_config.interceptor",
         None,
     ),
+    "QueryEndpoint": (__SPEC_PARENT__, "tools.typescript.decorators", None),
+    "MutationEndpoint": (__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-0.3.12a5 → jararaca-0.3.12a7}/src/jararaca/cli.py

@@ -5,6 +5,7 @@ import multiprocessing
 import os
 import sys
 import time
+import traceback
 from codecs import StreamWriter
 from pathlib import Path
 from typing import Any, Callable
@@ -615,6 +616,7 @@ def generate_interfaces(
         return content
     except Exception as e:
         click.echo(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
         return ""
 
 

jararaca-0.3.12a7/src/jararaca/tools/typescript/decorators.py

@@ -0,0 +1,62 @@
+from typing import Any, Callable, TypeVar, cast
+
+DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
+
+
+class QueryEndpoint:
+    """
+    Decorator to mark a endpoint function as a query endpoint for Typescript generation.
+    """
+
+    METADATA_KEY = "__jararaca_query_endpoint__"
+
+    def __init__(self, has_infinite_query: bool = False) -> None:
+        """
+        Initialize the QueryEndpoint decorator.
+
+        Args:
+            has_infinite_query: Whether the query endpoint supports infinite queries.
+            Important:
+            - Make sure a PaginatedQuery child instance is on the first argument
+            - Make sure the endpoint is a Patch (recommended) or Put method
+            - Make sure the endpoint returns a Paginated[T]
+        """
+        self.has_infinite_query = has_infinite_query
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        """
+        Decorate the function to mark it as a query endpoint.
+        """
+        setattr(func, self.METADATA_KEY, self)
+        return func
+
+    @staticmethod
+    def extract_query_endpoint(func: Any) -> "QueryEndpoint":
+        """
+        Check if the function is marked as a query endpoint.
+        """
+        return cast(QueryEndpoint, getattr(func, QueryEndpoint.METADATA_KEY, None))
+
+
+class MutationEndpoint:
+    """
+    Decorator to mark a endpoint function as a mutation endpoint for Typescript generation.
+    """
+
+    METADATA_KEY = "__jararaca_mutation_endpoint__"
+
+    def __init__(self) -> None: ...
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        """
+        Decorate the function to mark it as a mutation endpoint.
+        """
+        setattr(func, self.METADATA_KEY, True)
+        return func
+
+    @staticmethod
+    def is_mutation(func: Any) -> bool:
+        """
+        Check if the function is marked as a mutation endpoint.
+        """
+        return getattr(func, MutationEndpoint.METADATA_KEY, False)

{jararaca-0.3.12a5 → jararaca-0.3.12a7}/src/jararaca/tools/typescript/interface_parser.py

@@ -8,7 +8,7 @@ from datetime import date, datetime, time
 from decimal import Decimal
 from enum import Enum
 from io import StringIO
-from types import NoneType, UnionType
+from types import FunctionType, NoneType, UnionType
 from typing import (
     IO,
     Annotated,
@@ -35,6 +35,7 @@ from jararaca.presentation.websocket.decorators import RegisterWebSocketMessage
 from jararaca.presentation.websocket.websocket_interceptor import (
     WebSocketMessageWrapper,
 )
+from jararaca.tools.typescript.decorators import MutationEndpoint, QueryEndpoint
 
 CONSTANT_PATTERN = re.compile(r"^[A-Z_]+$")
 
@@ -67,6 +68,13 @@ def snake_to_camel(snake_str: str) -> str:
     return components[0] + "".join(x.title() for x in components[1:])
 
 
+def pascal_to_camel(pascal_str: str) -> str:
+    """Convert a PascalCase string to camelCase."""
+    if not pascal_str:
+        return pascal_str
+    return pascal_str[0].lower() + pascal_str[1:]
+
+
 def parse_literal_value(value: Any) -> str:
     if value is None:
         return "null"
@@ -354,12 +362,17 @@ def write_microservice_to_typescript_interface(
         if rest_controller is None:
             continue
 
-        controller_class_str, types = write_rest_controller_to_typescript_interface(
-            rest_controller, controller
+        controller_class_strio, types, hooks_strio = (
+            write_rest_controller_to_typescript_interface(
+                rest_controller,
+                controller,
+            )
         )
 
         mapped_types_set.update(types)
-        rest_controller_buffer.write(controller_class_str)
+        rest_controller_buffer.write(controller_class_strio.getvalue())
+        if hooks_strio is not None:
+            rest_controller_buffer.write(hooks_strio.getvalue())
 
         registered = RegisterWebSocketMessage.get(controller)
 
@@ -376,6 +389,7 @@ def write_microservice_to_typescript_interface(
 
     final_buffer.write(
         """
+import { createClassQueryHooks , createClassMutationHooks, createClassInfiniteQueryHooks, paginationModelByFirstArgPaginationFilter } from "@jararaca/core";
 export type WebSocketMessageMap = {
 %s
 }
@@ -494,11 +508,16 @@ def is_primitive(field_type: Any) -> bool:
 
 def write_rest_controller_to_typescript_interface(
     rest_controller: RestController, controller: type
-) -> tuple[str, set[Any]]:
+) -> tuple[StringIO, set[Any], StringIO | None]:
+
+    class_name = controller.__name__
+
+    decorated_queries: list[tuple[str, FunctionType, QueryEndpoint]] = []
+    decorated_mutations: list[tuple[str, FunctionType]] = []
 
     class_buffer = StringIO()
 
-    class_buffer.write(f"export class {controller.__name__} extends HttpService {{\n")
+    class_buffer.write(f"export class {class_name} extends HttpService {{\n")
 
     mapped_types: set[Any] = set()
 
@@ -514,6 +533,11 @@ def write_rest_controller_to_typescript_interface(
             if return_type is None:
                 return_type = NoneType
 
+            if query_endpoint := QueryEndpoint.extract_query_endpoint(member):
+                decorated_queries.append((name, member, query_endpoint))
+            if MutationEndpoint.is_mutation(member):
+                decorated_mutations.append((name, member))
+
             mapped_types.update(extract_all_envolved_types(return_type))
 
             return_value_repr = get_field_type_for_ts(return_type)
@@ -588,7 +612,44 @@ def write_rest_controller_to_typescript_interface(
 
     class_buffer.write("}\n")
 
-    return class_buffer.getvalue(), mapped_types
+    controller_hooks_builder: StringIO | None = None
+
+    if decorated_queries or decorated_mutations:
+        controller_hooks_builder = StringIO()
+        controller_hooks_builder.write(
+            f"export const {pascal_to_camel(class_name)} = {{\n"
+        )
+
+        if decorated_queries:
+            controller_hooks_builder.write(
+                f"\t...createClassQueryHooks({class_name},\n"
+            )
+            for name, member, _ in decorated_queries:
+                controller_hooks_builder.write(f'\t\t"{snake_to_camel(name)}",\n')
+            controller_hooks_builder.write("\t),\n")
+
+        if decorated_queries and any(
+            query.has_infinite_query for _, _, query in decorated_queries
+        ):
+            controller_hooks_builder.write(
+                f"\t...createClassInfiniteQueryHooks({class_name}, {{\n"
+            )
+            for name, member, query in decorated_queries:
+                if query.has_infinite_query:
+                    controller_hooks_builder.write(
+                        f'\t\t"{snake_to_camel(name)}": paginationModelByFirstArgPaginationFilter(),\n'
+                    )
+            controller_hooks_builder.write("\t}),\n")
+        if decorated_mutations:
+            controller_hooks_builder.write(
+                f"\t...createClassMutationHooks({class_name},\n"
+            )
+            for name, member in decorated_mutations:
+                controller_hooks_builder.write(f'\t\t"{snake_to_camel(name)}",\n')
+            controller_hooks_builder.write("\t),\n")
+        controller_hooks_builder.write("};\n")
+
+    return class_buffer, mapped_types, controller_hooks_builder
 
 
 EXCLUDED_REQUESTS_TYPES = [Request, Response]