infrahub-server 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

infrahub/core/attribute.py

@@ -15,18 +15,27 @@ 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.constants import (
+    NULL_VALUE,
+    SYSTEM_USER_ID,
+    AttributeDBNodeType,
+    BranchSupportType,
+    InfrahubKind,
+    MetadataOptions,
+)
+from infrahub.core.metadata.interface import MetadataInterface
+from infrahub.core.metadata.model import MetadataInfo
 from infrahub.core.property import FlagPropertyMixin, NodePropertyData, NodePropertyMixin
 from infrahub.core.query.attribute import (
     AttributeClearNodePropertyQuery,
-    AttributeGetQuery,
+    AttributeDeleteQuery,
     AttributeUpdateFlagQuery,
     AttributeUpdateNodePropertyQuery,
     AttributeUpdateValueQuery,
 )
 from infrahub.core.query.node import AttributeFromDB, NodeListGetAttributeQuery
 from infrahub.core.timestamp import Timestamp
-from infrahub.core.utils import add_relationship, convert_ip_to_binary_str, update_relationships_to
+from infrahub.core.utils import convert_ip_to_binary_str
 from infrahub.exceptions import ValidationError
 from infrahub.helpers import hash_password
 
@@ -70,12 +79,11 @@ class AttributeCreateData(BaseModel):
     content: dict[str, Any]
     is_default: bool
     is_protected: bool
-    is_visible: bool
     source_prop: list[NodePropertyData] = Field(default_factory=list)
     owner_prop: list[NodePropertyData] = Field(default_factory=list)
 
 
-class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
+class BaseAttribute(FlagPropertyMixin, NodePropertyMixin, MetadataInterface):
     type: type | tuple[type] | None = None
 
     _rel_to_node_label: str = RELATIONSHIP_TO_NODE_LABEL
@@ -91,7 +99,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         id: str | None = None,
         db_id: str | None = None,
         data: dict | str | AttributeFromDB | None = None,
-        updated_at: Timestamp | str | None = None,
         is_default: bool = False,
         is_from_profile: bool = False,
         **kwargs: dict[str, Any],
@@ -99,7 +106,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         self.id = id
         self.db_id = db_id
 
-        self.updated_at = updated_at
         self.name = name
         self.node = node
         self.schema = schema
@@ -112,6 +118,13 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         self._init_node_property_mixin(kwargs)
         self._init_flag_property_mixin(kwargs)
 
+        self._metadata = MetadataInfo(
+            created_at=kwargs.get("created_at"),
+            created_by=kwargs.get("created_by"),
+            updated_at=kwargs.get("updated_at"),
+            updated_by=kwargs.get("updated_by"),
+        )
+
         self.value = None
 
         if isinstance(data, AttributeFromDB):
@@ -130,8 +143,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             for field_name in fields_to_extract_from_data:
                 setattr(self, field_name, data.get(field_name, None))
 
-            if not self.updated_at and "updated_at" in data:
-                self.updated_at = Timestamp(data.get("updated_at"))
         elif data is None:
             self.is_default = True
         else:
@@ -151,9 +162,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if self.is_protected is None:
             self.is_protected = False
 
-        if self.is_visible is None:
-            self.is_visible = True
-
     @property
     def is_enum(self) -> bool:
         return bool(self.schema.enum)
@@ -187,6 +195,30 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if self.is_enum and self.value:
             self.value = self.schema.convert_value_to_enum(self.value)
 
+    def _set_created_at(self, value: Timestamp | None) -> None:
+        self._metadata.created_at = value
+
+    def _set_created_by(self, value: str | None) -> None:
+        self._metadata.created_by = value
+
+    def _set_updated_at(self, value: Timestamp | None) -> None:
+        self._metadata.updated_at = value
+
+    def _set_updated_by(self, value: str | None) -> None:
+        self._metadata.updated_by = value
+
+    def _get_created_at(self) -> Timestamp | None:
+        return self._metadata.created_at
+
+    def _get_created_by(self) -> str | None:
+        return self._metadata.created_by
+
+    def _get_updated_at(self) -> Timestamp | None:
+        return self._metadata.updated_at
+
+    def _get_updated_by(self) -> str | None:
+        return self._metadata.updated_by
+
     @staticmethod
     def get_allowed_property_in_path() -> list[str]:
         return ["value"]
@@ -302,8 +334,10 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             if prop_name in data.node_properties:
                 setattr(self, prop_name, data.node_properties[prop_name].uuid)
 
