infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

infrahub/core/migrations/graph/m040_profile_attrs_in_db.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Console
+from rich.progress import Progress
+
+from infrahub.core.branch.models import Branch
+from infrahub.core.initialization import initialization
+from infrahub.core.manager import NodeManager
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.query import Query, QueryType
+from infrahub.core.timestamp import Timestamp
+from infrahub.lock import initialize_lock
+from infrahub.log import get_logger
+from infrahub.profiles.node_applier import NodeProfilesApplier
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.core.node import Node
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class GetProfilesByBranchQuery(Query):
+    """
+    Get CoreProfile UUIDs by which branches they have attribute updates on
+    """
+
+    name = "get_profiles_by_branch"
+    type = QueryType.READ
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (profile:CoreProfile)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[e:HAS_VALUE]->(:AttributeValue)
+WITH DISTINCT profile.uuid AS profile_uuid, e.branch AS branch
+RETURN profile_uuid, collect(branch) AS branches
+        """
+        self.add_to_query(query)
+        self.return_labels = ["profile_uuid", "branches"]
+
+    def get_profile_ids_by_branch(self) -> dict[str, set[str]]:
+        """Get dictionary of branch names to set of updated profile UUIDs"""
+        profiles_by_branch = defaultdict(set)
+        for result in self.get_results():
+            profile_uuid = result.get_as_type("profile_uuid", str)
+            branches = result.get_as_type("branches", list[str])
+            for branch in branches:
+                profiles_by_branch[branch].add(profile_uuid)
+        return profiles_by_branch
+
+
+class GetNodesWithProfileUpdatesByBranchQuery(Query):
+    """
+    Get Node UUIDs by which branches they have updated profiles on
+    """
+
+    name = "get_nodes_with_profile_updates_by_branch"
+    type = QueryType.READ
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (node:Node)-[e1:IS_RELATED]->(:Relationship {name: "node__profile"})
+WHERE NOT node:CoreProfile
+WITH DISTINCT node.uuid AS node_uuid, e1.branch AS branch
+RETURN node_uuid, collect(branch) AS branches
+        """
+        self.add_to_query(query)
+        self.return_labels = ["node_uuid", "branches"]
+
+    def get_node_ids_by_branch(self) -> dict[str, set[str]]:
+        """Get dictionary of branch names to set of updated node UUIDs"""
+        nodes_by_branch = defaultdict(set)
+        for result in self.get_results():
+            node_uuid = result.get_as_type("node_uuid", str)
+            branches = result.get_as_type("branches", list[str])
+            for branch in branches:
+                nodes_by_branch[branch].add(node_uuid)
+        return nodes_by_branch
+
+
+class Migration040(ArbitraryMigration):
+    """
+    Save profile attribute values on each node using the profile in the database
+    For any profile that has updates on a given branch (including default branch)
+    - run NodeProfilesApplier.apply_profiles on each node related to the profile on that branch
+    For any node that has an updated relationship to a profile on a given branch
+    - run NodeProfilesApplier.apply_profiles on the node on that branch
+    """
+
+    name: str = "040_profile_attrs_in_db"
+    minimum_version: int = 39
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._appliers_by_branch: dict[str, NodeProfilesApplier] = {}
+
+    async def _get_profile_applier(self, db: InfrahubDatabase, branch_name: str) -> NodeProfilesApplier:
+        if branch_name not in self._appliers_by_branch:
+            branch = await Branch.get_by_name(db=db, name=branch_name)
+            self._appliers_by_branch[branch_name] = NodeProfilesApplier(db=db, branch=branch)
+        return self._appliers_by_branch[branch_name]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        console = Console()
+        result = MigrationResult()
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+
+        console.print("Gathering profiles for each branch...", end="")
+        get_profiles_by_branch_query = await GetProfilesByBranchQuery.init(db=db)
+        await get_profiles_by_branch_query.execute(db=db)
+        profiles_ids_by_branch = get_profiles_by_branch_query.get_profile_ids_by_branch()
+
+        profiles_by_branch: dict[str, list[Node]] = {}
+        for branch_name, profile_ids in profiles_ids_by_branch.items():
+            profiles_map = await NodeManager.get_many(db=db, branch=branch_name, ids=list(profile_ids))
+            profiles_by_branch[branch_name] = list(profiles_map.values())
+        console.print("done")
+
+        node_ids_to_update_by_branch: dict[str, set[str]] = defaultdict(set)
+        total_size = sum(len(profiles) for profiles in profiles_by_branch.values())
+        with Progress() as progress:
+            gather_nodes_task = progress.add_task(
+                "Gathering affected objects for each profile on each branch...", total=total_size
+            )
+
+            for branch_name, profiles in profiles_by_branch.items():
+                for profile in profiles:
+                    node_relationship_manager = profile.get_relationship("related_nodes")
+                    node_peers = await node_relationship_manager.get_db_peers(db=db)
+                    node_ids_to_update_by_branch[branch_name].update({str(peer.peer_id) for peer in node_peers})
+                    progress.update(gather_nodes_task, advance=1)
+
+        console.print("Identifying nodes with profile updates by branch...", end="")
+        get_nodes_with_profile_updates_by_branch_query = await GetNodesWithProfileUpdatesByBranchQuery.init(db=db)
+        await get_nodes_with_profile_updates_by_branch_query.execute(db=db)
+        nodes_ids_by_branch = get_nodes_with_profile_updates_by_branch_query.get_node_ids_by_branch()
+        for branch_name, node_ids in nodes_ids_by_branch.items():
+            node_ids_to_update_by_branch[branch_name].update(node_ids)
+        console.print("done")
+
+        right_now = Timestamp()
+        total_size = sum(len(node_ids) for node_ids in node_ids_to_update_by_branch.values())
+        with Progress() as progress:
+            apply_task = progress.add_task("Applying profiles to nodes...", total=total_size)
+            for branch_name, node_ids in node_ids_to_update_by_branch.items():
+                applier = await self._get_profile_applier(db=db, branch_name=branch_name)
+                for node_id in node_ids:
+                    node = await NodeManager.get_one(db=db, branch=branch_name, id=node_id, at=right_now)
+                    if node:
+                        updated_field_names = await applier.apply_profiles(node=node)
+                        if updated_field_names:
+                            await node.save(db=db, fields=updated_field_names, at=right_now)
+                    progress.update(apply_task, advance=1)
+
+        return result

