infrahub-server 1.6.3__py3-none-any.whl → 1.7.0b0__py3-none-any.whl

infrahub/core/migrations/graph/m050_backfill_vertex_metadata.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.query import Query, QueryType
+
+from ..shared import GraphMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+class BackfillAttributeMetadataQuery(Query):
+    """Backfill created_at and updated_at for Attribute vertices on default/global branches.
+
+    - created_at = from time of HAS_ATTRIBUTE edge
+    - updated_at = latest from or to time of any non-HAS_ATTRIBUTE edge
+    """
+
+    name = "backfill_attribute_metadata"
+    type: QueryType = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+        // Find all Attribute vertices on default/global branch without created_at
+        MATCH (:Node)-[ha:HAS_ATTRIBUTE {status: "active"}]->(attr:Attribute)
+        WHERE ha.branch_level = 1
+        AND attr.created_at IS NULL
+
+        // created_at = from time of HAS_ATTRIBUTE edge
+        WITH DISTINCT attr, ha.from AS created_at
+
+        // Find latest change time from all non-HAS_ATTRIBUTE edges (both from and to)
+        CALL (attr) {
+            MATCH (attr)-[e]->()
+            WHERE e.branch_level = 1
+            WITH e.from AS change_time
+            WHERE change_time IS NOT NULL
+            RETURN change_time
+            UNION ALL
+            MATCH (attr)-[e]->()
+            WHERE e.branch_level = 1
+            AND e.to IS NOT NULL
+            RETURN e.to AS change_time
+        }
+        WITH attr, created_at, max(change_time) AS updated_at
+
+        // Set metadata (use coalesce to fall back to created_at if no changes found)
+        CALL (attr, created_at, updated_at) {
+            SET attr.created_at = created_at
+            SET attr.updated_at = coalesce(updated_at, created_at)
+        } IN TRANSACTIONS
+        """
+        self.add_to_query(query)
+
+
+class BackfillRelationshipMetadataQuery(Query):
+    """Backfill created_at and updated_at for Relationship vertices on default/global branches.
+
+    - created_at = earliest from time of any IS_RELATED edge
+    - updated_at = latest from or to time of any non-IS_RELATED edge
+    """
+
+    name = "backfill_relationship_metadata"
+    type: QueryType = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+        // Find all Relationship vertices on default/global branch without created_at
+        MATCH (:Node)-[ir:IS_RELATED]-(rel:Relationship)
+        WHERE ir.branch_level = 1
+        AND rel.created_at IS NULL
+        WITH DISTINCT rel
+
+        // created_at = earliest IS_RELATED edge from time
+        CALL (rel) {
+            MATCH ()-[ir:IS_RELATED]-(rel)
+            WHERE ir.branch_level = 1
+            RETURN min(ir.from) AS created_at
+        }
+
+        // Find latest change time from all non-IS_RELATED edges (both from and to)
+        CALL (rel) {
+            MATCH (rel)-[e:!IS_RELATED]-()
+            WHERE e.branch_level = 1
+            WITH e.from AS change_time
+            WHERE change_time IS NOT NULL
+            RETURN change_time
+            UNION ALL
+            MATCH (rel)-[e:!IS_RELATED]-()
+            WHERE e.branch_level = 1
+            AND e.to IS NOT NULL
+            RETURN e.to AS change_time
+        }
+        WITH rel, created_at, max(change_time) AS updated_at
+
+        // Set metadata (use coalesce to fall back to created_at if no changes found)
+        CALL (rel, created_at, updated_at) {
+            SET rel.created_at = created_at
+            SET rel.updated_at = coalesce(updated_at, created_at)
+        } IN TRANSACTIONS
+        """
+        self.add_to_query(query)
+
+
+class BackfillNodeMetadataQuery(Query):
+    """Backfill created_at and updated_at for Node vertices on default/global branches.
+
+    - created_at = earliest from time of any IS_PART_OF edge for Nodes with this UUID
+    - updated_at = latest updated_at from any linked Attribute or Relationship
+
+    Must run after BackfillAttributeMetadataQuery and BackfillRelationshipMetadataQuery
+    since Node.updated_at depends on field updated_at values.
+    """
+
+    name = "backfill_node_metadata"
+    type: QueryType = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+        // Find all Node vertices on default/global branch without created_at
+        MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
+        WHERE e.branch_level = 1
+        AND n.created_at IS NULL
+        WITH DISTINCT n
+
+        // created_at = earliest IS_PART_OF edge from time for this UUID
+        // (handles migrated kind/namespace where multiple Node vertices share same UUID)
+        CALL (n) {
+            MATCH (:Node {uuid: n.uuid})-[ip:IS_PART_OF]->(:Root)
+            WHERE ip.branch_level = 1
+            RETURN min(ip.from) AS created_at
+        }
+
+        // updated_at = latest updated_at from any linked Attribute or Relationship
+        CALL (n) {
+            MATCH (n)-[:HAS_ATTRIBUTE|IS_RELATED]-(field:Attribute|Relationship)
+            WHERE field.updated_at IS NOT NULL
+            RETURN max(field.updated_at) AS latest_field_update
+        }
+
+        // Set metadata (use coalesce to fall back to created_at if no field updates found)
+        CALL (n, created_at, latest_field_update) {
+            SET n.created_at = created_at
+            SET n.updated_at = coalesce(latest_field_update, created_at)
+        } IN TRANSACTIONS
+        """
+        self.add_to_query(query)
+
+
+class Migration050(GraphMigration):
+    name: str = "050_backfill_vertex_metadata"
+    minimum_version: int = 49
+    queries: Sequence[type[Query]] = [
+        BackfillAttributeMetadataQuery,  # Run first
+        BackfillRelationshipMetadataQuery,  # Run second
+        BackfillNodeMetadataQuery,  # Run last (depends on Attr/Rel updated_at)
+    ]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        return await self.do_execute(db=db)

infrahub/core/migrations/query/attribute_add.py

@@ -47,15 +47,20 @@ class AttributeAddQuery(Query):
         else:
             self.params["attr_value"] = NULL_VALUE
 
+        self.params["user_id"] = self.user_id
+
         self.params["rel_props"] = {
             "branch": self.branch.name,
             "branch_level": self.branch.hierarchy_level,
             "status": RelationshipStatus.ACTIVE.value,
             "from": self.at.to_string(),
+            "from_user_id": self.user_id,
         }
 
         self.params["is_protected_default"] = False
-        self.params["is_visible_default"] = True
+
+        # Set metadata for vertex properties on default/global branch
+        self.params["set_metadata"] = self.branch.is_default or self.branch.is_global
 
         attr_value_label = GraphAttributeValueNode.get_default_label()
         if not is_large_attribute_type(self.attribute_kind):
@@ -84,8 +89,7 @@ class AttributeAddQuery(Query):
         query = """
         %(match_query)s
         MERGE (is_protected_value:Boolean { value: $is_protected_default })
