GeneralManager 0.89.3__tar.gz → 0.91.0__tar.gz

{generalmanager-0.89.3/src/GeneralManager.egg-info → generalmanager-0.91.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.89.3
+Version: 0.91.0
 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.89.3 → generalmanager-0.91.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.89.3"
+version = "0.91.0"
 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.89.3 → generalmanager-0.91.0/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.89.3
+Version: 0.91.0
 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.89.3 → generalmanager-0.91.0}/src/GeneralManager.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ src/general_manager/api/graphql_view.py
 src/general_manager/api/graphql_warmup.py
 src/general_manager/api/graphql_warmup_registry.py
 src/general_manager/api/graphql_warmup_tasks.py
+src/general_manager/api/graphql_work_limits.py
 src/general_manager/api/mutation.py
 src/general_manager/api/mutation_controls.py
 src/general_manager/api/notification_batching.py

{generalmanager-0.89.3 → generalmanager-0.91.0}/src/general_manager/api/graphql.py

@@ -246,6 +246,23 @@ def _contains_measurement(annotation: object) -> bool:
     return any(_contains_measurement(argument) for argument in get_args(annotation))
 
 
+class InvalidGraphQLMutationDefaultError(TypeError):
+    """Raised when the global generated CRUD default is not boolean."""
+
+    def __init__(self) -> None:
+        super().__init__("GRAPHQL_MUTATIONS_ENABLED must be a bool.")
+
+
+class InvalidGraphQLMutationConfigurationError(TypeError):
+    """Raised when a manager's generated CRUD allowlist is invalid."""
+
+    def __init__(self, manager_name: str) -> None:
+        super().__init__(
+            f"{manager_name}.__graphql_mutations__ must be a set or frozenset "
+            "containing only 'create', 'update', and 'delete'."
+        )
+
+
 class GraphQLOutputTypeError(ValueError):
     """Raised when an output declaration cannot be registered safely."""
 
@@ -724,7 +741,14 @@ class GraphQL:
         registering anything. Otherwise, it generates create/update/delete
         mutation classes when the manager's Interface advertises support for the
         corresponding operation: either by overriding the `InterfaceBase` method
-        or by listing the operation in `Interface.get_capabilities()`. Each
+        or by listing the operation in `Interface.get_capabilities()`. The
+        manager's `__graphql_mutations__` set or frozenset must also include that
+        operation. When omitted, the global GRAPHQL_MUTATIONS_ENABLED setting
+        defaults to True (all three operations); False hides all. Explicit
+        inherited allowlists override that default. An empty set
+        disables generated CRUD without changing Python writes, permissions,
+        queries, or separately registered custom mutations. Invalid allowlists
+        raise `TypeError` before mutation registration changes. Each
         successfully generated mutation is stored on the class-level registry
         (`_mutations`) under the names `create<ManagerName>`,
         `update<ManagerName>`, and `delete<ManagerName>`. If a mutation factory
@@ -741,6 +765,20 @@ class GraphQL:
         if not interface_cls:
             return None
 
+        supported_mutations = {"create", "update", "delete"}
+        global_default = get_setting("GRAPHQL_MUTATIONS_ENABLED", True)
+        if not isinstance(global_default, bool):
+            raise InvalidGraphQLMutationDefaultError()
+        graphql_mutations = getattr(
+            generalManagerClass,
+            "__graphql_mutations__",
+            supported_mutations if global_default else frozenset(),
+        )
+        if not isinstance(graphql_mutations, (set, frozenset)) or not (
+            graphql_mutations <= supported_mutations
+        ):
+            raise InvalidGraphQLMutationConfigurationError(generalManagerClass.__name__)
+
         default_return_values = {
             "success": graphene.Boolean(),
             generalManagerClass.__name__: graphene.Field(
@@ -765,7 +803,7 @@ class GraphQL:
             method_overridden = base_method.__code__ != method.__code__
             return method_overridden or op_name in capabilities
 
-        if _supports("create", "create"):
+        if "create" in graphql_mutations and _supports("create", "create"):
             create_name = f"create{generalManagerClass.__name__}"
             create_mutation = cls.generate_create_mutation_class(
                 generalManagerClass, default_return_values
@@ -780,7 +818,7 @@ class GraphQL:
                     },
                 )
 
-        if _supports("update", "update"):
+        if "update" in graphql_mutations and _supports("update", "update"):
             update_name = f"update{generalManagerClass.__name__}"
             update_mutation = cls.generate_update_mutation_class(
                 generalManagerClass, default_return_values
@@ -795,7 +833,7 @@ class GraphQL:
                     },
                 )
 
