GeneralManager 0.13.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

general_manager/api/graphql.py

@@ -1,6 +1,18 @@
 from __future__ import annotations
 import graphene
-from typing import Any, Callable, get_args, TYPE_CHECKING, cast, Type
+from typing import (
+    Any,
+    Callable,
+    get_args,
+    get_origin,
+    TYPE_CHECKING,
+    cast,
+    Type,
+    Generator,
+    Union,
+)
+from types import UnionType
+
 from decimal import Decimal
 from datetime import date, datetime
 import json
@@ -156,18 +168,45 @@ class GraphQL:
             fields[resolver_name] = cls._createResolver(field_name, field_type)
 
         # handle GraphQLProperty attributes
-        for attr_name, attr_value in generalManagerClass.__dict__.items():
-            if isinstance(attr_value, GraphQLProperty):
-                type_hints = get_args(attr_value.graphql_type_hint)
-                field_type = (
-                    type_hints[0]
-                    if type_hints
-                    else cast(type, attr_value.graphql_type_hint)
+        for (
+            attr_name,
+            attr_value,
+        ) in generalManagerClass.Interface.getGraphQLProperties().items():
+            raw_hint = attr_value.graphql_type_hint
+            origin = get_origin(raw_hint)
+            type_args = [t for t in get_args(raw_hint) if t is not type(None)]
+
+            if origin in (Union, UnionType) and type_args:
+                raw_hint = type_args[0]
+                origin = get_origin(raw_hint)
+                type_args = [t for t in get_args(raw_hint) if t is not type(None)]
+
+            if origin in (list, tuple, set):
+                element = type_args[0] if type_args else Any
+                if isinstance(element, type) and issubclass(element, GeneralManager):  # type: ignore
+                    graphene_field = graphene.List(
+                        lambda elem=element: GraphQL.graphql_type_registry[
+                            elem.__name__
+                        ]
+                    )
+                else:
+                    base_type = GraphQL._mapFieldToGrapheneBaseType(
+                        cast(type, element if isinstance(element, type) else str)
+                    )
+                    graphene_field = graphene.List(base_type)
+                resolved_type = cast(
+                    type, element if isinstance(element, type) else str
                 )
-                fields[attr_name] = cls._mapFieldToGrapheneRead(field_type, attr_name)
-                fields[f"resolve_{attr_name}"] = cls._createResolver(
-                    attr_name, field_type
+            else:
+                resolved_type = (
+                    cast(type, type_args[0]) if type_args else cast(type, raw_hint)
                 )
+                graphene_field = cls._mapFieldToGrapheneRead(resolved_type, attr_name)
+
+            fields[attr_name] = graphene_field
+            fields[f"resolve_{attr_name}"] = cls._createResolver(
+                attr_name, resolved_type
+            )
 
         graphene_type = type(graphene_type_name, (graphene.ObjectType,), fields)
         cls.graphql_type_registry[generalManagerClass.__name__] = graphene_type
@@ -194,6 +233,20 @@ class GraphQL:
             else:
                 sort_options.append(field_name)
 
+        for (
+            prop_name,
+            prop,
+        ) in generalManagerClass.Interface.getGraphQLProperties().items():
+            if prop.sortable is False:
+                continue
+            type_hints = [
+                t for t in get_args(prop.graphql_type_hint) if t is not type(None)
+            ]
+            field_type = (
+                type_hints[0] if type_hints else cast(type, prop.graphql_type_hint)
+            )
+            sort_options.append(prop_name)
+
         if not sort_options:
             return None
 
@@ -203,9 +256,54 @@ class GraphQL:
             {option: option for option in sort_options},
         )
 
+    @staticmethod
+    def _getFilterOptions(attribute_type: type, attribute_name: str) -> Generator[
+        tuple[
+            str, type[graphene.ObjectType] | MeasurementScalar | graphene.List | None
+        ],
+        None,
+        None,
+    ]:
+        number_options = ["exact", "gt", "gte", "lt", "lte"]
+        string_options = [
+            "exact",
+            "icontains",
+            "contains",
+            "in",
+            "startswith",
+            "endswith",
+        ]
+
+        if issubclass(attribute_type, GeneralManager):
+            yield attribute_name, None
+        elif issubclass(attribute_type, Measurement):
+            yield attribute_name, MeasurementScalar()
+            for option in number_options:
+                yield f"{attribute_name}__{option}", MeasurementScalar()
+        else:
+            yield attribute_name, GraphQL._mapFieldToGrapheneRead(
+                attribute_type, attribute_name
+            )
+            if issubclass(attribute_type, (int, float, Decimal, date, datetime)):
+                for option in number_options:
+                    yield f"{attribute_name}__{option}", (
+                        GraphQL._mapFieldToGrapheneRead(attribute_type, attribute_name)
+                    )
+            elif issubclass(attribute_type, str):
+                base_type = GraphQL._mapFieldToGrapheneBaseType(attribute_type)
+                for option in string_options:
+                    if option == "in":
+                        yield f"{attribute_name}__in", graphene.List(base_type)
+                    else:
+                        yield f"{attribute_name}__{option}", (
+                            GraphQL._mapFieldToGrapheneRead(
+                                attribute_type, attribute_name
+                            )
+                        )
+
     @staticmethod
     def _createFilterOptions(
-        field_name: str, field_type: GeneralManagerMeta
+        field_type: GeneralManagerMeta,
     ) -> type[graphene.InputObjectType] | None:
         """
         Dynamically generates a Graphene InputObjectType for filtering fields of a GeneralManager subclass.
@@ -213,21 +311,11 @@ class GraphQL:
         Creates filter fields for each attribute based on its type, supporting numeric and string filter operations, and specialized handling for Measurement attributes. Returns the generated InputObjectType, or None if no applicable filter fields exist.
 
         Parameters:
-            field_name (str): The name of the field to generate filter options for.
             field_type (GeneralManagerMeta): The manager class whose attributes are used to build filter fields.
 
         Returns:
             type[graphene.InputObjectType] | None: The generated filter input type, or None if no filter fields are applicable.
         """
-        number_options = ["exact", "gt", "gte", "lt", "lte"]
-        string_options = [
-            "exact",
-            "icontains",
-            "contains",
-            "in",
-            "startswith",
-            "endswith",
-        ]
 
         graphene_filter_type_name = f"{field_type.__name__}FilterType"
         if graphene_filter_type_name in GraphQL.graphql_filter_type_registry:
@@ -236,26 +324,28 @@ class GraphQL:
         filter_fields = {}
         for attr_name, attr_info in field_type.Interface.getAttributeTypes().items():
             attr_type = attr_info["type"]
-            if issubclass(attr_type, GeneralManager):
+            filter_fields = {
+                **filter_fields,
+                **{
+                    k: v
+                    for k, v in GraphQL._getFilterOptions(attr_type, attr_name)
+                    if v is not None
+                },
+            }
+        for prop_name, prop in field_type.Interface.getGraphQLProperties().items():
+            if not prop.filterable:
                 continue
-            elif issubclass(attr_type, Measurement):
-                filter_fields[f"{attr_name}"] = MeasurementScalar()
-                for option in number_options:
-                    filter_fields[f"{attr_name}__{option}"] = MeasurementScalar()
-            else:
-                filter_fields[attr_name] = GraphQL._mapFieldToGrapheneRead(
-                    attr_type, attr_name
-                )
-                if issubclass(attr_type, (int, float, Decimal, date, datetime)):
-                    for option in number_options:
-                        filter_fields[f"{attr_name}__{option}"] = (
-                            GraphQL._mapFieldToGrapheneRead(attr_type, attr_name)
-                        )
-                elif issubclass(attr_type, str):
-                    for option in string_options:
-                        filter_fields[f"{attr_name}__{option}"] = (
-                            GraphQL._mapFieldToGrapheneRead(attr_type, attr_name)
-                        )
+            hints = [t for t in get_args(prop.graphql_type_hint) if t is not type(None)]
+            prop_type = hints[0] if hints else cast(type, prop.graphql_type_hint)
+            filter_fields = {
+                **filter_fields,
+                **{
+                    k: v
+                    for k, v in GraphQL._getFilterOptions(prop_type, prop_name)
+                    if v is not None
+                },
+            }
+
         if not filter_fields:
             return None
 
@@ -284,14 +374,14 @@ class GraphQL:
                     "page_size": graphene.Int(),
                     "group_by": graphene.List(graphene.String),
                 }
