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

infrahub/core/query/node.py

@@ -8,6 +8,8 @@ from dataclasses import field as dataclass_field
 from enum import Enum
 from typing import TYPE_CHECKING, Any, AsyncIterator, Generator
 
+import ujson
+
 from infrahub import config
 from infrahub.core import registry
 from infrahub.core.constants import (
@@ -15,6 +17,7 @@ from infrahub.core.constants import (
     PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
     PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
     AttributeDBNodeType,
+    MetadataOptions,
     RelationshipDirection,
     RelationshipHierarchyDirection,
 )
@@ -22,6 +25,7 @@ from infrahub.core.query import Query, QueryResult, QueryType
 from infrahub.core.query.subquery import build_subquery_filter, build_subquery_order
 from infrahub.core.query.utils import find_node_schema
 from infrahub.core.schema.attribute_schema import AttributeSchema
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.utils import build_regex_attrs, extract_field_filters
 from infrahub.exceptions import QueryError
 from infrahub.graphql.models import OrderModel
@@ -44,14 +48,15 @@ if TYPE_CHECKING:
 class NodeToProcess:
     schema: NodeSchema | ProfileSchema | TemplateSchema | None
 
+    labels: list[str]
     node_id: str
     node_uuid: str
-
-    updated_at: str
-
     branch: str
 
-    labels: list[str]
+    created_at: Timestamp | None = None
+    created_by: str | None = None
+    updated_at: Timestamp | None = None
+    updated_by: str | None = None
 
 
 @dataclass
@@ -74,13 +79,16 @@ class AttributeFromDB:
     value: Any
     content: Any
 
-    updated_at: str
-
     branch: str
 
     is_default: bool
     is_from_profile: bool = dataclass_field(default=False)
 
+    updated_at: Timestamp | None = None
+    updated_by: str | None = None
+    created_at: Timestamp | None = None
+    created_by: str | None = None
+
     node_properties: dict[str, AttributeNodePropertyFromDB] = dataclass_field(default_factory=dict)
     flag_properties: dict[str, bool] = dataclass_field(default_factory=dict)
 
@@ -108,8 +116,6 @@ class NodeQuery(Query):
         branch: Branch | None = None,
         **kwargs,
     ) -> None:
-        # TODO Validate that Node is a valid node
-        # Eventually extract the branch from Node as well
         self.node = node
         self.node_id = node_id or id
         self.node_db_id = node_db_id
@@ -133,6 +139,7 @@ class NodeCreateAllQuery(NodeQuery):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002, PLR0915
         at = self.at or self.node._at
+        self.params["user_id"] = self.user_id
         self.params["uuid"] = self.node.id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
@@ -188,7 +195,7 @@ class NodeCreateAllQuery(NodeQuery):
                         pass
                     except ValueError:
                         # Relationship has not been initialized yet, it means the peer does not exist in db yet
-                        # typically because it will be allocated from a ressource pool. In that case, the peer
+                        # typically because it will be allocated from a resource pool. In that case, the peer
                         # will be fetched using `rel.resolve` later.
                         pass
 
@@ -220,14 +227,40 @@ class NodeCreateAllQuery(NodeQuery):
             "namespace": self.node._schema.namespace,
             "branch_support": self.node._schema.branch,
         }
+        if self.branch.is_default or self.branch.is_global:
+            self.params["node_prop"].update(
+                {
+                    "created_at": at.to_string(),
+                    "created_by": self.user_id,
+                    "updated_at": at.to_string(),
+                    "updated_by": self.user_id,
+                }
+            )
         self.params["node_branch_prop"] = {
             "branch": self.branch.name,
             "branch_level": self.branch.hierarchy_level,
             "status": "active",
             "from": at.to_string(),
+            "from_user_id": self.user_id,
         }
 
-        rel_prop_str = "{ branch: rel.branch, branch_level: rel.branch_level, status: rel.status, hierarchy: rel.hierarchical, from: $at }"
+        # set all the property strings that we reuse
+        # include the create/updated_at/by metadata if on default or global branch
+        attr_edge_prop_str = "{ branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at, from_user_id: $user_id }"
+        attr_vertex_prop_str = "{ uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support"
+        if self.branch.is_default or self.branch.is_global:
+            attr_vertex_prop_str += ", created_at: $at, created_by: $user_id, updated_at: $at, updated_by: $user_id"
+        attr_vertex_prop_str += " }"
+
+        rel_edge_prop_str = "{ branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at, from_user_id: $user_id }"
+        rel_edge_prop_str_hierarchy = (
+            "{ branch: rel.branch, branch_level: rel.branch_level, "
+            "status: rel.status, hierarchy: rel.hierarchical, from: $at, from_user_id: $user_id }"
+        )
+        rel_vertex_prop_str = "{ uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support"
+        if self.branch.is_default or self.branch.is_global:
+            rel_vertex_prop_str += ", created_at: $at, created_by: $user_id, updated_at: $at, updated_by: $user_id"
+        rel_vertex_prop_str += " }"
 
         iphost_prop = {
             "value": "attr.content.value",
@@ -270,102 +303,102 @@ class NodeCreateAllQuery(NodeQuery):
             LIMIT 1
         }
         CALL (n, attr, av) {
-            CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
-            CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
-            CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
+            CREATE (a:Attribute %(attr_vertex)s)
+            CREATE (n)-[:HAS_ATTRIBUTE %(attr_edge)s]->(a)
+            CREATE (a)-[:HAS_VALUE %(attr_edge)s]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
-            MERGE (iv:Boolean { value: attr.is_visible })
-            WITH a, ip, iv
+            WITH a, ip
             LIMIT 1
-            CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
-            CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
+            CREATE (a)-[:IS_PROTECTED %(attr_edge)s]->(ip)
             FOREACH ( prop IN attr.source_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_SOURCE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_SOURCE %(attr_edge)s]->(peer)
             )
             FOREACH ( prop IN attr.owner_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_OWNER %(attr_edge)s]->(peer)
             )