-        MERGE (is_visible_value:Boolean { value: $is_visible_default })
-        WITH av, is_protected_value, is_visible_value
+        WITH av, is_protected_value
         MATCH (n:%(node_kinds_str)s)
         CALL (n) {
             MATCH (:Root)<-[r:IS_PART_OF]-(n)
@@ -98,16 +102,23 @@ class AttributeAddQuery(Query):
             ORDER BY has_attr_e.branch_level DESC, has_attr_e.from ASC, is_part_of_e.branch_level DESC, is_part_of_e.from ASC
             LIMIT 1
         }
-        WITH n, is_part_of_e, has_attr_e, av, is_protected_value, is_visible_value
+        WITH n, is_part_of_e, has_attr_e, av, is_protected_value
         WHERE is_part_of_e.status = "active" AND (has_attr_e IS NULL OR has_attr_e.status = "deleted")
         CREATE (a:Attribute { name: $attr_name, branch_support: $branch_support })
         CREATE (n)-[:HAS_ATTRIBUTE $rel_props ]->(a)
         CREATE (a)-[:HAS_VALUE $rel_props ]->(av)
         CREATE (a)-[:IS_PROTECTED $rel_props]->(is_protected_value)
-        CREATE (a)-[:IS_VISIBLE $rel_props]->(is_visible_value)
         %(uuid_generation)s
