jararaca 0.3.11a16__py3-none-any.whl → 0.4.0a5__py3-none-any.whl

jararaca/scheduler/decorators.py

@@ -1,17 +1,22 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import inspect
 from dataclasses import dataclass
-from typing import Any, Awaitable, Callable, TypeVar, cast
+from types import FunctionType
+from typing import Any, Awaitable, Callable, TypeVar
 
 from jararaca.reflect.controller_inspect import (
     ControllerMemberReflect,
     inspect_controller,
 )
+from jararaca.reflect.decorators import StackableDecorator
 
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
 
 
-class ScheduledAction:
-    SCHEDULED_ACTION_ATTR = "__scheduled_action__"
+class ScheduledAction(StackableDecorator):
 
     def __init__(
         self,
@@ -62,23 +67,6 @@ class ScheduledAction:
         An optional name for the scheduled action, used for filtering which actions to run.
         """
 
-    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
-        ScheduledAction.register(func, self)
-        return func
-
-    @staticmethod
-    def register(func: DECORATED_FUNC, scheduled_action: "ScheduledAction") -> None:
-        setattr(func, ScheduledAction.SCHEDULED_ACTION_ATTR, scheduled_action)
-
-    @staticmethod
-    def get_scheduled_action(func: DECORATED_FUNC) -> "ScheduledAction | None":
-        if not hasattr(func, ScheduledAction.SCHEDULED_ACTION_ATTR):
-            return None
-
-        return cast(
-            ScheduledAction, getattr(func, ScheduledAction.SCHEDULED_ACTION_ATTR)
-        )
-
     @staticmethod
     def get_function_id(
         func: Callable[..., Any],
@@ -103,12 +91,17 @@ def get_type_scheduled_actions(
 
     _, member_metadata_map = inspect_controller(instance.__class__)
 
-    members = inspect.getmembers(instance, predicate=inspect.ismethod)
+    members: list[tuple[str, FunctionType]] = []
+    for name, value in inspect.getmembers_static(
+        instance, predicate=inspect.isfunction
+    ):
+
+        members.append((name, value))
 
     scheduled_actions: list[ScheduledActionData] = []
 
     for name, member in members:
-        scheduled_action = ScheduledAction.get_scheduled_action(member)
+        scheduled_action = ScheduledAction.get_last(member)
 
         if scheduled_action is None:
             continue

jararaca/scheduler/types.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 from pydantic import BaseModel
 
 

jararaca/tools/app_config/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later

jararaca/tools/app_config/decorators.py

@@ -1,31 +1,19 @@
-from typing import Any, Type, TypeVar, cast
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Any, Type, TypeVar
 
 from pydantic import BaseModel
 
 from jararaca.core.providers import Token
+from jararaca.reflect.decorators import StackableDecorator
 
 DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
 
 
-class RequiresConfig:
-
-    REQUIRE_CONFIG_ATTR = "__requires_config__"
+class RequiresConfig(StackableDecorator):
 
     def __init__(self, token: Token[Any], config: Type[BaseModel]):
         self.config = config
         self.token = token
-
-    @staticmethod
-    def register(cls: Type[DECORATED_CLASS], config: "RequiresConfig") -> None:
-        setattr(cls, RequiresConfig.REQUIRE_CONFIG_ATTR, config)
-
-    @staticmethod
-    def get(cls: Type[DECORATED_CLASS]) -> "RequiresConfig | None":
-        if not hasattr(cls, RequiresConfig.REQUIRE_CONFIG_ATTR):
-            return None
-
-        return cast(RequiresConfig, getattr(cls, RequiresConfig.REQUIRE_CONFIG_ATTR))
-
-    def __call__(self, cls: Type[DECORATED_CLASS]) -> Type[DECORATED_CLASS]:
-        RequiresConfig.register(cls, self)
-        return cls

jararaca/tools/app_config/interceptor.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import logging
 import os
 from contextlib import asynccontextmanager
@@ -56,7 +60,7 @@ class AppConfigurationInterceptor(AppInterceptor, AppInterceptorWithLifecycle):
             *[
                 (config.token, config.config)
                 for controller in app.controllers
-                if (config := RequiresConfig.get(controller))
+                if (config := RequiresConfig.get_last(controller))
             ],
         ]
 
@@ -90,7 +94,7 @@ class AppConfigurationInterceptor(AppInterceptor, AppInterceptorWithLifecycle):
 
         yield
 
-        logger.info("finalizando")
+        logger.debug("finalizando")
 
 
 class AppConfigValidationError(Exception):

jararaca/tools/typescript/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later

jararaca/tools/typescript/decorators.py

@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Any, Callable, TypeVar
+
+from pydantic import BaseModel
+
+from jararaca.reflect.decorators import StackableDecorator
+
+DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
+
+
+class QueryEndpoint(StackableDecorator):
+    """
+    Decorator to mark a endpoint function as a query endpoint for Typescript generation.
+    """
+
+    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
+
+    @staticmethod
+    def extract_query_endpoint(func: Any) -> "QueryEndpoint | None":
+        """
+        Check if the function is marked as a query endpoint.
+        """
+        return QueryEndpoint.get_last(func)
+
+
+class MutationEndpoint(StackableDecorator):
+    """
+    Decorator to mark a endpoint function as a mutation endpoint for Typescript generation.
+    """
+
+    def __init__(self) -> None: ...
+
+    @staticmethod
+    def is_mutation(func: Any) -> bool:
+        """
+        Check if the function is marked as a mutation endpoint.
+        """
+        return MutationEndpoint.get_last(func) is not None
+
+
+BASEMODEL_T = TypeVar("BASEMODEL_T", bound=BaseModel)
+
+
+class SplitInputOutput(StackableDecorator):
+    """
+    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
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def is_split_model(cls: type) -> bool:
+        """
+        Check if the Pydantic model is marked for split interface generation.
+        """
+        return SplitInputOutput.get_last(cls) is not None
+
+
+class ExposeType:
+    """
+    Decorator to explicitly expose types for TypeScript interface generation.
+
+    Use this decorator to include types in the generated TypeScript output without
+    needing them as request/response bodies or indirect dependencies.
+
+    Example:
+        @ExposeType()
+        class UserRole(BaseModel):
+            id: str
+            name: str
+
+        # This ensures UserRole interface is generated even if it's not
+        # directly referenced in any REST endpoint
+    """
+
+    METADATA_KEY = "__jararaca_expose_type__"
+    _exposed_types: set[type] = set()
+
+    def __init__(self) -> None:
+        pass
+
+    def __call__(self, cls: type[BASEMODEL_T]) -> type[BASEMODEL_T]:
+        """
+        Decorate the type to mark it for explicit TypeScript generation.
+        """
+        setattr(cls, self.METADATA_KEY, True)
+        ExposeType._exposed_types.add(cls)
+        return cls
+
+    @staticmethod
+    def is_exposed_type(cls: type) -> bool:
+        """
+        Check if the type is marked for explicit exposure.
+        """
+        return getattr(cls, ExposeType.METADATA_KEY, False)
+
+    @staticmethod
+    def get_all_exposed_types() -> set[type]:
+        """
+        Get all types that have been marked for explicit exposure.
+        """
+        return ExposeType._exposed_types.copy()