infrahub/core/node/__init__.py

@@ -42,6 +42,7 @@ from infrahub.types import ATTRIBUTE_TYPES
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
 from ...graphql.models import OrderModel
 from ...log import get_logger
+from ..attribute import BaseAttribute
 from ..query.relationship import RelationshipDeleteAllQuery
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
@@ -53,8 +54,6 @@ if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.database import InfrahubDatabase
 
-    from ..attribute import BaseAttribute
-
 SchemaProtocol = TypeVar("SchemaProtocol")
 
 # ---------------------------------------------------------------------------------------
@@ -100,6 +99,28 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     def get_updated_at(self) -> Timestamp | None:
         return self._updated_at
 
+    def get_attribute(self, name: str) -> BaseAttribute:
+        attribute = getattr(self, name)
+        if not isinstance(attribute, BaseAttribute):
+            raise ValueError(f"{name} is not an attribute of {self.get_kind()}")
+        return attribute
+
+    def get_relationship(self, name: str) -> RelationshipManager:
+        relationship = getattr(self, name)
+        if not isinstance(relationship, RelationshipManager):
+            raise ValueError(f"{name} is not a relationship of {self.get_kind()}")
+        return relationship
+
+    def uses_profiles(self) -> bool:
+        for attr_name in self.get_schema().attribute_names:
+            try:
+                node_attr = self.get_attribute(attr_name)
+            except ValueError:
+                continue
+            if node_attr and node_attr.is_from_profile:
+                return True
+        return False
+
     async def get_hfid(self, db: InfrahubDatabase, include_kind: bool = False) -> list[str] | None:
         """Return the Human friendly id of the node."""
         if not self._schema.human_friendly_id:

infrahub/core/node/create.py

@@ -2,18 +2,23 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Mapping
 
+from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
-from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
+from infrahub.core.node.lock_utils import get_kind_lock_names_on_object_mutation
 from infrahub.core.protocols import CoreObjectTemplate
+from infrahub.core.schema import GenericSchema
 from infrahub.dependencies.registry import get_component_registry
+from infrahub.lock import InfrahubMultiLock
+from infrahub.profiles.node_applier import NodeProfilesApplier
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.relationship.model import RelationshipManager
     from infrahub.core.schema import MainSchemaTypes, NonGenericSchemaTypes, RelationshipSchema
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -76,6 +81,7 @@ async def handle_template_relationships(
     template: CoreObjectTemplate,
     fields: list,
     constraint_runner: NodeConstraintRunner | None = None,
+    at: Timestamp | None = None,
 ) -> None:
     if constraint_runner is None:
         component_registry = get_component_registry()
@@ -103,7 +109,7 @@ async def handle_template_relationships(
                 current_template=template,
             )
 
-            obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch)
+            obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch, at=at)
             await obj_peer.new(db=db, **obj_peer_data)
             await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
             await obj_peer.save(db=db)
@@ -115,6 +121,7 @@ async def handle_template_relationships(
                 obj=obj_peer,
                 template=template_relationship_peer,
                 fields=fields,
+                at=at,
             )
 
 
@@ -125,43 +132,20 @@ async def get_profile_ids(db: InfrahubDatabase, obj: Node) -> set[str]:
     return {pr.peer_id for pr in profile_rels}
 
 
-async def refresh_for_profile_update(
-    db: InfrahubDatabase,
-    branch: Branch,
-    obj: Node,
-    schema: NonGenericSchemaTypes,
-    previous_profile_ids: set[str] | None = None,
-) -> Node:
-    if not hasattr(obj, "profiles"):
-        return obj
-    current_profile_ids = await get_profile_ids(db=db, obj=obj)
-    if previous_profile_ids is None or previous_profile_ids != current_profile_ids:
-        refreshed_node = await NodeManager.get_one_by_id_or_default_filter(
-            db=db,
-            kind=schema.kind,
-            id=obj.get_id(),
-            branch=branch,
-            include_owner=True,
-            include_source=True,
-        )
-        refreshed_node._node_changelog = obj.node_changelog
-        return refreshed_node
-    return obj
-
-
 async def _do_create_node(
     node_class: type[Node],
+    node_constraint_runner: NodeConstraintRunner,
     db: InfrahubDatabase,
-    data: dict,
     schema: NonGenericSchemaTypes,
-    fields_to_validate: list,
     branch: Branch,
-    node_constraint_runner: NodeConstraintRunner,
+    fields_to_validate: list[str],
+    data: dict[str, Any],
+    at: Timestamp | None = None,
 ) -> Node:
     obj = await node_class.init(db=db, schema=schema, branch=branch)
     await obj.new(db=db, **data)
     await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-    await obj.save(db=db)
+    await obj.save(db=db, at=at)
 
     object_template = await obj.get_object_template(db=db)
     if object_template:
@@ -171,18 +155,62 @@ async def _do_create_node(
             template=object_template,
             obj=obj,
             fields=fields_to_validate,
+            at=at,
         )
     return obj
 
 
