GeneralManager 0.71.0__tar.gz → 0.72.0__tar.gz

{generalmanager-0.71.0/src/GeneralManager.egg-info → generalmanager-0.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.71.0
+Version: 0.72.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.71.0 → generalmanager-0.72.0}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.71.0
+Version: 0.72.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.71.0 → generalmanager-0.72.0}/src/general_manager/api/graphql_resolvers.py

@@ -37,6 +37,7 @@ from general_manager.permission.graphql_capabilities import (
     get_capability_context,
     get_graphql_capabilities,
 )
+from general_manager.utils.filter_parser import UnknownInputFieldError
 from general_manager.utils.type_checks import safe_issubclass
 
 if TYPE_CHECKING:
@@ -88,6 +89,15 @@ class UnsupportedExcludeNoneRelationFilterError(ValueError):
         )
 
 
+@dataclass(frozen=True, slots=True)
+class QueryParameterPlan:
+    """Normalized filter and exclusion operations for a list query."""
+
+    filters: GraphQLFilterMapping
+    excludes: GraphQLFilterMapping
+    normalized_excludes: GraphQLFilterMapping
+
+
 @dataclass(slots=True)
 class ReadAuthorizationResult(Generic[GeneralManagerT]):
     """Aggregate outcome from GraphQL read prefiltering and row authorization.
@@ -148,6 +158,99 @@ def contains_none_relation_filter(input_val: object) -> bool:
 # ---------------------------------------------------------------------------
 
 
+def build_query_parameter_plan(
+    filter_input: GraphQLFilterInput,
+    exclude_input: GraphQLFilterInput,
+    filter_normalizer: FilterNormalizer | None = None,
+) -> QueryParameterPlan:
+    """Parse and normalize filter and exclusion inputs once."""
+    filters = parse_input(filter_input)
+    excludes = parse_input(exclude_input)
+    normalized_excludes: GraphQLFilterMapping = {}
+
+    if filters and filter_normalizer is not None:
+        normalized = filter_normalizer(filters)
+        filters = normalized["filter"]
+        normalized_excludes = normalized["exclude"]
+
+    if excludes and filter_normalizer is not None:
+        if contains_none_relation_filter(excludes):
+            raise UnsupportedExcludeNoneRelationFilterError
+        normalized = filter_normalizer(excludes)
+        excludes = normalized["filter"]
+        normalized_excludes = {**normalized_excludes, **normalized["exclude"]}
+
+    return QueryParameterPlan(
+        filters=filters,
+        excludes=excludes,
+        normalized_excludes=normalized_excludes,
+    )
+
+
+def partition_calculation_query_plan(
+    manager_class: type[GeneralManager],
+    plan: QueryParameterPlan,
+) -> tuple[QueryParameterPlan, QueryParameterPlan]:
+    """Partition calculation predicates into input and computed-property plans.
+
+    Calculation inputs can constrain the combinations generated by a
+    calculation bucket. Predicates rooted at GraphQL properties must be
+    deferred until those combinations have been materialized. This helper only
+    inspects interface metadata and the already-normalized plan; it does not
+    instantiate managers or access descriptors. Manager-input ``_id`` aliases
+    are classified with their declared input while preserving the original
+    lookup for the bucket parser.
+    """
+    interface = manager_class.Interface
+    input_fields = interface.input_fields
+    input_names = set(input_fields)
+    computed_names = set(interface.get_graph_ql_properties())
+    known_names = input_names | computed_names
+
+    def partition_mapping(
+        mapping: GraphQLFilterMapping,
+    ) -> tuple[GraphQLFilterMapping, GraphQLFilterMapping]:
+        input_mapping: GraphQLFilterMapping = {}
+        deferred_mapping: GraphQLFilterMapping = {}
+        for lookup, value in mapping.items():
+            root = lookup.partition("__")[0]
+            classified_root = root
+            if root not in known_names and root.endswith("_id"):
+                alias_root = root.removesuffix("_id")
+                alias_input = input_fields.get(alias_root)
+                if (
+                    alias_input is not None
+                    and isinstance(alias_input.type, type)
+                    and issubclass(alias_input.type, GeneralManager)
+                ):
+                    classified_root = alias_root
+            if classified_root not in known_names:
+                raise UnknownInputFieldError(root)
+            if classified_root in input_names:
+                input_mapping[lookup] = value
+            else:
+                deferred_mapping[lookup] = value
+        return input_mapping, deferred_mapping
+
+    input_filters, deferred_filters = partition_mapping(plan.filters)
+    input_excludes, deferred_excludes = partition_mapping(plan.excludes)
+    input_normalized_excludes, deferred_normalized_excludes = partition_mapping(
+        plan.normalized_excludes
+    )
+    return (
+        QueryParameterPlan(
+            filters=input_filters,
+            excludes=input_excludes,
+            normalized_excludes=input_normalized_excludes,
+        ),
+        QueryParameterPlan(
+            filters=deferred_filters,
+            excludes=deferred_excludes,
+            normalized_excludes=deferred_normalized_excludes,
+        ),
+    )
+
+
 def apply_sorting(
     queryset: Bucket[GeneralManager] | GroupBucket[GeneralManager],
     sort_by: graphene.Enum | None,
@@ -160,6 +263,26 @@ def apply_sorting(
     return queryset.sort(sort_by_str, reverse=reverse)
 
 
+def apply_query_parameter_plan(
+    queryset: Bucket[GeneralManager],
+    plan: QueryParameterPlan,
+    sort_by: graphene.Enum | None,
+    reverse: bool,
+) -> Bucket[GeneralManager]:
+    """Apply a normalized query-parameter plan to *queryset*."""
+    if plan.filters:
+        queryset = queryset.filter(**plan.filters)
+    if plan.excludes:
+        queryset = queryset.exclude(**plan.excludes)
+    if plan.normalized_excludes:
+        queryset = queryset.exclude(**plan.normalized_excludes)
+
+    return cast(
+        Bucket[GeneralManager],
+        apply_sorting(queryset, sort_by, reverse),
+    )
+
+
 def apply_query_parameters(
     queryset: Bucket[GeneralManager],
     filter_input: GraphQLFilterInput,
@@ -199,32 +322,12 @@ def apply_query_parameters(
     Raises:
         UnsupportedExcludeNoneRelationFilterError: If an exclude input contains a nested relation ``none`` filter.
     """
