GeneralManager 0.57.0__tar.gz → 0.57.2__tar.gz

{generalmanager-0.57.0/src/GeneralManager.egg-info → generalmanager-0.57.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.57.0
+Version: 0.57.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.57.0 → generalmanager-0.57.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.57.0"
+version = "0.57.2"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.57.0 → generalmanager-0.57.2/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.57.0
+Version: 0.57.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.57.0 → generalmanager-0.57.2}/src/general_manager/api/graphql_search.py

@@ -69,6 +69,31 @@ GrapheneReadMapper = Callable[
 SearchResolverPayload = dict[str, object]
 SearchHitEntry = tuple[float | None, SearchHit, GeneralManager]
 SortableValue = float | datetime | str | None
+_BAD_USER_INPUT_CODE = "BAD_USER_INPUT"
+_PAGE_MUST_BE_POSITIVE = "page must be a positive integer."
+_PAGE_SIZE_MUST_BE_POSITIVE = "pageSize must be a positive integer."
+
+
+def _resolve_search_pagination(
+    page: int | None,
+    page_size: int | None,
+) -> tuple[int, int]:
+    """
+    Resolve omitted search pagination arguments and reject non-positive values.
+    """
+    current_page = 1 if page is None else page
+    limit = 10 if page_size is None else page_size
+    if current_page <= 0:
+        raise GraphQLError(
+            _PAGE_MUST_BE_POSITIVE,
+            extensions={"code": _BAD_USER_INPUT_CODE},
+        )
+    if limit <= 0:
+        raise GraphQLError(
+            _PAGE_SIZE_MUST_BE_POSITIVE,
+            extensions={"code": _BAD_USER_INPUT_CODE},
+        )
+    return current_page, limit
 
 
 # ---------------------------------------------------------------------------
@@ -803,15 +828,14 @@ def register_search_query(
         The resolver parses user filters, validates configured filter keys,
         searches each selected manager type, instantiates manager objects from
         hit identification, applies read permission filters/instance checks, and
-        returns paginated authorized manager instances. ``page`` and
-        ``page_size`` values that are ``None`` or falsey fall back to ``1`` and
-        ``10`` respectively. Backend raw payloads are collected once per backend
-        request in the ``raw`` list.
+        returns paginated authorized manager instances. Omitted ``page`` and
+        ``page_size`` values default to ``1`` and ``10`` respectively. Supplied
+        non-positive values raise a ``GraphQLError``. Backend raw payloads are
+        collected once per backend request in the ``raw`` list.
         """
         index_name = index or "global"
-        limit = page_size or 10
-        current_page = page or 1
-        offset = max(current_page - 1, 0) * limit
+        current_page, limit = _resolve_search_pagination(page, page_size)
+        offset = (current_page - 1) * limit
         parsed_filters = parse_search_filters(filters)
         if parsed_filters:
             try:

{generalmanager-0.57.0 → generalmanager-0.57.2}/src/general_manager/api/mutation.py

@@ -103,6 +103,29 @@ class DuplicateMutationOutputNameError(ValueError):
         )
 
 
+class MutationTupleReturnLengthMismatchError(ValueError):
+    """Raised when a tuple-annotated mutation returns the wrong number of values."""
+
+    def __init__(
+        self,
+        function_name: str,
+        expected_count: int,
+        received_count: int,
+    ) -> None:
+        """
+        Initialize the exception indicating a tuple return length mismatch.
+
+        Parameters:
+            function_name (str): Name of the mutation function that returned values.
+            expected_count (int): Number of tuple values declared by the annotation.
+            received_count (int): Number of tuple values returned by the resolver.
+        """
+        super().__init__(
+            f"Mutation {function_name} expected {expected_count} "
+            f"tuple return values but received {received_count}."
+        )
+
+
 def _is_general_manager_type(annotation: object) -> TypeGuard[type[GeneralManager]]:
     """Return True for class annotations that subclass GeneralManager."""
     return inspect.isclass(annotation) and issubclass(annotation, GeneralManager)
@@ -389,11 +412,9 @@ def graph_ql_mutation(
             raise MissingMutationReturnAnnotationError(fn.__name__)
 
         # Unpack tuple return or single
-        out_types = (
-            list(get_args(return_ann))
-            if get_origin(return_ann) in (tuple, Tuple)
-            else [return_ann]
-        )
+        return_origin = get_origin(return_ann)
+        is_tuple_return = return_origin in (tuple, Tuple)
+        out_types = list(get_args(return_ann)) if is_tuple_return else [return_ann]
         for out in out_types:
             is_named_type = isinstance(out, TypeAliasType)
             is_type = isinstance(out, type)
@@ -436,16 +457,22 @@ def graph_ql_mutation(
                     permission.check(normalized_kwargs, info.context.user)
                 result = fn(info, **normalized_kwargs)
                 data: MutationData = {}
-                if isinstance(result, tuple):
+                if is_tuple_return:
+                    result_values = result if isinstance(result, tuple) else (result,)
+                    expected_count = len(out_types)
+                    received_count = len(result_values)
+                    if received_count != expected_count:
+                        raise MutationTupleReturnLengthMismatchError(
+                            fn.__name__,
+                            expected_count,
+                            received_count,
+                        )
                     # unpack according to outputs ordering after success
-                    for (field, _), val in zip(
-                        outputs.items(),
-                        [None, *list(result)],
-                        strict=False,  # None for success field to be set later
+                    for field, val in zip(
+                        (field for field in outputs if field != "success"),
+                        result_values,
+                        strict=True,
                     ):
-                        # skip success
-                        if field == "success":
-                            continue
                         data[field] = val
                 else:
                     only = next(k for k in outputs if k != "success")