infrahub-server 1.4.12__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/proposed_change/tasks.py

@@ -8,9 +8,10 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import pytest
-from infrahub_sdk.exceptions import ModuleImportError
+from infrahub_sdk.exceptions import ModuleImportError, NodeNotFoundError, URLNotFoundError
 from infrahub_sdk.node import InfrahubNode
 from infrahub_sdk.protocols import (
+    CoreArtifactDefinition,
     CoreArtifactValidator,
     CoreGeneratorDefinition,
     CoreGeneratorValidator,
@@ -44,7 +45,7 @@ from infrahub.core.diff.model.diff import DiffElementType, SchemaConflict
 from infrahub.core.diff.model.path import NodeDiffFieldSummary
 from infrahub.core.integrity.object_conflict.conflict_recorder import ObjectConflictValidatorRecorder
 from infrahub.core.manager import NodeManager
-from infrahub.core.protocols import CoreArtifactDefinition, CoreDataCheck, CoreValidator
+from infrahub.core.protocols import CoreDataCheck, CoreValidator
 from infrahub.core.protocols import CoreProposedChange as InternalCoreProposedChange
 from infrahub.core.timestamp import Timestamp
 from infrahub.core.validators.checks_runner import run_checks_and_update_validator
@@ -59,6 +60,8 @@ from infrahub.git.base import extract_repo_file_information
 from infrahub.git.models import TriggerRepositoryInternalChecks, TriggerRepositoryUserChecks
 from infrahub.git.repository import InfrahubRepository, get_initialized_repo
 from infrahub.git.utils import fetch_artifact_definition_targets, fetch_proposed_change_generator_definition_targets
+from infrahub.graphql.analyzer import InfrahubGraphQLQueryAnalyzer
+from infrahub.graphql.initialization import prepare_graphql_params
 from infrahub.log import get_logger
 from infrahub.message_bus.types import (
     ProposedChangeArtifactDefinition,
@@ -308,6 +311,7 @@ async def run_generators(model: RequestProposedChangeRunGenerators, context: Inf
         populate_store=True,
         branch=model.source_branch,
     )
+
     generator_definitions = [
         ProposedChangeGeneratorDefinition(
             definition_id=generator.id,
@@ -320,8 +324,11 @@ async def run_generators(model: RequestProposedChangeRunGenerators, context: Inf
             parameters=generator.parameters.value,
             group_id=generator.targets.peer.id,
             convert_query_response=generator.convert_query_response.value,
+            execute_in_proposed_change=generator.execute_in_proposed_change.value,
+            execute_after_merge=generator.execute_after_merge.value,
         )
         for generator in generators
+        if generator.execute_in_proposed_change.value
     ]
 
     diff_summary = await get_diff_summary_cache(pipeline_id=model.branch_diff.pipeline_id)
@@ -525,7 +532,11 @@ async def run_proposed_change_user_tests(model: RequestProposedChangeUserTests)
     log = get_run_logger()
     client = get_client()
 
-    proposed_change = await client.get(kind=InfrahubKind.PROPOSEDCHANGE, id=model.proposed_change)
+    try:
+        proposed_change = await client.get(kind=CoreProposedChange, id=model.proposed_change)
+    except NodeNotFoundError:
+        log.warning(f"Proposed change ({model.proposed_change}) not found, skipping user tests execution")
+        return
 
     def _execute(
         directory: Path, repository: ProposedChangeRepository, proposed_change: InfrahubNode
@@ -664,6 +675,27 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
     repository = model.branch_diff.get_repository(repository_id=model.artifact_definition.repository_id)
     impacted_artifacts = model.branch_diff.get_subscribers_ids(kind=InfrahubKind.ARTIFACT)
 
+    source_schema_branch = registry.schema.get_schema_branch(name=model.source_branch)
+    source_branch = registry.get_branch_from_registry(branch=model.source_branch)
+
+    graphql_params = await prepare_graphql_params(db=await get_database(), branch=model.source_branch)
+    query_analyzer = InfrahubGraphQLQueryAnalyzer(
+        query=model.artifact_definition.query_payload,
+        branch=source_branch,
+        schema_branch=source_schema_branch,
+        schema=graphql_params.schema,
+    )
+
+    only_has_unique_targets = query_analyzer.query_report.only_has_unique_targets
+    if not only_has_unique_targets:
+        log.warning(
+            f"Artifact definition {artifact_definition.name.value} query does not guarantee unique targets. All targets will be processed."
+        )
+
+    managed_branch = model.source_branch_sync_with_git and model.branch_diff.has_file_modifications
+    if managed_branch:
+        log.info("Source branch is synced with Git repositories with updates, all artifacts will be processed")
+
     checks = []
 
     for relationship in group.members.peers:
@@ -671,8 +703,9 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
         artifact_id = artifacts_by_member.get(member.id)
         if _should_render_artifact(
             artifact_id=artifact_id,
-            managed_branch=model.source_branch_sync_with_git,
+            managed_branch=managed_branch,
             impacted_artifacts=impacted_artifacts,
+            only_has_unique_targets=only_has_unique_targets,
         ):
             log.info(f"Trigger Artifact processing for {member.display_label}")
 
@@ -718,21 +751,26 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
     )
 
 
-def _should_render_artifact(artifact_id: str | None, managed_branch: bool, impacted_artifacts: list[str]) -> bool:  # noqa: ARG001
+def _should_render_artifact(
+    artifact_id: str | None,
+    managed_branch: bool,
+    impacted_artifacts: list[str],
+    only_has_unique_targets: bool,
+) -> bool:
     """Returns a boolean to indicate if an artifact should be generated or not.
     Will return true if:
         * The artifact_id wasn't set which could be that it's a new object that doesn't have a previous artifact
-        * The source brance is not data only which would indicate that it could contain updates in git to the transform
+        * The source branch is not data only which would indicate that it could contain updates in git to the transform
         * The artifact_id exists in the impacted_artifacts list
+        * The query failes the only_has_unique_targets check
     Will return false if:
         * The source branch is a data only branch and the artifact_id exists and is not in the impacted list
     """
 
-    # if not artifact_id or managed_branch:
-    #    return True
-    # return artifact_id in impacted_artifacts
-    # Temporary workaround tracked in https://github.com/opsmill/infrahub/issues/4991
-    return True
+    if not only_has_unique_targets or not artifact_id or managed_branch:
+        return True
+
+    return artifact_id in impacted_artifacts
 
 
 @flow(
@@ -762,6 +800,8 @@ async def run_generator_as_check(model: RunGeneratorAsCheckModel, context: Infra
         query=model.generator_definition.query_name,
         targets=model.generator_definition.group_id,
         convert_query_response=model.generator_definition.convert_query_response,
+        execute_in_proposed_change=model.generator_definition.execute_in_proposed_change,
+        execute_after_merge=model.generator_definition.execute_after_merge,
     )
 
     commit_worktree = repository.get_commit_worktree(commit=model.commit)
@@ -788,6 +828,8 @@ async def run_generator_as_check(model: RunGeneratorAsCheckModel, context: Infra
             params=model.variables,
             generator_instance=generator_instance.id,
             convert_query_response=generator_definition.convert_query_response,
+            execute_after_merge=generator_definition.execute_after_merge,
+            execute_in_proposed_change=generator_definition.execute_in_proposed_change,
             infrahub_node=InfrahubNode,
         )
         generator._init_client.request_context = context.to_request_context()
@@ -931,7 +973,7 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
     requested_instances = 0
     impacted_instances = model.branch_diff.get_subscribers_ids(kind=InfrahubKind.GENERATORINSTANCE)
 
-    check_generator_run_models = []
+    check_generator_run_models: list[RunGeneratorAsCheckModel] = []
     for relationship in group.members.peers:
         member = relationship.peer
         generator_instance = instance_by_member.get(member.id)
@@ -967,6 +1009,7 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
             context=context,
         )
         for check_generator_run_model in check_generator_run_models
+        if check_generator_run_model.generator_definition.execute_in_proposed_change
     ]
 
     await run_checks_and_update_validator(
@@ -1249,6 +1292,9 @@ query GatherArtifactDefinitions {
                 name {
                   value
                 }
+                query {
+                  value
+                }
               }
             }
             ... on CoreTransformJinja2 {
@@ -1466,6 +1512,7 @@ def _parse_artifact_definitions(definitions: list[dict]) -> list[ProposedChangeA
             query_name=definition["node"]["transformation"]["node"]["query"]["node"]["name"]["value"],
             query_id=definition["node"]["transformation"]["node"]["query"]["node"]["id"],
             query_models=definition["node"]["transformation"]["node"]["query"]["node"]["models"]["value"] or [],
+            query_payload=definition["node"]["transformation"]["node"]["query"]["node"]["query"]["value"],
             repository_id=definition["node"]["transformation"]["node"]["repository"]["node"]["id"],
             transform_kind=definition["node"]["transformation"]["node"]["__typename"],
         )
@@ -1489,8 +1536,14 @@ async def _get_proposed_change_repositories(
     destination_all = await client.execute_graphql(
         query=DESTINATION_ALLREPOSITORIES, branch_name=model.destination_branch
     )
-    source_managed = await client.execute_graphql(query=SOURCE_REPOSITORIES, branch_name=model.source_branch)
-    source_readonly = await client.execute_graphql(query=SOURCE_READONLY_REPOSITORIES, branch_name=model.source_branch)
+    try:
+        source_managed = await client.execute_graphql(query=SOURCE_REPOSITORIES, branch_name=model.source_branch)
+        source_readonly = await client.execute_graphql(
+            query=SOURCE_READONLY_REPOSITORIES, branch_name=model.source_branch
+        )
+    except URLNotFoundError:
+        # If the URL is not found it means that the source branch has been deleted after the proposed change was created
+        return []
 
     destination_all = destination_all[InfrahubKind.GENERICREPOSITORY]["edges"]
     source_all = (

infrahub/repositories/create_repository.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from infrahub.core.constants import RepositoryInternalStatus
+from infrahub.core.constants.infrahubkind import READONLYREPOSITORY, REPOSITORY
+from infrahub.core.protocols import CoreGenericRepository, CoreReadOnlyRepository, CoreRepository
+from infrahub.exceptions import ValidationError
+from infrahub.git.models import GitRepositoryAdd, GitRepositoryAddReadOnly
+from infrahub.log import get_logger
+from infrahub.message_bus import messages
+from infrahub.message_bus.messages.git_repository_connectivity import GitRepositoryConnectivityResponse
+from infrahub.workflows.catalogue import GIT_REPOSITORY_ADD, GIT_REPOSITORY_ADD_READ_ONLY
+
+if TYPE_CHECKING:
+    from infrahub.auth import AccountSession
+    from infrahub.context import InfrahubContext
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+    from infrahub.services import InfrahubServices
+
+log = get_logger()
+
+
+class RepositoryFinalizer:
+    def __init__(
+        self,
+        account_session: AccountSession,
+        services: InfrahubServices,
+        context: InfrahubContext,
+    ) -> None:
+        self.account_session = account_session
+        self.services = services
+        self.context = context
+
+    async def post_create(
+        self,
+        obj: CoreGenericRepository,
+        branch: Branch,
+        db: InfrahubDatabase,
+        delete_on_connectivity_failure: bool = True,
+    ) -> None:
+        """
+        Method meant to be called after a repository has been created in the database.
+        It mainly checks the connectivity to the remote repository and submit the workflow to create the repository in the local filesystem.
+        """
+
+        # If the connectivity is not good, we remove the repository to allow the user to add a new one
+        if delete_on_connectivity_failure:
+            message = messages.GitRepositoryConnectivity(
+                repository_name=obj.name.value,
+                repository_location=obj.location.value,
+            )
+            response = await self.services.message_bus.rpc(
+                message=message, response_class=GitRepositoryConnectivityResponse
+            )
+
+            if response.data.success is False:
+                await obj.delete(db=db)
+                raise ValidationError(response.data.message)
+
+        # If we are in the default branch, we set the sync status to Active
+        # If we are in another branch, we set the sync status to Staging
+        if branch.is_default:
+            obj.internal_status.value = RepositoryInternalStatus.ACTIVE.value
+        else:
+            obj.internal_status.value = RepositoryInternalStatus.STAGING.value
+        await obj.save(db=db)
+
+        # Create the new repository in the filesystem.
+        log.info("create_repository", name=obj.name.value)
+        authenticated_user = None
+        if self.account_session and self.account_session.authenticated:
+            authenticated_user = self.account_session.account_id
+
+        if obj.get_kind() == READONLYREPOSITORY:
+            obj = cast(CoreReadOnlyRepository, obj)
+            model = GitRepositoryAddReadOnly(
+                repository_id=obj.id,
+                repository_name=obj.name.value,
+                location=obj.location.value,
+                ref=obj.ref.value,
+                infrahub_branch_name=branch.name,
+                infrahub_branch_id=str(branch.get_uuid()),
+                internal_status=obj.internal_status.value,
+                created_by=authenticated_user,
+            )
+            await self.services.workflow.submit_workflow(
+                workflow=GIT_REPOSITORY_ADD_READ_ONLY,
+                context=self.context,
+                parameters={"model": model},
+            )
+
+        elif obj.get_kind() == REPOSITORY:
+            obj = cast(CoreRepository, obj)
+            git_repo_add_model = GitRepositoryAdd(
+                repository_id=obj.id,
+                repository_name=obj.name.value,
+                location=obj.location.value,
+                default_branch_name=obj.default_branch.value,
+                infrahub_branch_name=branch.name,
+                infrahub_branch_id=str(branch.get_uuid()),
+                internal_status=obj.internal_status.value,
+                created_by=authenticated_user,
+            )
+
+            await self.services.workflow.submit_workflow(
+                workflow=GIT_REPOSITORY_ADD,
+                context=self.context,
+                parameters={"model": git_repo_add_model},
+            )
+        else:
+            raise ValueError(f"Unknown repository kind: {obj.get_kind()}")

infrahub/server.py

@@ -24,6 +24,7 @@ from infrahub.api.exception_handlers import generic_api_exception_handler
 from infrahub.components import ComponentType
 from infrahub.constants.environment import INSTALLATION_TYPE
 from infrahub.core.initialization import initialization
+from infrahub.database.graph import validate_graph_version
 from infrahub.dependencies.registry import build_component_registry
 from infrahub.exceptions import Error, ValidationError
 from infrahub.graphql.api.endpoints import router as graphql_router
@@ -83,10 +84,17 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
     initialize_lock(service=service)
     # We must initialize DB after initialize lock and initialize lock depends on cache initialization
     async with application.state.db.start_session() as db:
-        await initialization(db=db, add_database_indexes=True)
+        is_initial_setup = await initialization(db=db, add_database_indexes=True)
+
+    async with database.start_session() as dbs:
+        await validate_graph_version(db=dbs)
+
+    # Initialize the workflow after the registry has been setup
+    await service.initialize_workflow(is_initial_setup=is_initial_setup)
 
     application.state.service = service
     application.state.response_delay = config.SETTINGS.miscellaneous.response_delay
+
     if enable_scheduler:
         await service.scheduler.start_schedule()
 

infrahub/services/__init__.py

@@ -110,14 +110,17 @@ class InfrahubServices:
         # This circular dependency could be removed if InfrahubScheduler only depends on what it needs.
         scheduler.service = service
 
-        if workflow is not None and isinstance(workflow, WorkflowWorkerExecution):
-            assert service.component is not None
+        return service
+
+    async def initialize_workflow(self, is_initial_setup: bool = False) -> None:
+        if self.workflow is not None and isinstance(self.workflow, WorkflowWorkerExecution):
+            assert self.component is not None
             # Ideally `WorkflowWorkerExecution.initialize` would be directly part of WorkflowWorkerExecution
             # constructor but this requires some redesign as it depends on InfrahubComponent which is instantiated
             # after workflow instantiation.
-            await workflow.initialize(component_is_primary_server=await service.component.is_primary_gunicorn_worker())
-
-        return service
+            await self.component.refresh_heartbeat()
+            is_primary = await self.component.is_primary_gunicorn_worker()
+            await self.workflow.initialize(component_is_primary_server=is_primary, is_initial_setup=is_initial_setup)
 
     @property
     def component(self) -> InfrahubComponent:

infrahub/services/adapters/http/__init__.py

@@ -3,10 +3,15 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
+    import ssl
+
     import httpx
 
 
 class InfrahubHTTP:
+    def verify_tls(self, verify: bool | None = None) -> bool | ssl.SSLContext:
+        raise NotImplementedError()
+
     async def get(
         self,
         url: str,

infrahub/services/adapters/workflow/worker.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, overload
 
 from prefect.client.schemas.objects import StateType
+from prefect.context import AsyncClientContext
 from prefect.deployments import run_deployment
 
+from infrahub.services.adapters.http.httpx import HttpxAdapter
 from infrahub.workers.utils import inject_context_parameter
-from infrahub.workflows.initialization import setup_task_manager
+from infrahub.workflows.initialization import setup_task_manager, setup_task_manager_identifiers
 from infrahub.workflows.models import WorkflowInfo
 
 from . import InfrahubWorkflow, Return
@@ -19,11 +21,19 @@ if TYPE_CHECKING:
 
 
 class WorkflowWorkerExecution(InfrahubWorkflow):
+    # This is required to grab a cached SSLContext from the HttpAdapter.
+    # We cannot use the get_http() dependency since it introduces a circular dependency.
+    # We could remove this later on by introducing a cached SSLContext outside of this adapter.
+    _http_adapter = HttpxAdapter()
+
     @staticmethod
-    async def initialize(component_is_primary_server: bool) -> None:
+    async def initialize(component_is_primary_server: bool, is_initial_setup: bool = False) -> None:
         if component_is_primary_server:
             await setup_task_manager()
 
+        if is_initial_setup:
+            await setup_task_manager_identifiers()
+
     @overload
     async def execute_workflow(
         self,
@@ -79,5 +89,6 @@ class WorkflowWorkerExecution(InfrahubWorkflow):
         parameters = dict(parameters) if parameters is not None else {}
         inject_context_parameter(func=flow_func, parameters=parameters, context=context)
 
-        flow_run = await run_deployment(name=workflow.full_name, timeout=0, parameters=parameters or {}, tags=tags)  # type: ignore[return-value, misc]
+        async with AsyncClientContext(httpx_settings={"verify": self._http_adapter.verify_tls()}):
+            flow_run = await run_deployment(name=workflow.full_name, timeout=0, parameters=parameters or {}, tags=tags)  # type: ignore[return-value, misc]
         return WorkflowInfo.from_flow(flow_run=flow_run)

infrahub/task_manager/event.py

@@ -160,6 +160,9 @@ class PrefectEventData(PrefectEventModel):
     def _return_branch_rebased(self) -> dict[str, Any]:
         return {"rebased_branch": self._get_branch_name_from_resource()}
 
+    def _return_branch_migrated(self) -> dict[str, Any]:
+        return {"migrated_branch": self._get_branch_name_from_resource()}
+
     def _return_group_event(self) -> dict[str, Any]:
         members = []
         ancestors = []
@@ -228,6 +231,8 @@ class PrefectEventData(PrefectEventModel):
                 event_specifics = self._return_branch_deleted()
             case "infrahub.branch.merged":
                 event_specifics = self._return_branch_merged()
+            case "infrahub.branch.migrated":
+                event_specifics = self._return_branch_migrated()
             case "infrahub.branch.rebased":
                 event_specifics = self._return_branch_rebased()
             case "infrahub.group.member_added" | "infrahub.group.member_removed":

infrahub/task_manager/models.py

@@ -141,6 +141,13 @@ class InfrahubEventFilter(EventFilter):
             if branches:
                 self.resource = EventResourceFilter(labels=ResourceSpecification({"infrahub.branch.name": branches}))
 
+        if branch_migrated := event_type_filter.get("branch_migrated"):
+            branches = branch_migrated.get("branches") or []
+            if "infrahub.branch.created" not in event_type:
+                event_type.append("infrahub.branch.migrated")
+            if branches:
+                self.resource = EventResourceFilter(labels=ResourceSpecification({"infrahub.branch.name": branches}))
+
         if branch_rebased := event_type_filter.get("branch_rebased"):
             branches = branch_rebased.get("branches") or []
             if "infrahub.branch.created" not in event_type:

infrahub/task_manager/task.py

@@ -1,7 +1,10 @@
+import asyncio
 import uuid
+from datetime import datetime, timedelta, timezone
 from typing import Any
 from uuid import UUID
 
+from prefect import State
 from prefect.client.orchestration import PrefectClient, get_client
 from prefect.client.schemas.filters import (
     ArtifactFilter,
@@ -12,6 +15,7 @@ from prefect.client.schemas.filters import (
     FlowRunFilter,
     FlowRunFilterId,
     FlowRunFilterName,
+    FlowRunFilterStartTime,
     FlowRunFilterState,
     FlowRunFilterStateType,
     FlowRunFilterTags,
@@ -311,3 +315,72 @@ class PrefectTask:
                     )
 
         return {"count": count or 0, "edges": nodes}
+
+    @classmethod
+    async def delete_flow_runs(
+        cls,
+        states: list[StateType] = [StateType.COMPLETED, StateType.FAILED, StateType.CANCELLED],  # noqa: B006
+        delete: bool = True,
+        days_to_keep: int = 2,
+        batch_size: int = 100,
+    ) -> None:
+        """Delete flow runs in the specified states and older than specified days."""
+
+        logger = get_logger()
+
+        async with get_client(sync_client=False) as client:
+            cutoff = datetime.now(timezone.utc) - timedelta(days=days_to_keep)
+
+            flow_run_filter = FlowRunFilter(
+                start_time=FlowRunFilterStartTime(before_=cutoff),  # type: ignore[arg-type]
+                state=FlowRunFilterState(type=FlowRunFilterStateType(any_=states)),
+            )
+
+            # Get flow runs to delete
+            flow_runs = await client.read_flow_runs(flow_run_filter=flow_run_filter, limit=batch_size)
+
+            deleted_total = 0
+
+            while True:
+                batch_deleted = 0
+                failed_deletes = []
+
+                # Delete each flow run through the API
+                for flow_run in flow_runs:
+                    try:
+                        if delete:
+                            await client.delete_flow_run(flow_run_id=flow_run.id)
+                        else:
+                            await client.set_flow_run_state(
+                                flow_run_id=flow_run.id,
+                                state=State(type=StateType.CRASHED),
+                                force=True,
+                            )
+                        deleted_total += 1
+                        batch_deleted += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to delete flow run {flow_run.id}: {e}")
+                        failed_deletes.append(flow_run.id)
+
+                    # Rate limiting
+                    if batch_deleted % 10 == 0:
+                        await asyncio.sleep(0.5)
+
+                logger.info(f"Delete {batch_deleted}/{len(flow_runs)} flow runs (total: {deleted_total})")
+
+                # Get next batch
+                previous_flow_run_ids = [fr.id for fr in flow_runs]
+                flow_runs = await client.read_flow_runs(flow_run_filter=flow_run_filter, limit=batch_size)
+
+                if not flow_runs:
+                    logger.info("No more flow runs to delete")
+                    break
+
+                if previous_flow_run_ids == [fr.id for fr in flow_runs]:
+                    logger.info("Found same flow runs to delete, aborting")
+                    break
+
+                # Delay between batches to avoid overwhelming the API
+                await asyncio.sleep(1.0)
+
+            logger.info(f"Retention complete. Total deleted tasks: {deleted_total}")

infrahub/tasks/registry.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING
 from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
+from infrahub.graphql.registry import registry as graphql_registry
 from infrahub.log import get_logger
 from infrahub.worker import WORKER_IDENTITY
 
@@ -20,9 +21,8 @@ def update_graphql_schema(branch: Branch, schema_branch: SchemaBranch) -> None:
     """
     Update the GraphQL schema for the given branch.
     """
-    from infrahub.graphql.manager import GraphQLSchemaManager
 
-    gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
+    gqlm = graphql_registry.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
     gqlm.get_graphql_schema(
         include_query=True,
         include_mutation=True,
@@ -67,6 +67,9 @@ async def update_branch_registry(db: InfrahubDatabase, branch: Branch) -> None:
                 worker=WORKER_IDENTITY,
             )
             registry.branch[branch.name] = branch
+        elif existing_branch.status != branch.status:
+            log.info(f"Updating registry branch cache for {branch.name=}")
+            registry.branch[branch.name] = branch
         return
 
     log.info(
@@ -89,7 +92,6 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
     If a branch is already present with a different value for the hash
     We pull the new schema from the database and we update the registry.
     """
-    from infrahub.graphql.manager import GraphQLSchemaManager
 
     async with lock.registry.local_schema_lock():
         active_branches = await registry.branch_object.get_list(db=db)
@@ -106,7 +108,7 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
 
         purged_branches = await registry.purge_inactive_branches(db=db, active_branches=active_branches)
         purged_branches.update(
-            GraphQLSchemaManager.purge_inactive(active_branches=[branch.name for branch in active_branches])
+            graphql_registry.purge_inactive(active_branches=[branch.name for branch in active_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/trigger/catalogue.py

@@ -4,6 +4,8 @@ from infrahub.computed_attribute.triggers import (
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
 )
+from infrahub.display_labels.triggers import TRIGGER_DISPLAY_LABELS_ALL_SCHEMA
+from infrahub.hfid.triggers import TRIGGER_HFID_ALL_SCHEMA
 from infrahub.schema.triggers import TRIGGER_SCHEMA_UPDATED
 from infrahub.trigger.models import TriggerDefinition
 from infrahub.webhook.triggers import TRIGGER_WEBHOOK_DELETE, TRIGGER_WEBHOOK_SETUP_UPDATE
@@ -13,6 +15,8 @@ builtin_triggers: list[TriggerDefinition] = [
     TRIGGER_BRANCH_MERGED,
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+    TRIGGER_DISPLAY_LABELS_ALL_SCHEMA,
+    TRIGGER_HFID_ALL_SCHEMA,
     TRIGGER_SCHEMA_UPDATED,
     TRIGGER_WEBHOOK_DELETE,
     TRIGGER_WEBHOOK_SETUP_UPDATE,

infrahub/trigger/models.py

@@ -37,6 +37,8 @@ class TriggerType(str, Enum):
     COMPUTED_ATTR_JINJA2 = "computed_attr_jinja2"
     COMPUTED_ATTR_PYTHON = "computed_attr_python"
     COMPUTED_ATTR_PYTHON_QUERY = "computed_attr_python_query"
+    DISPLAY_LABEL_JINJA2 = "display_label_jinja2"
+    HUMAN_FRIENDLY_ID = "human_friendly_id"
     # OBJECT = "object"