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

infrahub/menu/repository.py

@@ -6,7 +6,7 @@ from .models import MenuDict, MenuItemDefinition, MenuItemDict
 
 
 class MenuRepository:
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase) -> None:
         self.db = db
 
     async def get_menu(self, nodes: dict[str, CoreMenuItem] | None = None) -> MenuDict:

infrahub/patch/queries/base.py

@@ -6,7 +6,7 @@ from ..models import PatchPlan
 
 
 class PatchQuery(ABC):
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase) -> None:
         self.db = db
 
     @abstractmethod

infrahub/pools/number.py

@@ -37,14 +37,7 @@ class NumberUtilizationGetter:
         query = await NumberPoolGetAllocated.init(db=self.db, pool=self.pool, branch=self.branch, branch_agnostic=True)
         await query.execute(db=self.db)
 
-        self.used = [
-            UsedNumber(
-                number=result.get_as_type(label="value", return_type=int),
-                branch=result.get_as_type(label="branch", return_type=str),
-            )
-            for result in query.results
-            if result.get_as_optional_type(label="value", return_type=int) is not None
-        ]
+        self.used = [UsedNumber(number=item.value, branch=item.branch) for item in query.get_data()]
 
         self.used_default_branch = {entry.number for entry in self.used if entry.branch == registry.default_branch}
         used_branches = {entry.number for entry in self.used if entry.branch != registry.default_branch}

infrahub/profiles/gather.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from prefect import task
+from prefect.cache_policies import NONE
+
+from infrahub.core.constants import RelationshipKind
+from infrahub.core.registry import registry
+from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+from infrahub.workflows.catalogue import PROFILE_REFRESH_PROCESS
+
+from .models import ProfileRefreshTriggerDefinition
+
+
+@task(name="gather-trigger-profile-refresh", cache_policy=NONE)
+async def gather_trigger_profile_refresh(
+    db: InfrahubDatabase | None = None,  # noqa: ARG001 Needed to have a common function signature for gathering functions
+) -> list[ProfileRefreshTriggerDefinition]:
+    """Gather profile refresh triggers for all profile schemas.
+
+    This function creates trigger definitions for each profile schema that will
+    listen for `NodeUpdatedEvent` on profiles. When a profile's attributes or
+    relationships change, the trigger will fire and execute the profile refresh
+    workflow to re-apply profiles to all related nodes.
+    """
+    branches_with_diff_from_main = registry.get_altered_schema_branches()
+    branches_to_process: list[tuple[str, list[str]]] = [(branch, []) for branch in branches_with_diff_from_main]
+    branches_to_process.append((registry.default_branch, branches_with_diff_from_main))
+
+    triggers: list[ProfileRefreshTriggerDefinition] = []
+
+    for branch_scope, branches_out_of_scope in branches_to_process:
+        schema_branch = registry.schema.get_schema_branch(name=branch_scope)
+
+        for profile_name in schema_branch.profile_names:
+            profile_schema = schema_branch.get_profile(name=profile_name, duplicate=False)
+
+            trigger_attr = [attr.name for attr in profile_schema.attributes if attr.name != "profile_name"]
+            trigger_rels = [
+                rel.name
+                for rel in profile_schema.relationships
+                if rel.kind in {RelationshipKind.GENERIC, RelationshipKind.ATTRIBUTE} and rel.name != "related_nodes"
+            ]
+            trigger_fields = sorted(trigger_attr + trigger_rels)
+
+            if trigger_fields:
+                triggers.append(
+                    ProfileRefreshTriggerDefinition.from_profile_schema(
+                        branch=branch_scope,
+                        profile_kind=profile_schema.kind,
+                        trigger_fields=trigger_fields,
+                        workflow=PROFILE_REFRESH_PROCESS,
+                        branches_out_of_scope=branches_out_of_scope,
+                    )
+                )
+
+    return triggers