-        if not self.updated_at and data.updated_at:
-            self.updated_at = Timestamp(data.updated_at)
+        self._set_created_at(data.created_at)
+        self._set_created_by(data.created_by)
+        self._set_updated_at(data.updated_at)
+        self._set_updated_by(data.updated_by)
 
     def value_from_db(self, data: AttributeFromDB) -> Any:
         if data.value == NULL_VALUE:
@@ -320,7 +354,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         """Deserialize the value coming from the database."""
         return data.value
 
-    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
+    async def save(
+        self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID, at: Timestamp | None = None
+    ) -> AttributeChangelog | None:
         """Create or Update the Attribute in the database."""
 
         save_at = Timestamp(at)
@@ -328,70 +364,34 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if not self.id:
             return None
 
-        return await self._update(at=save_at, db=db)
+        return await self._update(db=db, user_id=user_id, at=save_at)
 
-    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
+    async def delete(
+        self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID, at: Timestamp | None = None
+    ) -> AttributeChangelog | None:
         if not self.db_id:
             return None
 
         delete_at = Timestamp(at)
+        branch = self.get_branch_based_on_support_type()
 
-        query = await AttributeGetQuery.init(db=db, attr=self, at=delete_at)
+        query = await AttributeDeleteQuery.init(db=db, branch=branch, attr=self, user_id=user_id, at=delete_at)
         await query.execute(db=db)
-        results = query.get_results()
+        previous_value = query.get_previous_property_value()
 
-        if not results:
+        if not previous_value:
             return None
 