-        }"""
+        }""" % {"attr_edge": attr_edge_prop_str, "attr_vertex": attr_vertex_prop_str}
 
         attrs_indexed_query = """
         WITH distinct n
         UNWIND $attrs_indexed AS attr
         CALL (n, attr) {
-            CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
-            CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
+            CREATE (a:Attribute %(attr_vertex)s)
+            CREATE (n)-[:HAS_ATTRIBUTE %(attr_edge)s]->(a)
             MERGE (av:AttributeValue:AttributeValueIndexed { value: attr.content.value, is_default: attr.content.is_default })
             WITH av, a
             LIMIT 1
-            CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
+            CREATE (a)-[:HAS_VALUE %(attr_edge)s]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
-            MERGE (iv:Boolean { value: attr.is_visible })
-            CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
-            CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
+            CREATE (a)-[:IS_PROTECTED %(attr_edge)s]->(ip)
             FOREACH ( prop IN attr.source_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_SOURCE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_SOURCE %(attr_edge)s]->(peer)
             )
             FOREACH ( prop IN attr.owner_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_OWNER %(attr_edge)s]->(peer)
             )
-        }"""
+        }""" % {"attr_edge": attr_edge_prop_str, "attr_vertex": attr_vertex_prop_str}
 
         attrs_iphost_query = """
         WITH distinct n
         UNWIND $attrs_iphost AS attr
         CALL (n, attr) {
-            CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
-            CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
+            CREATE (a:Attribute %(attr_vertex)s)
+            CREATE (n)-[:HAS_ATTRIBUTE %(attr_edge)s]->(a)
             MERGE (av:AttributeValue:AttributeValueIndexed:AttributeIPHost { %(iphost_prop)s })
             WITH attr, av, a
             LIMIT 1
-            CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
+            CREATE (a)-[:HAS_VALUE %(attr_edge)s]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
-            MERGE (iv:Boolean { value: attr.is_visible })
-            WITH a, ip, iv
+            WITH a, ip
             LIMIT 1
-            CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
-            CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
+            CREATE (a)-[:IS_PROTECTED %(attr_edge)s]->(ip)
             FOREACH ( prop IN attr.source_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_SOURCE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_SOURCE %(attr_edge)s]->(peer)
             )
             FOREACH ( prop IN attr.owner_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_OWNER %(attr_edge)s]->(peer)
             )
         }
