infrahub-server 1.5.0b0__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

infrahub/hfid/tasks.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from typing import cast
+
+from infrahub_sdk.exceptions import URLNotFoundError
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.registry import registry
+from infrahub.events import BranchDeletedEvent
+from infrahub.trigger.models import TriggerSetupReport, TriggerType
+from infrahub.trigger.setup import setup_triggers_specific
+from infrahub.workers.dependencies import get_client, get_component, get_database, get_workflow
+from infrahub.workflows.catalogue import HFID_PROCESS, TRIGGER_UPDATE_HFID
+from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
+
+from .gather import gather_trigger_hfid
+from .models import HFIDGraphQL, HFIDGraphQLResponse, HFIDTriggerDefinition
+
+UPDATE_HFID = """
+mutation UpdateHFID(
+    $id: String!,
+    $kind: String!,
+    $value: [String!]!
+  ) {
+  InfrahubUpdateHFID(
+    data: {id: $id, value: $value, kind: $kind}
+  ) {
+    ok
+  }
+}
+"""
+
+
+@flow(
+    name="hfid-update-value",
+    flow_run_name="Update value for hfid on {node_kind}",
+)
+async def hfid_update_value(
+    branch_name: str,
+    obj: HFIDGraphQLResponse,
+    node_kind: str,
+    hfid_definition: list[str],
+) -> None:
+    log = get_run_logger()
+    client = get_client()
+
+    await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
+
+    rendered_hfid: list[str] = []
+    for hfid_component in hfid_definition:
+        if hfid_component in obj.variables:
+            rendered_hfid.append(obj.variables[hfid_component])
+    # value = await template.render(variables=obj.variables)
+    if rendered_hfid == obj.hfid_value:
+        log.debug(f"Ignoring to update {obj} with existing value on human_friendly_id={obj.hfid_value}")
+        return
+
+    try:
+        await client.execute_graphql(
+            query=UPDATE_HFID,
+            variables={"id": obj.node_id, "kind": node_kind, "value": rendered_hfid},
+            branch_name=branch_name,
+        )
+        log.info(f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id})")
+    except URLNotFoundError:
+        log.warning(
+            f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id}) failed for branch {branch_name} (branch not found)"
+        )
+
+
+@flow(
+    name="hfid-process",
+    flow_run_name="Process human friendly ids for {target_kind}",
+)
+async def process_hfid(
+    branch_name: str,
+    node_kind: str,
+    object_id: str,
+    target_kind: str,
+    context: InfrahubContext,  # noqa: ARG001
+) -> None:
+    log = get_run_logger()
+    client = get_client()
+
+    await add_tags(branches=[branch_name])
+
+    target_schema = branch_name if branch_name in registry.get_altered_schema_branches() else registry.default_branch
+    schema_branch = registry.schema.get_schema_branch(name=target_schema)
+    node_schema = schema_branch.get_node(name=target_kind, duplicate=False)
+
+    if node_kind == target_kind:
+        hfid_definition = schema_branch.hfids.get_node_definition(kind=node_kind)
+    else:
+        hfid_definition = schema_branch.hfids.get_related_definition(related_kind=node_kind, target_kind=target_kind)
+
+    # jinja_template = Jinja2Template(template=display_label_template.template)
+    # variables = jinja_template.get_variables()
+    hfid_graphql = HFIDGraphQL(
+        node_schema=node_schema, variables=hfid_definition.hfid, filter_key=hfid_definition.filter_key
+    )
+
+    query = hfid_graphql.render_graphql_query(filter_id=object_id)
+    response = await client.execute_graphql(query=query, branch_name=branch_name)
+    update_candidates = hfid_graphql.parse_response(response=response)
+
+    if not update_candidates:
+        log.debug("No nodes found that requires updates")
+        return
+
+    batch = await client.create_batch()
+    for node in update_candidates:
+        batch.add(
+            task=hfid_update_value,
+            branch_name=branch_name,
+            obj=node,
+            node_kind=node_schema.kind,
+            hfid_definition=hfid_definition.hfid,
+        )
+
+    _ = [response async for _, response in batch.execute()]
+
+
+@flow(name="hfid-setup", flow_run_name="Setup human friendly ids in task-manager")
+async def hfid_setup(context: InfrahubContext, branch_name: str | None = None, event_name: str | None = None) -> None:
+    database = await get_database()
+    async with database.start_session() as db:
+        log = get_run_logger()
+
+        if branch_name:
+            await add_tags(branches=[branch_name])
+            component = await get_component()
+            await wait_for_schema_to_converge(branch_name=branch_name, component=component, db=db, log=log)
+
+        report: TriggerSetupReport = await setup_triggers_specific(
+            gatherer=gather_trigger_hfid, trigger_type=TriggerType.HUMAN_FRIENDLY_ID
+        )  # type: ignore[misc]
+
+        # Configure all DisplayLabelTriggerDefinitions in Prefect
+        hfid_reports = [cast(HFIDTriggerDefinition, entry) for entry in report.updated + report.created]
+        direct_target_triggers = [hfid_report for hfid_report in hfid_reports if hfid_report.target_kind]
+
+        for display_report in direct_target_triggers:
+            if event_name != BranchDeletedEvent.event_name and display_report.branch == branch_name:
+                await get_workflow().submit_workflow(
+                    workflow=TRIGGER_UPDATE_HFID,
+                    context=context,
+                    parameters={
+                        "branch_name": display_report.branch,
+                        "kind": display_report.target_kind,
+                    },
+                )
+
+        log.info(f"{report.in_use_count} HFID automation configurations completed")
+
+
+@flow(
+    name="trigger-update-hfid",
+    flow_run_name="Trigger updates for HFID for {kind}",
+)
+async def trigger_update_hfid(
+    branch_name: str,
+    kind: str,
+    context: InfrahubContext,
+) -> None:
+    await add_tags(branches=[branch_name])
+
+    client = get_client()
+
+    # NOTE we only need the id of the nodes, this query will still query for the HFID
+    node_schema = registry.schema.get_node_schema(name=kind, branch=branch_name)
+    nodes = await client.all(
+        kind=kind,
+        branch=branch_name,
+        exclude=node_schema.attribute_names + node_schema.relationship_names,
+        populate_store=False,
+    )
+
+    for node in nodes:
+        await get_workflow().submit_workflow(
+            workflow=HFID_PROCESS,
+            context=context,
+            parameters={
+                "branch_name": branch_name,
+                "node_kind": kind,
+                "target_kind": kind,
+                "object_id": node.id,
+                "context": context,
+            },
+        )