infrahub/profiles/mandatory_fields_checker.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.query.node import NodeGetByHFIDQuery
+
+from .queries.get_profile_data import GetProfileDataQuery, RelationshipFilter
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.schema import NodeSchema
+    from infrahub.database import InfrahubDatabase
+
+
+@dataclass
+class ProfileIdentifiers:
+    ids: list[str]
+    hfids: list[list[str]]
+
+
+def _extract_profile_identifiers_from_input(profiles_data: Sequence[Any] | None) -> ProfileIdentifiers:
+    """Extract profile IDs and HFIDs from input data."""
+    if not profiles_data:
+        return ProfileIdentifiers(ids=[], hfids=[])
+
+    ids: list[str] = []
+    hfids: list[list[str]] = []
+    for item in profiles_data:
+        if isinstance(item, str):
+            # IDs
+            ids.append(item)
+        elif isinstance(item, dict):
+            # Dicts with `id` or `hfid` keys
+            if profile_id := item.get("id"):
+                ids.append(profile_id)
+            elif profile_hfid := item.get("hfid"):
+                hfids.append(profile_hfid)
+        elif hasattr(item, "id"):
+            # Avoid circular import by not importing Node directly
+            ids.append(item.id)
+
+    return ProfileIdentifiers(ids=ids, hfids=hfids)
+
+
+async def _resolve_hfids_to_ids(
+    db: InfrahubDatabase, branch: Branch, profile_kind: str, hfids: list[list[str]]
+) -> list[str]:
+    query = await NodeGetByHFIDQuery.init(db=db, branch=branch, node_kind=profile_kind, hfids=hfids)
+    await query.execute(db=db)
+    return query.get_node_uuids()
+
+
+class ProfilesMandatoryFieldGetter:
+    def __init__(self, db: InfrahubDatabase, branch: Branch) -> None:
+        self.db = db
+        self.branch = branch
+
+    async def get_mandatory_fields_from_profiles(
+        self,
+        schema: NodeSchema,
+        profiles_data: Sequence[Any] | None,
+        mandatory_attr_names: list[str],
+        mandatory_rel_names: list[str],
+    ) -> tuple[set[str], set[str]]:
+        """Get mandatory attributes and relationships that are provided by profiles."""
+        identifiers = _extract_profile_identifiers_from_input(profiles_data=profiles_data)
+
+        profile_ids = list(identifiers.ids)
+        if identifiers.hfids:
+            resolved_ids = await _resolve_hfids_to_ids(
+                db=self.db, branch=self.branch, profile_kind=f"Profile{schema.kind}", hfids=identifiers.hfids
+            )
+            profile_ids.extend(resolved_ids)
+
+        if not profile_ids:
+            return set(), set()
+
+        rel_filters: list[RelationshipFilter] = []
+        rel_name_to_filter: dict[str, RelationshipFilter] = {}
+        for rel_name in mandatory_rel_names:
+            rel_schema = schema.get_relationship(name=rel_name)
+            if not rel_schema.support_profiles:
+                continue
+
+            rel_filter = RelationshipFilter(
+                relationship_identifier=f"profile_{rel_schema.get_identifier()}", direction=rel_schema.direction
+            )
+            rel_filters.append(rel_filter)
+            rel_name_to_filter[rel_name] = rel_filter
+
+        query = await GetProfileDataQuery.init(
+            db=self.db,
+            branch=self.branch,
+            profile_ids=profile_ids,
+            attr_names=mandatory_attr_names,
+            relationship_filters=rel_filters,
+        )
+        await query.execute(db=self.db)
+        profile_data_list = query.get_profile_data()
+
+        provided_attrs: set[str] = set()
+        provided_rels: set[str] = set()
+
+        for profile_data in profile_data_list:
+            for attr_name in mandatory_attr_names:
+                if profile_data.attribute_values.get(attr_name) is not None:
+                    provided_attrs.add(attr_name)
+
+            for rel_name, rel_filter in rel_name_to_filter.items():
+                if profile_data.relationship_peers.get(rel_filter):
+                    provided_rels.add(rel_name)
+
+        return provided_attrs, provided_rels

