infrahub-server 1.4.13__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/core/query/attribute.py

@@ -133,7 +133,7 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
     def __init__(
         self,
         prop_name: str,
-        prop_id: str,
+        prop_id: str | None = None,
         **kwargs: Any,
     ):
         self.prop_name = prop_name
@@ -144,6 +144,8 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         at = self.at or self.attr.at
 
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=at)
+        self.params.update(branch_params)
         self.params["attr_uuid"] = self.attr.id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
@@ -151,21 +153,92 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
         self.params["prop_name"] = self.prop_name
         self.params["prop_id"] = self.prop_id
 
-        rel_name = f"HAS_{self.prop_name.upper()}"
+        rel_label = f"HAS_{self.prop_name.upper()}"
 
-        query = (
+        if self.branch.is_default or self.branch.is_global:
+            node_query = """
+        MATCH (np:Node { uuid: $prop_id })-[r:IS_PART_OF]->(:Root)
+        WHERE r.branch IN $branch0
+        AND r.status = "active"
+        AND r.from <= $at AND (r.to IS NULL OR r.to > $at)
+        WITH np
+        LIMIT 1
             """
+        else:
+            node_query = """
+        MATCH (np:Node { uuid: $prop_id })-[r:IS_PART_OF]->(:Root)
+        WHERE %(branch_filter)s
+        ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+        LIMIT 1
+        WITH np
+        WHERE r.status = "active"
+            """ % {"branch_filter": branch_filter}
+        self.add_to_query(node_query)
+
+        attr_query = """
         MATCH (a:Attribute { uuid: $attr_uuid })
-        MATCH (np:Node { uuid: $prop_id })
-        CREATE (a)-[r:%s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(np)
-        """
-            % rel_name
-        )
+        CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(np)
+        """ % {"rel_label": rel_label}
+        self.add_to_query(attr_query)
 
-        self.add_to_query(query)
         self.return_labels = ["a", "np", "r"]
 
 
+class AttributeClearNodePropertyQuery(AttributeQuery):
+    name = "attribute_clear_node_property"
+    type: QueryType = QueryType.WRITE
+    insert_return: bool = False
+
+    def __init__(
+        self,
+        prop_name: str,
+        prop_id: str | None = None,
+        **kwargs: Any,
+    ):
+        self.prop_name = prop_name
+        self.prop_id = prop_id
+
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        at = self.at or self.attr.at
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=at)
+        self.params.update(branch_params)
+        self.params["attr_uuid"] = self.attr.id
+        self.params["branch"] = self.branch.name
+        self.params["branch_level"] = self.branch.hierarchy_level
+        self.params["at"] = at.to_string()
+        self.params["prop_name"] = self.prop_name
+        self.params["prop_id"] = self.prop_id
+
+        rel_label = f"HAS_{self.prop_name.upper()}"
+        query = """
+MATCH (a:Attribute { uuid: $attr_uuid })-[r:%(rel_label)s]->(np:Node { uuid: $prop_id })
+WITH DISTINCT a, np
+CALL (a, np) {
+    MATCH (a)-[r:%(rel_label)s]->(np)
+    WHERE %(branch_filter)s
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+    RETURN r AS property_edge
+}
+WITH a, np, property_edge
+WHERE property_edge.status = "active"
+CALL (property_edge) {
+    WITH property_edge
+    WHERE property_edge.branch = $branch
+    SET property_edge.to = $at
+}
+CALL (a, np, property_edge) {
+    WITH property_edge
+    WHERE property_edge.branch_level < $branch_level
+    CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at }]->(np)
+}
+        """ % {"branch_filter": branch_filter, "rel_label": rel_label}
+        self.add_to_query(query)
+
+
 class AttributeGetQuery(AttributeQuery):
     name = "attribute_get"
     type: QueryType = QueryType.READ
@@ -204,7 +277,6 @@ async def default_attribute_query_filter(
     param_prefix: str | None = None,
     db: InfrahubDatabase | None = None,  # noqa: ARG001
     partial_match: bool = False,
-    support_profiles: bool = False,
 ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
     """Generate Query String Snippet to filter the right node."""
     attribute_value_label = GraphAttributeValueNode.get_default_label()
@@ -251,9 +323,6 @@ async def default_attribute_query_filter(
                 query_where.append(f"toString(av.{filter_name}) =~ ${param_prefix}_{filter_name}")
             elif filter_name == "isnull":
                 query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
-            elif support_profiles:
-                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
-                query_where.append(f"(av.{filter_name} = ${param_prefix}_{filter_name} OR av.is_default)")
             else:
                 query_filter.append(
                     QueryNode(
@@ -271,8 +340,6 @@ async def default_attribute_query_filter(
         if attribute_kind and attribute_kind == "List":
             query_params[f"{param_prefix}_{filter_name}"] = build_regex_attrs(values=filter_value)
             query_where.append(f"toString(av.value) =~ ${param_prefix}_{filter_name}")
-        elif support_profiles:
-            query_where.append(f"(av.value IN ${param_prefix}_value OR av.is_default)")
         else:
             query_where.append(f"av.value IN ${param_prefix}_value")
         query_params[f"{param_prefix}_value"] = filter_value

infrahub/core/query/ipam.py

@@ -450,12 +450,23 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         CALL (ip_node) {
             OPTIONAL MATCH parent_prefix_path = (ip_node)-[r1:IS_RELATED]->(:Relationship {name: "parent__child"})-[r2:IS_RELATED]->(current_parent:%(ip_prefix_kind)s)
-            WHERE all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
+            WHERE $is_prefix = TRUE
+            AND all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
             RETURN current_parent, (r1.status = "active" AND r2.status = "active") AS parent_is_active
             ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
             LIMIT 1
         }
-        WITH ip_namespace, ip_node, CASE WHEN parent_is_active THEN current_parent ELSE NULL END as current_parent
+        WITH ip_namespace, ip_node, CASE WHEN parent_is_active THEN current_parent ELSE NULL END as prefix_parent
+        CALL (ip_node) {
+            OPTIONAL MATCH parent_prefix_path = (ip_node)-[r1:IS_RELATED]->(:Relationship {name: "ip_prefix__ip_address"})<-[r2:IS_RELATED]-(current_parent:%(ip_prefix_kind)s)
+            WHERE $is_prefix = FALSE
+            AND all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
+            RETURN current_parent, (r1.status = "active" AND r2.status = "active") AS parent_is_active
+            ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+            LIMIT 1
+        }
+        WITH ip_namespace, ip_node, prefix_parent, CASE WHEN parent_is_active THEN current_parent ELSE NULL END as address_parent
+        WITH ip_namespace, ip_node, COALESCE(prefix_parent, address_parent) AS current_parent
         """ % {
             "branch_filter": branch_filter,
             "ip_prefix_kind": InfrahubKind.IPPREFIX,
@@ -467,7 +478,7 @@ class IPPrefixReconcileQuery(Query):
         // Get prefix node's current prefix children, if any exist
         // ------------------
         CALL (ip_node) {
-            OPTIONAL MATCH child_prefix_path = (ip_node)<-[r1:IS_RELATED]-(:Relationship {name: "parent__child"})<-[r2:IS_RELATED]-(current_prefix_child:%(ip_prefix_kind)s)
+            OPTIONAL MATCH child_prefix_path = (ip_node:%(ip_prefix_kind)s)<-[r1:IS_RELATED]-(:Relationship {name: "parent__child"})<-[r2:IS_RELATED]-(current_prefix_child:%(ip_prefix_kind)s)
             WHERE all(r IN relationships(child_prefix_path) WHERE (%(branch_filter)s))
             WITH current_prefix_child, (r1.status = "active" AND r2.status = "active") AS is_active
             ORDER BY current_prefix_child.uuid, r1.branch_level DESC, r1.from DESC, r2.branch_level DESC, r2.from DESC
@@ -479,7 +490,7 @@ class IPPrefixReconcileQuery(Query):
         // Get prefix node's current address children, if any exist
         // ------------------
         CALL (ip_node) {
-            OPTIONAL MATCH child_address_path = (ip_node)-[r1:IS_RELATED]-(:Relationship {name: "ip_prefix__ip_address"})-[r2:IS_RELATED]-(current_address_child:%(ip_address_kind)s)
+            OPTIONAL MATCH child_address_path = (ip_node:%(ip_prefix_kind)s)-[r1:IS_RELATED]->(:Relationship {name: "ip_prefix__ip_address"})<-[r2:IS_RELATED]-(current_address_child:%(ip_address_kind)s)
             WHERE all(r IN relationships(child_address_path) WHERE (%(branch_filter)s))
             WITH current_address_child, (r1.status = "active" AND r2.status = "active") AS is_active
             ORDER BY current_address_child.uuid, r1.branch_level DESC, r1.from DESC, r2.branch_level DESC, r2.from DESC
@@ -688,6 +699,7 @@ class IPPrefixReconcileQuery(Query):
             "ip_address_attribute_kind": ADDRESS_ATTRIBUTE_LABEL,
         }
         self.add_to_query(get_new_children_query)
+        self.order_by = ["ip_node.uuid"]
         self.return_labels = ["ip_node", "current_parent", "current_children", "new_parent", "new_children"]
 
     def _get_uuid_from_query(self, node_name: str) -> str | None:

infrahub/core/query/node.py

@@ -11,6 +11,7 @@ from infrahub import config
 from infrahub.core import registry
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
+    PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
     AttributeDBNodeType,
     RelationshipDirection,
     RelationshipHierarchyDirection,
@@ -43,7 +44,6 @@ class NodeToProcess:
 
     node_id: str
     node_uuid: str
-    profile_uuids: list[str]
 
     updated_at: str
 
@@ -142,9 +142,22 @@ class NodeCreateAllQuery(NodeQuery):
         attributes_ipnetwork: list[AttributeCreateData] = []
         attributes_indexed: list[AttributeCreateData] = []
 
+        if self.node.has_display_label():
+            attributes_indexed.append(
+                self.node._display_label.get_node_attribute(node=self.node, at=at).get_create_data(
+                    node_schema=self.node.get_schema()
+                )
+            )
+        if self.node.has_human_friendly_id():
+            attributes_indexed.append(
+                self.node._human_friendly_id.get_node_attribute(node=self.node, at=at).get_create_data(
+                    node_schema=self.node.get_schema()
+                )
+            )
+
         for attr_name in self.node._attributes:
             attr: BaseAttribute = getattr(self.node, attr_name)
-            attr_data = attr.get_create_data()
+            attr_data = attr.get_create_data(node_schema=self.node.get_schema())
             node_type = attr.get_db_node_type()
 
             if AttributeDBNodeType.IPHOST in node_type:
@@ -610,6 +623,7 @@ class NodeListGetAttributeQuery(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
+        self.params["profile_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
             at=self.at, branch_agnostic=self.branch_agnostic
@@ -618,6 +632,7 @@ class NodeListGetAttributeQuery(Query):
 
         query = """
         MATCH (n:Node) WHERE n.uuid IN $ids
+        WITH n, exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_relationship_name})) AS might_use_profile
         MATCH (n)-[:HAS_ATTRIBUTE]-(a:Attribute)
         """
         if self.fields:
@@ -628,27 +643,36 @@ class NodeListGetAttributeQuery(Query):
 
         query = """
 CALL (n, a) {
-    MATCH (n)-[r:HAS_ATTRIBUTE]->(a:Attribute)
+    MATCH (n)-[r:HAS_ATTRIBUTE]-(a:Attribute)
     WHERE %(branch_filter)s
-    RETURN r.status = "active" AS is_active
+    RETURN r AS r1
+    ORDER BY r.branch_level DESC, r.from DESC
+    LIMIT 1
+}
+WITH n, r1, a, might_use_profile
+WHERE r1.status = "active"
+WITH n, r1, a, might_use_profile
+CALL (a, might_use_profile) {
+    OPTIONAL MATCH (a)-[r:HAS_SOURCE]->(:CoreProfile)
+    WHERE might_use_profile = TRUE AND %(branch_filter)s
+    RETURN r.status = "active" AS has_active_profile
     ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
     LIMIT 1
 }
-WITH n, a
-WHERE is_active = TRUE
+WITH *, has_active_profile = TRUE AS is_from_profile
 CALL (a) {
-    MATCH (a)-[r:HAS_VALUE]->(av:AttributeValue)
+    MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
     WHERE %(branch_filter)s
-    RETURN av, r AS r2
-    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    RETURN r as r2, av
+    ORDER BY r.branch_level DESC, r.from DESC
     LIMIT 1
 }
-WITH n, a, av, r2
+WITH n, r1, a, r2, av, is_from_profile
 WHERE r2.status = "active"
         """ % {"branch_filter": branch_filter}
         self.add_to_query(query)
 
-        self.return_labels = ["n", "a", "av", "r2"]
+        self.return_labels = ["n", "a", "av", "r1", "r2", "is_from_profile"]
 
         # Add Is_Protected and Is_visible
         query = """
@@ -673,16 +697,32 @@ CALL (a) {
 
         if self.include_source:
             query = """
-            OPTIONAL MATCH (a)-[rel_source:HAS_SOURCE]-(source)
-            WHERE all(r IN [rel_source] WHERE ( %(branch_filter)s ))
+            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 = """
-            OPTIONAL MATCH (a)-[rel_owner:HAS_OWNER]-(owner)
-            WHERE all(r IN [rel_owner] WHERE ( %(branch_filter)s ))
+            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"])
@@ -713,6 +753,7 @@ CALL (a) {
     def _extract_attribute_data(self, result: QueryResult) -> AttributeFromDB:
         attr = result.get_node("a")
         attr_value = result.get_node("av")
+        is_from_profile = result.get_as_type(label="is_from_profile", return_type=bool)
 
         data = AttributeFromDB(
             name=attr.get("name"),
@@ -724,6 +765,7 @@ CALL (a) {
             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,
             content=attr_value._properties,
             branch=self.branch.name,
             flag_properties={
@@ -948,6 +990,8 @@ class NodeListGetInfoQuery(Query):
             at=self.at, branch_agnostic=self.branch_agnostic
         )
         self.params.update(branch_params)
+        self.params["ids"] = self.ids
+        self.order_by = ["n.uuid"]
 
         query = """
         MATCH p = (root:Root)<-[:IS_PART_OF]-(n:Node)
@@ -961,16 +1005,11 @@ class NodeListGetInfoQuery(Query):
         }
         WITH n1 as n, r1 as rb
         WHERE rb.status = "active"
-        OPTIONAL MATCH profile_path = (n)-[:IS_RELATED]->(profile_r:Relationship)<-[:IS_RELATED]-(profile:Node)-[:IS_PART_OF]->(:Root)
-        WHERE profile_r.name = "node__profile"
-        AND profile.namespace = "Profile"
-        AND all(r in relationships(profile_path) WHERE %(branch_filter)s and r.status = "active")
         """ % {"branch_filter": branch_filter}
 
         self.add_to_query(query)
-        self.params["ids"] = self.ids
 
-        self.return_labels = ["collect(profile.uuid) as profile_uuids", "n", "rb"]
+        self.return_labels = ["n", "rb"]
 
     async def get_nodes(self, db: InfrahubDatabase, duplicate: bool = False) -> AsyncIterator[NodeToProcess]:
         """Return all the node objects as NodeToProcess."""
@@ -984,24 +1023,11 @@ class NodeListGetInfoQuery(Query):
                 schema=schema,
                 node_id=result.get_node("n").element_id,
                 node_uuid=result.get_node("n").get("uuid"),
-                profile_uuids=[str(puuid) for puuid in result.get("profile_uuids")],
                 updated_at=result.get_rel("rb").get("from"),
                 branch=node_branch,
                 labels=list(result.get_node("n").labels),
             )
 
-    def get_profile_ids_by_node_id(self) -> dict[str, list[str]]:
-        profile_id_map: dict[str, list[str]] = {}
-        for result in self.results:
-            node_id = result.get_node("n").get("uuid")
-            profile_ids = result.get("profile_uuids")
-            if not node_id or not profile_ids:
-                continue
-            if node_id not in profile_id_map:
-                profile_id_map[node_id] = []
-            profile_id_map[node_id].extend(profile_ids)
-        return profile_id_map
-
 
 class FieldAttributeRequirementType(Enum):
     FILTER = "filter"
@@ -1018,7 +1044,7 @@ class FieldAttributeRequirement:
     types: list[FieldAttributeRequirementType] = dataclass_field(default_factory=list)
 
     @property
-    def supports_profile(self) -> bool:
+    def is_attribute_value(self) -> bool:
         return bool(self.field and self.field.is_attribute and self.field_attr_name in ("value", "values", "isnull"))
 
     @property
@@ -1029,26 +1055,10 @@ class FieldAttributeRequirement:
     def is_order(self) -> bool:
         return FieldAttributeRequirementType.ORDER in self.types
 
-    @property
-    def is_default_query_variable(self) -> str:
-        return f"attr{self.index}_is_default"
-
     @property
     def node_value_query_variable(self) -> str:
         return f"attr{self.index}_node_value"
 
-    @property
-    def profile_value_query_variable(self) -> str:
-        return f"attr{self.index}_profile_value"
-
-    @property
-    def profile_final_value_query_variable(self) -> str:
-        return f"attr{self.index}_final_profile_value"
-
-    @property
-    def final_value_query_variable(self) -> str:
-        return f"attr{self.index}_final_value"
-
     @property
     def comparison_operator(self) -> str:
         if self.field_attr_name == "isnull":
@@ -1184,7 +1194,6 @@ class NodeGetListQuery(Query):
             self.params["node_ids"] = self.filters["ids"]
 
         field_attribute_requirements = self._get_field_requirements(disable_order=disable_order)
-        use_profiles = any(far for far in field_attribute_requirements if far.supports_profile)
         await self._add_node_filter_attributes(
             db=db, field_attribute_requirements=field_attribute_requirements, branch_filter=branch_filter
         )
@@ -1196,21 +1205,11 @@ class NodeGetListQuery(Query):
             for far in field_attribute_requirements:
                 if not far.is_order:
                     continue
-                if far.supports_profile:
-                    self.order_by.append(far.final_value_query_variable)
-                    continue
                 self.order_by.append(far.node_value_query_variable)
 
         # Always order by uuid to guarantee pagination, see https://github.com/opsmill/infrahub/pull/4704.
         self.order_by.append("n.uuid")
 
-        if use_profiles:
-            await self._add_profiles_per_node_query(db=db, branch_filter=branch_filter)
-            await self._add_profile_attributes(
-                db=db, field_attribute_requirements=field_attribute_requirements, branch_filter=branch_filter
-            )
-            await self._add_profile_rollups(field_attribute_requirements=field_attribute_requirements)
-
         self._add_final_filter(field_attribute_requirements=field_attribute_requirements)
 
     async def _add_node_filter_attributes(
@@ -1228,8 +1227,6 @@ class NodeGetListQuery(Query):
 
         for far in field_attribute_requirements:
             extra_tail_properties = {far.node_value_query_variable: "value"}
-            if far.supports_profile:
-                extra_tail_properties[far.is_default_query_variable] = "is_default"
             subquery, subquery_params, subquery_result_name = await build_subquery_filter(
                 db=db,
                 field=far.field,
@@ -1240,7 +1237,6 @@ class NodeGetListQuery(Query):
                 branch=self.branch,
                 subquery_idx=far.index,
                 partial_match=self.partial_match,
-                support_profiles=far.supports_profile,
                 extra_tail_properties=extra_tail_properties,
             )
             for query_var in extra_tail_properties:
@@ -1280,9 +1276,6 @@ class NodeGetListQuery(Query):
         for far in field_attribute_requirements:
             if far.field is None:
                 continue
-            extra_tail_properties = {}
-            if far.supports_profile:
-                extra_tail_properties[far.is_default_query_variable] = "is_default"
 
             subquery, subquery_params, _ = await build_subquery_order(
                 db=db,
@@ -1293,11 +1286,7 @@ class NodeGetListQuery(Query):
                 branch=self.branch,
                 subquery_idx=far.index,
                 result_prefix=far.node_value_query_variable,
-                support_profiles=far.supports_profile,
-                extra_tail_properties=extra_tail_properties,
             )
-            for query_var in extra_tail_properties:
-                self._track_variable(query_var)
             self._track_variable(far.node_value_query_variable)
             with_str = ", ".join(self._get_tracked_variables())
 
@@ -1311,122 +1300,11 @@ class NodeGetListQuery(Query):
             self.add_to_query(sort_query)
         self.params.update(sort_params)
 
-    async def _add_profiles_per_node_query(self, db: InfrahubDatabase, branch_filter: str) -> None:
-        with_str = ", ".join(self._get_tracked_variables())
-        froms_str = db.render_list_comprehension(items="relationships(profile_path)", item_name="from")
-        profiles_per_node_query = (
-            """
-            CALL (n) {
-                OPTIONAL MATCH profile_path = (n)-[:IS_RELATED]->(profile_r:Relationship)<-[:IS_RELATED]-(maybe_profile_n:Node)-[:IS_PART_OF]->(:Root)
-                WHERE profile_r.name = "node__profile"
-                AND all(r in relationships(profile_path) WHERE %(branch_filter)s)
-                WITH
-                    maybe_profile_n,
-                    profile_path,
-                    reduce(br_lvl = 0, r in relationships(profile_path) | br_lvl + r.branch_level) AS branch_level,
-                    %(froms_str)s AS froms,
-                    all(r in relationships(profile_path) WHERE r.status = "active") AS is_active
-                RETURN maybe_profile_n, is_active, branch_level, froms
-            }
-            WITH %(with_str)s, maybe_profile_n, branch_level, froms, is_active
-            ORDER BY n.uuid, maybe_profile_n.uuid, branch_level DESC, froms[-1] DESC, froms[-2] DESC, froms[-3] DESC
-            WITH %(with_str)s, maybe_profile_n, collect(is_active) as ordered_is_actives
-            WITH %(with_str)s, CASE
-                WHEN ordered_is_actives[0] = True THEN maybe_profile_n ELSE NULL
-            END AS profile_n
-            CALL (profile_n) {
-                OPTIONAL MATCH profile_priority_path = (profile_n)-[pr1:HAS_ATTRIBUTE]->(a:Attribute)-[pr2:HAS_VALUE]->(av:AttributeValue)
-                WHERE a.name = "profile_priority"
-                AND all(r in relationships(profile_priority_path) WHERE %(branch_filter)s and r.status = "active")
-                RETURN av.value as profile_priority
-                ORDER BY pr1.branch_level + pr2.branch_level DESC, pr2.from DESC, pr1.from DESC
-                LIMIT 1
-            }
-            WITH %(with_str)s, profile_n, profile_priority
-            """
-        ) % {"branch_filter": branch_filter, "with_str": with_str, "froms_str": froms_str}
-        self.add_to_query(profiles_per_node_query)
-        self._track_variable("profile_n")
-        self._track_variable("profile_priority")
-
-    async def _add_profile_attributes(
-        self, db: InfrahubDatabase, field_attribute_requirements: list[FieldAttributeRequirement], branch_filter: str
-    ) -> None:
-        attributes_queries: list[str] = []
-        attributes_params: dict[str, Any] = {}
-        profile_attributes = [far for far in field_attribute_requirements if far.supports_profile]
-
-        for profile_attr in profile_attributes:
-            if not profile_attr.field:
-                continue
-            subquery, subquery_params, _ = await build_subquery_order(
-                db=db,
-                field=profile_attr.field,
-                node_alias="profile_n",
-                name=profile_attr.field_name,
-                order_by=profile_attr.field_attr_name,
-                branch_filter=branch_filter,
-                branch=self.branch,
-                subquery_idx=profile_attr.index,
-                result_prefix=profile_attr.profile_value_query_variable,
-                support_profiles=False,
-            )
-            attributes_params.update(subquery_params)
-            self._track_variable(profile_attr.profile_value_query_variable)
-            with_str = ", ".join(self._get_tracked_variables())
-
-            attributes_queries.append("CALL (profile_n) {")
-            attributes_queries.append(subquery)
-            attributes_queries.append("}")
-            attributes_queries.append(f"WITH {with_str}")
-
-        self.add_to_query(attributes_queries)
-        self.params.update(attributes_params)
-
-    async def _add_profile_rollups(self, field_attribute_requirements: list[FieldAttributeRequirement]) -> None:
-        profile_attributes = [far for far in field_attribute_requirements if far.supports_profile]
-        profile_value_collects = []
-        for profile_attr in profile_attributes:
-            self._untrack_variable(profile_attr.profile_value_query_variable)
-            profile_value_collects.append(
-                f"""head(
-                    reduce(
-                        non_null_values = [], v in collect({profile_attr.profile_value_query_variable}) |
-                        CASE WHEN v IS NOT NULL AND v <> "NULL" THEN non_null_values + [v] ELSE non_null_values END
-                    )
-                ) as {profile_attr.profile_final_value_query_variable}"""
-            )
-        self._untrack_variable("profile_n")
-        self._untrack_variable("profile_priority")
-        profile_rollup_with_str = ", ".join(self._get_tracked_variables() + profile_value_collects)
-        profile_rollup_query = f"""
-        ORDER BY n.uuid, profile_priority ASC, profile_n.uuid ASC
-        WITH {profile_rollup_with_str}
-        """
-        self.add_to_query(profile_rollup_query)
-        for profile_attr in profile_attributes:
-            self._track_variable(profile_attr.profile_final_value_query_variable)
-
-        final_value_with = []
-        for profile_attr in profile_attributes:
-            final_value_with.append(f"""
-            CASE
-                WHEN {profile_attr.is_default_query_variable} AND {profile_attr.profile_final_value_query_variable} IS NOT NULL
-                THEN {profile_attr.profile_final_value_query_variable}
-                ELSE {profile_attr.node_value_query_variable}
-            END AS {profile_attr.final_value_query_variable}
-            """)
-            self._untrack_variable(profile_attr.is_default_query_variable)
-            self._untrack_variable(profile_attr.profile_final_value_query_variable)
-            self._untrack_variable(profile_attr.node_value_query_variable)
-        final_value_with_str = ", ".join(self._get_tracked_variables() + final_value_with)
-        self.add_to_query(f"WITH {final_value_with_str}")
-
     def _add_final_filter(self, field_attribute_requirements: list[FieldAttributeRequirement]) -> None:
         where_parts = []
         where_str = ""
         for far in field_attribute_requirements:
-            if not far.is_filter or not far.supports_profile:
+            if not far.is_filter or not far.is_attribute_value:
                 continue
             var_name = f"final_attr_value{far.index}"
             self.params[var_name] = far.field_attr_comparison_value
@@ -1435,11 +1313,11 @@ class NodeGetListQuery(Query):
                     # If the any filter is an array/list
                     var_array = f"{var_name}_array"
                     where_parts.append(
-                        f"any({var_array} IN ${var_name} WHERE toLower(toString({far.final_value_query_variable})) CONTAINS toLower({var_array}))"
+                        f"any({var_array} IN ${var_name} WHERE toLower(toString({far.node_value_query_variable})) CONTAINS toLower({var_array}))"
                     )
                 else:
                     where_parts.append(
-                        f"toLower(toString({far.final_value_query_variable})) CONTAINS toLower(toString(${var_name}))"
+                        f"toLower(toString({far.node_value_query_variable})) CONTAINS toLower(toString(${var_name}))"
                     )
                 continue
             if far.field and isinstance(far.field, AttributeSchema) and far.field.kind == "List":
@@ -1448,10 +1326,10 @@ class NodeGetListQuery(Query):
                 else:
                     self.params[var_name] = build_regex_attrs(values=[far.field_attr_comparison_value])
 
-                where_parts.append(f"toString({far.final_value_query_variable}) =~ ${var_name}")
+                where_parts.append(f"toString({far.node_value_query_variable}) =~ ${var_name}")
                 continue
 
-            where_parts.append(f"{far.final_value_query_variable} {far.comparison_operator} ${var_name}")
+            where_parts.append(f"{far.node_value_query_variable} {far.comparison_operator} ${var_name}")
         if where_parts:
             where_str = "WHERE " + " AND ".join(where_parts)
         self.add_to_query(where_str)