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

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:
@@ -627,61 +642,87 @@ class NodeListGetAttributeQuery(Query):
         self.add_to_query(query)
 
         query = """
-        CALL (n, a) {
-            MATCH (n)-[r:HAS_ATTRIBUTE]-(a:Attribute)
-            WHERE %(branch_filter)s
-            RETURN n as n1, r as r1, a as a1
-            ORDER BY r.branch_level DESC, r.from DESC
-            LIMIT 1
-        }
-        WITH n1 as n, r1, a1 as a
-        WHERE r1.status = "active"
-        WITH n, r1, a
-        MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
-        WHERE %(branch_filter)s
-        CALL (a, av) {
-            MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
-            WHERE %(branch_filter)s
-            RETURN a as a1, r as r2, av as av1
-            ORDER BY r.branch_level DESC, r.from DESC
-            LIMIT 1
-        }
-        WITH n, r1, a1 as a, r2, av1 as av
-        WHERE r2.status = "active"
-        WITH n, a, av, r1, r2
+CALL (n, a) {
+    MATCH (n)-[r:HAS_ATTRIBUTE]-(a:Attribute)
+    WHERE %(branch_filter)s
+    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 *, has_active_profile = TRUE AS is_from_profile
+CALL (a) {
+    MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
+    WHERE %(branch_filter)s
+    RETURN r as r2, av
+    ORDER BY r.branch_level DESC, r.from DESC
+    LIMIT 1
+}
+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", "r1", "r2"]
+        self.return_labels = ["n", "a", "av", "r1", "r2", "is_from_profile"]
 
         # Add Is_Protected and Is_visible
-        rel_isv_branch_filter, _ = self.branch.get_query_filter_path(
-            at=self.at, branch_agnostic=self.branch_agnostic, variable_name="rel_isv"
-        )
-        rel_isp_branch_filter, _ = self.branch.get_query_filter_path(
-            at=self.at, branch_agnostic=self.branch_agnostic, variable_name="rel_isp"
-        )
         query = """
-        MATCH (a)-[rel_isv:IS_VISIBLE]-(isv:Boolean)
-        MATCH (a)-[rel_isp:IS_PROTECTED]-(isp:Boolean)
-        WHERE (%(rel_isv_branch_filter)s) AND (%(rel_isp_branch_filter)s)
-        """ % {"rel_isv_branch_filter": rel_isv_branch_filter, "rel_isp_branch_filter": rel_isp_branch_filter}
+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)
+    RETURN r AS rel_isp, isp
+    ORDER BY rel_isp.branch_level DESC, rel_isp.from DESC, rel_isp.status ASC
+    LIMIT 1
+}
+        """ % {"branch_filter": branch_filter}
         self.add_to_query(query)
 
         self.return_labels.extend(["isv", "isp", "rel_isv", "rel_isp"])
 
         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"])
@@ -712,6 +753,7 @@ class NodeListGetAttributeQuery(Query):
     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"),
@@ -723,6 +765,7 @@ class NodeListGetAttributeQuery(Query):
             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={
@@ -878,6 +921,7 @@ class NodeListGetRelationshipsQuery(Query):
         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"]
 
     def get_peers_group_by_node(self) -> GroupedPeerNodes:
@@ -946,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)
@@ -959,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."""
@@ -982,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"
@@ -1016,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
@@ -1027,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":
@@ -1182,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
         )
@@ -1194,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(
@@ -1226,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,
@@ -1238,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:
@@ -1278,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,
@@ -1291,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())
 
@@ -1309,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
@@ -1433,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":
@@ -1446,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)

infrahub/core/query/relationship.py

@@ -350,17 +350,20 @@ class RelationshipUpdatePropertyQuery(RelationshipQuery):
 
     def __init__(
         self,
-        properties_to_update: list[str],
-        data: RelationshipPeerData,
+        rel_node_id: str,
+        flag_properties_to_update: dict[str, bool],
+        node_properties_to_update: dict[str, str],
         **kwargs,
     ):
-        self.properties_to_update = properties_to_update
-        self.data = data
-
+        self.rel_node_id = rel_node_id
+        if not flag_properties_to_update and not node_properties_to_update:
+            raise ValueError("Either flag_properties_to_update or node_properties_to_update must be set")
+        self.flag_properties_to_update = flag_properties_to_update
+        self.node_properties_to_update = node_properties_to_update
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
-        self.params["rel_node_id"] = self.data.rel_node_id
+        self.params["rel_node_id"] = self.rel_node_id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["at"] = self.at.to_string()
@@ -370,36 +373,51 @@ class RelationshipUpdatePropertyQuery(RelationshipQuery):
         """
         self.add_to_query(query)
 
-        self.query_add_all_flag_property_merge()
         self.query_add_all_node_property_merge()
+        self.query_add_all_flag_property_merge()
 
-        self.query_add_all_flag_property_create()
         self.query_add_all_node_property_create()
+        self.query_add_all_flag_property_create()
 
     def query_add_all_flag_property_merge(self) -> None:
-        for prop_name in self.rel._flag_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_flag_property_merge(name=prop_name)
+        for prop_name, prop_value in self.flag_properties_to_update.items():
+            self.query_add_flag_property_merge(name=prop_name, value=prop_value)
 