infrahub/profiles/models.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Self
+
+from infrahub.core.registry import registry
+from infrahub.events import NodeUpdatedEvent
+from infrahub.trigger.constants import NAME_SEPARATOR
+from infrahub.trigger.models import EventTrigger, ExecuteWorkflow, TriggerBranchDefinition, TriggerType
+
+if TYPE_CHECKING:
+    from infrahub.workflows.models import WorkflowDefinition
+
+
+class ProfileRefreshTriggerDefinition(TriggerBranchDefinition):
+    """Trigger definition for profile refresh when profile attributes/relationships change."""
+
+    type: TriggerType = TriggerType.PROFILE
+    profile_kind: str
+
+    @classmethod
+    def from_profile_schema(
+        cls,
+        branch: str,
+        profile_kind: str,
+        trigger_fields: list[str],
+        workflow: WorkflowDefinition,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> Self:
+        """Create a trigger definition for profile refresh when profile attributes/relationships change."""
+        event_trigger = EventTrigger()
+        event_trigger.events.add(NodeUpdatedEvent.event_name)
+        event_trigger.match = {"infrahub.node.kind": profile_kind}
+
+        if branches_out_of_scope:
+            event_trigger.match["infrahub.branch.name"] = [f"!{b}" for b in branches_out_of_scope]
+        elif branch != registry.default_branch:
+            event_trigger.match["infrahub.branch.name"] = branch
+
+        event_trigger.match_related = {
+            "prefect.resource.role": ["infrahub.node.attribute_update", "infrahub.node.relationship_update"],
+            "infrahub.field.name": trigger_fields,
+        }
+
+        workflow_action = ExecuteWorkflow(
+            workflow=workflow,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "profile_kind": profile_kind,
+                "profile_id": "{{ event.resource['infrahub.node.id'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {
+                        "__prefect_kind": "jinja",
+                        "template": "{{ event.payload['context'] | tojson }}",
+                    },
+                },
+            },
+        )
+
+        return cls(
+            name=f"{profile_kind}{NAME_SEPARATOR}refresh",
+            branch=branch,
+            profile_kind=profile_kind,
+            trigger=event_trigger,
+            actions=[workflow_action],
+        )

infrahub/profiles/node_applier.py

@@ -2,10 +2,13 @@ from typing import Any
 
 from infrahub.core.attribute import BaseAttribute
 from infrahub.core.branch import Branch
+from infrahub.core.constants import InfrahubKind
 from infrahub.core.node import Node
+from infrahub.core.relationship import RelationshipManager
+from infrahub.core.relationship.model import Relationship
 from infrahub.database import InfrahubDatabase
 
-from .queries.get_profile_data import GetProfileDataQuery, ProfileData
+from .queries.get_profile_data import GetProfileDataQuery, ProfileData, RelationshipFilter
 
 
 class NodeProfilesApplier:
@@ -18,7 +21,7 @@ class NodeProfilesApplier:
     3. Profile priority determines which profile wins when multiple profiles set the same attribute
     """
 
-    def __init__(self, db: InfrahubDatabase, branch: Branch):
+    def __init__(self, db: InfrahubDatabase, branch: Branch) -> None:
         self.db = db
         self.branch = branch
 
@@ -42,13 +45,51 @@ class NodeProfilesApplier:
                 attr_names_for_profiles.append(attr_name)
         return attr_names_for_profiles
 
+    async def _get_rel_names_for_profiles(self, node: Node) -> list[str]:
+        node_schema = node.get_schema()
+
+        rel_names_for_profiles: list[str] = []
+        for rel_schema in node_schema.relationships:
+            if not rel_schema.support_profiles:
+                continue
+
+            rel_name = rel_schema.name
+            node_rel = node.get_relationship(rel_name)
+
+            current_rels = await node_rel.get_relationships(db=self.db)
+            if node_rel.is_from_profile or len(current_rels) == 0:
+                rel_names_for_profiles.append(rel_name)
+
+        return rel_names_for_profiles
+
+    async def _get_rel_filters_for_profiles(self, node: Node, rel_names: list[str]) -> list[RelationshipFilter]:
+        node_schema = node.get_schema()
+
+        identifiers: list[RelationshipFilter] = []
+        for rel_name in rel_names:
+            rel_schema = node_schema.get_relationship(name=rel_name)
+            identifiers.append(
+                RelationshipFilter(
+                    relationship_identifier=f"profile_{rel_schema.get_identifier()}", direction=rel_schema.direction
+                )
+            )
+
+        return identifiers
+
     async def _get_sorted_profile_data(
-        self, profile_ids: list[str], attr_names_for_profiles: list[str]
+        self,
+        profile_ids: list[str],
+        attr_names_for_profiles: list[str],
+        relationship_filters: list[RelationshipFilter] | None = None,
     ) -> list[ProfileData]:
         if not profile_ids:
             return []
         query = await GetProfileDataQuery.init(
-            db=self.db, branch=self.branch, profile_ids=profile_ids, attr_names=attr_names_for_profiles
+            db=self.db,
+            branch=self.branch,
+            profile_ids=profile_ids,
+            attr_names=attr_names_for_profiles,
+            relationship_filters=relationship_filters,
         )
         await query.execute(db=self.db)
         profile_data_list = query.get_profile_data()
@@ -76,35 +117,135 @@ class NodeProfilesApplier:
         node_attr.is_default = True
         node_attr.is_from_profile = False
 
+    async def _apply_profile_to_relationship(
+        self, node: Node, node_rel: RelationshipManager, peer_ids: list[str], profile_id: str
+    ) -> bool:
+        """Apply profile relationship peers to a node relationship.
+
+        Profile relationships are only applied if the node has no user-set peers for this relationship.
+        User-set peers (not from profile) take precedence over profile values.
+        """
+        is_changed = False
+
+        current_rels = await node_rel.get_relationships(db=self.db)
+        profile_peer_ids = set(peer_ids)
+
+        user_set_peer_ids: set[str] = set()
+        profile_set_rels: list[Relationship] = []
+        for rel in current_rels:
+            if rel.peer_id:
+                if rel.is_from_profile:
+                    profile_set_rels.append(rel)
+                else:
+                    user_set_peer_ids.add(rel.peer_id)
+
+        # If user has set any peers, they override profile values entirely
+        if user_set_peer_ids:
+            for rel in profile_set_rels:
+                if rel.peer_id and rel.peer_id not in user_set_peer_ids:
+                    await node_rel.remove_locally(peer_id=rel.peer_id, db=self.db)
+                    is_changed = True
+                elif rel.peer_id and rel.peer_id in user_set_peer_ids:
+                    rel.clear_source()
+                    is_changed = True
+
+            if is_changed:
+                node_rel.is_from_profile = False
+                await node_rel.save(db=self.db)
+            return is_changed
+
+        profile_set_peer_ids = {rel.peer_id for rel in profile_set_rels if rel.peer_id}
+        relationships_to_replace: dict[str, list[Relationship]] = {"insert": [], "remove": []}
+
+        # Remove relationships that are from profile but not in the new profile value
+        for rel in profile_set_rels:
+            if rel.peer_id and rel.peer_id not in profile_peer_ids:
+                relationships_to_replace["remove"].append(rel)
+
+        # Add relationships that are in profile but not present
+        for peer_id in profile_peer_ids:
+            if peer_id not in profile_set_peer_ids:
+                new_rel = Relationship(
+                    schema=node_rel.schema,
+                    branch=self.branch,
+                    source_kind=InfrahubKind.PROFILE,
+                    node=node,
+                )
+                await new_rel.new(db=self.db, data=peer_id)
+                new_rel.set_source(value=profile_id)
+                relationships_to_replace["insert"].append(new_rel)
+
+        is_changed |= await node_rel.update_relationships(
+            db=self.db,
+            relationships_to_remove=relationships_to_replace["remove"],
+            relationships_to_insert=relationships_to_replace["insert"],
+        )
+
+        if profile_peer_ids:
+            node_rel.is_from_profile = True
+
+        if is_changed:
+            await node_rel.save(db=self.db)
+
+        return is_changed
+
+    async def _remove_profile_from_relationship(self, relationship_manager: RelationshipManager) -> None:
+        relationship_manager.is_from_profile = False
+        await relationship_manager.delete(db=self.db)
+
     async def apply_profiles(self, node: Node) -> list[str]:
         profile_ids = await self._get_profile_ids(node=node)
         attr_names_for_profiles = await self._get_attr_names_for_profiles(node=node)
-
-        if not attr_names_for_profiles:
+        rel_names_for_profiles = await self._get_rel_names_for_profiles(node=node)
+        rel_filters_for_profiles = await self._get_rel_filters_for_profiles(node=node, rel_names=rel_names_for_profiles)
+        if not attr_names_for_profiles and not rel_filters_for_profiles:
             return []
 
-        # get profiles priorities and attribute values on branch
+        # get profiles priorities, attribute values, and relationship peers on branch
         sorted_profile_data = await self._get_sorted_profile_data(
-            profile_ids=profile_ids, attr_names_for_profiles=attr_names_for_profiles
+            profile_ids=profile_ids,
+            attr_names_for_profiles=attr_names_for_profiles,
+            relationship_filters=rel_filters_for_profiles,
         )
 
-        updated_field_names = []
+        updated_field_names: list[str] = []
         # set attribute values/is_default/is_from_profile on nodes
         for attr_name in attr_names_for_profiles:
-            has_profile_data = False
+            has_profile_attr_data = False
             node_attr = node.get_attribute(attr_name)
             for profile_data in sorted_profile_data:
                 profile_value = profile_data.attribute_values.get(attr_name)
                 if profile_value is not None:
-                    has_profile_data = True
-                    is_changed = False
+                    has_profile_attr_data = True
                     is_changed = self._apply_profile_to_attribute(
                         node_attr=node_attr, profile_value=profile_value, profile_id=profile_data.uuid
                     )
                     if is_changed:
                         updated_field_names.append(attr_name)
                     break
-            if not has_profile_data and node_attr.is_from_profile:
+            if not has_profile_attr_data and node_attr.is_from_profile:
                 self._remove_profile_from_attribute(node_attr=node_attr)
                 updated_field_names.append(attr_name)
+
+        for rel_filter in rel_filters_for_profiles:
+            has_profile_rel_data = False
+            node_rel = node.get_relationship_by_identifier(rel_filter.relationship_identifier.removeprefix("profile_"))
+
+            for profile_data in sorted_profile_data:
+                profile_peers = profile_data.relationship_peers.get(rel_filter)
+                if profile_peers:
+                    has_profile_rel_data = True
+                    is_changed = await self._apply_profile_to_relationship(
+                        node=node, node_rel=node_rel, peer_ids=profile_peers, profile_id=profile_data.uuid
+                    )
+                    if is_changed:
+                        updated_field_names.append(node_rel.name)
+                    break
+
+            # Refresh the relationship manager to update the is_from_profile property
+            await node_rel.fetch_relationship_ids(db=self.db)
+            if not has_profile_rel_data and node_rel.is_from_profile:
+                await self._remove_profile_from_relationship(relationship_manager=node_rel)
+                updated_field_names.append(node_rel.name)
+
         return updated_field_names