-                filter_options = GraphQL._createFilterOptions(field_name, field_type)
+                filter_options = GraphQL._createFilterOptions(field_type)
                 if filter_options:
-                    attributes["filter"] = filter_options()
-                    attributes["exclude"] = filter_options()
+                    attributes["filter"] = graphene.Argument(filter_options)
+                    attributes["exclude"] = graphene.Argument(filter_options)
 
                 sort_by_options = GraphQL._sortByOptions(field_type)
                 if sort_by_options:
-                    attributes["sort_by"] = sort_by_options()
+                    attributes["sort_by"] = graphene.Argument(sort_by_options)
 
                 page_type = GraphQL._getOrCreatePageType(
                     field_type.__name__ + "Page",
@@ -299,10 +389,6 @@ class GraphQL:
                 )
                 return graphene.Field(page_type, **attributes)
 
-                return graphene.List(
-                    lambda: GraphQL.graphql_type_registry[field_type.__name__],
-                    **attributes,
-                )
             return graphene.Field(
                 lambda: GraphQL.graphql_type_registry[field_type.__name__]
             )
@@ -314,6 +400,8 @@ class GraphQL:
         """
         Ordnet einen Python-Typ einem entsprechenden Graphene-Feld zu.
         """
+        if issubclass(field_type, dict):
+            raise TypeError("GraphQL does not support dict fields")
         if issubclass(field_type, str):
             return graphene.String
         elif issubclass(field_type, bool):