+async def _do_create_node_with_lock(
+    node_class: type[Node],
+    node_constraint_runner: NodeConstraintRunner,
+    db: InfrahubDatabase,
+    schema: NonGenericSchemaTypes,
+    branch: Branch,
+    fields_to_validate: list[str],
+    data: dict[str, Any],
+    at: Timestamp | None = None,
+) -> Node:
+    schema_branch = registry.schema.get_schema_branch(name=branch.name)
+    lock_names = get_kind_lock_names_on_object_mutation(
+        kind=schema.kind, branch=branch, schema_branch=schema_branch, data=dict(data)
+    )
+
+    if lock_names:
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            return await _do_create_node(
+                node_class=node_class,
+                node_constraint_runner=node_constraint_runner,
+                db=db,
+                schema=schema,
+                branch=branch,
+                fields_to_validate=fields_to_validate,
+                data=data,
+                at=at,
+            )
+    return await _do_create_node(
+        node_class=node_class,
+        node_constraint_runner=node_constraint_runner,
+        db=db,
+        schema=schema,
+        branch=branch,
+        fields_to_validate=fields_to_validate,
+        data=data,
+        at=at,
+    )
+
+
 async def create_node(
-    data: dict,
+    data: dict[str, Any],
     db: InfrahubDatabase,
     branch: Branch,
-    schema: NonGenericSchemaTypes,
+    schema: MainSchemaTypes,
+    at: Timestamp | None = None,
 ) -> Node:
     """Create a node in the database if constraint checks succeed."""
 