-    def query_add_flag_property_merge(self, name: str) -> None:
+    def query_add_flag_property_merge(self, name: str, value: bool) -> None:
         self.add_to_query("MERGE (prop_%s:Boolean { value: $prop_%s })" % (name, name))
-        self.params[f"prop_{name}"] = getattr(self.rel, name)
+        self.params[f"prop_{name}"] = value
         self.return_labels.append(f"prop_{name}")
 
     def query_add_all_node_property_merge(self) -> None:
-        for prop_name in self.rel._node_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_node_property_merge(name=prop_name)
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at)
+        self.params.update(branch_params)
 
-    def query_add_node_property_merge(self, name: str) -> None:
-        self.add_to_query("MERGE (prop_%s:Node { uuid: $prop_%s })" % (name, name))
-        self.params[f"prop_{name}"] = getattr(self.rel, f"{name}_id")
-        self.return_labels.append(f"prop_{name}")
+        for prop_name, prop_value in self.node_properties_to_update.items():
+            self.params[f"prop_{prop_name}"] = prop_value
+            if self.branch.is_default or self.branch.is_global:
+                node_query = """
+            MATCH (prop_%(prop_name)s:Node {uuid: $prop_%(prop_name)s })-[r_%(prop_name)s:IS_PART_OF]->(:Root)
+            WHERE r_%(prop_name)s.branch IN $branch0
+            AND r_%(prop_name)s.status = "active"
+            AND r_%(prop_name)s.from <= $at AND (r_%(prop_name)s.to IS NULL OR r_%(prop_name)s.to > $at)
+            WITH *
+            LIMIT 1
+                """ % {"prop_name": prop_name}
+            else:
+                node_query = """
+            MATCH (prop_%(prop_name)s:Node {uuid: $prop_%(prop_name)s })-[r_%(prop_name)s:IS_PART_OF]->(:Root)
+            WHERE all(r in [r_%(prop_name)s] WHERE %(branch_filter)s)
+            ORDER BY r_%(prop_name)s.branch_level DESC, r_%(prop_name)s.from DESC, r_%(prop_name)s.status ASC
+            LIMIT 1
+            WITH *
+            WHERE r_%(prop_name)s.status = "active"
+                """ % {"branch_filter": branch_filter, "prop_name": prop_name}
+            self.add_to_query(node_query)
+            self.return_labels.append(f"prop_{prop_name}")
 
     def query_add_all_flag_property_create(self) -> None:
-        for prop_name in self.rel._flag_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_flag_property_create(name=prop_name)
+        for prop_name in self.flag_properties_to_update:
+            self.query_add_flag_property_create(name=prop_name)
 
     def query_add_flag_property_create(self, name: str) -> None:
         query = """
@@ -411,9 +429,8 @@ class RelationshipUpdatePropertyQuery(RelationshipQuery):
         self.add_to_query(query)
 
     def query_add_all_node_property_create(self) -> None:
-        for prop_name in self.rel._node_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_node_property_create(name=prop_name)
+        for prop_name in self.node_properties_to_update:
+            self.query_add_node_property_create(name=prop_name)
 
     def query_add_node_property_create(self, name: str) -> None:
         query = """
@@ -1019,6 +1036,7 @@ class RelationshipCountPerNodeQuery(Query):
         """ % {"branch_filter": branch_filter, "path": path}
 
         self.add_to_query(query)
+        self.order_by = ["peer_node.uuid"]
         self.return_labels = ["peer_node.uuid", "COUNT(peer_node.uuid) as nbr_peers"]
 
     async def get_count_per_peer(self) -> dict[str, int]:

infrahub/core/query/subquery.py

@@ -25,12 +25,8 @@ async def build_subquery_filter(
     partial_match: bool = False,
     optional_match: bool = False,
     result_prefix: str = "filter",
-    support_profiles: bool = False,
     extra_tail_properties: dict[str, str] | None = None,
 ) -> tuple[str, dict[str, Any], str]:
-    support_profiles = (
-        support_profiles and field and field.is_attribute and filter_name in ("value", "values", "isnull")
-    )
     params = {}
     prefix = f"{result_prefix}{subquery_idx}"
 
@@ -52,7 +48,6 @@ async def build_subquery_filter(
         param_prefix=prefix,
         db=db,
         partial_match=partial_match,
-        support_profiles=support_profiles,
     )
     params.update(field_params)
 
@@ -109,10 +104,8 @@ async def build_subquery_order(
     branch: Branch = None,
     subquery_idx: int = 1,
     result_prefix: str | None = None,
-    support_profiles: bool = False,
     extra_tail_properties: dict[str, str] | None = None,
 ) -> tuple[str, dict[str, Any], str]:
-    support_profiles = support_profiles and field and field.is_attribute and order_by in ("value", "values")
     params = {}
     prefix = result_prefix or f"order{subquery_idx}"
 
@@ -124,7 +117,6 @@ async def build_subquery_order(
         filter_value=None,
         branch=branch,
         param_prefix=prefix,
-        support_profiles=support_profiles,
     )
     params.update(field_params)