-    normalized_excludes: GraphQLFilterMapping = {}
-
-    filters = parse_input(filter_input)
-    if filters and filter_normalizer is not None:
-        normalized = filter_normalizer(filters)
-        filters = normalized["filter"]
-        normalized_excludes = normalized["exclude"]
-    if filters:
-        queryset = queryset.filter(**filters)
-
-    excludes = parse_input(exclude_input)
-    if excludes and filter_normalizer is not None:
-        if contains_none_relation_filter(excludes):
-            raise UnsupportedExcludeNoneRelationFilterError
-        normalized = filter_normalizer(excludes)
-        excludes = normalized["filter"]
-        normalized_excludes = {**normalized_excludes, **normalized["exclude"]}
-    if excludes:
-        queryset = queryset.exclude(**excludes)
-    if normalized_excludes:
-        queryset = queryset.exclude(**normalized_excludes)
-
-    return cast(
-        Bucket[GeneralManager],
-        apply_sorting(queryset, sort_by, reverse),
+    plan = build_query_parameter_plan(
+        filter_input,
+        exclude_input,
+        filter_normalizer,
     )
+    return apply_query_parameter_plan(queryset, plan, sort_by, reverse)
 
 
 def apply_permission_filters(
@@ -688,13 +791,17 @@ def create_list_resolver(
     ``base_queryset._manager_class`` when that is a GeneralManager subclass,
     otherwise using ``fallback_manager_class``. That manager class drives
     permission checks, filter normalization, dependency prefetching, and
-    capability warmups. The resolver applies permission prefilters and the
-    permission row gate before user-supplied query arguments,
-    then explicit filters, normalized filter-side excludes, explicit excludes,
-    normalized exclude-side excludes, optional grouping, sorting, and pagination.
-    Sorting therefore applies to records when grouping is omitted and to grouped
-    manager objects when grouping is active. It computes ``total_count`` after
-    grouping and sorting and before pagination. Non-grouped page items are
+    capability warmups. For non-calculation managers, the resolver applies
+    permission prefilters and the permission row gate before all user-supplied
+    query predicates. For calculation managers, it applies input predicates
+    before authorization to limit generated candidates, fences that exact
+    candidate subset before permission prefilters, then applies deferred
+    computed-property predicates afterward. Permission constraints can only
+    narrow the user-selected input domain. Grouping, sorting, and pagination
+    remain after those predicate phases. Sorting therefore applies to records
+    when grouping is omitted and to grouped manager objects when grouping is
+    active. It computes ``total_count`` after grouping and sorting and before
+    pagination. Non-grouped page items are
     materialized to a list; grouped results remain a
     ``GroupBucket`` and are returned as the Python-side ``items`` value. When
     grouping is active, pagination slices the group bucket before it is returned.
@@ -750,7 +857,6 @@ def create_list_resolver(
             and issubclass(manager_class, GeneralManager)
         ):
             manager_class = fallback_manager_class
-        qs = apply_permission_filters(base_queryset, manager_class, info)
         bound_filter_normalizer = None
         if filter_normalizer is not None:
 
@@ -759,14 +865,36 @@ def create_list_resolver(
             ) -> NormalizedFilterPlan:
                 return filter_normalizer(manager_class, filters)
 
-        qs = apply_query_parameters(
-            qs,
+        plan = build_query_parameter_plan(
             filter,
             exclude,
-            None,
-            reverse,
             filter_normalizer=bound_filter_normalizer,
         )
+        from general_manager.interface import CalculationInterface
+
+        interface = getattr(manager_class, "Interface", None)
+        if isinstance(interface, type) and issubclass(interface, CalculationInterface):
+            input_plan, deferred_plan = partition_calculation_query_plan(
+                manager_class,
+                plan,
+            )
+            input_queryset = apply_query_parameter_plan(
+                base_queryset,
+                input_plan,
+                None,
+                reverse,
+            )
+            if (
+                input_plan.filters
+                or input_plan.excludes
+                or input_plan.normalized_excludes
+            ):
+                input_queryset = input_queryset.with_instances(input_queryset)
+            qs = apply_permission_filters(input_queryset, manager_class, info)
+            qs = apply_query_parameter_plan(qs, deferred_plan, None, reverse)
+        else:
+            qs = apply_permission_filters(base_queryset, manager_class, info)
+            qs = apply_query_parameter_plan(qs, plan, None, reverse)
         qs_grouped = apply_grouping(qs, group_by)
         qs_sorted = apply_sorting(qs_grouped, sort_by, reverse)