-        changelog = AttributeChangelog(
+        return AttributeChangelog(
             name=self.name,
             value=None,
-            value_previous=None,
+            value_previous=previous_value,
             kind=self.schema.kind,
         )
 
-        properties_to_delete = []
-        branch = self.get_branch_based_on_support_type()
-
-        # 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(
-                src_node_id=self.db_id,
-                dst_node_id=result.get_node("ap").element_id,
-                rel_type=result.get_rel("r2").type,
-                branch_name=branch.name,
-                branch_level=branch.hierarchy_level,
-                at=delete_at,
-                status=RelationshipStatus.DELETED,
-                db=db,
-            )
-
-            for rel in result.get_rels():
-                if rel.get("branch") == branch.name:
-                    rel_ids_to_update.add(rel.element_id)
-
-        if rel_ids_to_update:
-            await update_relationships_to(ids=list(rel_ids_to_update), to=delete_at, db=db)
-
-        await add_relationship(
-            src_node_id=self.node.db_id,
-            dst_node_id=self.db_id,
-            rel_type="HAS_ATTRIBUTE",
-            branch_name=branch.name,
-            branch_level=branch.hierarchy_level,
-            at=delete_at,
-            status=RelationshipStatus.DELETED,
-            db=db,
-        )
-
-        return changelog
-
-    async def _update(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
+    async def _update(
+        self, db: InfrahubDatabase, user_id: str, at: Timestamp | None = None
+    ) -> AttributeChangelog | None:
         """Update the attribute in the database.
 
         Get the current value
@@ -422,13 +422,10 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             fields={self.name: True},
             branch=self.branch,
             at=update_at,
-            include_source=True,
-            include_owner=True,
+            include_metadata=MetadataOptions.LINKED_NODES,
         )
         await query.execute(db=db)
-        current_attr_data, current_attr_result = query.get_result_by_id_and_name(self.node.id, self.name)
-
-        branch = self.get_branch_based_on_support_type()
+        current_attr_data, _ = query.get_result_by_id_and_name(self.node.id, self.name)
 
         changelog = AttributeChangelog(
             name=self.name,
@@ -437,36 +434,26 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             kind=self.schema.kind,
         )
 
+        branch = self.get_branch_based_on_support_type()
+
         # ---------- Update the Value ----------
         if current_attr_data.content != self.to_db():
             # Create the new AttributeValue and update the existing relationship
-            query = await AttributeUpdateValueQuery.init(db=db, attr=self, at=update_at)
+            query = await AttributeUpdateValueQuery.init(db=db, branch=branch, attr=self, user_id=user_id, at=update_at)
             await query.execute(db=db)
 
-            # TODO check that everything went well
-            rel = current_attr_result.get_rel("r2")
-            if rel.get("branch") == branch.name:
-                await update_relationships_to([rel.element_id], to=update_at, db=db)
-
         # ---------- Update the Flags ----------
-        SUPPORTED_FLAGS = (
-            ("is_visible", "isv", "rel_isv"),
-            ("is_protected", "isp", "rel_isp"),
-        )
-
-        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)
-
-                rel = current_attr_result.get(rel_name)
-                if rel.get("branch") == branch.name:
-                    await update_relationships_to([rel.element_id], to=update_at, db=db)
+        flag_name = "is_protected"
+        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, branch=branch, attr=self, user_id=user_id, at=update_at, flag_name=flag_name
+            )
+            await query.execute(db=db)
 
         # ---------- Update the Node Properties ----------
         for prop_name in self._node_properties:
@@ -488,21 +475,27 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
             if needs_update:
                 query = await AttributeUpdateNodePropertyQuery.init(
-                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=current_prop_id
+                    db=db,
+                    branch=branch,
+                    attr=self,
+                    user_id=user_id,
+                    at=update_at,
+                    prop_name=prop_name,
+                    prop_id=current_prop_id,
                 )
                 await query.execute(db=db)
 
             if needs_clear:
                 query = await AttributeClearNodePropertyQuery.init(
-                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=database_prop_id
+                    db=db,
+                    branch=branch,
+                    attr=self,
+                    user_id=user_id,
+                    at=update_at,
+                    prop_name=prop_name,
                 )
                 await query.execute(db=db)
 
-            # set the to time on the previously active edge
-            rel = current_attr_result.get(f"rel_{prop_name}")
-            if rel and rel.get("branch") == branch.name:
-                await update_relationships_to([rel.element_id], to=update_at, db=db)
-
         if changelog.has_updates:
             return changelog
 
@@ -531,10 +524,19 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         for field_name in field_names:
             if field_name == "updated_at":
-                if self.updated_at:
-                    response[field_name] = await self.updated_at.to_graphql()
-                else:
-                    response[field_name] = None
+                updated_at = self._get_updated_at()
+                response[field_name] = await updated_at.to_graphql() if updated_at else None
+                continue
+
+            if field_name == "updated_by":
+                response[field_name] = (
+                    {
+                        "id": self._get_updated_by(),
+                        "__kind__": InfrahubKind.ACCOUNT,
+                    }
+                    if self._get_updated_by()
+                    else None
+                )
                 continue
 
             if field_name == "__typename":
@@ -620,9 +622,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if "is_protected" in data and data["is_protected"] != self.is_protected:
             self.is_protected = data["is_protected"]
             changed = True
-        if "is_visible" in data and data["is_visible"] != self.is_visible:
-            self.is_visible = data["is_visible"]
-            changed = True
 
         if "source" in data and data["source"] != self.source_id:
             self.source = data["source"]
@@ -657,7 +656,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             content=self.to_db(),
             is_default=self.is_default,
             is_protected=self.is_protected,
-            is_visible=self.is_visible,
         )
         if self.source_id:
             data.source_prop.append(NodePropertyData(name="source", peer_id=self.source_id))

infrahub/core/branch/models.py

@@ -6,17 +6,15 @@ from typing import TYPE_CHECKING, Any, Optional, Self, Union, cast
 from pydantic import Field, field_validator
 
 from infrahub.core.branch.enums import BranchStatus
-from infrahub.core.constants import GLOBAL_BRANCH_NAME
+from infrahub.core.constants import GLOBAL_BRANCH_NAME, SYSTEM_USER_ID
 from infrahub.core.graph import GRAPH_VERSION
 from infrahub.core.models import SchemaBranchHash  # noqa: TC001
-from infrahub.core.node.standard import StandardNode
+from infrahub.core.node.standard import StandardNode, StandardNodeOrdering
 from infrahub.core.query import Query, QueryType
 from infrahub.core.query.branch import (
     BranchNodeGetListQuery,
     DeleteBranchRelationshipsQuery,
-    GetAllBranchInternalRelationshipQuery,
-    RebaseBranchDeleteRelationshipQuery,
-    RebaseBranchUpdateRelationshipQuery,
+    RebaseBranchQuery,
 )
 from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
@@ -37,7 +35,6 @@ class Branch(StandardNode):
     origin_branch: str = "main"
     branched_from: Optional[str] = Field(default=None, validate_default=True)
     hierarchy_level: int = 2
-    created_at: Optional[str] = Field(default=None, validate_default=True)
     is_default: bool = False
     is_global: bool = False
     is_protected: bool = False
@@ -93,11 +90,6 @@ class Branch(StandardNode):
             raise RuntimeError(f"branched_from not set for branch {self.name}")
         return self.branched_from
 
-    @field_validator("created_at", mode="before")
-    @classmethod
-    def set_created_at(cls, value: str) -> str:
-        return Timestamp(value).to_string()
-
     def get_created_at(self) -> str:
         if not self.created_at:
             raise RuntimeError(f"created_at not set for branch {self.name}")
@@ -162,10 +154,18 @@ class Branch(StandardNode):
         limit: int = 1000,
         ids: list[str] | None = None,
         name: str | None = None,
+        node_ordering: StandardNodeOrdering | None = None,
         **kwargs: Any,
     ) -> list[Self]:
+        node_ordering = node_ordering or StandardNodeOrdering()
         query: Query = await BranchNodeGetListQuery.init(
-            db=db, node_class=cls, ids=ids, node_name=name, limit=limit, **kwargs
+            db=db,
+            node_class=cls,
+            ids=ids,
+            node_name=name,
+            limit=limit,
+            node_ordering=node_ordering,
+            **kwargs,
         )
         await query.execute(db=db)
 
@@ -178,10 +178,18 @@ class Branch(StandardNode):
         limit: int = 1000,
         ids: list[str] | None = None,
         name: str | None = None,
+        partial_match: bool = False,
         **kwargs: Any,
     ) -> int:
         query: Query = await BranchNodeGetListQuery.init(
-            db=db, node_class=cls, ids=ids, node_name=name, limit=limit, exclude_global=True, **kwargs
+            db=db,
+            node_class=cls,
+            ids=ids,
+            node_name=name,
+            limit=limit,
+            exclude_global=True,
+            partial_match=partial_match,
+            **kwargs,
         )
         return await query.count(db=db)
 
@@ -208,7 +216,7 @@ class Branch(StandardNode):
 
         return [default_branch, self.name]
 
-    def get_branches_and_times_to_query(self, at: Optional[Union[Timestamp, str]] = None) -> dict[frozenset, str]:
+    def get_branches_and_times_to_query(self, at: Optional[Timestamp] = None) -> dict[frozenset, str]:
         """Return all the names of the branches that are constituing this branch with the associated times excluding the global branch"""
 
         at = Timestamp(at)
@@ -229,7 +237,7 @@ class Branch(StandardNode):
 
     def get_branches_and_times_to_query_global(
         self,
-        at: Optional[Union[Timestamp, str]] = None,
+        at: Optional[Timestamp] = None,
         is_isolated: bool = True,
     ) -> dict[frozenset, str]:
         """Return all the names of the branches that are constituting this branch with the associated times."""
@@ -281,9 +289,9 @@ class Branch(StandardNode):
 
         return start, end
 
-    async def create(self, db: InfrahubDatabase) -> bool:
+    async def create(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> bool:
         self.graph_version = GRAPH_VERSION
-        return await super().create(db=db)
+        return await super().create(db=db, user_id=user_id)
 
     async def delete(self, db: InfrahubDatabase) -> None:
         if self.is_default:
@@ -299,7 +307,7 @@ class Branch(StandardNode):
         await super().delete(db=db)
 
     def get_query_filter_relationships(
-        self, rel_labels: list, at: Optional[Union[Timestamp, str]] = None, include_outside_parentheses: bool = False
+        self, rel_labels: list, at: Optional[Timestamp] = None, include_outside_parentheses: bool = False
     ) -> tuple[list, dict]:
         """
         Generate a CYPHER Query filter based on a list of relationships to query a part of the graph at a specific time and on a specific branch.
@@ -362,7 +370,7 @@ class Branch(StandardNode):
             params[f"{pp}time1"] = at_str
             return filter_str, params
 
-        branches_times = self.get_branches_and_times_to_query_global(at=at_str, is_isolated=is_isolated)
+        branches_times = self.get_branches_and_times_to_query_global(at=at, is_isolated=is_isolated)
 
         for idx, (branch_name, time_to_query) in enumerate(branches_times.items()):
             params[f"{pp}branch{idx}"] = list(branch_name)
@@ -387,8 +395,8 @@ class Branch(StandardNode):
     def get_query_filter_relationships_range(
         self,
         rel_labels: list,
-        start_time: Union[Timestamp, str],
-        end_time: Union[Timestamp, str],
+        start_time: Timestamp,
+        end_time: Timestamp,
         include_outside_parentheses: bool = False,
         include_global: bool = False,
     ) -> tuple[list, dict]:
@@ -468,9 +476,7 @@ class Branch(StandardNode):
 
         return filters, params
 
-    def get_query_filter_range(
-        self, rel_label: list, start_time: Union[Timestamp, str], end_time: Union[Timestamp, str]
-    ) -> tuple[list, dict]:
+    def get_query_filter_range(self, rel_label: list, start_time: Timestamp, end_time: Timestamp) -> tuple[list, dict]:
         """
         Generate a CYPHER Query filter to query a range of values in the graph between start_time and end_time."""
 
@@ -496,67 +502,34 @@ class Branch(StandardNode):
 
         return filters, params
 
-    async def rebase(self, db: InfrahubDatabase, at: Optional[Union[str, Timestamp]] = None) -> None:
+    async def rebase(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> None:
         """Rebase the current Branch with its origin branch"""
 
-        at = Timestamp(at)
-
-        # Find all relationships with the name of the branch
-        # Delete all relationship that have a to date defined in the past
-        # Update the from time on all other relationships
-        # If conflict is set, ignore the one with Drop
+        at = Timestamp()
 
         await self.rebase_graph(db=db, at=at)
 
-        # FIXME, we must ensure that there is no conflict before rebasing a branch
-        #   Otherwise we could endup with a complicated situation
         self.branched_from = at.to_string()
         self.status = BranchStatus.OPEN
-        await self.save(db=db)
+        await self.save(db=db, user_id=user_id)
 
         # Update the branch in the registry after the rebase
         registry.branch[self.name] = self
 
-    async def rebase_graph(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
-        at = Timestamp(at)
+    async def rebase_graph(self, db: InfrahubDatabase, at: Timestamp) -> None:
+        """Rebase all relationships on this branch to a new point in time.
 
-        query = await GetAllBranchInternalRelationshipQuery.init(db=db, branch=self)
-        await query.execute(db=db)
+        This method updates the graph to reflect the state of the branch as if it had been created
+        at the specified timestamp. Relationships are processed as follows:
 
-        rels_to_delete = []
-        rels_to_update = []
-        for result in query.get_results():
-            element_id = result.get("r").element_id
+        - Relationships with no `to` timestamp and `from` <= at: Updated to start from `at`
+        - Relationships with `to` < at: Deleted (ended before rebase point)
+        - Relationships with `to` >= at: Updated to start from `at`
 
-            conflict_status = result.get("r").get("conflict", None)
-            if conflict_status and conflict_status == "drop":
-                rels_to_delete.append(element_id)
-                continue
-
-            time_to_str = result.get("r").get("to", None)
-            time_from_str = result.get("r").get("from")
-            time_from = Timestamp(time_from_str)
-
-            if not time_to_str and time_from_str and time_from <= at:
-                rels_to_update.append(element_id)
-                continue
-
-            if not time_to_str and time_from_str and time_from > at:
-                rels_to_delete.append(element_id)
-                continue
-
-            time_to = Timestamp(time_to_str)
-            if time_to < at:
-                rels_to_delete.append(element_id)
-                continue
-
-            rels_to_update.append(element_id)
-
-        update_query = await RebaseBranchUpdateRelationshipQuery.init(db=db, ids=rels_to_update, at=at)
-        await update_query.execute(db=db)
-
-        delete_query = await RebaseBranchDeleteRelationshipQuery.init(db=db, ids=rels_to_delete, at=at)
-        await delete_query.execute(db=db)
+        Orphaned nodes (nodes with no remaining relationships) are also cleaned up.
+        """
+        query = await RebaseBranchQuery.init(db=db, branch=self, at=at)
+        await query.execute(db=db)
 
 
 registry.branch_object = Branch

infrahub/core/branch/tasks.py

@@ -170,7 +170,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
         migrations = []
         async with lock.registry.global_graph_lock():
             async with db.start_transaction() as dbt:
-                await obj.rebase(db=dbt)
+                await obj.rebase(db=dbt, user_id=context.account.account_id)
                 log.info("Branch successfully rebased")
 
             if obj.has_schema_changes:
@@ -187,7 +187,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
                 )
                 registry.schema.set_schema_branch(name=obj.name, schema=updated_schema)
                 obj.update_schema_hash()
-                await obj.save(db=db)
+                await obj.save(db=db, user_id=context.account.account_id)
 
                 # Execute the migrations
                 migrations = await merger.calculate_migrations(target_schema=updated_schema)
@@ -198,6 +198,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
                         new_schema=candidate_schema,
                         previous_schema=schema_in_main_before,
                         migrations=migrations,
+                        user_id=context.account.account_id,
                     )
                 )
                 for error in errors:
@@ -302,6 +303,7 @@ async def merge_branch(branch: str, context: InfrahubContext, proposed_change_id
                     new_schema=merger.destination_schema,
                     previous_schema=merger.initial_source_schema,
                     migrations=merger.migrations,
+                    user_id=context.account.account_id,
                 )
             )
             for error in errors:
@@ -431,7 +433,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
             new_schema = origin_schema.duplicate(name=obj.name)
             registry.schema.set_schema_branch(name=obj.name, schema=new_schema)
             obj.update_schema_hash()
-            await obj.save(db=db)
+            await obj.save(db=db, user_id=context.account.account_id)
 
             # Add Branch to registry
             registry.branch[obj.name] = obj