infrahub-server 1.2.4__py3-none-any.whl → 1.2.6__py3-none-any.whl

infrahub/core/schema/schema_branch.py

@@ -1005,9 +1005,11 @@ class SchemaBranch:
             generic_schema = self.get_generic(name=name, duplicate=False)
             for attribute in generic_schema.attributes:
                 if attribute.computed_attribute and attribute.computed_attribute.kind != ComputedAttributeKind.USER:
-                    raise ValueError(
-                        f"{generic_schema.kind}: Attribute {attribute.name!r} computed attributes are only allowed on nodes not generics"
-                    )
+                    for inheriting_node in generic_schema.used_by:
+                        node_schema = self.get_node(name=inheriting_node, duplicate=False)
+                        self.computed_attributes.validate_generic_inheritance(
+                            node=node_schema, attribute=attribute, generic=generic_schema
+                        )
 
     def _validate_computed_attribute(self, node: NodeSchema, attribute: AttributeSchema) -> None:
         if not attribute.computed_attribute or attribute.computed_attribute.kind == ComputedAttributeKind.USER:
@@ -1907,10 +1909,8 @@ class SchemaBranch:
 
                 self.set(name=node_name, schema=node_schema)
 
-    def add_relationships_to_template(self, node: NodeSchema) -> None:
+    def add_relationships_to_template(self, node: NodeSchema | GenericSchema) -> None:
         template_schema = self.get(name=self._get_object_template_kind(node_kind=node.kind), duplicate=False)
-        if template_schema.is_generic_schema:
-            return
 
         # Remove previous relationships to account for new ones
         template_schema.relationships = [
@@ -1952,6 +1952,7 @@ class SchemaBranch:
                     label=f"{relationship.name} template".title()
                     if relationship.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
                     else relationship.name.title(),
+                    inherited=relationship.inherited,
                 )
             )
 
@@ -1981,9 +1982,6 @@ class SchemaBranch:
         need_template_kinds = [n.kind for n in need_templates]
 
         if node.is_generic_schema:
-            # When needing a template for a generic, we generate an empty shell mostly to make sure that schemas (including the GraphQL one) will
-            # look right. We don't really care about applying inheritance of fields as it was already processed and actual templates will have the
-            # correct attributes and relationships
             template = GenericSchema(
                 name=node.kind,
                 namespace="Template",
@@ -1992,43 +1990,44 @@ class SchemaBranch:
                 generate_profile=False,
                 branch=node.branch,
                 include_in_menu=False,
+                display_labels=["template_name__value"],
+                human_friendly_id=["template_name__value"],
+                uniqueness_constraints=[["template_name__value"]],
                 attributes=[template_name_attr],
             )
 
             for used in node.used_by:
                 if used in need_template_kinds:
                     template.used_by.append(self._get_object_template_kind(node_kind=used))
+        else:
+            template = TemplateSchema(
+                name=node.kind,
+                namespace="Template",
+                label=f"Object template {node.label}",
+                description=f"Object template for {node.kind}",
+                branch=node.branch,
+                include_in_menu=False,
+                display_labels=["template_name__value"],
+                human_friendly_id=["template_name__value"],
+                uniqueness_constraints=[["template_name__value"]],
+                inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
+                default_filter="template_name__value",
+                attributes=[template_name_attr],
+                relationships=[
+                    RelationshipSchema(
+                        name="related_nodes",
+                        identifier="node__objecttemplate",
+                        peer=node.kind,
+                        kind=RelationshipKind.TEMPLATE,
+                        cardinality=RelationshipCardinality.MANY,
+                        branch=BranchSupportType.AWARE,
+                    )
+                ],
+            )
 
