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

infrahub/core/migrations/graph/m025_uniqueness_nulls.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Sequence
 
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.migrations.shared import MigrationResult
 from infrahub.log import get_logger
 
@@ -22,5 +23,5 @@ class Migration025(InternalSchemaMigration):
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
         return MigrationResult()
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/graph/m026_0000_prefix_fix.py

@@ -4,6 +4,7 @@ import ipaddress
 from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core.branch.models import Branch
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.initialization import initialization
 from infrahub.core.ipam.reconciler import IpamReconciler
 from infrahub.core.manager import NodeManager
@@ -28,7 +29,7 @@ class Migration026(InternalSchemaMigration):
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
         return MigrationResult()
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         # load schemas from database into registry
         initialize_lock()
         await initialization(db=db)

infrahub/core/migrations/graph/m029_duplicates_cleanup.py

@@ -631,7 +631,6 @@ class Migration029(ArbitraryMigration):
                     offset=offset,
                     outbound_edge_types=[
                         DatabaseEdgeType.IS_RELATED,
-                        DatabaseEdgeType.IS_VISIBLE,
                         DatabaseEdgeType.IS_PROTECTED,
                         DatabaseEdgeType.HAS_OWNER,
                         DatabaseEdgeType.HAS_SOURCE,

infrahub/core/migrations/graph/m031_check_number_attributes.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Sequence
 from infrahub import config
 from infrahub.core import registry
 from infrahub.core.branch import Branch
-from infrahub.core.constants import SchemaPathType
+from infrahub.core.constants import SYSTEM_USER_ID, SchemaPathType
 from infrahub.core.initialization import initialization
 from infrahub.core.migrations.shared import InternalSchemaMigration, MigrationResult, SchemaMigration
 from infrahub.core.path import SchemaPath
@@ -35,7 +35,7 @@ class Migration031(InternalSchemaMigration):
     minimum_version: int = 30
     migrations: Sequence[SchemaMigration] = []
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         """Retrieve all number attributes that have a min/max/excluded_values
         For any of these attributes, check if corresponding existing nodes are valid."""
 

infrahub/core/migrations/graph/m038_redo_0000_prefix_fix.py

@@ -4,6 +4,7 @@ import ipaddress
 from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core.branch.models import Branch
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.initialization import initialization
 from infrahub.core.ipam.reconciler import IpamReconciler
 from infrahub.core.manager import NodeManager
@@ -37,7 +38,7 @@ class Migration038(InternalSchemaMigration):
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
         return MigrationResult()
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         # load schemas from database into registry
         initialize_lock()
         await initialization(db=db)

infrahub/core/migrations/graph/m041_deleted_dup_edges.py

@@ -73,7 +73,7 @@ class DeleteDuplicatedRelationshipEdges(Query):
     type = QueryType.WRITE
     insert_return = False
 
-    def __init__(self, migrated_kind_nodes_only: bool = True, **kwargs: Any):
+    def __init__(self, migrated_kind_nodes_only: bool = True, **kwargs: Any) -> None:
         self.migrated_kind_nodes_only = migrated_kind_nodes_only
         super().__init__(**kwargs)
 

infrahub/core/migrations/graph/m049_remove_is_visible_relationship.py

@@ -0,0 +1,53 @@
+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 RemoveIsVisibleRelationshipQuery(Query):
+    name = "remove_is_visible_relationship"
+    type: QueryType = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+        MATCH ()-[rel:IS_VISIBLE]->()
+        CALL (rel) {
+          DELETE rel
+        } IN TRANSACTIONS
+        """
+        self.add_to_query(query)
+
+
+class RemoveIsVisibleFromDiffsQuery(Query):
+    name = "remove_is_visible_from_diffs"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        query = """
+        MATCH (diff_prop:DiffProperty {property_type: "IS_VISIBLE"})
+        CALL (diff_prop) {
+            DETACH DELETE diff_prop
+        } IN TRANSACTIONS
+        """
+        self.add_to_query(query)
+
+
+class Migration049(GraphMigration):
+    name: str = "049_remove_is_visible_relationship"
+    minimum_version: int = 48
+    queries: Sequence[type[Query]] = [RemoveIsVisibleRelationshipQuery, RemoveIsVisibleFromDiffsQuery]
+
+    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/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/__init__.py

@@ -20,7 +20,7 @@ class MigrationQuery(MigrationBaseQuery):
         self,
         migration: SchemaMigration,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.migration = migration
         super().__init__(**kwargs)
 
@@ -32,6 +32,6 @@ class AttributeMigrationQuery(MigrationBaseQuery):
         self,
         migration: AttributeSchemaMigration,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.migration = migration
         super().__init__(**kwargs)

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/query/schema_attribute_update.py

@@ -24,7 +24,7 @@ class SchemaAttributeUpdateQuery(Query):
         new_value: Any,
         previous_value: Any | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.attr_name = attribute_name
         self.node_name = node_name
         self.node_namespace = node_namespace

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"
@@ -108,6 +114,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 +129,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,7 +140,17 @@ 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": (
@@ -154,10 +172,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)