infrahub-server 1.1.7__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/core/attribute.py

@@ -7,13 +7,14 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 
 import netaddr
 import ujson
-from infrahub_sdk.timestamp import TimestampFormatError
+from infrahub_sdk.exceptions import TimestampFormatError
 from infrahub_sdk.utils import is_valid_url
 from infrahub_sdk.uuidt import UUIDT
 from pydantic import BaseModel, Field
 
 from infrahub import config
 from infrahub.core import registry
+from infrahub.core.changelog.models import AttributeChangelog
 from infrahub.core.constants import NULL_VALUE, AttributeDBNodeType, BranchSupportType, RelationshipStatus
 from infrahub.core.property import FlagPropertyMixin, NodePropertyData, NodePropertyMixin
 from infrahub.core.query.attribute import (
@@ -37,8 +38,6 @@ if TYPE_CHECKING:
     from infrahub.core.schema import AttributeSchema
     from infrahub.database import InfrahubDatabase
 
-# pylint: disable=redefined-builtin,c-extension-no-member,too-many-lines,too-many-public-methods
-
 
 # Use a more user-friendly threshold than Neo4j one (8167 bytes).
 MAX_STRING_LENGTH = 4096
@@ -81,7 +80,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
     _rel_to_node_label: str = RELATIONSHIP_TO_NODE_LABEL
     _rel_to_value_label: str = RELATIONSHIP_TO_VALUE_LABEL
 
-    def __init__(  # pylint: disable=too-many-branches
+    def __init__(
         self,
         name: str,
         schema: AttributeSchema,
@@ -218,7 +217,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         value_to_check = value
         if schema.enum and isinstance(value, Enum):
             value_to_check = value.value
-        if not isinstance(value_to_check, cls.type):  # pylint: disable=isinstance-second-argument-not-valid-type
+        if not isinstance(value_to_check, cls.type):
             raise ValidationError({name: f"{value} is not a valid {schema.kind}"})
 
     @classmethod
@@ -267,7 +266,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
     @classmethod
     def deserialize_from_string(cls, value_as_string: str) -> Any:
         """Return a value corresponding to the attribute type given it formatted as a string."""
-        return cls.type(value_as_string)  # pylint: disable=not-callable
+        return cls.type(value_as_string)
 
     def to_db(self) -> dict[str, Any]:
         """Return the properties of the AttributeValue node in Dict format."""
@@ -318,19 +317,19 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         """Deserialize the value coming from the database."""
         return data.value
 
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> bool:
+    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
         """Create or Update the Attribute in the database."""
 
         save_at = Timestamp(at)
 
         if not self.id or self.is_from_profile:
-            return False
+            return None
 
         return await self._update(at=save_at, db=db)
 
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> bool:
+    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
         if not self.db_id:
-            return False
+            return None
 
         delete_at = Timestamp(at)
 
@@ -339,7 +338,14 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         results = query.get_results()
 
         if not results:
-            return False
+            return None
+
+        changelog = AttributeChangelog(
+            name=self.name,
+            value=None,
+            value_previous=None,
+            kind=self.schema.kind,
+        )
 
         properties_to_delete = []
         branch = self.get_branch_based_on_support_type()
@@ -347,6 +353,8 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         # Check all the relationship and update the one that are in the same branch
         rel_ids_to_update = set()
         for result in results:
+            if result.get_rel("r2").type == "HAS_VALUE":
+                changelog.value_previous = result.get_node("ap").get("value")
             properties_to_delete.append((result.get_rel("r2").type, result.get_node("ap").element_id))
 
             await add_relationship(
@@ -378,9 +386,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             db=db,
         )
 
-        return True
+        return changelog
 
-    async def _update(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> bool:
+    async def _update(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
         """Update the attribute in the database.
 
         Get the current value
@@ -420,6 +428,13 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         branch = self.get_branch_based_on_support_type()
 
+        changelog = AttributeChangelog(
+            name=self.name,
+            value=self.to_db().get("value"),
+            value_previous=current_attr_data.value,
+            kind=self.schema.kind,
+        )
+
         # ---------- Update the Value ----------
         if current_attr_data.content != self.to_db():
             # Create the new AttributeValue and update the existing relationship
@@ -439,6 +454,11 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         for flag_name, _, rel_name in SUPPORTED_FLAGS:
             if current_attr_data.flag_properties[flag_name] != getattr(self, flag_name):
+                changelog.add_property(
+                    name=flag_name,
+                    value_current=getattr(self, flag_name),
+                    value_previous=current_attr_data.flag_properties[flag_name],
+                )
                 query = await AttributeUpdateFlagQuery.init(db=db, attr=self, at=update_at, flag_name=flag_name)
                 await query.execute(db=db)
 
@@ -452,6 +472,16 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                 prop_name in current_attr_data.node_properties
                 and current_attr_data.node_properties[prop_name].uuid == getattr(self, f"{prop_name}_id")
             ):
+                previous_attribute_node_property = current_attr_data.node_properties.get(prop_name)
+                previous_value = None
+                if previous_attribute_node_property:
+                    previous_value = previous_attribute_node_property.uuid
+
+                changelog.add_property(
+                    name=prop_name,
+                    value_current=getattr(self, f"{prop_name}_id"),
+                    value_previous=previous_value,
+                )
                 query = await AttributeUpdateNodePropertyQuery.init(
                     db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=getattr(self, f"{prop_name}_id")
                 )
@@ -461,7 +491,8 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                 if rel and rel.get("branch") == branch.name:
                     await update_relationships_to([rel.element_id], to=update_at, db=db)
 
-        return True
+        if changelog.has_updates:
+            return changelog
 
     async def to_graphql(
         self,
@@ -473,7 +504,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         include_properties: bool = True,
     ) -> dict:
         """Generate GraphQL Payload for this attribute."""
-        # pylint: disable=too-many-branches
 
         response: dict[str, Any] = {"id": self.id}
 
@@ -530,11 +560,11 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                     field = field.value
             if isinstance(field, str):
                 response[field_name] = self._filter_sensitive(value=field, filter_sensitive=filter_sensitive)
-            elif isinstance(field, (int, bool, dict, list)):
+            elif isinstance(field, int | bool | dict | list):
                 response[field_name] = field
 
-            if related_node_ids and self.is_from_profile and getattr(self, "source_id"):
-                related_node_ids.add(getattr(self, "source_id"))
+            if related_node_ids and self.is_from_profile and self.source_id:
+                related_node_ids.add(self.source_id)
 
         return response
 
@@ -592,7 +622,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         return AttributeDBNodeType.DEFAULT
 
     def get_create_data(self) -> AttributeCreateData:
-        # pylint: disable=no-member
         branch = self.branch
         hierarchy_level = branch.hierarchy_level
         if self.schema.branch == BranchSupportType.AGNOSTIC:
@@ -1162,7 +1191,7 @@ class ListAttribute(BaseAttribute):
 
     def deserialize_value(self, data: AttributeFromDB) -> Any:
         """Deserialize the value (potentially) coming from the database."""
-        if isinstance(data.value, (str, bytes)):
+        if isinstance(data.value, str | bytes):
             return ujson.loads(data.value)
         return data.value
 
@@ -1198,7 +1227,7 @@ class JSONAttribute(BaseAttribute):
 
     def deserialize_value(self, data: AttributeFromDB) -> Any:
         """Deserialize the value (potentially) coming from the database."""
-        if data.value and isinstance(data.value, (str, bytes)):
+        if data.value and isinstance(data.value, str | bytes):
             return ujson.loads(data.value)
         return data.value
 

infrahub/core/branch/models.py

@@ -25,7 +25,7 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
-class Branch(StandardNode):  # pylint: disable=too-many-public-methods
+class Branch(StandardNode):
     name: str = Field(
         max_length=250, min_length=3, description="Name of the branch (git ref standard)", validate_default=True
     )
@@ -274,7 +274,7 @@ class Branch(StandardNode):  # pylint: disable=too-many-public-methods
 
         for rel in rel_labels:
             filters_per_rel = []
-            for idx, (branch_name, time_to_query) in enumerate(branches_times.items()):
+            for idx in range(len(branches_times)):
                 filters_per_rel.append(
                     f"({rel}.branch IN $branch{idx} AND {rel}.from <= $time{idx} AND {rel}.to IS NULL)"
                 )
@@ -324,7 +324,7 @@ class Branch(StandardNode):  # pylint: disable=too-many-public-methods
             params[f"time{idx}"] = time_to_query
 
         filters = []
-        for idx, (branch_name, time_to_query) in enumerate(branches_times.items()):
+        for idx in range(len(branches_times)):
             filters.append(
                 f"({variable_name}.branch IN $branch{idx} AND {variable_name}.from <= $time{idx} AND {variable_name}.to IS NULL)"
             )
@@ -404,7 +404,7 @@ class Branch(StandardNode):  # pylint: disable=too-many-public-methods
 
         for rel in rel_labels:
             filters_per_rel = []
-            for idx, branch_name in enumerate(start_times.keys()):
+            for idx in range(len(start_times)):
                 filters_per_rel.extend(
                     [
                         f"""({rel}.branch = $branch{idx}

infrahub/core/branch/tasks.py

@@ -1,66 +1,62 @@
 from __future__ import annotations
 
-from datetime import timedelta
 from typing import Any
+from uuid import uuid4
 
 import pydantic
 from prefect import flow, get_run_logger
-from prefect.automations import AutomationCore
-from prefect.client.orchestration import get_client
-from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
 from prefect.client.schemas.objects import State  # noqa: TC002
-from prefect.events.actions import RunDeployment
-from prefect.events.schemas.automations import EventTrigger, Posture
 from prefect.states import Completed, Failed
 
 from infrahub import lock
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
 from infrahub.core import registry
 from infrahub.core.branch import Branch
+from infrahub.core.changelog.diff import DiffChangelogCollector, MigrationTracker
+from infrahub.core.constants import MutationAction
 from infrahub.core.diff.coordinator import DiffCoordinator
 from infrahub.core.diff.ipam_diff_parser import IpamDiffParser
 from infrahub.core.diff.merger.merger import DiffMerger
-from infrahub.core.diff.model.path import BranchTrackingId
+from infrahub.core.diff.model.path import BranchTrackingId, EnrichedDiffRoot, EnrichedDiffRootMetadata
 from infrahub.core.diff.repository.repository import DiffRepository
 from infrahub.core.merge import BranchMerger
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.migrations.schema.tasks import schema_apply_migrations
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.validators.determiner import ConstraintValidatorDeterminer
 from infrahub.core.validators.models.validate_migration import SchemaValidateMigrationData
 from infrahub.core.validators.tasks import schema_validate_migrations
 from infrahub.dependencies.registry import get_component_registry
-from infrahub.events.branch_action import BranchCreateEvent, BranchDeleteEvent, BranchRebaseEvent
+from infrahub.events.branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedEvent, BranchRebasedEvent
+from infrahub.events.models import EventMeta, InfrahubEvent
+from infrahub.events.node_action import NodeMutatedEvent
 from infrahub.exceptions import BranchNotFoundError, MergeFailedError, ValidationError
 from infrahub.graphql.mutations.models import BranchCreateModel  # noqa: TC001
 from infrahub.log import get_log_data
 from infrahub.message_bus import Meta, messages
-from infrahub.services import services
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.worker import WORKER_IDENTITY
 from infrahub.workflows.catalogue import (
     BRANCH_CANCEL_PROPOSED_CHANGES,
-    COMPUTED_ATTRIBUTE_REMOVE_PYTHON,
-    COMPUTED_ATTRIBUTE_SETUP_PYTHON,
     DIFF_REFRESH_ALL,
     GIT_REPOSITORIES_CREATE_BRANCH,
     IPAM_RECONCILIATION,
 )
-from infrahub.workflows.utils import add_branch_tag
-
-from .constants import AUTOMATION_NAME_CREATE, AUTOMATION_NAME_REMOVE
+from infrahub.workflows.utils import add_tags
 
 
 @flow(name="branch-rebase", flow_run_name="Rebase branch {branch}")
-async def rebase_branch(branch: str) -> None:
-    service = services.service
-
+async def rebase_branch(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
     async with service.database.start_session() as db:
         log = get_run_logger()
-        await add_branch_tag(branch_name=branch)
+        await add_tags(branches=[branch])
         obj = await Branch.get_by_name(db=db, name=branch)
         base_branch = await Branch.get_by_name(db=db, name=registry.default_branch)
         component_registry = get_component_registry()
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
         diff_coordinator = await component_registry.get_component(DiffCoordinator, db=db, branch=obj)
         diff_merger = await component_registry.get_component(DiffMerger, db=db, branch=obj)
+        initial_from_time = Timestamp(obj.get_branched_from())
         merger = BranchMerger(
             db=db,
             diff_coordinator=diff_coordinator,
@@ -69,7 +65,7 @@ async def rebase_branch(branch: str) -> None:
             source_branch=obj,
             service=service,
         )
-        diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
+
         enriched_diff_metadata = await diff_coordinator.update_branch_diff(base_branch=base_branch, diff_branch=obj)
         async for _ in diff_repository.get_all_conflicts_for_diff(
             diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
@@ -94,14 +90,17 @@ async def rebase_branch(branch: str) -> None:
             constraints += await merger.calculate_validations(target_schema=candidate_schema)
         if constraints:
             responses = await schema_validate_migrations(
-                message=SchemaValidateMigrationData(branch=obj, schema_branch=candidate_schema, constraints=constraints)
+                message=SchemaValidateMigrationData(
+                    branch=obj, schema_branch=candidate_schema, constraints=constraints
+                ),
+                service=service,
             )
             error_messages = [violation.message for response in responses for violation in response.violations]
             if error_messages:
                 raise ValidationError(",\n".join(error_messages))
 
         schema_in_main_before = merger.destination_schema.duplicate()
-
+        migrations = []
         async with lock.registry.global_graph_lock():
             async with db.start_transaction() as dbt:
                 await obj.rebase(db=dbt)
@@ -132,11 +131,20 @@ async def rebase_branch(branch: str) -> None:
                         new_schema=candidate_schema,
                         previous_schema=schema_in_main_before,
                         migrations=migrations,
-                    )
+                    ),
+                    service=service,
                 )
                 for error in errors:
                     log.error(error)
 
+        default_branch_diff = await _get_diff_root(
+            diff_coordinator=diff_coordinator,
+            enriched_diff_metadata=enriched_diff_metadata,
+            diff_repository=diff_repository,
+            base_branch=base_branch,
+            target_from=initial_from_time,
+        )
+
         # -------------------------------------------------------------
         # Trigger the reconciliation of IPAM data after the rebase
         # -------------------------------------------------------------
@@ -147,28 +155,55 @@ async def rebase_branch(branch: str) -> None:
         )
         if ipam_node_details:
             await service.workflow.submit_workflow(
-                workflow=IPAM_RECONCILIATION, parameters={"branch": obj.name, "ipam_node_details": ipam_node_details}
+                workflow=IPAM_RECONCILIATION,
+                context=context,
+                parameters={"branch": obj.name, "ipam_node_details": ipam_node_details},
             )
 
-    await service.workflow.submit_workflow(workflow=DIFF_REFRESH_ALL, parameters={"branch_name": obj.name})
+    await service.workflow.submit_workflow(
+        workflow=DIFF_REFRESH_ALL, context=context, parameters={"branch_name": obj.name}
+    )
 
     # -------------------------------------------------------------
     # Generate an event to indicate that a branch has been rebased
     # -------------------------------------------------------------
-    await service.event.send(event=BranchRebaseEvent(branch=obj.name, branch_id=obj.get_id()))
+    rebase_event = BranchRebasedEvent(
+        branch_name=obj.name, branch_id=str(obj.uuid), meta=EventMeta(branch=obj, context=context)
+    )
+    events: list[InfrahubEvent] = [rebase_event]
+    changelog_collector = DiffChangelogCollector(
+        diff=default_branch_diff, branch=obj, db=db, migration_tracker=MigrationTracker(migrations=migrations)
+    )
+    for action, node_changelog in changelog_collector.collect_changelogs():
+        mutate_event = NodeMutatedEvent(
+            kind=node_changelog.node_kind,
+            node_id=node_changelog.node_id,
+            data=node_changelog,
+            action=MutationAction.from_diff_action(diff_action=action),
+            fields=node_changelog.updated_fields,
+            meta=EventMeta.from_parent(parent=rebase_event, branch=obj),
+        )
+        events.append(mutate_event)
+
+    for event in events:
+        await service.event.send(event)
 
 
 @flow(name="branch-merge", flow_run_name="Merge branch {branch} into main")
-async def merge_branch(branch: str) -> None:
-    service = services.service
+async def merge_branch(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
     async with service.database.start_session() as db:
         log = get_run_logger()
 
-        await add_branch_tag(branch_name=branch)
-        await add_branch_tag(branch_name=registry.default_branch)
+        await add_tags(branches=[branch, registry.default_branch])
 
         obj = await Branch.get_by_name(db=db, name=branch)
+        default_branch = await registry.get_branch(db=db, branch=registry.default_branch)
         component_registry = get_component_registry()
+        merge_event = BranchMergedEvent(
+            branch_name=obj.name,
+            branch_id=str(obj.get_uuid()),
+            meta=EventMeta.from_context(context=context, branch=registry.get_global_branch()),
+        )
 
         merger: BranchMerger | None = None
         async with lock.registry.global_graph_lock():
@@ -186,13 +221,15 @@ async def merge_branch(branch: str) -> None:
                 service=service,
             )
             try:
-                await merger.merge()
+                branch_diff = await merger.merge()
             except Exception as exc:
                 log.exception("Merge failed, beginning rollback")
                 await merger.rollback()
                 raise MergeFailedError(branch_name=branch) from exc
             await merger.update_schema()
 
+        changelog_collector = DiffChangelogCollector(diff=branch_diff, branch=obj, db=db)
+        node_events = changelog_collector.collect_changelogs()
         if merger and merger.migrations:
             errors = await schema_apply_migrations(
                 message=SchemaApplyMigrationData(
@@ -200,7 +237,8 @@ async def merge_branch(branch: str) -> None:
                     new_schema=merger.destination_schema,
                     previous_schema=merger.initial_source_schema,
                     migrations=merger.migrations,
-                )
+                ),
+                service=service,
             )
             for error in errors:
                 log.error(error)
@@ -216,6 +254,7 @@ async def merge_branch(branch: str) -> None:
         if ipam_node_details:
             await service.workflow.submit_workflow(
                 workflow=IPAM_RECONCILIATION,
+                context=context,
                 parameters={"branch": registry.default_branch, "ipam_node_details": ipam_node_details},
             )
         # -------------------------------------------------------------
@@ -234,24 +273,46 @@ async def merge_branch(branch: str) -> None:
         message = messages.EventBranchMerge(
             source_branch=obj.name,
             target_branch=registry.default_branch,
+            context=context,
             meta=Meta(initiator_id=WORKER_IDENTITY, request_id=request_id),
         )
-        await service.send(message=message)
+        await service.message_bus.send(message=message)
+
+        events: list[InfrahubEvent] = [merge_event]
+
+        for action, node_changelog in node_events:
+            meta = EventMeta.from_parent(parent=merge_event, branch=default_branch)
+            mutate_event = NodeMutatedEvent(
+                kind=node_changelog.node_kind,
+                node_id=node_changelog.node_id,
+                data=node_changelog,
+                action=MutationAction.from_diff_action(diff_action=action),
+                fields=node_changelog.updated_fields,
+                meta=meta,
+            )
+            events.append(mutate_event)
 
+        for event in events:
+            await service.event.send(event=event)
 
-@flow(name="branch-delete", flow_run_name="Delete branch {branch}")
-async def delete_branch(branch: str) -> None:
-    service = services.service
 
-    await add_branch_tag(branch_name=branch)
+@flow(name="branch-delete", flow_run_name="Delete branch {branch}")
+async def delete_branch(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
+    await add_tags(branches=[branch])
 
     async with service.database.start_session() as db:
         obj = await Branch.get_by_name(db=db, name=str(branch))
-        event = BranchDeleteEvent(branch=branch, branch_id=obj.get_id(), sync_with_git=obj.sync_with_git)
         await obj.delete(db=db)
 
+        event = BranchDeletedEvent(
+            branch_name=branch,
+            branch_id=str(obj.uuid),
+            sync_with_git=obj.sync_with_git,
+            meta=EventMeta.from_context(context=context, branch=registry.get_global_branch()),
+        )
+
         await service.workflow.submit_workflow(
-            workflow=BRANCH_CANCEL_PROPOSED_CHANGES, parameters={"branch_name": branch}
+            workflow=BRANCH_CANCEL_PROPOSED_CHANGES, context=context, parameters={"branch_name": branch}
         )
 
         await service.event.send(event=event)
@@ -263,9 +324,8 @@ async def delete_branch(branch: str) -> None:
     description="Validate if the branch has some conflicts",
     persist_result=True,
 )
-async def validate_branch(branch: str) -> State:
-    service = services.service
-    await add_branch_tag(branch_name=branch)
+async def validate_branch(branch: str, service: InfrahubServices) -> State:
+    await add_tags(branches=[branch])
 
     async with service.database.start_session() as db:
         obj = await Branch.get_by_name(db=db, name=branch)
@@ -281,9 +341,8 @@ async def validate_branch(branch: str) -> State:
 
 
 @flow(name="create-branch", flow_run_name="Create branch {model.name}")
-async def create_branch(model: BranchCreateModel) -> None:
-    service = services.service
-    await add_branch_tag(model.name)
+async def create_branch(model: BranchCreateModel, context: InfrahubContext, service: InfrahubServices) -> None:
+    await add_tags(branches=[model.name])
 
     async with service.database.start_session() as db:
         try:
@@ -293,8 +352,7 @@ async def create_branch(model: BranchCreateModel) -> None:
             pass
 
         data_dict: dict[str, Any] = dict(model)
-        if "is_isolated" in data_dict:
-            del data_dict["is_isolated"]
+        data_dict.pop("is_isolated", None)
 
         try:
             obj = Branch(**data_dict)
@@ -314,93 +372,40 @@ async def create_branch(model: BranchCreateModel) -> None:
             registry.branch[obj.name] = obj
             await service.component.refresh_schema_hash(branches=[obj.name])
 
-        event = BranchCreateEvent(branch=obj.name, branch_id=str(obj.uuid), sync_with_git=obj.sync_with_git)
+        event = BranchCreatedEvent(
+            branch_name=obj.name,
+            branch_id=str(obj.uuid),
+            sync_with_git=obj.sync_with_git,
+            meta=EventMeta.from_context(context=context, branch=registry.get_global_branch()),
+        )
         await service.event.send(event=event)
 
         if obj.sync_with_git:
             await service.workflow.submit_workflow(
                 workflow=GIT_REPOSITORIES_CREATE_BRANCH,
+                context=context,
                 parameters={"branch": obj.name, "branch_id": str(obj.uuid)},
             )
 
 
-@flow(name="branch-actions-setup", flow_run_name="Setup branch action events in task-manager")
-async def branch_actions_setup() -> None:
-    log = get_run_logger()
-
-    async with get_client(sync_client=False) as client:
-        deployments = {
-            item.name: item
-            for item in await client.read_deployments(
-                deployment_filter=DeploymentFilter(
-                    name=DeploymentFilterName(
-                        any_=[COMPUTED_ATTRIBUTE_SETUP_PYTHON.name, COMPUTED_ATTRIBUTE_REMOVE_PYTHON.name]
-                    )
-                )
-            )
-        }
-        deployment_id_computed_attribute_setup_python = deployments[COMPUTED_ATTRIBUTE_SETUP_PYTHON.name].id
-        deployment_id_computed_attribute_remove_python = deployments[COMPUTED_ATTRIBUTE_REMOVE_PYTHON.name].id
-
-        branch_create_automation = await client.find_automation(id_or_name=AUTOMATION_NAME_CREATE)
-
-        automation = AutomationCore(
-            name=AUTOMATION_NAME_CREATE,
-            description="Trigger actions on branch create event",
-            enabled=True,
-            trigger=EventTrigger(
-                posture=Posture.Reactive,
-                expect={"infrahub.branch.created"},
-                within=timedelta(0),
-                threshold=1,
-            ),
-            actions=[
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_computed_attribute_setup_python,
-                    parameters={
-                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
-                        "trigger_updates": False,
-                    },
-                    job_variables={},
-                ),
-            ],
-        )
-
-        if branch_create_automation:
-            await client.update_automation(automation_id=branch_create_automation.id, automation=automation)
-            log.info(f"{AUTOMATION_NAME_CREATE} Updated")
-        else:
-            await client.create_automation(automation=automation)
-            log.info(f"{AUTOMATION_NAME_CREATE} Created")
-
-        branch_remove_automation = await client.find_automation(id_or_name=AUTOMATION_NAME_REMOVE)
-
-        automation = AutomationCore(
-            name=AUTOMATION_NAME_REMOVE,
-            description="Trigger actions on branch delete event",
-            enabled=True,
-            trigger=EventTrigger(
-                posture=Posture.Reactive,
-                expect={"infrahub.branch.deleted"},
-                within=timedelta(0),
-                threshold=1,
-            ),
-            actions=[
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_computed_attribute_remove_python,
-                    parameters={
-                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
-                    },
-                    job_variables={},
-                ),
-            ],
+async def _get_diff_root(
+    diff_coordinator: DiffCoordinator,
+    enriched_diff_metadata: EnrichedDiffRootMetadata,
+    diff_repository: DiffRepository,
+    base_branch: Branch,
+    target_from: Timestamp,
+) -> EnrichedDiffRoot:
+    default_branch_diff = await diff_coordinator.create_or_update_arbitrary_timeframe_diff(
+        base_branch=base_branch,
+        diff_branch=base_branch,
+        from_time=target_from,
+        to_time=enriched_diff_metadata.to_time,
+        name=str(uuid4()),
+    )
+    # make sure we have the actual diff with data and not just the metadata
+    if not isinstance(default_branch_diff, EnrichedDiffRoot):
+        default_branch_diff = await diff_repository.get_one(
+            diff_branch_name=base_branch.name, diff_id=default_branch_diff.uuid
         )
 
-        if branch_remove_automation:
-            await client.update_automation(automation_id=branch_remove_automation.id, automation=automation)
-            log.info(f"{AUTOMATION_NAME_REMOVE} Updated")
-        else:
-            await client.create_automation(automation=automation)
-            log.info(f"{AUTOMATION_NAME_REMOVE} Created")
+    return default_branch_diff