-        """ % {"iphost_prop": ", ".join(iphost_prop_list)}
+        """ % {
+            "iphost_prop": ", ".join(iphost_prop_list),
+            "attr_edge": attr_edge_prop_str,
+            "attr_vertex": attr_vertex_prop_str,
+        }
 
         attrs_ipnetwork_query = """
         WITH distinct n
         UNWIND $attrs_ipnetwork AS attr
         CALL (n, attr) {
-            CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
-            CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
+            CREATE (a:Attribute %(attr_vertex)s)
+            CREATE (n)-[:HAS_ATTRIBUTE %(attr_edge)s]->(a)
             MERGE (av:AttributeValue:AttributeValueIndexed:AttributeIPNetwork { %(ipnetwork_prop)s })
             WITH attr, av, a
             LIMIT 1
-            CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
+            CREATE (a)-[:HAS_VALUE %(attr_edge)s]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
-            MERGE (iv:Boolean { value: attr.is_visible })
-            WITH a, ip, iv
+            WITH a, ip
             LIMIT 1
-            CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
-            CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
+            CREATE (a)-[:IS_PROTECTED %(attr_edge)s]->(ip)
             FOREACH ( prop IN attr.source_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_SOURCE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_SOURCE %(attr_edge)s]->(peer)
             )
             FOREACH ( prop IN attr.owner_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+                CREATE (a)-[:HAS_OWNER %(attr_edge)s]->(peer)
             )
         }
-        """ % {"ipnetwork_prop": ", ".join(ipnetwork_prop_list)}
+        """ % {
+            "ipnetwork_prop": ", ".join(ipnetwork_prop_list),
+            "attr_edge": attr_edge_prop_str,
+            "attr_vertex": attr_vertex_prop_str,
+        }
 
         deepest_branch = await registry.get_branch(db=db, branch=deepest_branch_name)
         branch_filter, branch_params = deepest_branch.get_query_filter_path(at=self.at)
@@ -409,75 +442,84 @@ class NodeCreateAllQuery(NodeQuery):
         UNWIND $rels_bidir AS rel
         %(dest_node_subquery)s
         CALL (n, rel, dest_node) {
-            CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
-            CREATE (n)-[:IS_RELATED %(rel_prop)s ]->(rl)
-            CREATE (dest_node)-[:IS_RELATED %(rel_prop)s ]->(rl)
+            CREATE (rl:Relationship %(rel_vertex)s)
+            CREATE (n)-[:IS_RELATED %(rel_edge_hierarchy)s ]->(rl)
+            CREATE (dest_node)-[:IS_RELATED %(rel_edge_hierarchy)s ]->(rl)
             MERGE (ip:Boolean { value: rel.is_protected })
-            MERGE (iv:Boolean { value: rel.is_visible })
-            WITH rl, ip, iv
+            WITH rl, ip
             LIMIT 1
-            CREATE (rl)-[:IS_PROTECTED { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(ip)
-            CREATE (rl)-[:IS_VISIBLE { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(iv)
+            CREATE (rl)-[:IS_PROTECTED %(rel_edge)s]->(ip)
             FOREACH ( prop IN rel.source_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (rl)-[:HAS_SOURCE { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
+                CREATE (rl)-[:HAS_SOURCE %(rel_edge)s]->(peer)
             )
             FOREACH ( prop IN rel.owner_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (rl)-[:HAS_OWNER { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
+                CREATE (rl)-[:HAS_OWNER %(rel_edge)s]->(peer)
             )
         }
-        """ % {"rel_prop": rel_prop_str, "dest_node_subquery": dest_node_subquery}
+        """ % {
+            "rel_edge": rel_edge_prop_str,
+            "rel_edge_hierarchy": rel_edge_prop_str_hierarchy,
+            "rel_vertex": rel_vertex_prop_str,
+            "dest_node_subquery": dest_node_subquery,
+        }
 
         rels_out_query = """
         WITH distinct n
         UNWIND $rels_out AS rel
         %(dest_node_subquery)s
         CALL (n, rel, dest_node) {
-            CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
-            CREATE (n)-[:IS_RELATED %(rel_prop)s ]->(rl)
-            CREATE (dest_node)<-[:IS_RELATED %(rel_prop)s ]-(rl)
+            CREATE (rl:Relationship %(rel_vertex)s)
+            CREATE (n)-[:IS_RELATED %(rel_edge_hierarchy)s ]->(rl)
+            CREATE (dest_node)<-[:IS_RELATED %(rel_edge_hierarchy)s ]-(rl)
             MERGE (ip:Boolean { value: rel.is_protected })
-            MERGE (iv:Boolean { value: rel.is_visible })
-            WITH rl, ip, iv
+            WITH rl, ip
             LIMIT 1
-            CREATE (rl)-[:IS_PROTECTED { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(ip)
-            CREATE (rl)-[:IS_VISIBLE { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(iv)
+            CREATE (rl)-[:IS_PROTECTED %(rel_edge)s]->(ip)
             FOREACH ( prop IN rel.source_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (rl)-[:HAS_SOURCE { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
+                CREATE (rl)-[:HAS_SOURCE %(rel_edge)s]->(peer)
             )
             FOREACH ( prop IN rel.owner_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (rl)-[:HAS_OWNER { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
+                CREATE (rl)-[:HAS_OWNER %(rel_edge)s]->(peer)
             )
         }
-        """ % {"rel_prop": rel_prop_str, "dest_node_subquery": dest_node_subquery}
+        """ % {
+            "rel_edge": rel_edge_prop_str,
+            "rel_edge_hierarchy": rel_edge_prop_str_hierarchy,
+            "rel_vertex": rel_vertex_prop_str,
+            "dest_node_subquery": dest_node_subquery,
+        }
 
         rels_in_query = """
         WITH distinct n
         UNWIND $rels_in AS rel
         %(dest_node_subquery)s
         CALL (n, rel, dest_node) {
-            CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
-            CREATE (n)<-[:IS_RELATED %(rel_prop)s ]-(rl)
-            CREATE (dest_node)-[:IS_RELATED %(rel_prop)s ]->(rl)
+            CREATE (rl:Relationship %(rel_vertex)s)
+            CREATE (n)<-[:IS_RELATED %(rel_edge_hierarchy)s ]-(rl)
+            CREATE (dest_node)-[:IS_RELATED %(rel_edge_hierarchy)s ]->(rl)
             MERGE (ip:Boolean { value: rel.is_protected })
-            MERGE (iv:Boolean { value: rel.is_visible })
-            WITH rl, ip, iv
+            WITH rl, ip
             LIMIT 1
-            CREATE (rl)-[:IS_PROTECTED { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(ip)
-            CREATE (rl)-[:IS_VISIBLE { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(iv)
+            CREATE (rl)-[:IS_PROTECTED %(rel_edge)s]->(ip)
             FOREACH ( prop IN rel.source_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (rl)-[:HAS_SOURCE { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
+                CREATE (rl)-[:HAS_SOURCE %(rel_edge)s]->(peer)
             )
             FOREACH ( prop IN rel.owner_prop |
                 MERGE (peer:Node { uuid: prop.peer_id })
-                CREATE (rl)-[:HAS_OWNER { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
+                CREATE (rl)-[:HAS_OWNER %(rel_edge)s]->(peer)
             )
         }
-        """ % {"rel_prop": rel_prop_str, "dest_node_subquery": dest_node_subquery}
+        """ % {
+            "rel_edge": rel_edge_prop_str,
+            "rel_edge_hierarchy": rel_edge_prop_str_hierarchy,
+            "rel_vertex": rel_vertex_prop_str,
+            "dest_node_subquery": dest_node_subquery,
+        }
 
         query = f"""
         MATCH (root:Root)
@@ -526,48 +568,83 @@ class NodeCreateAllQuery(NodeQuery):
 
 class NodeDeleteQuery(NodeQuery):
     name = "node_delete"
-
     type: QueryType = QueryType.WRITE
-
-    raise_error_if_empty: bool = True
+    insert_return = False
+    raise_error_if_empty = False
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
+        self.params["user_id"] = self.user_id
         self.params["uuid"] = self.node_id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
+        self.params["at"] = self.at.to_string()
 
         if self.branch.is_global or self.branch.is_default:
+            # update the updated_at/by metadata on the Node if we're on the global or default branch
             node_query_match = """
-            MATCH (n:Node { uuid: $uuid })
-            OPTIONAL MATCH (n)-[delete_edge:IS_PART_OF {status: "deleted", branch: $branch}]->(:Root)
-            WHERE delete_edge.from <= $at
-            WITH n WHERE delete_edge IS NULL
+MATCH (n:Node { uuid: $uuid })-[r:IS_PART_OF { branch_level: 1, status: "active" }]->(:Root)
+WHERE r.to IS NULL
+OPTIONAL MATCH (n)-[delete_edge:IS_PART_OF {status: "deleted", branch: $branch}]->(:Root)
+WHERE delete_edge.from <= $at
+WITH n, r
+WHERE delete_edge IS NULL
+SET n.updated_at = $at, n.updated_by = $user_id
+WITH n, r
             """
         else:
             node_filter, node_filter_params = self.branch.get_query_filter_path(at=self.at, variable_name="r")
             node_query_match = """
-                MATCH (n:Node { uuid: $uuid })
-                CALL (n) {
-                    MATCH (n)-[r:IS_PART_OF]->(:Root)
-                    WHERE %(node_filter)s
-                    RETURN r.status = "active" AS is_active
-                    ORDER BY r.from DESC
-                    LIMIT 1
-                }
-                WITH n WHERE is_active = TRUE
+MATCH (n:Node { uuid: $uuid })
+CALL (n) {
+    MATCH (n)-[r:IS_PART_OF]->(:Root)
+    WHERE %(node_filter)s
+    RETURN r
+    ORDER BY r.from DESC
+    LIMIT 1
+}
+WITH n, r
+WHERE r.status = "active"
                 """ % {"node_filter": node_filter}
             self.params.update(node_filter_params)
         self.add_to_query(node_query_match)
 
+        # set the to time/user_id if the active IS_PART_OF edge is on this branch
         query = """
-        MATCH (root:Root)
-        CREATE (n)-[r:IS_PART_OF { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at }]->(root)
+MATCH (root:Root)
+LIMIT 1
+CREATE (n)-[delete_edge:IS_PART_OF { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at, from_user_id: $user_id }]->(root)
+WITH r
+WHERE r.branch = $branch
+SET r.to = $at
+SET r.to_user_id = $user_id
         """
+        self.add_to_query(query)
 
+
+class NodeUpdateMetadataQuery(NodeQuery):
+    name = "node_update_metadata"
+    type: QueryType = QueryType.WRITE
+    insert_return = False
+    raise_error_if_empty = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
+        if not self.branch.is_default and not self.branch.is_global:
+            raise ValueError("NodeUpdateMetadataQuery can only be used on the default or global branch")
+        self.params["uuid"] = self.node_id
+        self.params["branch"] = self.branch.name
         self.params["at"] = self.at.to_string()
+        self.params["user_id"] = self.user_id
 
+        query = """
+MATCH (n:Node { uuid: $uuid })-[r:IS_PART_OF { branch_level: 1, status: "active" }]->(:Root)
+WHERE r.to IS NULL
+OPTIONAL MATCH (n)-[delete_edge:IS_PART_OF {status: "deleted", branch: $branch}]->(:Root)
+WHERE delete_edge.from <= $at
+WITH n, r
+WHERE delete_edge IS NULL
+SET n.updated_at = $at, n.updated_by = $user_id
+        """
         self.add_to_query(query)
-        self.return_labels = ["n"]
 
 
 class NodeCheckIDQuery(Query):
@@ -603,30 +680,140 @@ class NodeListGetAttributeQuery(Query):
         "HAS_OWNER": ("rel_owner", "owner"),
         "HAS_SOURCE": ("rel_source", "source"),
         "IS_PROTECTED": ("rel_isp", "isp"),
-        "IS_VISIBLE": ("rel_isv", "isv"),
     }
 
     def __init__(
         self,
         ids: list[str],
         fields: dict | None = None,
-        include_source: bool = False,
-        include_owner: bool = False,
-        account=None,
+        include_metadata: MetadataOptions = MetadataOptions.NONE,
         **kwargs,
     ):
-        self.account = account
         self.ids = ids
         self.fields = fields
-        self.include_source = include_source
-        self.include_owner = include_owner
-
+        self.include_metadata = include_metadata
         super().__init__(order_by=["n.uuid", "a.name"], **kwargs)
 
+    @property
+    def _include_source(self) -> bool:
+        return bool(self.include_metadata & MetadataOptions.SOURCE)
+
+    @property
+    def _include_owner(self) -> bool:
+        return bool(self.include_metadata & MetadataOptions.OWNER)
+
+    @property
+    def _include_updated_metadata(self) -> bool:
+        return bool(self.include_metadata & (MetadataOptions.UPDATED_AT | MetadataOptions.UPDATED_BY))
+
+    @property
+    def _include_created_metadata(self) -> bool:
+        return bool(self.include_metadata & (MetadataOptions.CREATED_AT | MetadataOptions.CREATED_BY))
+
+    def _add_source_to_query(self, branch_filter_str: str) -> None:
+        if not self._include_source:
+            return
+        source_query = """
+CALL (a) {
+    OPTIONAL MATCH (a)-[rel_source:HAS_SOURCE]-(source)
+    WHERE all(r IN [rel_source] WHERE ( %(branch_filter)s ))
+    RETURN source, rel_source
+    ORDER BY rel_source.branch_level DESC, rel_source.from DESC, rel_source.status ASC
+    LIMIT 1
+}
+WITH *,
+    CASE WHEN rel_source.status = "active" THEN source ELSE NULL END AS source,
+    CASE WHEN rel_source.status = "active" THEN rel_source ELSE NULL END AS rel_source
+        """ % {"branch_filter": branch_filter_str}
+        self.add_to_query(source_query)
+        self.return_labels.extend(["source", "rel_source"])
+
+    def _add_owner_to_query(self, branch_filter_str: str) -> None:
+        if not self._include_owner:
+            return
+        owner_query = """
+CALL (a) {
+    OPTIONAL MATCH (a)-[rel_owner:HAS_OWNER]-(owner)
+    WHERE all(r IN [rel_owner] WHERE ( %(branch_filter)s ))
+    RETURN owner, rel_owner
+    ORDER BY rel_owner.branch_level DESC, rel_owner.from DESC, rel_owner.status ASC
+    LIMIT 1
+}
+WITH *,
+    CASE WHEN rel_owner.status = "active" THEN owner ELSE NULL END AS owner,
+    CASE WHEN rel_owner.status = "active" THEN rel_owner ELSE NULL END AS rel_owner
+        """ % {"branch_filter": branch_filter_str}
+        self.add_to_query(owner_query)
+        self.return_labels.extend(["owner", "rel_owner"])
+
+    def _add_created_metadata_to_query(self) -> None:
+        if not self._include_created_metadata:
+            return
+        if self.branch.is_default or self.branch.is_global:
+            last_created_query = """
+WITH *, a.created_at AS created_at, a.created_by AS created_by
+            """
+        else:
+            last_created_query = """
+CALL (a) {
+    MATCH ()-[e:HAS_ATTRIBUTE {status: "active"}]->(a)
+    RETURN e.from AS created_at, e.from_user_id AS created_by
+    ORDER BY e.from ASC
+    LIMIT 1
+}
+            """
+        self.add_to_query(last_created_query)
+        self.return_labels.extend(["created_at", "created_by"])
+
+    def _add_updated_metadata_to_query(self, branch_filter_str: str) -> None:
+        if not self._include_updated_metadata:
+            return
+        if self.branch.is_default or self.branch.is_global:
+            last_updated_query = """
+WITH *, a.updated_at AS updated_at, a.updated_by AS updated_by
+            """
+        else:
+            if self.branch_agnostic:
+                time_details = """
+    WITH [r.from, r.from_user_id] AS from_details, [r.to, r.to_user_id] AS to_details
+                """
+            else:
+                time_details = """
+    WITH CASE
+        WHEN r.branch IN $branch0 AND r.from < $time0 THEN [r.from, r.from_user_id]
+        WHEN r.branch IN $branch1 AND r.from < $time1 THEN [r.from, r.from_user_id]
+        ELSE [NULL, NULL]
+    END AS from_details,
+    CASE
+        WHEN r.branch IN $branch0 AND r.to < $time0 THEN [r.to, r.to_user_id]
+        WHEN r.branch IN $branch1 AND r.to < $time1 THEN [r.to, r.to_user_id]
+        ELSE [NULL, NULL]
+    END AS to_details
+                """
+            last_updated_query = """
+CALL (a) {
+    MATCH (a)-[r]->(property)
+    WHERE %(branch_filter)s
+    %(time_details)s
+    WITH collect(from_details) AS from_details_list, collect(to_details) AS to_details_list
+    WITH from_details_list + to_details_list AS details_list
+    UNWIND details_list AS one_details
+    WITH one_details[0] AS updated_at, one_details[1] AS updated_by
+    WHERE updated_at IS NOT NULL
+    WITH updated_at, updated_by
+    ORDER BY updated_at DESC
+    LIMIT 1
+    RETURN updated_at, updated_by
+}
+            """ % {"branch_filter": branch_filter_str, "time_details": time_details}
+        self.add_to_query(last_updated_query)
+        self.return_labels.extend(["updated_at", "updated_by"])
+
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
         self.params["profile_node_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
         self.params["profile_template_relationship_name"] = PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER
+        self.params["field_names"] = list(self.fields.keys()) if self.fields else []
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
             at=self.at, branch_agnostic=self.branch_agnostic
@@ -640,11 +827,9 @@ class NodeListGetAttributeQuery(Query):
             exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_template_relationship_name}))
         ) AS might_use_profile
         MATCH (n)-[:HAS_ATTRIBUTE]-(a:Attribute)
+        WHERE (a.name IN $field_names OR size($field_names) = 0)
+        WITH DISTINCT n, a, might_use_profile
         """
-        if self.fields:
-            query += "\n WHERE a.name IN $field_names"
-            self.params["field_names"] = list(self.fields.keys())
-
         self.add_to_query(query)
 
         query = """
@@ -680,15 +865,8 @@ WHERE r2.status = "active"
 
         self.return_labels = ["n", "a", "av", "r1", "r2", "is_from_profile"]
 
-        # Add Is_Protected and Is_visible
+        # Add Is_Protected
         query = """
-CALL (a) {
-    MATCH (a)-[r:IS_VISIBLE]-(isv:Boolean)
-    WHERE (%(branch_filter)s)
-    RETURN r AS rel_isv, isv
-    ORDER BY rel_isv.branch_level DESC, rel_isv.from DESC, rel_isv.status ASC
-    LIMIT 1
-}
 CALL (a) {
     MATCH (a)-[r:IS_PROTECTED]-(isp:Boolean)
     WHERE (%(branch_filter)s)
@@ -699,39 +877,12 @@ CALL (a) {
         """ % {"branch_filter": branch_filter}
         self.add_to_query(query)
 
-        self.return_labels.extend(["isv", "isp", "rel_isv", "rel_isp"])
+        self.return_labels.extend(["isp", "rel_isp"])
 
-        if self.include_source:
-            query = """
-            CALL (a) {
-                OPTIONAL MATCH (a)-[rel_source:HAS_SOURCE]-(source)
-                WHERE all(r IN [rel_source] WHERE ( %(branch_filter)s ))
-                RETURN source, rel_source
-                ORDER BY rel_source.branch_level DESC, rel_source.from DESC, rel_source.status ASC
-                LIMIT 1
-            }
-            WITH *,
-                CASE WHEN rel_source.status = "active" THEN source ELSE NULL END AS source,
-                CASE WHEN rel_source.status = "active" THEN rel_source ELSE NULL END AS rel_source
-            """ % {"branch_filter": branch_filter}
-            self.add_to_query(query)
-            self.return_labels.extend(["source", "rel_source"])
-
-        if self.include_owner:
-            query = """
-            CALL (a) {
-                OPTIONAL MATCH (a)-[rel_owner:HAS_OWNER]-(owner)
-                WHERE all(r IN [rel_owner] WHERE ( %(branch_filter)s ))
-                RETURN owner, rel_owner
-                ORDER BY rel_owner.branch_level DESC, rel_owner.from DESC, rel_owner.status ASC
-                LIMIT 1
-            }
-            WITH *,
-                CASE WHEN rel_owner.status = "active" THEN owner ELSE NULL END AS owner,
-                CASE WHEN rel_owner.status = "active" THEN rel_owner ELSE NULL END AS rel_owner
-            """ % {"branch_filter": branch_filter}
-            self.add_to_query(query)
-            self.return_labels.extend(["owner", "rel_owner"])
+        self._add_source_to_query(branch_filter_str=branch_filter)
+        self._add_owner_to_query(branch_filter_str=branch_filter)
+        self._add_created_metadata_to_query()
+        self._add_updated_metadata_to_query(branch_filter_str=branch_filter)
 
     def get_attributes_group_by_node(self) -> dict[str, NodeAttributesFromDB]:
         attrs_by_node: dict[str, NodeAttributesFromDB] = {}
@@ -768,7 +919,6 @@ CALL (a) {
             attr_uuid=attr.get("uuid"),
             attr_value_id=attr_value.element_id,
             attr_value_uuid=attr_value.get("uuid"),
-            updated_at=result.get_rel("r2").get("from"),
             value=attr_value.get("value"),
             is_default=attr_value.get("is_default"),
             is_from_profile=is_from_profile,
@@ -776,16 +926,26 @@ CALL (a) {
             branch=self.branch.name,
             flag_properties={
                 "is_protected": result.get("isp").get("value"),
-                "is_visible": result.get("isv").get("value"),
             },
         )
 
-        if self.include_source and result.get("source"):
+        if self.include_metadata & MetadataOptions.CREATED_AT:
+            created_at_str = result.get_as_str("created_at")
+            data.created_at = Timestamp(created_at_str) if created_at_str else None
+        if self.include_metadata & MetadataOptions.CREATED_BY:
+            data.created_by = result.get_as_str("created_by")
+        if self.include_metadata & MetadataOptions.UPDATED_AT:
+            updated_at_str = result.get_as_str("updated_at")
+            data.updated_at = Timestamp(updated_at_str) if updated_at_str else None
+        if self.include_metadata & MetadataOptions.UPDATED_BY:
+            data.updated_by = result.get_as_str("updated_by")
+
+        if self._include_source and result.get("source"):
             data.node_properties["source"] = AttributeNodePropertyFromDB(
                 uuid=result.get_node("source").get("uuid"), labels=list(result.get_node("source").labels)
             )
 
-        if self.include_owner and result.get("owner"):
+        if self._include_owner and result.get("owner"):
             data.node_properties["owner"] = AttributeNodePropertyFromDB(
                 uuid=result.get_node("owner").get("uuid"), labels=list(result.get_node("owner").labels)
             )
@@ -799,12 +959,37 @@ class GroupedPeerNodes:
         self._rel_names_by_node_id: dict[str, set[str]] = defaultdict(set)
         # {(node_id, rel_name): {RelationshipDirection: {peer_id, ...}}}
         self._rel_directions_map: dict[tuple[str, str], dict[RelationshipDirection, set[str]]] = defaultdict(dict)
+        # {(node_id, rel_name, direction, peer_Id): {MetadataOptions: value}}
+        self._metadata_map: dict[
+            tuple[str, str, RelationshipDirection, str], dict[MetadataOptions, Timestamp | str | None]
+        ] = {}
 
-    def add_peer(self, node_id: str, rel_name: str, peer_id: str, direction: RelationshipDirection) -> None:
+    def add_peer(
+        self,
+        node_id: str,
+        rel_name: str,
+        peer_id: str,
+        direction: RelationshipDirection,
+        created_at: Timestamp | None = None,
+        created_by: str | None = None,
+        updated_at: Timestamp | None = None,
+        updated_by: str | None = None,
+    ) -> None:
         self._rel_names_by_node_id[node_id].add(rel_name)
         if direction not in self._rel_directions_map[node_id, rel_name]:
             self._rel_directions_map[node_id, rel_name][direction] = set()
         self._rel_directions_map[node_id, rel_name][direction].add(peer_id)
+        key = (node_id, rel_name, direction, peer_id)
+        if created_at is not None or created_by is not None or updated_at is not None or updated_by is not None:
+            self._metadata_map[key] = {}
+        if created_at is not None:
+            self._metadata_map[key][MetadataOptions.CREATED_AT] = created_at
+        if created_by is not None:
+            self._metadata_map[key][MetadataOptions.CREATED_BY] = created_by
+        if updated_at is not None:
+            self._metadata_map[key][MetadataOptions.UPDATED_AT] = updated_at
+        if updated_by is not None:
+            self._metadata_map[key][MetadataOptions.UPDATED_BY] = updated_by
 
     def get_peer_ids(self, node_id: str, rel_name: str, direction: RelationshipDirection) -> set[str]:
         if (node_id, rel_name) not in self._rel_directions_map:
@@ -821,11 +1006,15 @@ class GroupedPeerNodes:
     def has_node(self, node_id: str) -> bool:
         return node_id in self._rel_names_by_node_id
 
+    def get_metadata_map(
+        self, node_id: str, rel_name: str, direction: RelationshipDirection, peer_id: str
+    ) -> dict[MetadataOptions, Timestamp | str | None]:
+        return self._metadata_map.get((node_id, rel_name, direction, peer_id), {})
+
 
 class NodeListGetRelationshipsQuery(Query):
     name: str = "node_list_get_relationship"
     type: QueryType = QueryType.READ
-    insert_return: bool = False
 
     def __init__(
         self,
@@ -833,14 +1022,80 @@ class NodeListGetRelationshipsQuery(Query):
         outbound_identifiers: list[str] | None = None,
         inbound_identifiers: list[str] | None = None,
         bidirectional_identifiers: list[str] | None = None,
+        include_metadata: MetadataOptions = MetadataOptions.NONE,
         **kwargs,
     ):
         self.ids = ids
         self.outbound_identifiers = outbound_identifiers
         self.inbound_identifiers = inbound_identifiers
         self.bidirectional_identifiers = bidirectional_identifiers
+        self.include_metadata = include_metadata
         super().__init__(**kwargs)
 
+    def _add_created_metadata_to_query(self) -> None:
+        if not (self.include_metadata & (MetadataOptions.CREATED_AT | MetadataOptions.CREATED_BY)):
+            return
+        if self.branch.is_default or self.branch.is_global:
+            last_created_query = """
+WITH *, rel.created_at AS created_at, rel.created_by AS created_by
+            """
+        else:
+            last_created_query = """
+WITH *, CASE
+    WHEN r1.from < r2.from THEN [r1.from, r1.from_user_id]
+    ELSE [r2.from, r2.from_user_id]
+END AS created_details
+WITH *, created_details[0] AS created_at, created_details[1] AS created_by
+            """
+        self.add_to_query(last_created_query)
+        self.return_labels.extend(["created_at", "created_by"])
+
+    def _add_updated_metadata_to_query(self, branch_filter_str: str) -> None:
+        if not (self.include_metadata & (MetadataOptions.UPDATED_AT | MetadataOptions.UPDATED_BY)):
+            return
+        if self.branch.is_default or self.branch.is_global:
+            last_updated_query = """
+WITH *, rel.updated_at AS updated_at, rel.updated_by AS updated_by
+            """
+        else:
+            if self.branch_agnostic:
+                time_details = """
+    WITH [r.from, r.from_user_id] AS from_details, [r.to, r.to_user_id] AS to_details
+                """
+            else:
+                time_details = """
+    WITH CASE
+        WHEN r.branch IN $branch0 AND r.from < $time0 THEN [r.from, r.from_user_id]
+        WHEN r.branch IN $branch1 AND r.from < $time1 THEN [r.from, r.from_user_id]
+        ELSE [NULL, NULL]
+    END AS from_details,
+    CASE
+        WHEN r.branch IN $branch0 AND r.to < $time0 THEN [r.to, r.to_user_id]
+        WHEN r.branch IN $branch1 AND r.to < $time1 THEN [r.to, r.to_user_id]
+        ELSE [NULL, NULL]
+    END AS to_details
+                """
+            last_updated_query = """
+CALL (rel) {
+    // don't use IS_RELATED edges to handle the case when at least one of the
+    // peers is a migrated-kind node
+    MATCH (rel)-[r:!IS_RELATED]->(property)
+    WHERE %(branch_filter)s
+    %(time_details)s
+    WITH collect(from_details) AS from_details_list, collect(to_details) AS to_details_list
+    WITH from_details_list + to_details_list AS details_list
+    UNWIND details_list AS one_details
+    WITH one_details[0] AS updated_at, one_details[1] AS updated_by
+    WHERE updated_at IS NOT NULL
+    WITH updated_at, updated_by
+    ORDER BY updated_at DESC
+    LIMIT 1
+    RETURN updated_at, updated_by
+}
+            """ % {"branch_filter": branch_filter_str, "time_details": time_details}
+        self.add_to_query(last_updated_query)
+        self.return_labels.extend(["updated_at", "updated_by"])
+
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
         self.params["outbound_identifiers"] = self.outbound_identifiers
@@ -872,9 +1127,9 @@ class NodeListGetRelationshipsQuery(Query):
                 LIMIT 1
                 WITH r1, r AS r2
                 WHERE r2.status = "active"
-                RETURN 1 AS is_active
+                RETURN r1, r2
             }
-            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "inbound" as direction
+            RETURN n.uuid AS n_uuid, rel, peer.uuid AS peer_uuid, "inbound" as direction, r1, r2
             UNION
             WITH n
             MATCH (n)-[:IS_RELATED]->(rel:Relationship)-[:IS_RELATED]->(peer)
@@ -896,9 +1151,9 @@ class NodeListGetRelationshipsQuery(Query):
                 LIMIT 1
                 WITH r1, r AS r2
                 WHERE r2.status = "active"
-                RETURN 1 AS is_active
+                RETURN r1, r2
             }
-            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "outbound" as direction
+            RETURN n.uuid AS n_uuid, rel, peer.uuid AS peer_uuid, "outbound" as direction, r1, r2
             UNION
             WITH n
             MATCH (n)-[:IS_RELATED]->(rel:Relationship)<-[:IS_RELATED]-(peer)
@@ -920,15 +1175,21 @@ class NodeListGetRelationshipsQuery(Query):
                 LIMIT 1
                 WITH r1, r AS r2
                 WHERE r2.status = "active"
-                RETURN 1 AS is_active
+                RETURN r1, r2
             }
-            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "bidirectional" as direction
+            RETURN n.uuid AS n_uuid, rel, peer.uuid AS peer_uuid, "bidirectional" as direction, r1, r2
         }
-        RETURN DISTINCT n_uuid, rel_name, peer_uuid, direction
         """ % {"filters": rels_filter}
         self.add_to_query(query)
+
         self.order_by = ["n_uuid", "rel_name", "peer_uuid", "direction"]
-        self.return_labels = ["n_uuid", "rel_name", "peer_uuid", "direction"]
+        self.return_labels = ["n_uuid", "peer_uuid", "direction"]
+
+        self._add_created_metadata_to_query()
+        self._add_updated_metadata_to_query(branch_filter_str=rels_filter)
+        return_labels_str = ", ".join(sorted(self.return_labels))
+        self.add_to_query(f"WITH DISTINCT {return_labels_str}, rel.name AS rel_name")
+        self.return_labels.append("rel_name")
 
     def get_peers_group_by_node(self) -> GroupedPeerNodes:
         gpn = GroupedPeerNodes()
@@ -937,12 +1198,40 @@ class NodeListGetRelationshipsQuery(Query):
             rel_name = result.get("rel_name")
             peer_id = result.get("peer_uuid")
             direction = str(result.get("direction"))
+
+            created_at = None
+            if self.include_metadata & MetadataOptions.CREATED_AT:
+                created_at_str = result.get("created_at")
+                created_at = Timestamp(created_at_str) if created_at_str else None
+
+            created_by_str = None
+            if self.include_metadata & MetadataOptions.CREATED_BY:
+                created_by_str = result.get("created_by")
+
+            updated_at = None
+            if self.include_metadata & MetadataOptions.UPDATED_AT:
+                updated_at_str = result.get("updated_at")
+                updated_at = Timestamp(updated_at_str) if updated_at_str else None
+
+            updated_by_str = None
+            if self.include_metadata & MetadataOptions.UPDATED_BY:
+                updated_by_str = result.get("updated_by")
+
             direction_enum = {
                 "inbound": RelationshipDirection.INBOUND,
                 "outbound": RelationshipDirection.OUTBOUND,
                 "bidirectional": RelationshipDirection.BIDIR,
             }.get(direction)
-            gpn.add_peer(node_id=node_id, rel_name=rel_name, peer_id=peer_id, direction=direction_enum)
+            gpn.add_peer(
+                node_id=node_id,
+                rel_name=rel_name,
+                peer_id=peer_id,
+                direction=direction_enum,
+                created_at=created_at,
+                created_by=created_by_str,
+                updated_at=updated_at,
+                updated_by=updated_by_str,
+            )
 
         return gpn
 
@@ -986,11 +1275,81 @@ class NodeListGetInfoQuery(Query):
     name = "node_list_get_info"
     type = QueryType.READ
 
-    def __init__(self, ids: list[str], account=None, **kwargs: Any) -> None:
-        self.account = account
+    def __init__(self, ids: list[str], include_metadata: MetadataOptions = MetadataOptions.NONE, **kwargs: Any) -> None:
         self.ids = ids
+        self.include_metadata = include_metadata
         super().__init__(**kwargs)
 
+    def _needs_user_timestamp_metadata(self) -> bool:
+        return bool(self.include_metadata & MetadataOptions.USER_TIMESTAMPS)
+
+    def _add_created_metadata_to_query(self, branch_filter_str: str) -> None:
+        if self.branch.is_default or self.branch.is_global:
+            created_metadata_query = """
+WITH *, n.created_at AS created_at, n.created_by AS created_by
+            """
+        else:
+            created_metadata_query = """
+CALL (n) {
+    MATCH (:Node {uuid: n.uuid})-[r:IS_PART_OF {status: "active"}]->(:Root)
+    WHERE %(branch_filter)s
+    RETURN r.from AS created_at, r.from_user_id AS created_by
+    ORDER BY r.from ASC
+    LIMIT 1
+}
+            """ % {"branch_filter": branch_filter_str}
+        self.add_to_query(created_metadata_query)
+        self.return_labels.extend(["created_at", "created_by"])
+
+    def _add_updated_metadata_to_query(self, branch_filter_str: str) -> None:
+        if self.branch.is_default or self.branch.is_global:
+            last_update_query = """
+WITH *, n.updated_at AS updated_at, n.updated_by AS updated_by
+            """
+        else:
+            if self.branch_agnostic:
+                time_details = """
+    WITH [r.from, r.from_user_id] AS from_details, [r.to, r.to_user_id] AS to_details
+                """
+            else:
+                time_details = """
+    WITH CASE
+        WHEN r.branch IN $branch0 AND r.from < $time0 THEN [r.from, r.from_user_id]
+        WHEN r.branch IN $branch1 AND r.from < $time1 THEN [r.from, r.from_user_id]
+        ELSE [NULL, NULL]
+    END AS from_details,
+    CASE
+        WHEN r.branch IN $branch0 AND r.to < $time0 THEN [r.to, r.to_user_id]
+        WHEN r.branch IN $branch1 AND r.to < $time1 THEN [r.to, r.to_user_id]
+        ELSE [NULL, NULL]
+    END AS to_details
+                """
+            last_update_query = """
+MATCH (n)-[r:HAS_ATTRIBUTE|IS_RELATED]-(field:Attribute|Relationship)
+WHERE %(branch_filter)s
+WITH DISTINCT n, r_is_part_of, field
+CALL (field) {
+    MATCH (field)-[r]-(property)
+    WHERE %(branch_filter)s
+    %(time_details)s
+    WITH collect(from_details) AS from_details_list, collect(to_details) AS to_details_list
+    WITH from_details_list + to_details_list AS details_list
+    UNWIND details_list AS one_details
+    WITH one_details[0] AS updated_at, one_details[1] AS updated_by
+    WHERE updated_at IS NOT NULL
+    WITH updated_at, updated_by
+    ORDER BY updated_at DESC
+    LIMIT 1
+    RETURN updated_at, updated_by
+}
+WITH n, r_is_part_of, updated_at, updated_by
+// updated_by ordering preferences non "__system__" users
+ORDER BY elementId(n), updated_at DESC, updated_by DESC
+WITH n, r_is_part_of, head(collect(updated_at)) AS updated_at, head(collect(updated_by)) AS updated_by
+            """ % {"branch_filter": branch_filter_str, "time_details": time_details}
+        self.add_to_query(last_update_query)
+        self.return_labels.extend(["updated_at", "updated_by"])
+
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         branch_filter, branch_params = self.branch.get_query_filter_path(
             at=self.at, branch_agnostic=self.branch_agnostic
@@ -1005,36 +1364,115 @@ class NodeListGetInfoQuery(Query):
         CALL (root, n) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(n:Node)
             WHERE %(branch_filter)s
-            RETURN n as n1, r as r1
-            ORDER BY r.branch_level DESC, r.from DESC
+            RETURN r AS r_is_part_of
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
             LIMIT 1
         }
-        WITH n1 as n, r1 as rb
-        WHERE rb.status = "active"
+        WITH n, r_is_part_of
+        WHERE r_is_part_of.status = "active"
         """ % {"branch_filter": branch_filter}
-
         self.add_to_query(query)
+        self.return_labels = [
+            "labels(n) AS node_labels",
+            "r_is_part_of.branch AS branch",
+            "elementId(n) AS node_database_id",
+            "n.uuid AS node_uuid",
+        ]
 
-        self.return_labels = ["n", "rb"]
+        if self._needs_user_timestamp_metadata():
+            self._add_updated_metadata_to_query(branch_filter_str=branch_filter)
+            self._add_created_metadata_to_query(branch_filter_str=branch_filter)
 
     async def get_nodes(self, db: InfrahubDatabase, duplicate: bool = False) -> AsyncIterator[NodeToProcess]:
         """Return all the node objects as NodeToProcess."""
 
-        for result in self.get_results_group_by(("n", "uuid")):
-            schema = find_node_schema(db=db, node=result.get_node("n"), branch=self.branch, duplicate=duplicate)
+        for result in self.get_results():
+            raw_labels: list[str] = result.get_as_type(label="node_labels", return_type=list)
+            labels = [str(lbl) for lbl in raw_labels]
+            schema = find_node_schema(db=db, branch=self.branch, labels=labels, duplicate=duplicate)
             node_branch = self.branch
             if self.branch_agnostic:
-                node_branch = result.get_rel("rb").get("branch")
+                node_branch = result.get_as_type(label="branch", return_type=str)
+
+            created_at = None
+            created_by = None
+            if self.include_metadata & (MetadataOptions.CREATED_AT | MetadataOptions.UPDATED_AT):
+                raw_created_at = result.get_as_str(label="created_at")
+                created_at = Timestamp(raw_created_at) if raw_created_at else None
+            if self.include_metadata & (MetadataOptions.CREATED_BY | MetadataOptions.UPDATED_BY):
+                created_by = result.get_as_str(label="created_by")
+            updated_at = None
+            updated_by = None
+            if self.include_metadata & MetadataOptions.UPDATED_AT:
+                raw_updated_at = result.get_as_str(label="updated_at")
+                updated_at = Timestamp(raw_updated_at) if raw_updated_at else None
+            if self.include_metadata & MetadataOptions.UPDATED_BY:
+                updated_by = result.get_as_str(label="updated_by")
+
             yield NodeToProcess(
                 schema=schema,
-                node_id=result.get_node("n").element_id,
-                node_uuid=result.get_node("n").get("uuid"),
-                updated_at=result.get_rel("rb").get("from"),
+                node_id=result.get_as_type(label="node_database_id", return_type=str),
+                node_uuid=result.get_as_type(label="node_uuid", return_type=str),
                 branch=node_branch,
-                labels=list(result.get_node("n").labels),
+                labels=labels,
+                created_at=created_at,
+                created_by=created_by,
+                updated_at=updated_at or created_at,
+                updated_by=updated_by or created_by,
             )
 
 
+class NodeGetByHFIDQuery(Query):
+    """Query to lookup nodes by their HFID.
+
+    This query uses the stored `human_friendly_id` attribute on nodes.
+    """
+
+    name = "node_get_by_hfid"
+    type = QueryType.READ
+
+    def __init__(self, node_kind: str, hfids: list[list[str]], **kwargs: Any) -> None:
+        self.node_kind = node_kind
+        self.hfids = hfids
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at)
+        self.params.update(branch_params)
+        # The list is stored as a string in the database
+        self.params["hfid_values"] = [ujson.dumps(hfid) for hfid in self.hfids]
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH (n)-[r:IS_PART_OF]->(:Root)
+            WHERE %(branch_filter)s
+            RETURN r AS r_part_of
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        WITH n, r_part_of
+        WHERE r_part_of.status = "active"
+        MATCH (n)-[:HAS_ATTRIBUTE]->(attr:Attribute {name: "human_friendly_id"})
+        CALL (attr) {
+            MATCH (attr)-[r:HAS_VALUE]->(av)
+            WHERE %(branch_filter)s
+            RETURN av, r AS r_attr
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        WITH n, av, r_attr
+        WHERE r_attr.status = "active" AND av.value IN $hfid_values
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_kind}
+
+        self.add_to_query(query)
+        self.return_labels = ["n.uuid AS node_uuid", "av.value AS hfid"]
+
+    def get_node_uuids(self) -> list[str]:
+        """Get the list of node UUIDs from the query results."""
+        return [result.get_as_type(label="node_uuid", return_type=str) for result in self.get_results()]
+
+
 class FieldAttributeRequirementType(Enum):
     FILTER = "filter"
     ORDER = "order"