infrahub/hfid/triggers.py

@@ -0,0 +1,22 @@
+from infrahub.events.branch_action import BranchDeletedEvent
+from infrahub.events.schema_action import SchemaUpdatedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import HFID_SETUP
+
+TRIGGER_HFID_ALL_SCHEMA = BuiltinTriggerDefinition(
+    name="hfid-setup-all",
+    trigger=EventTrigger(events={SchemaUpdatedEvent.event_name, BranchDeletedEvent.event_name}),
+    actions=[
+        ExecuteWorkflow(
+            workflow=HFID_SETUP,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "event_name": "{{ event.event }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

infrahub/lock.py

@@ -5,6 +5,7 @@ import time
 import uuid
 from asyncio import Lock as LocalLock
 from asyncio import sleep
+from contextvars import ContextVar
 from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
@@ -50,9 +51,12 @@ GLOBAL_GRAPH_LOCK = "global.graph"
 class InfrahubMultiLock:
     """Context manager to allow multiple locks to be reserved together"""
 
-    def __init__(self, lock_registry: InfrahubLockRegistry, locks: list[str] | None = None) -> None:
+    def __init__(
+        self, lock_registry: InfrahubLockRegistry, locks: list[str] | None = None, metrics: bool = True
+    ) -> None:
         self.registry = lock_registry
         self.locks = locks or []
+        self.metrics = metrics
 
     async def __aenter__(self):
         await self.acquire()
@@ -67,11 +71,11 @@ class InfrahubMultiLock:
 
     async def acquire(self) -> None:
         for lock in self.locks:
-            await self.registry.get(name=lock).acquire()
+            await self.registry.get(name=lock, metrics=self.metrics).acquire()
 
     async def release(self) -> None:
         for lock in reversed(self.locks):
-            await self.registry.get(name=lock).release()
+            await self.registry.get(name=lock, metrics=self.metrics).release()
 
 
 class NATSLock:
@@ -98,10 +102,10 @@ class NATSLock:
         while True:
             if await self.do_acquire(token):
                 self.token = token
-                return True
+                return
             await sleep(0.1)  # default Redis GlobalLock value
 
-    async def do_acquire(self, token: str) -> bool:
+    async def do_acquire(self, token: str) -> bool | None:
         return await self.service.cache.set(key=self.name, value=token, not_exists=True)
 
     async def release(self) -> None:
@@ -123,16 +127,19 @@ class InfrahubLock:
         connection: redis.Redis | InfrahubServices | None = None,
         local: bool | None = None,
         in_multi: bool = False,
+        metrics: bool = True,
     ) -> None:
-        self.use_local: bool = local
+        self.use_local: bool | None = local
         self.local: LocalLock = None
         self.remote: GlobalLock = None
         self.name: str = name
         self.connection: redis.Redis | None = connection
         self.in_multi: bool = in_multi
         self.lock_type: str = "multi" if self.in_multi else "individual"
-        self.acquire_time: int | None = None
+        self._acquire_time: int | None = None
         self.event = asyncio.Event()
+        self._recursion_var: ContextVar[int | None] = ContextVar(f"infrahub_lock_recursion_{self.name}", default=None)
+        self.metrics = metrics
 
         if not self.connection or (self.use_local is None and name.startswith("local.")):
             self.use_local = True
@@ -144,6 +151,17 @@ class InfrahubLock:
         else:
             self.remote = NATSLock(service=self.connection, name=f"{LOCK_PREFIX}.{self.name}")
 
+    @property
+    def acquire_time(self) -> int:
+        if self._acquire_time is not None:
+            return self._acquire_time
+
+        raise ValueError("The lock has not been initialized")
+
+    @acquire_time.setter
+    def acquire_time(self, value: int) -> None:
+        self._acquire_time = value
+
     async def __aenter__(self):
         await self.acquire()
 
@@ -156,21 +174,47 @@ class InfrahubLock:
         await self.release()
 
     async def acquire(self) -> None:
-        with LOCK_ACQUIRE_TIME_METRICS.labels(self.name, self.lock_type).time():
-            if not self.use_local:
-                await self.remote.acquire(token=f"{current_timestamp()}::{WORKER_IDENTITY}")
-            else:
-                await self.local.acquire()
+        depth = self._recursion_var.get()
+        if depth is not None:
+            self._recursion_var.set(depth + 1)
+            return
+
+        if self.metrics:
+            with LOCK_ACQUIRE_TIME_METRICS.labels(self.name, self.lock_type).time():
+                if not self.use_local:
+                    await self.remote.acquire(token=f"{current_timestamp()}::{WORKER_IDENTITY}")
+                else:
+                    await self.local.acquire()
+        elif not self.use_local:
+            await self.remote.acquire(token=f"{current_timestamp()}::{WORKER_IDENTITY}")
+        else:
+            await self.local.acquire()
+
         self.acquire_time = time.time_ns()
         self.event.clear()
+        self._recursion_var.set(1)
 
     async def release(self) -> None:
-        duration_ns = time.time_ns() - self.acquire_time
-        LOCK_RESERVE_TIME_METRICS.labels(self.name, self.lock_type).observe(duration_ns / 1000000000)
+        depth = self._recursion_var.get()
+        if depth is None:
+            raise RuntimeError("Lock release attempted without ownership context.")
+
+        if depth > 1:
+            self._recursion_var.set(depth - 1)
+            return
+
+        if self.acquire_time is not None:
+            duration_ns = time.time_ns() - self.acquire_time
+            if self.metrics:
+                LOCK_RESERVE_TIME_METRICS.labels(self.name, self.lock_type).observe(duration_ns / 1000000000)
+            self.acquire_time = None
+
         if not self.use_local:
             await self.remote.release()
         else:
             self.local.release()
+
+        self._recursion_var.set(None)
         self.event.set()
 
     async def locked(self) -> bool:
@@ -261,11 +305,18 @@ class InfrahubLockRegistry:
         return self.locks[lock_name]
 
     def get(
-        self, name: str, namespace: str | None = None, local: bool | None = None, in_multi: bool = False
+        self,
+        name: str,
+        namespace: str | None = None,
+        local: bool | None = None,
+        in_multi: bool = False,
+        metrics: bool = True,
     ) -> InfrahubLock:
         lock_name = self.name_generator.generate_name(name=name, namespace=namespace, local=local)
         if lock_name not in self.locks:
-            self.locks[lock_name] = InfrahubLock(name=lock_name, connection=self.connection, in_multi=in_multi)
+            self.locks[lock_name] = InfrahubLock(
+                name=lock_name, connection=self.connection, in_multi=in_multi, metrics=metrics
+            )
         return self.locks[lock_name]
 
     def local_schema_lock(self) -> LocalLock:

infrahub/message_bus/types.py

@@ -89,7 +89,8 @@ class ProposedChangeArtifactDefinition(BaseModel):
     definition_id: str
     definition_name: str
     artifact_name: str
-    query_name: str
+    query_name: str  # Deprecated
+    query_id: str
     query_models: list[str]
     repository_id: str
     transform_kind: str

infrahub/middleware.py

@@ -1,7 +1,8 @@
 from typing import Any
 
+from fastapi.middleware.gzip import GZipMiddleware
 from starlette.middleware.cors import CORSMiddleware
-from starlette.types import ASGIApp
+from starlette.types import ASGIApp, Receive, Scope, Send
 
 from infrahub import config
 
@@ -15,3 +16,27 @@ class InfrahubCORSMiddleware(CORSMiddleware):
         kwargs["allow_headers"] = config.SETTINGS.api.cors_allow_headers
 
         super().__init__(app, *args, **kwargs)
+
+
+class ConditionalGZipMiddleware(GZipMiddleware):
+    def __init__(
+        self,
+        app: ASGIApp,
+        *,
+        minimum_size: int = 500,
+        compresslevel: int = 9,
+        include_paths: tuple[str, ...] = (),
+    ) -> None:
+        super().__init__(app, minimum_size=minimum_size, compresslevel=compresslevel)
+        self.include_paths = include_paths
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:  # type: ignore[override]
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        path = scope.get("path", "")
+        if any(path.startswith(include) for include in self.include_paths):
+            await super().__call__(scope, receive, send)
+        else:
+            await self.app(scope, receive, send)

infrahub/permissions/constants.py

@@ -30,6 +30,7 @@ GLOBAL_PERMISSION_DENIAL_MESSAGE = {
     GlobalPermissions.MANAGE_ACCOUNTS.value: "You are not allowed to manage user accounts, groups or roles",
     GlobalPermissions.MANAGE_PERMISSIONS.value: "You are not allowed to manage permissions",
     GlobalPermissions.MANAGE_REPOSITORIES.value: "You are not allowed to manage repositories",
+    GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL.value: "You are not allowed to update human friendly IDs and display labels ad hoc",
 }
 
 GLOBAL_PERMISSION_DESCRIPTION = {
@@ -42,4 +43,5 @@ GLOBAL_PERMISSION_DESCRIPTION = {
     GlobalPermissions.MANAGE_PERMISSIONS: "Allow a user to manage permissions",
     GlobalPermissions.MANAGE_REPOSITORIES: "Allow a user to manage repositories",
     GlobalPermissions.SUPER_ADMIN: "Allow a user to do anything",
+    GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL: "Allow a user to update objects' display labels and human friendly IDs ad hoc",
 }

infrahub/proposed_change/tasks.py

@@ -8,7 +8,7 @@ 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 (
     CoreArtifactValidator,
@@ -44,7 +44,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 CoreDataCheck, CoreValidator
+from infrahub.core.protocols import CoreArtifactDefinition, 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
@@ -58,6 +58,7 @@ from infrahub.generators.models import ProposedChangeGeneratorDefinition
 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.log import get_logger
 from infrahub.message_bus.types import (
     ProposedChangeArtifactDefinition,
@@ -307,6 +308,7 @@ async def run_generators(model: RequestProposedChangeRunGenerators, context: Inf
         populate_store=True,
         branch=model.source_branch,
     )
+
     generator_definitions = [
         ProposedChangeGeneratorDefinition(
             definition_id=generator.id,
@@ -319,8 +321,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)
@@ -524,7 +529,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
@@ -612,7 +621,7 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
     client = get_client()
 
     artifact_definition = await client.get(
-        kind=InfrahubKind.ARTIFACTDEFINITION,
+        kind=CoreArtifactDefinition,
         id=model.artifact_definition.definition_id,
         branch=model.source_branch,
     )
@@ -652,9 +661,9 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
         branch=model.source_branch,
     )
 
-    await artifact_definition.targets.fetch()
-    group = artifact_definition.targets.peer
-    await group.members.fetch()
+    group = await fetch_artifact_definition_targets(
+        client=client, branch=model.source_branch, definition=artifact_definition
+    )
 
     artifacts_by_member = {}
     for artifact in existing_artifacts:
@@ -691,6 +700,7 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
                 repository_kind=repository.kind,
                 branch_name=model.source_branch,
                 query=model.artifact_definition.query_name,
+                query_id=model.artifact_definition.query_id,
                 variables=await member.extract(params=artifact_definition.parameters.value),
                 target_id=member.id,
                 target_kind=member.get_kind(),
@@ -760,6 +770,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)
@@ -786,6 +798,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()
@@ -917,14 +931,9 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
         branch=model.source_branch,
     )
 
-    group = await client.get(
-        kind=InfrahubKind.GENERICGROUP,
-        prefetch_relationships=True,
-        populate_store=True,
-        id=model.generator_definition.group_id,
-        branch=model.source_branch,
+    group = await fetch_proposed_change_generator_definition_targets(
+        client=client, branch=model.source_branch, definition=model.generator_definition
     )
-    await group.members.fetch()
 
     instance_by_member = {}
     for instance in existing_instances:
@@ -934,7 +943,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)
@@ -970,6 +979,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(
@@ -1245,6 +1255,7 @@ query GatherArtifactDefinitions {
             }
             query {
               node {
+                id
                 models {
                   value
                 }
@@ -1466,6 +1477,7 @@ def _parse_artifact_definitions(definitions: list[dict]) -> list[ProposedChangeA
             content_type=definition["node"]["content_type"]["value"],
             timeout=definition["node"]["transformation"]["node"]["timeout"]["value"],
             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 [],
             repository_id=definition["node"]["transformation"]["node"]["repository"]["node"]["id"],
             transform_kind=definition["node"]["transformation"]["node"]["__typename"],
@@ -1490,8 +1502,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/server.py

@@ -10,7 +10,6 @@ from asgi_correlation_id import CorrelationIdMiddleware
 from asgi_correlation_id.context import correlation_id
 from fastapi import FastAPI, Request, Response
 from fastapi.logger import logger
-from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
@@ -25,12 +24,13 @@ 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
 from infrahub.lock import initialize_lock
 from infrahub.log import clear_log_context, get_logger, set_log_data
-from infrahub.middleware import InfrahubCORSMiddleware
+from infrahub.middleware import ConditionalGZipMiddleware, InfrahubCORSMiddleware
 from infrahub.services import InfrahubServices
 from infrahub.trace import add_span_exception, configure_trace, get_traceid
 from infrahub.worker import WORKER_IDENTITY
@@ -84,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()
 
@@ -184,7 +191,17 @@ app.add_middleware(
     skip_paths=["/health"],
 )
 app.add_middleware(InfrahubCORSMiddleware)
-app.add_middleware(GZipMiddleware, minimum_size=100_000)
+app.add_middleware(
+    ConditionalGZipMiddleware,
+    minimum_size=100_000,
+    compresslevel=1,
+    include_paths=(
+        "/assets",
+        "/favicons",
+        "/docs",
+        "/api/schema",
+    ),
+)
 
 app.add_exception_handler(Error, generic_api_exception_handler)
 app.add_exception_handler(TimestampFormatError, partial(generic_api_exception_handler, http_code=400))