-            return template
-
-        template = TemplateSchema(
-            name=node.kind,
-            namespace="Template",
-            label=f"Object template {node.label}",
-            description=f"Object template for {node.kind}",
-            branch=node.branch,
-            include_in_menu=False,
-            display_labels=["template_name__value"],
-            human_friendly_id=["template_name__value"],
-            uniqueness_constraints=[["template_name__value"]],
-            inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
-            default_filter="template_name__value",
-            attributes=[template_name_attr],
-            relationships=[
-                RelationshipSchema(
-                    name="related_nodes",
-                    identifier="node__objecttemplate",
-                    peer=node.kind,
-                    kind=RelationshipKind.TEMPLATE,
-                    cardinality=RelationshipCardinality.MANY,
-                    branch=BranchSupportType.AWARE,
-                )
-            ],
-        )
-
-        for inherited in node.inherit_from:
-            if inherited in need_template_kinds:
-                template.inherit_from.append(self._get_object_template_kind(node_kind=inherited))
+            for inherited in node.inherit_from:
+                if inherited in need_template_kinds:
+                    template.inherit_from.append(self._get_object_template_kind(node_kind=inherited))
 
         for node_attr in node.attributes:
             if node_attr.unique or node_attr.read_only:
@@ -2036,7 +2035,7 @@ class SchemaBranch:
 
             attr = AttributeSchema(
                 optional=node_attr.optional if is_autogenerated_subtemplate else True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "inherited"]),
+                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only"]),
             )
             template.attributes.append(attr)
 

infrahub/core/schema/schema_branch_computed.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field
 from infrahub.core.schema import AttributeSchema  # noqa: TC001
 
 if TYPE_CHECKING:
-    from infrahub.core.schema import NodeSchema, SchemaAttributePath
+    from infrahub.core.schema import GenericSchema, NodeSchema, SchemaAttributePath
 
 
 @dataclass
@@ -90,6 +90,7 @@ class ComputedAttributes:
     ) -> None:
         self._computed_python_transform_attribute_map: dict[str, list[AttributeSchema]] = transform_attribute_map or {}
         self._computed_jinja2_attribute_map: dict[str, RegisteredNodeComputedAttribute] = jinja2_attribute_map or {}
+        self._defined_from_generic: dict[str, str] = {}
 
     def duplicate(self) -> ComputedAttributes:
         return self.__class__(
@@ -166,6 +167,16 @@ class ComputedAttributes:
                 schema_path.active_relationship_schema.name
             ].append(deepcopy(source_attribute))
 
+    def validate_generic_inheritance(
+        self, node: NodeSchema, attribute: AttributeSchema, generic: GenericSchema
+    ) -> None:
+        attribute_key = f"{node.kind}__{attribute.name}"
+        if duplicate := self._defined_from_generic.get(attribute_key):
+            raise ValueError(
+                f"{node.kind}: {attribute.name!r} is declared as a computed attribute from multiple generics {sorted([duplicate, generic.kind])}"
+            )
+        self._defined_from_generic[attribute_key] = generic.kind
+
     def get_impacted_jinja2_targets(self, kind: str, updates: list[str] | None = None) -> list[ComputedAttributeTarget]:
         if mapping := self._computed_jinja2_attribute_map.get(kind):
             return mapping.get_targets(updates=updates)

infrahub/database/__init__.py

@@ -394,8 +394,10 @@ class InfrahubDatabase:
             with QUERY_EXECUTION_METRICS.labels(**labels).time():
                 response = await self.run_query(query=query, params=params, name=name)
                 if response is None:
+                    span.set_attribute("rows", "empty")
                     return [], {}
                 results = [item async for item in response]
+                span.set_attribute("rows", len(results))
                 return results, response._metadata or {}
 
     async def run_query(

infrahub/events/branch_action.py

@@ -100,6 +100,9 @@ class BranchMergedEvent(InfrahubEvent):
 
         return related
 
+    def get_messages(self) -> list[InfrahubMessage]:
+        return [RefreshRegistryBranches()]
+
 
 class BranchRebasedEvent(InfrahubEvent):
     """Event generated when a branch has been rebased"""

infrahub/events/group_action.py

@@ -22,7 +22,7 @@ class GroupMutatedEvent(InfrahubEvent):
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
 
-        if self.kind == InfrahubKind.GRAPHQLQUERYGROUP:
+        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
             # Temporary workaround to avoid too large payloads for the related field
             return related
 

infrahub/events/node_action.py

@@ -24,7 +24,7 @@ class NodeMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
-        if self.kind == InfrahubKind.GRAPHQLQUERYGROUP:
+        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
             # Temporary workaround to avoid too large payloads for the related field
             return related
 

infrahub/git/integrator.py

@@ -954,7 +954,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             source=self.id,
             is_protected=True,
         )