+        // Set metadata on Attribute and Node vertices if on default/global branch
+        WITH a, n, has_attr_e
+        CALL (a, n) {
+            WITH a, n
+            WHERE $set_metadata
+            SET a.created_at = $current_time, a.created_by = $user_id, a.updated_at = $current_time, a.updated_by = $user_id
+            SET n.updated_at = $current_time, n.updated_by = $user_id
+        }
         FOREACH (i in CASE WHEN has_attr_e.status = "deleted" THEN [1] ELSE [] END |
-            SET has_attr_e.to = $current_time
+            SET has_attr_e.to = $current_time, has_attr_e.to_user_id = $user_id
         )
         """ % {
             "match_query": match_query,

infrahub/core/migrations/query/attribute_remove.py

@@ -53,13 +53,19 @@ class AttributeRemoveQuery(Query):
         self.params["current_time"] = self.at.to_string()
         self.params["branch_name"] = self.branch.name
 
+        self.params["user_id"] = self.user_id
+
         self.params["rel_props"] = {
             "branch": self.branch.name,
             "branch_level": self.branch.hierarchy_level,
             "status": RelationshipStatus.DELETED.value,
             "from": self.at.to_string(),
+            "from_user_id": self.user_id,
         }
 
+        # Set metadata for vertex properties on default/global branch
+        self.params["set_metadata"] = self.branch.is_default or self.branch.is_global
+
         def render_sub_query_per_rel_type(rel_type: str, rel_def: FieldInfo) -> str:
             subquery = [
                 "WITH peer_node, rb, active_attr",
@@ -106,9 +112,9 @@ class AttributeRemoveQuery(Query):
         }
         WITH n1 as active_node, r1 as rb, attr1 as active_attr
         WHERE rb.status = "active"
-        WITH active_attr
+        WITH active_node, active_attr
         MATCH (active_attr)-[]-(peer)
-        WITH DISTINCT active_attr, peer
+        WITH DISTINCT active_node, active_attr, peer
         CALL (active_attr, peer) {
             MATCH (active_attr)-[r]-(peer)
             WHERE %(branch_filter)s
@@ -116,15 +122,23 @@ class AttributeRemoveQuery(Query):
             ORDER BY r.branch_level DESC, r.from DESC
             LIMIT 1
         }
-        WITH a1 as active_attr, r1 as rb, p1 as peer_node
+        WITH active_node, a1 as active_attr, r1 as rb, p1 as peer_node
         WHERE rb.status = "active"
         CALL (peer_node, rb, active_attr) {
             %(sub_query_all)s
         }
-        WITH p2 as peer_node, rb, active_attr
+        WITH p2 as peer_node, rb, active_node, active_attr
         FOREACH (i in CASE WHEN rb.branch = $branch_name THEN [1] ELSE [] END |
-            SET rb.to = $current_time
+            SET rb.to = $current_time, rb.to_user_id = $user_id
         )
+        // Set metadata on Attribute and Node vertices if on default/global branch
+        WITH active_attr, active_node
+        CALL (active_attr, active_node) {
+            WITH active_attr, active_node
+            WHERE $set_metadata
+            SET active_attr.updated_at = $current_time, active_attr.updated_by = $user_id
+            SET active_node.updated_at = $current_time, active_node.updated_by = $user_id
+        }
         RETURN DISTINCT active_attr
         """ % {
             "branch_filter": branch_filter,

infrahub/core/migrations/query/attribute_rename.py

@@ -32,7 +32,6 @@ class AttributeRenameQuery(Query):
     ) -> None:
         self.previous_attr = previous_attr
         self.new_attr = new_attr
-
         super().__init__(**kwargs)
 
     def render_match(self) -> str:
@@ -94,11 +93,14 @@ class AttributeRenameQuery(Query):
         self.params["current_time"] = self.at.to_string()
         self.params["branch_name"] = self.branch.name
 