@@ -322,7 +410,9 @@ class GraphQL:
             return graphene.Int
         elif issubclass(field_type, (float, Decimal)):
             return graphene.Float
-        elif issubclass(field_type, (date, datetime)):
+        elif issubclass(field_type, datetime):
+            return graphene.DateTime
+        elif issubclass(field_type, date):
             return graphene.Date
         elif issubclass(field_type, Measurement):
             return MeasurementScalar
@@ -385,7 +475,7 @@ class GraphQL:
     ) -> Bucket:
         """
         Applies permission-based filters to a queryset according to the permission interface of the given manager class.
-        
+
         Returns:
             A queryset containing only the items allowed by the user's read permissions. If no permission filters are defined, returns the original queryset unchanged.
         """
@@ -541,7 +631,7 @@ class GraphQL:
                 result = result.to(target_unit)
             return {
                 "value": result.quantity.magnitude,
-                "unit": result.quantity.units,
+                "unit": str(result.quantity.units),
             }
 
         return resolver
@@ -621,15 +711,13 @@ class GraphQL:
             "page_size": graphene.Int(),
             "group_by": graphene.List(graphene.String),
         }
-        filter_options = cls._createFilterOptions(
-            generalManagerClass.__name__.lower(), generalManagerClass
-        )
+        filter_options = cls._createFilterOptions(generalManagerClass)
         if filter_options:
-            attributes["filter"] = filter_options()
-            attributes["exclude"] = filter_options()
+            attributes["filter"] = graphene.Argument(filter_options)
+            attributes["exclude"] = graphene.Argument(filter_options)
         sort_by_options = cls._sortByOptions(generalManagerClass)
         if sort_by_options:
-            attributes["sort_by"] = sort_by_options()
+            attributes["sort_by"] = graphene.Argument(sort_by_options)
 
         page_type = cls._getOrCreatePageType(
             graphene_type.__name__ + "Page", graphene_type
@@ -829,7 +917,9 @@ class GraphQL:
             """
             try:
                 manager_id = kwargs.pop("id", None)
-                instance = generalManagerClass(manager_id).update(
+                if manager_id is None:
+                    raise ValueError("id is required")
+                instance = generalManagerClass(id=manager_id).update(
                     creator_id=info.context.user.id, **kwargs
                 )
             except Exception as e:
@@ -844,7 +934,7 @@ class GraphQL:
             }
 
         return type(
-            f"Create{generalManagerClass.__name__}",
+            f"Update{generalManagerClass.__name__}",
             (graphene.Mutation,),
             {
                 **default_return_values,
@@ -853,11 +943,14 @@ class GraphQL:
                     "Arguments",
                     (),
                     {
-                        field_name: field
-                        for field_name, field in cls.createWriteFields(
-                            interface_cls
-                        ).items()
-                        if field.editable
+                        "id": graphene.ID(required=True),
+                        **{
+                            field_name: field
+                            for field_name, field in cls.createWriteFields(
+                                interface_cls
+                            ).items()
+                            if field.editable
+                        },
                     },
                 ),
                 "mutate": update_mutation,
@@ -897,7 +990,9 @@ class GraphQL:
             """
             try:
                 manager_id = kwargs.pop("id", None)
-                instance = generalManagerClass(manager_id).deactivate(
+                if manager_id is None:
+                    raise ValueError("id is required")
+                instance = generalManagerClass(id=manager_id).deactivate(
                     creator_id=info.context.user.id
                 )
             except Exception as e:
@@ -946,7 +1041,7 @@ class GraphQL:
                     "code": "PERMISSION_DENIED",
                 },
             )