+    if isinstance(schema, GenericSchema):
+        raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+
     component_registry = get_component_registry()
     node_constraint_runner = await component_registry.get_component(
         NodeConstraintRunner, db=db.start_session() if not db.is_transaction else db, branch=branch
@@ -193,7 +221,7 @@ async def create_node(
 
     fields_to_validate = list(data)
     if db.is_transaction:
-        obj = await _do_create_node(
+        obj = await _do_create_node_with_lock(
             node_class=node_class,
             node_constraint_runner=node_constraint_runner,
             db=db,
@@ -201,10 +229,11 @@ async def create_node(
             branch=branch,
             fields_to_validate=fields_to_validate,
             data=data,
+            at=at,
         )
     else:
         async with db.start_transaction() as dbt:
-            obj = await _do_create_node(
+            obj = await _do_create_node_with_lock(
                 node_class=node_class,
                 node_constraint_runner=node_constraint_runner,
                 db=dbt,
@@ -212,9 +241,12 @@ async def create_node(
                 branch=branch,
                 fields_to_validate=fields_to_validate,
                 data=data,
+                at=at,
             )
 
     if await get_profile_ids(db=db, obj=obj):
-        obj = await refresh_for_profile_update(db=db, branch=branch, schema=schema, obj=obj)
+        node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+        await node_profiles_applier.apply_profiles(node=obj)
+        await obj.save(db=db)
 
     return obj

infrahub/core/node/lock_utils.py

@@ -0,0 +1,98 @@
+import hashlib
+from typing import Any
+
+from infrahub.core.branch import Branch
+from infrahub.core.constants.infrahubkind import GENERICGROUP, GRAPHQLQUERYGROUP
+from infrahub.core.schema import GenericSchema
+from infrahub.core.schema.schema_branch import SchemaBranch
+
+KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED = [GENERICGROUP]
+
+
+def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch) -> list[str]:
+    """
+    Return kinds for which we want to lock during creating / updating an object of a given schema node.
+    Lock should be performed on schema kind and its generics having a uniqueness_constraint defined.
+    If a generic uniqueness constraint is the same as the node schema one,
+    it means node schema overrided this constraint, in which case we only need to lock on the generic.
+    """
+
+    node_schema = schema_branch.get(name=kind, duplicate=False)
+
+    schema_uc = None
+    kinds = []
+    if node_schema.uniqueness_constraints:
+        kinds.append(node_schema.kind)
+        schema_uc = node_schema.uniqueness_constraints
+
+    if isinstance(node_schema, GenericSchema):
+        return kinds
+
+    generics_kinds = node_schema.inherit_from
+
+    node_schema_kind_removed = False
+    for generic_kind in generics_kinds:
+        generic_uc = schema_branch.get(name=generic_kind, duplicate=False).uniqueness_constraints
+        if generic_uc:
+            kinds.append(generic_kind)
+            if not node_schema_kind_removed and generic_uc == schema_uc:
+                # Check whether we should remove original schema kind as it simply overrides uniqueness_constraint
+                # of a generic
+                kinds.pop(0)
+                node_schema_kind_removed = True
+    return kinds
+
+
+def _should_kind_be_locked_on_any_branch(kind: str, schema_branch: SchemaBranch) -> bool:
+    """
+    Check whether kind or any kind generic is in KINDS_TO_LOCK_ON_ANY_BRANCH.
+    """
+
+    if kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
+        return True
+
+    node_schema = schema_branch.get(name=kind, duplicate=False)
+    if isinstance(node_schema, GenericSchema):
+        return False
+
+    for generic_kind in node_schema.inherit_from:
+        if generic_kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
+            return True
+    return False
+
+
+def _hash(value: str) -> str:
+    # Do not use builtin `hash` for lock names as due to randomization results would differ between
+    # different processes.
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def get_kind_lock_names_on_object_mutation(
+    kind: str, branch: Branch, schema_branch: SchemaBranch, data: dict[str, Any]
+) -> list[str]:
+    """
+    Return objects kind for which we want to avoid concurrent mutation (create/update). Except for some specific kinds,
+    concurrent mutations are only allowed on non-main branch as objects validations will be performed at least when merging in main branch.
+    """
+
+    if not branch.is_default and not _should_kind_be_locked_on_any_branch(kind=kind, schema_branch=schema_branch):
+        return []
+
+    if kind == GRAPHQLQUERYGROUP:
+        # Lock on name as well to improve performances
+        try:
+            name = data["name"].value
+            return [build_object_lock_name(kind + "." + _hash(name))]
+        except KeyError:
+            # We might reach here if we are updating a CoreGraphQLQueryGroup without updating the name,
+            # in which case we would not need to lock. This is not supposed to happen as current `update`
+            # logic first fetches the node with its name.
+            return []
+
+    lock_kinds = _get_kinds_to_lock_on_object_mutation(kind, schema_branch)
+    lock_names = [build_object_lock_name(kind) for kind in lock_kinds]
+    return lock_names
+
+
+def build_object_lock_name(name: str) -> str:
+    return f"global.object.{name}"

infrahub/core/property.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from enum import Enum
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -26,6 +27,10 @@ class NodePropertyData(BaseModel):
     peer_id: str
 
 
+class ClearValue(Enum):
+    CLEAR = "clear"
+
+
 class FlagPropertyMixin:
     _flag_properties: list[str] = [v.value for v in FlagProperty]
 
@@ -51,6 +56,7 @@ class NodePropertyMixin:
         for node in self._node_properties:
             setattr(self, f"_{node}", None)
             setattr(self, f"{node}_id", None)
+            setattr(self, f"_clear_{node}", False)
 
         if not kwargs:
             return
@@ -79,12 +85,14 @@ class NodePropertyMixin:
 
     def clear_owner(self) -> None:
         self._set_node_property(name="owner", value=None)
+        self._clear_owner = True
 
     async def get_source(self, db: InfrahubDatabase) -> Node | None:
         return await self._get_node_property(name="source", db=db)
 
     def clear_source(self) -> None:
         self._set_node_property(name="source", value=None)
+        self._clear_source = True
 
     def set_source(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="source", value=value)
@@ -95,6 +103,9 @@ class NodePropertyMixin:
     def set_owner(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="owner", value=value)
 
+    def is_clear(self, name: str) -> bool:
+        return getattr(self, f"_clear_{name}", False)
+
     def _get_node_property_from_cache(self, name: str) -> Node:
         """Return the node attribute if it's already present locally,
         Otherwise raise an exception

infrahub/core/protocols.py

@@ -125,6 +125,7 @@ class CoreGenericRepository(CoreNode):
     queries: RelationshipManager
     checks: RelationshipManager
     generators: RelationshipManager
+    groups_objects: RelationshipManager
 
 
 class CoreGroup(CoreNode):

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,18 +153,34 @@ 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"]
 
 
@@ -204,7 +222,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 +268,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 +285,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