+        self.params["user_id"] = self.user_id
+
         self.params["rel_props_create"] = {
             "branch": self.branch.name,
             "branch_level": self.branch.hierarchy_level,
             "status": RelationshipStatus.ACTIVE.value,
             "from": self.at.to_string(),
+            "from_user_id": self.user_id,
         }
 
         self.params["rel_props_delete"] = {
@@ -106,8 +108,12 @@ class AttributeRenameQuery(Query):
             "branch_level": self.branch.hierarchy_level,
             "status": RelationshipStatus.DELETED.value,
             "from": self.at.to_string(),
+            "from_user_id": self.user_id,
         }
 
+        # Set metadata for vertex properties on default/global branch
+        self.params["set_metadata"] = self.branch.is_default or self.branch.is_global
+
         sub_queries_create = [
             self._render_sub_query_per_rel_type_create_new(rel_type, rel_def)
             for rel_type, rel_def in GraphAttributeRelationships.model_fields.items()
@@ -145,8 +151,9 @@ class AttributeRenameQuery(Query):
         WHERE rb.status = "active"
         CREATE (new_attr:Attribute { name: $new_attr.name, branch_support: $new_attr.branch_support })
         %(add_uuid)s
-        WITH active_attr, new_attr
+        WITH active_node, active_attr, new_attr
         MATCH (active_attr)-[]-(peer)
+        WITH DISTINCT active_node, active_attr, new_attr, peer
         CALL (active_attr, peer) {
             MATCH (active_attr)-[r]-(peer)
             WHERE %(branch_filter)s
@@ -154,12 +161,12 @@ class AttributeRenameQuery(Query):
             ORDER BY r.branch_level DESC, r.from DESC
             LIMIT 1
         }
-        WITH a1 as active_attr, r1 as rb, p1 as peer_node, new_attr
+        WITH active_node, a1 as active_attr, r1 as rb, p1 as peer_node, new_attr
         WHERE rb.status = "active"
         CALL (peer_node, rb, active_attr, new_attr){
             %(sub_query_create_all)s
         }
-        WITH p2 as peer_node, rb, new_attr, active_attr
+        WITH p2 as peer_node, rb, new_attr, active_attr, active_node
         """ % {"branch_filter": branch_filter, "add_uuid": add_uuid, "sub_query_create_all": sub_query_create_all}
         self.add_to_query(query)
 
@@ -175,8 +182,17 @@ class AttributeRenameQuery(Query):
         else:
             query = """
             FOREACH (i in CASE WHEN rb.branch = $branch_name THEN [1] ELSE [] END |
-                SET rb.to = $current_time
+                SET rb.to = $current_time, rb.to_user_id = $user_id
             )
+            WITH new_attr, active_node
+            // Set metadata on new Attribute and Node vertices if on default/global branch
+            CALL (new_attr, active_node) {
+                WITH new_attr, active_node
+                WHERE $set_metadata
+                SET new_attr.created_at = $current_time, new_attr.created_by = $user_id
+                SET new_attr.updated_at = $current_time, new_attr.updated_by = $user_id
+                SET active_node.updated_at = $current_time, active_node.updated_by = $user_id
+            }
             RETURN DISTINCT new_attr
             """
             self.add_to_query(query)

infrahub/core/migrations/query/node_duplicate.py

@@ -40,7 +40,6 @@ class NodeDuplicateQuery(Query):
     ) -> None:
         self.previous_node = previous_node
         self.new_node = new_node
-
         super().__init__(**kwargs)
 
     def render_match(self) -> str:
@@ -140,16 +139,23 @@ class NodeDuplicateQuery(Query):
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["branch_support"] = self.new_node.branch_support
 
+        self.params["user_id"] = self.user_id
+
         self.params["rel_props_new"] = {
             "status": RelationshipStatus.ACTIVE.value,
             "from": self.at.to_string(),
+            "from_user_id": self.user_id,
         }
 
         self.params["rel_props_prev"] = {
             "status": RelationshipStatus.DELETED.value,
             "from": self.at.to_string(),
+            "from_user_id": self.user_id,
         }
 
+        # Set metadata for vertex properties on default/global branch
+        self.params["set_metadata"] = self.branch.is_default or self.branch.is_global
+
         sub_query_out, sub_query_out_args = self._render_sub_query_out()
         sub_query_in, sub_query_in_args = self._render_sub_query_in()
 
@@ -168,6 +174,16 @@ class NodeDuplicateQuery(Query):
         WHERE rb.status = "active"
         CREATE (new_node:Node:%(labels)s { uuid: active_node.uuid, kind: $new_node.kind, namespace: $new_node.namespace, branch_support: $new_node.branch_support })
         WITH active_node, new_node
+        // Set metadata on new Node vertex
+        CALL (active_node, new_node) {
+            // always pass created_by/at from active node
+            SET new_node.created_at = active_node.created_at, new_node.created_by = active_node.created_by
+            WITH new_node
+            // set updated_by/at if we're on the default/global branch
+            WHERE $set_metadata
+            SET new_node.updated_at = $current_time, new_node.updated_by = $user_id
+        }
+
         // Process Outbound Relationship
         MATCH (active_node)-[]->(peer)
         WITH DISTINCT active_node, new_node, peer
@@ -185,7 +201,7 @@ class NodeDuplicateQuery(Query):
         }
         WITH p2 as peer_node, rel_outband, active_node, new_node
         FOREACH (i in CASE WHEN rel_outband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
-            SET rel_outband.to = $current_time
+            SET rel_outband.to = $current_time, rel_outband.to_user_id = $user_id
         )
         WITH DISTINCT active_node, new_node
         // Process Inbound Relationship
@@ -205,9 +221,8 @@ class NodeDuplicateQuery(Query):
         }
         WITH p2 as peer_node, rel_inband, active_node, new_node
         FOREACH (i in CASE WHEN rel_inband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
-            SET rel_inband.to = $current_time
+            SET rel_inband.to = $current_time, rel_inband.to_user_id = $user_id
         )
-
         RETURN DISTINCT new_node
         """ % {
             "branch_filter": branch_filter,

infrahub/core/migrations/schema/attribute_kind_update.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Sequence
 
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.types import is_large_attribute_type
 
 from ..query import AttributeMigrationQuery, MigrationBaseQuery
@@ -26,6 +27,11 @@ class AttributeKindUpdateMigrationQuery(AttributeMigrationQuery):
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["at"] = self.at.to_string()
         self.params["attr_name"] = self.migration.previous_attribute_schema.name
+        self.params["user_id"] = self.user_id
+
+        # Set metadata for vertex properties on default/global branch
+        self.params["set_metadata"] = self.branch.is_default or self.branch.is_global
+
         new_attr_value_labels = "AttributeValue"
         if needs_index:
             new_attr_value_labels += ":AttributeValueIndexed"
@@ -34,7 +40,7 @@ class AttributeKindUpdateMigrationQuery(AttributeMigrationQuery):
 // ------------
 // start with all the Attribute vertices we might care about
 // ------------
-MATCH (n:%(schema_kinds)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
 WHERE attr.name = $attr_name
 WITH DISTINCT n, attr
 
@@ -70,7 +76,7 @@ CALL (av_is_default, av_value) {
 // ------------
 WITH 1 AS one
 LIMIT 1
-MATCH (n:%(schema_kinds)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
 WHERE attr.name = $attr_name
 WITH DISTINCT n, attr
 
@@ -88,6 +94,7 @@ CALL (n, attr) {
     RETURN has_value_e, av
 }
 
+
 // ------------
 // create and update the HAS_VALUE edges
 // ------------
@@ -108,6 +115,7 @@ CALL (attr, has_value_e, av) {
     SET new_has_value_e.branch = $branch
     SET new_has_value_e.branch_level = $branch_level
     SET new_has_value_e.from = $at
+    SET new_has_value_e.from_user_id = $user_id
     SET new_has_value_e.to = NULL
 
     // ------------
@@ -122,6 +130,7 @@ CALL (attr, has_value_e, av) {
     SET deleted_has_value_e.branch = $branch
     SET deleted_has_value_e.branch_level = $branch_level
     SET deleted_has_value_e.from = $at
+    SET deleted_has_value_e.from_user_id = $user_id
     SET deleted_has_value_e.to = NULL
 }
 
@@ -132,12 +141,20 @@ CALL (attr, has_value_e, av) {
 CALL (has_value_e) {
     WITH has_value_e
     WHERE has_value_e.branch = $branch
-    SET has_value_e.to = $at
+    SET has_value_e.to = $at, has_value_e.to_user_id = $user_id
+}
+
+// ------------
+// Set metadata on Attribute and Node vertices if on default/global branch
+// ------------
+CALL (attr, n) {
+    WITH attr, n
+    WHERE $set_metadata
+    SET attr.updated_at = $at, attr.updated_by = $user_id
+    SET n.updated_at = $at, n.updated_by = $user_id
 }
         """ % {
-            "schema_kinds": (
-                f"{self.migration.previous_schema.kind}|Profile{self.migration.previous_schema.kind}|Template{self.migration.previous_schema.kind}"
-            ),
+            "schema_kind": self.migration.previous_schema.kind,
             "branch_filter": branch_filter,
             "new_attr_value_labels": new_attr_value_labels,
         }
@@ -154,10 +171,11 @@ class AttributeKindUpdateMigration(AttributeSchemaMigration):
         branch: Branch,
         at: Timestamp | str | None = None,
         queries: Sequence[type[MigrationBaseQuery]] | None = None,
+        user_id: str = SYSTEM_USER_ID,
     ) -> MigrationResult:
         is_indexed_previous = is_large_attribute_type(self.previous_attribute_schema.kind)
         is_indexed_new = is_large_attribute_type(self.new_attribute_schema.kind)
         if is_indexed_previous is is_indexed_new:
             return MigrationResult()
 
-        return await super().execute(db=db, branch=branch, at=at, queries=queries)
+        return await super().execute(db=db, branch=branch, at=at, queries=queries, user_id=user_id)

infrahub/core/migrations/schema/attribute_supports_profile.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Sequence
 
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.migrations.query.attribute_remove import AttributeRemoveQuery
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.node_schema import NodeSchema
@@ -73,6 +74,7 @@ class AttributeSupportsProfileUpdateMigration(AttributeSchemaMigration):
         branch: Branch,
         at: Timestamp | str | None = None,
         queries: Sequence[type[MigrationBaseQuery]] | None = None,  # noqa: ARG002
+        user_id: str = SYSTEM_USER_ID,
     ) -> MigrationResult:
         if (
             # no change in whether the attribute should be used on profiles
@@ -87,4 +89,4 @@ class AttributeSupportsProfileUpdateMigration(AttributeSchemaMigration):
         if not self.new_attribute_schema.support_profiles:
             profiles_queries.append(ProfilesAttributeRemoveMigrationQuery)
 
-        return await super().execute(db=db, branch=branch, at=at, queries=profiles_queries)
+        return await super().execute(db=db, branch=branch, at=at, queries=profiles_queries, user_id=user_id)

infrahub/core/migrations/schema/models.py

@@ -3,6 +3,7 @@ from typing import Any
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_serializer
 
 from infrahub.core.branch import Branch
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.models import SchemaUpdateMigrationInfo
 from infrahub.core.path import SchemaPath
 from infrahub.core.schema.schema_branch import SchemaBranch
@@ -15,6 +16,7 @@ class SchemaApplyMigrationData(BaseModel):
     new_schema: SchemaBranch
     previous_schema: SchemaBranch
     migrations: list[SchemaUpdateMigrationInfo]
+    user_id: str = SYSTEM_USER_ID
 
     @model_serializer()
     def serialize_model(self) -> dict[str, Any]:
@@ -23,6 +25,7 @@ class SchemaApplyMigrationData(BaseModel):
             "previous_schema": self.previous_schema.to_dict_schema_object(),
             "new_schema": self.new_schema.to_dict_schema_object(),
             "migrations": [migration.model_dump() for migration in self.migrations],
+            "user_id": self.user_id,
         }
 
     @field_validator("new_schema", "previous_schema", mode="before")

infrahub/core/migrations/schema/node_attribute_add.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Sequence
 
 from infrahub.core import registry
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.node import Node
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.node_schema import NodeSchema
@@ -65,10 +66,11 @@ class NodeAttributeAddMigration(AttributeSchemaMigration):
         branch: Branch,
         at: Timestamp | str | None = None,
         queries: Sequence[type[MigrationBaseQuery]] | None = None,
+        user_id: str = SYSTEM_USER_ID,
     ) -> MigrationResult:
         if self.new_attribute_schema.inherited is True:
             return MigrationResult()
-        return await super().execute(db=db, branch=branch, at=at, queries=queries)
+        return await super().execute(db=db, branch=branch, at=at, queries=queries, user_id=user_id)
 
     async def execute_post_queries(
         self,
@@ -76,6 +78,7 @@ class NodeAttributeAddMigration(AttributeSchemaMigration):
         result: MigrationResult,
         branch: Branch,
         at: Timestamp,  # noqa: ARG002
+        user_id: str,  # noqa: ARG002
     ) -> MigrationResult:
         if self.new_attribute_schema.kind != "NumberPool":
             return result

infrahub/core/migrations/schema/node_remove.py

@@ -51,12 +51,17 @@ class NodeRemoveMigrationBaseQuery(MigrationQuery):
         self.params["branch_name"] = self.branch.name
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
+        self.params["user_id"] = self.user_id
 
         self.params["rel_props"] = {
             "status": RelationshipStatus.DELETED.value,
             "from": self.at.to_string(),
+            "from_user_id": self.user_id,
         }
 
+        # Set metadata for vertex properties on default/global branch
+        self.params["set_metadata"] = self.branch.is_default or self.branch.is_global
+
         node_remove_query = self.render_node_remove_query(branch_filter=branch_filter)
 
         query = """
@@ -72,6 +77,13 @@ class NodeRemoveMigrationBaseQuery(MigrationQuery):
         WITH n1 as active_node, r1 as rb
         WHERE rb.status = "active"
         %(node_remove_query)s
+        WITH active_node
+        // Set metadata on Node vertex if on default/global branch
+        CALL (active_node) {
+            WITH active_node
+            WHERE $set_metadata
+            SET active_node.updated_at = $current_time, active_node.updated_by = $user_id
+        }
         RETURN DISTINCT active_node
         """ % {
             "branch_filter": branch_filter,
@@ -103,12 +115,17 @@ class NodeRemoveMigrationQueryIn(NodeRemoveMigrationBaseQuery):
         }
         WITH n1 as active_node, rel_inband1 as rel_inband, p1 as peer_node
         WHERE rel_inband.status = "active"
+        CALL (peer_node) {
+            WITH peer_node
+            WHERE $set_metadata
+            SET peer_node.updated_at = $current_time, peer_node.updated_by = $user_id
+        }
         CALL (%(sub_query_args)s) {
             %(sub_query)s
         }
         WITH p2 as peer_node, rel_inband, active_node
         FOREACH (i in CASE WHEN rel_inband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
-            SET rel_inband.to = $current_time
+            SET rel_inband.to = $current_time, rel_inband.to_user_id = $user_id
         )
         """ % {"sub_query": sub_query, "sub_query_args": sub_query_args, "branch_filter": branch_filter}
         return query
@@ -150,11 +167,16 @@ class NodeRemoveMigrationQueryOut(NodeRemoveMigrationBaseQuery):
         }
         WITH n1 as active_node, rel_outband1 as rel_outband, p1 as peer_node
         WHERE rel_outband.status = "active"
+        CALL (peer_node) {
+            WITH peer_node
+            WHERE $set_metadata
+            SET peer_node.updated_at = $current_time, peer_node.updated_by = $user_id
+        }
         CALL (%(sub_query_args)s) {
             %(sub_query)s
         }
         FOREACH (i in CASE WHEN rel_outband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
-            SET rel_outband.to = $current_time
+            SET rel_outband.to = $current_time, rel_outband.to_user_id = $user_id
         )
         """ % {"sub_query": sub_query, "sub_query_args": sub_query_args, "branch_filter": branch_filter}