-        obj = await self.sdk.create(kind=CoreCheckDefinition, branch=branch_name, **create_payload)
+        obj = await self.sdk.create(kind=CoreCheckDefinition, branch=branch_name, data=create_payload)
         await obj.save()
 
         return obj
@@ -1012,7 +1012,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             source=str(self.id),
             is_protected=True,
         )
-        obj = await self.sdk.create(kind=CoreTransformPython, branch=branch_name, **create_payload)
+        obj = await self.sdk.create(kind=CoreTransformPython, branch=branch_name, data=create_payload)
         await obj.save()
         return obj
 

infrahub/graphql/manager.py

@@ -113,6 +113,16 @@ class GraphQLSchemaManager:
     def clear_cache(cls) -> None:
         cls._branch_details_by_name = {}
 
+    @classmethod
+    def purge_inactive(cls, active_branches: list[str]) -> set[str]:
+        """Return inactive branches that were purged"""
+        inactive_branches: set[str] = set()
+        for branch_name in list(cls._branch_details_by_name):
+            if branch_name not in active_branches:
+                inactive_branches.add(branch_name)
+                del cls._branch_details_by_name[branch_name]
+        return inactive_branches
+
     @classmethod
     def _cache_branch(
         cls, branch: Branch, schema_branch: SchemaBranch, schema_hash: str | None = None

infrahub/graphql/mutations/main.py

@@ -489,7 +489,8 @@ class InfrahubMutationMixin:
         we would update the node without rerunning uniqueness constraint.
         """
 
-        schema_name = cls._meta.active_schema.kind
+        schema = cls._meta.active_schema
+        schema_name = schema.kind
 
         graphql_context: GraphqlContext = info.context
         db = database or graphql_context.db
@@ -509,10 +510,8 @@ class InfrahubMutationMixin:
             )
             return updated_obj, mutation, False
 
-        if cls._meta.active_schema.default_filter is not None:
-            node = await node_getter_default_filter.get_node(
-                node_schema=cls._meta.active_schema, data=data, branch=branch
-            )
+        if not schema.human_friendly_id and schema.default_filter is not None:
+            node = await node_getter_default_filter.get_node(node_schema=schema, data=data, branch=branch)
 
         if "hfid" in data:
             node = await NodeManager.get_one_by_hfid(db=db, hfid=dict_data["hfid"], kind=schema_name, branch=branch)

infrahub/graphql/mutations/resource_manager.py

@@ -177,9 +177,9 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> Any:
         try:
-            pool_node = registry.get_node_schema(name=data["node"].value)
-        except ValueError as exc:
-            raise ValidationError(input_value="The selected model is not a Node") from exc
+            pool_node = registry.schema.get(name=data["node"].value)
+            if not pool_node.is_generic_schema and not pool_node.is_node_schema:
+                raise ValidationError(input_value="The selected model is not a Node or a Generic")
         except SchemaNotFoundError as exc:
             exc.message = "The selected model does not exist"
             raise exc

infrahub/message_bus/messages/__init__.py

@@ -1,7 +1,6 @@
 from infrahub.message_bus import InfrahubMessage, InfrahubResponse
 
 from .check_generator_run import CheckGeneratorRun
-from .event_branch_merge import EventBranchMerge
 from .finalize_validator_execution import FinalizeValidatorExecution
 from .git_file_get import GitFileGet, GitFileGetResponse
 from .git_repository_connectivity import GitRepositoryConnectivity
@@ -15,7 +14,6 @@ from .send_echo_request import SendEchoRequest, SendEchoRequestResponse
 
 MESSAGE_MAP: dict[str, type[InfrahubMessage]] = {
     "check.generator.run": CheckGeneratorRun,
-    "event.branch.merge": EventBranchMerge,
     "finalize.validator.execution": FinalizeValidatorExecution,
     "git.file.get": GitFileGet,
     "git.repository.connectivity": GitRepositoryConnectivity,

infrahub/message_bus/messages/request_proposedchange_pipeline.py

@@ -1,3 +1,5 @@
+import uuid
+
 from pydantic import Field
 
 from infrahub.context import InfrahubContext
@@ -16,3 +18,6 @@ class RequestProposedChangePipeline(InfrahubMessage):
         default=CheckType.ALL, description="Can be used to restrict the pipeline to a specific type of job"
     )
     context: InfrahubContext = Field(..., description="The context of the task")
+    pipeline_id: uuid.UUID = Field(
+        default_factory=uuid.uuid4, description="The unique ID of the execution of this pipeline"
+    )

infrahub/message_bus/operations/__init__.py

@@ -4,7 +4,6 @@ from prefect import Flow
 from infrahub.message_bus import RPCErrorResponse, messages
 from infrahub.message_bus.operations import (
     check,
-    event,
     finalize,
     git,
     refresh,
@@ -17,7 +16,6 @@ from infrahub.tasks.check import set_check_status
 
 COMMAND_MAP = {
     "check.generator.run": check.generator.run,
-    "event.branch.merge": event.branch.merge,
     "finalize.validator.execution": finalize.validator.execution,
     "git.file.get": git.file.get,
     "git.repository.connectivity": git.repository.connectivity,

infrahub/message_bus/operations/requests/proposed_change.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from enum import IntFlag
+from typing import TYPE_CHECKING
 
 from prefect import flow, task
 from prefect.logging import get_run_logger
@@ -20,6 +21,14 @@ from infrahub.message_bus.types import (
     ProposedChangeRepository,
     ProposedChangeSubscriber,
 )
+from infrahub.proposed_change.branch_diff import (
+    get_diff_summary_cache,
+    get_modified_kinds,
+    get_modified_node_ids,
+    has_data_changes,
+    has_node_changes,
+    set_diff_summary_cache,
+)
 from infrahub.proposed_change.models import (
     RequestArtifactDefinitionCheck,
     RequestProposedChangeDataIntegrity,
@@ -40,6 +49,9 @@ from infrahub.workflows.catalogue import (
 )
 from infrahub.workflows.utils import add_tags
 
+if TYPE_CHECKING:
+    from infrahub_sdk.diff import NodeDiff
+
 
 class DefinitionSelect(IntFlag):
     NONE = 0
@@ -101,8 +113,11 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
         await diff_coordinator.update_branch_diff(base_branch=destination_branch, diff_branch=source_branch)
 
     diff_summary = await service.client.get_diff_summary(branch=message.source_branch)
-    branch_diff = ProposedChangeBranchDiff(diff_summary=diff_summary, repositories=repositories)
-    await _populate_subscribers(branch_diff=branch_diff, service=service, branch=message.source_branch)
+    await set_diff_summary_cache(pipeline_id=message.pipeline_id, diff_summary=diff_summary, cache=service.cache)
+    branch_diff = ProposedChangeBranchDiff(repositories=repositories, pipeline_id=message.pipeline_id)
+    await _populate_subscribers(
+        branch_diff=branch_diff, diff_summary=diff_summary, service=service, branch=message.source_branch
+    )
 
     if message.check_type is CheckType.ARTIFACT:
         events.append(
@@ -132,8 +147,8 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             parameters={"model": model_proposed_change_run_generator},
         )
 
-    if message.check_type in [CheckType.ALL, CheckType.DATA] and branch_diff.has_node_changes(
-        branch=message.source_branch
+    if message.check_type in [CheckType.ALL, CheckType.DATA] and has_node_changes(
+        diff_summary=diff_summary, branch=message.source_branch
     ):
         model_proposed_change_data_integrity = RequestProposedChangeDataIntegrity(
             proposed_change=message.proposed_change,
@@ -162,8 +177,8 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             parameters={"model": model_proposed_change_repo_checks},
         )
 
-    if message.check_type in [CheckType.ALL, CheckType.SCHEMA] and branch_diff.has_data_changes(
-        branch=message.source_branch
+    if message.check_type in [CheckType.ALL, CheckType.SCHEMA] and has_data_changes(
+        diff_summary=diff_summary, branch=message.source_branch
     ):
         await service.workflow.submit_workflow(
             workflow=REQUEST_PROPOSED_CHANGE_SCHEMA_INTEGRITY,
@@ -215,6 +230,9 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
         definitions=definition_information[InfrahubKind.ARTIFACTDEFINITION]["edges"]
     )
 
+    diff_summary = await get_diff_summary_cache(pipeline_id=message.branch_diff.pipeline_id, cache=service.cache)
+    modified_kinds = get_modified_kinds(diff_summary=diff_summary, branch=message.source_branch)
+
     for artifact_definition in artifact_definitions:
         # Request artifact definition checks if the source branch that is managed in combination
         # to the Git repository containing modifications which could indicate changes to the transforms
@@ -229,7 +247,7 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
             condition=message.source_branch_sync_with_git and message.branch_diff.has_file_modifications,
         )
 
-        for changed_model in message.branch_diff.modified_kinds(branch=message.source_branch):
+        for changed_model in modified_kinds:
             condition = False
             if (changed_model in artifact_definition.query_models) or (
                 changed_model.startswith("Profile")
@@ -589,11 +607,13 @@ async def _gather_repository_repository_diffs(
             repo.files_changed = files_changed
 
 
-async def _populate_subscribers(branch_diff: ProposedChangeBranchDiff, service: InfrahubServices, branch: str) -> None:
+async def _populate_subscribers(
+    branch_diff: ProposedChangeBranchDiff, diff_summary: list[NodeDiff], service: InfrahubServices, branch: str
+) -> None:
     result = await service.client.execute_graphql(
         query=GATHER_GRAPHQL_QUERY_SUBSCRIBERS,
         branch_name=branch,
-        variables={"members": branch_diff.modified_nodes(branch=branch)},
+        variables={"members": get_modified_node_ids(diff_summary=diff_summary, branch=branch)},
     )
 
     for group in result[InfrahubKind.GRAPHQLQUERYGROUP]["edges"]:

infrahub/message_bus/types.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import re
+import uuid  # noqa: TC003
 from enum import Enum
 
-from infrahub_sdk.diff import NodeDiff  # noqa: TC002
 from pydantic import BaseModel, Field
 
 from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
@@ -109,9 +109,9 @@ class ProposedChangeArtifactDefinition(BaseModel):
 
 
 class ProposedChangeBranchDiff(BaseModel):
-    diff_summary: list[NodeDiff] = Field(default_factory=list, description="The DiffSummary between two branches")
     repositories: list[ProposedChangeRepository] = Field(default_factory=list)
     subscribers: list[ProposedChangeSubscriber] = Field(default_factory=list)
+    pipeline_id: uuid.UUID = Field(..., description="The unique ID of the execution of this pipeline")
 
     def get_repository(self, repository_id: str) -> ProposedChangeRepository:
         for repository in self.repositories:
@@ -122,39 +122,7 @@ class ProposedChangeBranchDiff(BaseModel):
     def get_subscribers_ids(self, kind: str) -> list[str]:
         return [subscriber.subscriber_id for subscriber in self.subscribers if subscriber.kind == kind]
 
-    def has_node_changes(self, branch: str) -> bool:
-        """Indicates if there is at least one node object that has been modified in the branch"""
-        return bool(
-            [
-                entry
-                for entry in self.diff_summary
-                if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
-            ]
-        )
-
-    def has_data_changes(self, branch: str) -> bool:
-        """Indicates if there are node or schema changes within the branch."""
-        return bool([entry for entry in self.diff_summary if entry["branch"] == branch])
-
     @property
     def has_file_modifications(self) -> bool:
         """Indicates modifications to any of the files in the Git repositories."""
         return any(repository.has_modifications for repository in self.repositories)
-
-    def modified_nodes(self, branch: str) -> list[str]:
-        """Return a list of non schema nodes that have been modified on the branch"""
-        return [
-            entry["id"]
-            for entry in self.diff_summary
-            if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
-        ]
-
-    def modified_kinds(self, branch: str) -> list[str]:
-        """Return a list of non schema kinds that have been modified on the branch"""
-        return list(
-            {
-                entry["kind"]
-                for entry in self.diff_summary
-                if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
-            }
-        )

infrahub/proposed_change/branch_diff.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import TYPE_CHECKING, cast
+
+from infrahub.exceptions import ResourceNotFoundError
+from infrahub.message_bus.types import KVTTL
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+    from infrahub_sdk.diff import NodeDiff
+
+    from infrahub.services.adapters.cache import InfrahubCache
+
+SCHEMA_CHANGE = re.compile(r"^Schema[A-Z]")
+
+
+def has_data_changes(diff_summary: list[NodeDiff], branch: str) -> bool:
+    """Indicates if there are node or schema changes within the branch."""
+    return any(entry["branch"] == branch for entry in diff_summary)
+
+
+def has_node_changes(diff_summary: list[NodeDiff], branch: str) -> bool:
+    """Indicates if there is at least one node object that has been modified in the branch"""
+    return any(entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"]) for entry in diff_summary)
+
+
+def get_modified_kinds(diff_summary: list[NodeDiff], branch: str) -> list[str]:
+    """Return a list of non schema kinds that have been modified on the branch"""
+    return list(
+        {
+            entry["kind"]
+            for entry in diff_summary
+            if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
+        }
+    )
+
+
+def get_modified_node_ids(diff_summary: list[NodeDiff], branch: str) -> list[str]:
+    """Return a list of non schema nodes that have been modified on the branch"""
+    return [
+        entry["id"] for entry in diff_summary if entry["branch"] == branch and not SCHEMA_CHANGE.match(entry["kind"])
+    ]
+
+
+async def set_diff_summary_cache(pipeline_id: UUID, diff_summary: list[NodeDiff], cache: InfrahubCache) -> None:
+    serialized = json.dumps(diff_summary)
+    await cache.set(
+        key=f"proposed_change:pipeline:pipeline_id:{pipeline_id}:diff_summary",
+        value=serialized,
+        expires=KVTTL.TWO_HOURS,
+    )
+
+
+async def get_diff_summary_cache(pipeline_id: UUID, cache: InfrahubCache) -> list[NodeDiff]:
+    summary_payload = await cache.get(
+        key=f"proposed_change:pipeline:pipeline_id:{pipeline_id}:diff_summary",
+    )
+
+    if not summary_payload:
+        raise ResourceNotFoundError(message=f"Diff summary for pipeline {pipeline_id} was not found in the cache")
+
+    return cast(list["NodeDiff"], json.loads(summary_payload))

infrahub/proposed_change/tasks.py

@@ -61,7 +61,10 @@ from infrahub.workflows.catalogue import (
 )
 from infrahub.workflows.utils import add_tags
 
+from .branch_diff import get_diff_summary_cache, get_modified_kinds
+
 if TYPE_CHECKING:
+    from infrahub_sdk.diff import NodeDiff
     from infrahub_sdk.node import InfrahubNode
 
     from infrahub.core.models import SchemaUpdateConstraintInfo
@@ -253,6 +256,9 @@ async def run_generators(
         for generator in generators
     ]
 
+    diff_summary = await get_diff_summary_cache(pipeline_id=model.branch_diff.pipeline_id, cache=service.cache)
+    modified_kinds = get_modified_kinds(diff_summary=diff_summary, branch=model.source_branch)
+
     for generator_definition in generator_definitions:
         # Request generator definitions if the source branch that is managed in combination
         # to the Git repository containing modifications which could indicate changes to the transforms
@@ -267,7 +273,7 @@ async def run_generators(
             condition=model.source_branch_sync_with_git and model.branch_diff.has_file_modifications,
         )
 
-        for changed_model in model.branch_diff.modified_kinds(branch=model.source_branch):
+        for changed_model in modified_kinds:
             select = select.add_flag(
                 current=select,
                 flag=DefinitionSelect.MODIFIED_KINDS,
@@ -338,8 +344,9 @@ async def run_proposed_change_schema_integrity_check(
     schema_diff = dest_schema.diff(other=candidate_schema)
     validation_result = dest_schema.validate_update(other=candidate_schema, diff=schema_diff)
 
+    diff_summary = await get_diff_summary_cache(pipeline_id=model.branch_diff.pipeline_id, cache=service.cache)
     constraints_from_data_diff = await _get_proposed_change_schema_integrity_constraints(
-        model=model, schema=candidate_schema
+        schema=candidate_schema, diff_summary=diff_summary
     )
     constraints_from_schema_diff = validation_result.constraints
     constraints = set(constraints_from_data_diff + constraints_from_schema_diff)
@@ -390,10 +397,11 @@ async def run_proposed_change_schema_integrity_check(
 
 
 async def _get_proposed_change_schema_integrity_constraints(
-    model: RequestProposedChangeSchemaIntegrity, schema: SchemaBranch
+    schema: SchemaBranch, diff_summary: list[NodeDiff]
 ) -> list[SchemaUpdateConstraintInfo]:
     node_diff_field_summary_map: dict[str, NodeDiffFieldSummary] = {}
-    for node_diff in model.branch_diff.diff_summary:
+
+    for node_diff in diff_summary:
         node_kind = node_diff["kind"]
         if node_kind not in node_diff_field_summary_map:
             node_diff_field_summary_map[node_kind] = NodeDiffFieldSummary(kind=node_kind)

infrahub/services/adapters/workflow/worker.py

@@ -66,7 +66,7 @@ class WorkflowWorkerExecution(InfrahubWorkflow):
         if response.state.type == StateType.CRASHED:
             raise RuntimeError(response.state.message)
 
-        return await response.state.result(raise_on_failure=True, fetch=True)  # type: ignore[call-overload]
+        return await response.state.result(raise_on_failure=True)
 
     async def submit_workflow(
         self,

infrahub/tasks/registry.py

@@ -61,5 +61,8 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
                 )
 
         purged_branches = await registry.purge_inactive_branches(db=db, active_branches=branches)
-        for branch_name in purged_branches:
+        purged_branches.update(
+            GraphQLSchemaManager.purge_inactive(active_branches=[branch.name for branch in branches])
+        )
+        for branch_name in sorted(purged_branches):
             log.info(f"Removed branch {branch_name!r} from the registry", branch=branch_name, worker=WORKER_IDENTITY)

infrahub/workflows/catalogue.py

@@ -190,6 +190,15 @@ BRANCH_MERGE = WorkflowDefinition(
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
+BRANCH_MERGE_POST_PROCESS = WorkflowDefinition(
+    name="branch-merge-post-process",
+    type=WorkflowType.CORE,
+    module="infrahub.core.branch.tasks",
+    function="post_process_branch_merge",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
+
 BRANCH_MERGE_MUTATION = WorkflowDefinition(
     name="merge-branch-mutation",
     type=WorkflowType.CORE,
@@ -431,6 +440,7 @@ workflows = [
     BRANCH_DELETE,
     BRANCH_MERGE,
     BRANCH_MERGE_MUTATION,
+    BRANCH_MERGE_POST_PROCESS,
     BRANCH_REBASE,
     BRANCH_VALIDATE,
     COMPUTED_ATTRIBUTE_PROCESS_JINJA2,