-        if _supports("delete", "delete"):
+        if "delete" in graphql_mutations and _supports("delete", "delete"):
             delete_name = f"delete{generalManagerClass.__name__}"
             delete_mutation = cls.generate_delete_mutation_class(
                 generalManagerClass, default_return_values

{generalmanager-0.89.3 → generalmanager-0.91.0}/src/general_manager/api/graphql_query_permissions.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING
 
 from graphql import GraphQLError
 
+from general_manager.api.graphql_work_limits import get_graphql_work_limit
 from general_manager.bucket.base_bucket import Bucket
 from general_manager.bucket.request_bucket import RequestBucket
 from general_manager.manager.general_manager import GeneralManager
@@ -47,7 +48,7 @@ CUSTOM_PROJECTION_ERROR = (
 )
 
 # Bound field/path decisions; bucket materialization and row checks precede this.
-MAX_QUERY_PERMISSION_CANDIDATES = 1000
+MAX_QUERY_PERMISSION_CANDIDATES: int | None = None
 _LOOKUPS = {
     "exact",
     "iexact",
@@ -79,11 +80,16 @@ class QueryFieldAuthorizationBudget:
     """Share only accounting across authorization calls in one operation."""
 
     decisions: int = 0
+    limit: int | None = field(
+        default_factory=lambda: get_graphql_work_limit(
+            "GRAPHQL_QUERY_PERMISSION_LIMIT", MAX_QUERY_PERMISSION_CANDIDATES
+        )
+    )
 
     def charge(self) -> None:
         """Reject work exceeding the operation's field/path decision limit."""
         self.decisions += 1
-        if self.decisions > MAX_QUERY_PERMISSION_CANDIDATES:
+        if self.limit is not None and self.decisions > self.limit:
             raise GraphQLError(_LIMIT_ERROR)
 
 

{generalmanager-0.89.3 → generalmanager-0.91.0}/src/general_manager/api/graphql_search.py

@@ -10,7 +10,6 @@ from __future__ import annotations
 from dataclasses import replace
 
 import json
-import os
 from collections.abc import Callable, Generator, Iterable, Mapping
 from datetime import date, datetime
 from decimal import Decimal
@@ -28,6 +27,7 @@ from graphql import GraphQLError, GraphQLID
 from django.core.exceptions import FieldDoesNotExist
 from django.db import models
 
+from general_manager.api.graphql_work_limits import get_graphql_work_limit
 from general_manager.conf import get_setting
 from general_manager.api.graphql_identifiers import property_identifier_type
 from general_manager.api.graphql_ordering import (
@@ -101,15 +101,11 @@ SearchTotalMode = Literal["exact", "bounded"]
 _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."
-DEFAULT_GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT = 1000
-_SEARCH_TOTAL_SCAN_LIMIT_UNSET = object()
+DEFAULT_GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT: int | None = None
 SEARCH_SOURCE_AUTHORIZATION_LIMIT_ERROR = (
     "Search source authorization candidate limit exceeded."
 )
 SEARCH_TOTAL_MODE_ERROR = "must be one of: exact, bounded."
-SEARCH_TOTAL_SCAN_LIMIT_ERROR = (
-    "GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT must be a positive integer."
-)
 _MALFORMED_NATIVE_ID = object()
 
 _SEARCH_SCAN_LIMIT_EXCEEDED = (
@@ -204,24 +200,11 @@ def normalize_search_total_mode(total_mode: str | None = None) -> SearchTotalMod
     return cast(SearchTotalMode, normalized)
 
 
-def get_graphql_search_total_scan_limit() -> int:
-    """Resolve the shared candidate budget from Django settings, then the env."""
-    raw_limit = get_setting(
-        "GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT",
-        _SEARCH_TOTAL_SCAN_LIMIT_UNSET,
+def get_graphql_search_total_scan_limit() -> int | None:
+    """Resolve the optional shared candidate budget from settings, then env."""
+    return get_graphql_work_limit(
+        "GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT", DEFAULT_GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT
     )
-    if raw_limit is _SEARCH_TOTAL_SCAN_LIMIT_UNSET:
-        env_limit = os.environ.get("GENERAL_MANAGER_GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT")
-        if env_limit is None:
-            raw_limit = DEFAULT_GRAPHQL_SEARCH_TOTAL_SCAN_LIMIT
-        else:
-            try:
-                raw_limit = int(env_limit)
-            except ValueError:
-                raise _bad_user_input_error(SEARCH_TOTAL_SCAN_LIMIT_ERROR) from None
-    if not isinstance(raw_limit, int) or isinstance(raw_limit, bool) or raw_limit <= 0:
-        raise _bad_user_input_error(SEARCH_TOTAL_SCAN_LIMIT_ERROR)
-    return raw_limit
 
 
 def sort_search_hit_entries(
@@ -1569,6 +1552,9 @@ def register_search_query(
             QueryFieldAuthorizationBudget,
         )
 
+        source_limit = get_graphql_work_limit(
+            "GRAPHQL_SEARCH_SOURCE_AUTHORIZATION_LIMIT", MAX_QUERY_PERMISSION_CANDIDATES
+        )
         source_candidate_count = 0
         authorization_budget = QueryFieldAuthorizationBudget()
 
@@ -1577,7 +1563,7 @@ def register_search_query(
         ) -> Generator[GeneralManager, None, None]:
             nonlocal source_candidate_count
             for candidate in source:
-                if source_candidate_count >= MAX_QUERY_PERMISSION_CANDIDATES:
+                if source_limit is not None and source_candidate_count >= source_limit:
                     raise GraphQLError(SEARCH_SOURCE_AUTHORIZATION_LIMIT_ERROR)
                 source_candidate_count += 1
                 if passes_permission_filters(candidate, info, permission_plan=plan):
@@ -1804,11 +1790,19 @@ def register_search_query(
                 fast_source is not None and common_filter_execution_valid()
             )
             while True:
-                remaining_scan_budget = total_scan_limit - scanned_hits
-                if remaining_scan_budget <= 0:
+                remaining_scan_budget = (
+                    None
+                    if total_scan_limit is None
+                    else total_scan_limit - scanned_hits
+                )
+                if remaining_scan_budget is not None and remaining_scan_budget <= 0:
                     manager_total_is_exact = False
                     break
-                query_limit = min(fetch_limit, remaining_scan_budget)
+                query_limit = (
+                    fetch_limit
+                    if remaining_scan_budget is None
+                    else min(fetch_limit, remaining_scan_budget)
+                )
                 result = backend.search(
                     index_name,
                     query,
@@ -1981,7 +1975,7 @@ def register_search_query(
                     break
                 if len(result.hits) < query_limit and not can_continue_page:
                     break
-                if scanned_hits >= total_scan_limit:
+                if total_scan_limit is not None and scanned_hits >= total_scan_limit:
                     manager_total_is_exact = False
                     break
             total += total_hits_for_manager

generalmanager-0.91.0/src/general_manager/api/graphql_work_limits.py

@@ -0,0 +1,35 @@
+"""Server-owned optional GraphQL workload budgets, independent of permissions."""
+
+from __future__ import annotations
+
+import os
+
+from graphql import GraphQLError
+
+from general_manager.conf import get_setting
+
+_UNSET = object()
+
+
+def get_graphql_work_limit(name: str, default: int | None = None) -> int | None:
+    """Resolve Django settings before environment; explicit None means unlimited."""
+    value = get_setting(name, _UNSET)
+    if value is _UNSET:
+        raw = os.environ.get(f"GENERAL_MANAGER_{name}")
+        if raw is None:
+            return default
+        if raw.strip().lower() in {"none", "unlimited"}:
+            return None
+        try:
+            value = int(raw)
+        except ValueError:
+            value = raw
+    if value is None:
+        return None
+    if isinstance(value, int) and not isinstance(value, bool) and value > 0:
+        return value
+    message = f"{name} must be a positive integer or None (unlimited)."
+    raise GraphQLError(
+        message,
+        extensions={"code": "BAD_USER_INPUT"},
+    )

{generalmanager-0.89.3 → generalmanager-0.91.0}/src/general_manager/manager/general_manager.py

@@ -178,6 +178,7 @@ def _reconstruct_general_manager(
 
 class GeneralManager(metaclass=GeneralManagerMeta):
     chat_exposed: bool = False
+    __graphql_mutations__: ClassVar[set[str] | frozenset[str]]
     _gm_uses_default_identification_dependency_active: ClassVar[bool] = True
     Permission: Type[BasePermission]
     _attributes: dict[str, object]

{generalmanager-0.89.3 → generalmanager-0.91.0}/src/general_manager/permission/permission_data_manager.py

@@ -45,6 +45,20 @@ class PermissionRelationResolutionError(PermissionError):
         )
 
 
+def _resolved_relation_model(
+    field: models.ForeignKey[models.Model],
+) -> type[models.Model]:
+    """Use Django's resolved relation owner, not an early cached string reference."""
+    # RelatedField.related_model is cached; inspecting it during model assembly
+    # can retain a string even after Django resolves remote_field.model.
+    related_model = getattr(field.remote_field, "model", None)
+    if not isinstance(related_model, type) or not issubclass(
+        related_model, models.Model
+    ):
+        raise PermissionRelationResolutionError(field.name)
+    return related_model
+
+
 GeneralManagerData = TypeVar("GeneralManagerData", bound=GeneralManager)
 
 
@@ -299,7 +313,7 @@ class PermissionDataManager(Generic[GeneralManagerData]):
         if identifier is None or name == field.attname:
             return identifier
 
-        related_type = field.related_model
+        related_type = _resolved_relation_model(field)
         manager_type = getattr(related_type, "_general_manager_class", None)
         # A write check needs the target on the write database even if a read
         # router would select a replica. Standalone checks retain Django hints.
@@ -342,7 +356,7 @@ class PermissionDataManager(Generic[GeneralManagerData]):
         backing = getattr(getattr(manager, "_interface", None), "_instance", None)
         if (
             manager.identification.get("id") != related.pk
-            or not isinstance(backing, field.related_model)
+            or not isinstance(backing, _resolved_relation_model(field))
             or backing.pk != related.pk
             or backing._state.db != related._state.db
             or getattr(backing, field.target_field.attname)