-        elif isinstance(error, (ValueError, ValidationError)):
+        elif isinstance(error, (ValueError, ValidationError, TypeError)):
             raise GraphQLError(
                 str(error),
                 extensions={

general_manager/api/mutation.py

@@ -19,23 +19,30 @@ from typing import TypeAliasType
 from general_manager.permission.mutationPermission import MutationPermission
 
 
-def graphQlMutation(permission: Optional[Type[MutationPermission]] = None):
+def graphQlMutation(_func=None, permission: Optional[Type[MutationPermission]] = None):
     """
     Decorator that converts a function into a GraphQL mutation class for use with Graphene, automatically generating argument and output fields from the function's signature and type annotations.
-    
+
     The decorated function must provide type hints for all parameters (except `info`) and a return annotation. The decorator dynamically constructs a mutation class with appropriate Graphene fields, enforces permission checks if a `permission` class is provided, and registers the mutation for use in the GraphQL API.
-    
+
     Parameters:
         permission (Optional[Type[MutationPermission]]): An optional permission class to enforce access control on the mutation.
-    
+
     Returns:
         Callable: A decorator that registers the mutation and returns the original function.
     """
+    if (
+        _func is not None
+        and inspect.isclass(_func)
+        and issubclass(_func, MutationPermission)
+    ):
+        permission = _func
+        _func = None
 
     def decorator(fn):
         """
         Decorator that transforms a function into a GraphQL mutation class compatible with Graphene.
-        
+
         Analyzes the decorated function's signature and type hints to dynamically generate a mutation class with appropriate argument and output fields. Handles permission checks if a permission class is provided, manages mutation execution, and registers the mutation for use in the GraphQL API. On success, returns output fields and a `success` flag; on error, returns only `success=False`.
         """
         sig = inspect.signature(fn)
@@ -122,10 +129,9 @@ def graphQlMutation(permission: Optional[Type[MutationPermission]] = None):
 
         # Define mutate method
         def _mutate(root, info, **kwargs):
-
             """
             Handles the execution of a GraphQL mutation, including permission checks, result unpacking, and error handling.
-            
+
             Returns:
                 An instance of the mutation class with output fields populated from the mutation result and a success status.
             """
@@ -169,4 +175,6 @@ def graphQlMutation(permission: Optional[Type[MutationPermission]] = None):
 
         return fn
 
+    if _func is not None and inspect.isfunction(_func):
+        return decorator(_func)
     return decorator

general_manager/api/property.py

@@ -1,20 +1,105 @@
-from typing import Any, Callable, get_type_hints
+from typing import Any, Callable, get_type_hints, overload, TypeVar
+import sys
+
+T = TypeVar("T", bound=Callable[..., Any])
 
 
 class GraphQLProperty(property):
-    def __init__(self, fget: Callable[..., Any], doc: str | None = None):
+    sortable: bool
+    filterable: bool
+    query_annotation: Any | None
+
+    def __init__(
+        self,
+        fget: Callable[..., Any],
+        doc: str | None = None,
+        *,
+        sortable: bool = False,
+        filterable: bool = False,
+        query_annotation: Any | None = None,
+    ) -> None:
         super().__init__(fget, doc=doc)
         self.is_graphql_resolver = True
-        self.graphql_type_hint = get_type_hints(fget).get("return", None)
+        self._owner: type | None = None
+        self._name: str | None = None
+        self._graphql_type_hint: Any | None = None
+
+        self.sortable = sortable
+        self.filterable = filterable
+        self.query_annotation = query_annotation
+
+        orig = getattr(
+            fget, "__wrapped__", fget
+        )  # falls decorator Annotations durchreicht
+        ann = getattr(orig, "__annotations__", {}) or {}
+        if "return" not in ann:
+            raise TypeError(
+                "GraphQLProperty requires a return type hint for the property function."
+            )
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self._owner = owner
+        self._name = name
+
+    def _try_resolve_type_hint(self) -> None:
+        if self._graphql_type_hint is not None:
+            return
+
+        try:
+            mod = sys.modules.get(self.fget.__module__)
+            globalns = vars(mod) if mod else {}
+
+            localns: dict[str, Any] = {}
+            if self._owner is not None:
+                localns = dict(self._owner.__dict__)
+                localns[self._owner.__name__] = self._owner
 
+            hints = get_type_hints(self.fget, globalns=globalns, localns=localns)
+            self._graphql_type_hint = hints.get("return", None)
+        except Exception:
+            self._graphql_type_hint = None
 
-def graphQlProperty(func: Callable[..., Any]):
+    @property
+    def graphql_type_hint(self) -> Any | None:
+        if self._graphql_type_hint is None:
+            self._try_resolve_type_hint()
+        return self._graphql_type_hint
+
+
+@overload
+def graphQlProperty(func: T) -> GraphQLProperty: ...
+@overload
+def graphQlProperty(
+    *,
+    sortable: bool = False,
+    filterable: bool = False,
+    query_annotation: Any | None = None,
+) -> Callable[[T], GraphQLProperty]: ...
+
+
+def graphQlProperty(
+    func: Callable[..., Any] | None = None,
+    *,
+    sortable: bool = False,
+    filterable: bool = False,
+    query_annotation: Any | None = None,
+) -> GraphQLProperty | Callable[[T], GraphQLProperty]:
     from general_manager.cache.cacheDecorator import cached
 
+    """Decorator to create a :class:`GraphQLProperty`.
+
+    It can be used without arguments or with optional configuration for
+    filtering, sorting and queryset annotation.
     """
-    Dekorator für GraphQL-Feld-Resolver, der automatisch:
-    - die Methode als benutzerdefiniertes Property registriert,
-    - die Resolver-Informationen speichert,
-    - den Field-Typ aus dem Type-Hint ableitet.
-    """
-    return GraphQLProperty(cached()(func))
+
+    def wrapper(f: Callable[..., Any]) -> GraphQLProperty:
+        return GraphQLProperty(
+            cached()(f),
+            sortable=sortable,
+            query_annotation=query_annotation,
+            filterable=filterable,
+        )
+
+    if func is None:
+        return wrapper
+    return wrapper(func)

general_manager/apps.py

@@ -162,17 +162,20 @@ class GeneralmanagerConfig(AppConfig):
         query_class = type("Query", (graphene.ObjectType,), GraphQL._query_fields)
         GraphQL._query_class = query_class
 
-        mutation_class = type(
-            "Mutation",
-            (graphene.ObjectType,),
-            {name: mutation.Field() for name, mutation in GraphQL._mutations.items()},
-        )
-        GraphQL._mutation_class = mutation_class
-
-        schema = graphene.Schema(
-            query=GraphQL._query_class,
-            mutation=GraphQL._mutation_class,
-        )
+        if GraphQL._mutations:
+            mutation_class = type(
+                "Mutation",
+                (graphene.ObjectType,),
+                {name: mutation.Field() for name, mutation in GraphQL._mutations.items()},
+            )
+            GraphQL._mutation_class = mutation_class
+            schema = graphene.Schema(
+                query=GraphQL._query_class,
+                mutation=mutation_class,
+            )
+        else:
+            GraphQL._mutation_class = None
+            schema = graphene.Schema(query=GraphQL._query_class)
         GeneralmanagerConfig.addGraphqlUrl(schema)
 
     @staticmethod