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

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:
@@ -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

infrahub/profiles/queries/get_profile_data.py

@@ -1,33 +1,67 @@
 from dataclasses import dataclass
 from typing import Any
 
-from infrahub.core.constants import NULL_VALUE
+from infrahub.core.constants import NULL_VALUE, RelationshipDirection
 from infrahub.core.query import Query, QueryType
 from infrahub.database import InfrahubDatabase
 
 
+@dataclass
+class RelationshipFilter:
+    relationship_identifier: str
+    direction: RelationshipDirection
+
+    def __hash__(self) -> int:
+        return hash((self.relationship_identifier, self.direction))
+
+
 @dataclass
 class ProfileData:
     uuid: str
     priority: float | int
     attribute_values: dict[str, Any]
+    relationship_peers: dict[RelationshipFilter, list[str]]
 
 
 class GetProfileDataQuery(Query):
     type: QueryType = QueryType.READ
     insert_return: bool = False
 
-    def __init__(self, *args: Any, profile_ids: list[str], attr_names: list[str], **kwargs: Any):
+    def __init__(
+        self,
+        *args: Any,
+        profile_ids: list[str],
+        attr_names: list[str],
+        relationship_filters: list[RelationshipFilter] | None = None,
+        **kwargs: Any,
+    ):
         super().__init__(*args, **kwargs)
         self.profile_ids = profile_ids
         self.attr_names = attr_names
+        self.relationship_filters = relationship_filters or []
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
-        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at)
         self.params.update(branch_params)
         self.params["profile_ids"] = self.profile_ids
         self.params["attr_names"] = self.attr_names + ["profile_priority"]
 
+        # Prepare relationship filters
+        outbound_identifiers = []
+        inbound_identifiers = []
+        bidirectional_identifiers = []
+        for rf in self.relationship_filters:
+            if rf.direction == RelationshipDirection.OUTBOUND:
+                outbound_identifiers.append(rf.relationship_identifier)
+            elif rf.direction == RelationshipDirection.INBOUND:
+                inbound_identifiers.append(rf.relationship_identifier)
+            elif rf.direction == RelationshipDirection.BIDIR:
+                bidirectional_identifiers.append(rf.relationship_identifier)
+
+        self.params["outbound_identifiers"] = outbound_identifiers
+        self.params["inbound_identifiers"] = inbound_identifiers
+        self.params["bidirectional_identifiers"] = bidirectional_identifiers
+
         query = """
 // --------------
 // get the Profile nodes
@@ -48,51 +82,129 @@ WHERE is_active = TRUE
 // --------------
 // get the attributes that we care about
 // --------------
-MATCH (profile)-[:HAS_ATTRIBUTE]-(attr:Attribute)
+OPTIONAL MATCH (profile)-[:HAS_ATTRIBUTE]-(attr:Attribute)
 WHERE attr.name IN $attr_names
 WITH DISTINCT profile, attr
 CALL (profile, attr) {
-    MATCH (profile)-[r:HAS_ATTRIBUTE]->(attr)
+    OPTIONAL MATCH (profile)-[r:HAS_ATTRIBUTE]->(attr)
     WHERE %(branch_filter)s
     ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
-    RETURN r.status = "active" AS is_active
+    RETURN r.status = "active" AS r1_is_active
 }
-WITH profile, attr
-WHERE is_active = TRUE
 // --------------
 // get the attribute values
 // --------------
 CALL (attr) {
-    MATCH (attr)-[r:HAS_VALUE]->(av)
+    OPTIONAL MATCH (attr)-[r:HAS_VALUE]->(av)
     WHERE %(branch_filter)s
     ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
-    RETURN av, r.status = "active" AS is_active
+    RETURN av, r.status = "active" AS r2_is_active
     LIMIT 1
 }
-WITH profile, attr, av
-WHERE is_active = TRUE
-RETURN profile.uuid AS profile_uuid, attr.name AS attr_name, av.value AS attr_value
+// --------------
+// filter out null and inactive attributes
+// --------------
+WITH profile, CASE
+    WHEN attr IS NOT NULL AND av IS NOT NULL AND r1_is_active = TRUE AND r2_is_active = TRUE THEN [attr.name, av.value]
+    ELSE NULL
+END AS attribute_details
+WITH profile, collect(attribute_details) AS attributes
+// --------------
+// get all possible relationships we might want for this profile
+// --------------
+OPTIONAL MATCH (profile)-[r:IS_RELATED]-(rel:Relationship)
+WHERE rel.name IN $outbound_identifiers + $bidirectional_identifiers + $inbound_identifiers
+AND %(branch_filter)s
+WITH DISTINCT profile, attributes, rel
+// --------------
+// filter to active near-side relationships with names and directions we want
+// --------------
+CALL (profile, rel) {
+    OPTIONAL MATCH (profile)-[r:IS_RELATED]-(rel)
+    WHERE (
+        (rel.name IN $outbound_identifiers AND startNode(r) = profile)
+        OR (rel.name IN $bidirectional_identifiers AND startNode(r) = profile)
+        OR (rel.name IN $inbound_identifiers AND startNode(r) = rel)
+    )
+    AND %(branch_filter)s
+    RETURN r AS r1
+    ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC
+    LIMIT 1
+}
+WITH profile, attributes, r1, rel
+// --------------
+// filter to active far-side relationships with names and directions we want
+// --------------
+CALL (profile, rel) {
+    OPTIONAL MATCH (rel)-[r:IS_RELATED]-(peer)
+    WHERE peer <> profile
+    AND (
+        (rel.name IN $outbound_identifiers AND startNode(r) = rel)
+        OR (rel.name IN $bidirectional_identifiers AND startNode(r) = peer)
+        OR (rel.name IN $inbound_identifiers AND startNode(r) = peer)
+    )
+    AND %(branch_filter)s
+    RETURN r AS r2, peer
+    ORDER BY r2.branch_level DESC, r2.from DESC, r2.status ASC
+    LIMIT 1
+}
+WITH profile, attributes, r1, rel, r2, peer
+// --------------
+// save the direction of the relationship
+// --------------
+WITH *, CASE
+    WHEN r1 IS NULL OR r2 IS NULL THEN NULL
+    WHEN startNode(r1) = profile AND startNode(r2) = rel THEN "outbound"
+    WHEN startNode(r1) = rel AND startNode(r2) = peer THEN "inbound"
+    ELSE "bidirectional"
+END AS direction
+// --------------
+// filter out null and inactive relationships
+// --------------
+WITH profile, attributes, CASE
+    WHEN rel IS NOT NULL AND peer IS NOT NULL AND r1.status = "active" AND r2.status = "active" THEN [rel.name, direction, peer.uuid]
+    ELSE NULL
+END AS relationship_details
+WITH profile, attributes, collect(relationship_details) AS relationships
+RETURN profile.uuid AS profile_uuid, attributes, relationships
         """ % {"branch_filter": branch_filter}
         self.add_to_query(query)
-        self.return_labels = ["profile_uuid", "attr_name", "attr_value"]
+        self.return_labels = ["profile_uuid", "attributes", "relationships"]
 
     def get_profile_data(self) -> list[ProfileData]:
-        profile_data_by_uuid: dict[str, ProfileData] = {}
+        profile_data_list: list[ProfileData] = []
         for result in self.results:
             profile_uuid = result.get_as_type(label="profile_uuid", return_type=str)
-            if profile_uuid not in profile_data_by_uuid:
-                profile_data_by_uuid[profile_uuid] = ProfileData(
-                    uuid=profile_uuid, priority=float("inf"), attribute_values={}
-                )
-            profile_data = profile_data_by_uuid[profile_uuid]
-            attr_name = result.get_as_type(label="attr_name", return_type=str)
-            attr_value: Any = result.get(label="attr_value")
-            if attr_value == NULL_VALUE:
-                attr_value = None
-            if attr_name == "profile_priority":
-                if attr_value is not None and not isinstance(attr_value, int):
-                    attr_value = int(attr_value)
-                profile_data.priority = attr_value
-            else:
-                profile_data.attribute_values[attr_name] = attr_value
-        return list(profile_data_by_uuid.values())
+            attributes = result.get(label="attributes")
+            relationships = result.get(label="relationships")
+
+            profile_data = ProfileData(
+                uuid=profile_uuid, priority=float("inf"), attribute_values={}, relationship_peers={}
+            )
+
+            for attr_pair in attributes:
+                if not isinstance(attr_pair, list) or len(attr_pair) != 2:
+                    continue
+                attr_name, attr_value = attr_pair
+                if attr_value == NULL_VALUE:
+                    attr_value = None
+                if attr_name == "profile_priority":
+                    if attr_value is not None and not isinstance(attr_value, int):
+                        attr_value = int(attr_value)
+                    profile_data.priority = attr_value
+                else:
+                    profile_data.attribute_values[attr_name] = attr_value
+
+            # Parse relationships
+            for rel_tuple in relationships:
+                if not isinstance(rel_tuple, list) or len(rel_tuple) != 3:
+                    continue
+                rel_name, direction_str, peer_uuid = rel_tuple
+                direction = RelationshipDirection(direction_str)
+                rel_filter = RelationshipFilter(relationship_identifier=rel_name, direction=direction)
+                if rel_filter not in profile_data.relationship_peers:
+                    profile_data.relationship_peers[rel_filter] = []
+                profile_data.relationship_peers[rel_filter].append(peer_uuid)
+
+            profile_data_list.append(profile_data)
+        return profile_data_list

infrahub/profiles/tasks.py

@@ -1,11 +1,21 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from prefect import flow
 from prefect.logging import get_run_logger
 
-from infrahub.workers.dependencies import get_client, get_workflow
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.trigger.models import TriggerSetupReport, TriggerType
+from infrahub.trigger.setup import setup_triggers_specific
+from infrahub.workers.dependencies import get_client, get_component, get_database, get_workflow
 from infrahub.workflows.catalogue import PROFILE_REFRESH
-from infrahub.workflows.utils import add_tags
+from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
+
+from .gather import gather_trigger_profile_refresh
+
+if TYPE_CHECKING:
+    from infrahub_sdk.node.relationship import RelationshipManager
 
 REFRESH_PROFILES_MUTATION = """
 mutation RefreshProfiles(
@@ -20,44 +30,86 @@ mutation RefreshProfiles(
 """
 
 
-@flow(
-    name="object-profiles-refresh",
-    flow_run_name="Refresh profiles for {node_id}",
-)
-async def object_profiles_refresh(
-    branch_name: str,
-    node_id: str,
-) -> None:
+@flow(name="object-profiles-refresh", flow_run_name="Refresh profiles for {node_id}")
+async def object_profiles_refresh(branch_name: str, node_id: str) -> None:
     log = get_run_logger()
     client = get_client()
 
     await add_tags(branches=[branch_name], nodes=[node_id], db_change=True)
-    await client.execute_graphql(
-        query=REFRESH_PROFILES_MUTATION,
-        variables={"id": node_id},
-        branch_name=branch_name,
-    )
+    await client.execute_graphql(query=REFRESH_PROFILES_MUTATION, variables={"id": node_id}, branch_name=branch_name)
     log.info(f"Profiles refreshed for {node_id}")
 
 
-@flow(
-    name="objects-profiles-refresh-multiple",
-    flow_run_name="Refresh profiles for multiple objects",
-)
-async def objects_profiles_refresh_multiple(
+@flow(name="objects-profiles-refresh-multiple", flow_run_name="Refresh profiles for multiple objects")
+async def objects_profiles_refresh_multiple(branch_name: str, node_ids: list[str]) -> None:
+    log = get_run_logger()
+
+    await add_tags(branches=[branch_name])
+
+    for node_id in node_ids:
+        log.info(f"Requesting profile refresh for {node_id}")
+        await get_workflow().submit_workflow(
+            workflow=PROFILE_REFRESH, parameters={"branch_name": branch_name, "node_id": node_id}
+        )
+
+
+@flow(name="profile-refresh-setup", flow_run_name="Setup profile refresh triggers")
+async def profile_refresh_setup(
+    context: InfrahubContext,  # noqa: ARG001
+    branch_name: str | None = None,
+    event_name: str | None = None,  # noqa: ARG001
+) -> None:
+    """Setup Prefect automations for profile refresh triggers.
+
+    This flow is triggered by schema changes and sets up automations that will
+    listen for profile updates. When a profile's attributes or relationships
+    change, the corresponding automation will trigger profile refresh for all
+    related nodes.
+    """
+    database = await get_database()
+    async with database.start_session() as db:
+        log = get_run_logger()
+
+        if branch_name:
+            await add_tags(branches=[branch_name])
+            component = await get_component()
+            await wait_for_schema_to_converge(branch_name=branch_name, component=component, db=db, log=log)
+
+        report: TriggerSetupReport = await setup_triggers_specific(
+            gatherer=gather_trigger_profile_refresh, trigger_type=TriggerType.PROFILE
+        )  # type: ignore[misc]
+
+        log.info(f"{report.in_use_count} Profile refresh automation configuration completed")
+
+
+@flow(name="profile-refresh-process", flow_run_name="Process profile refresh for {profile_kind}")
+async def profile_refresh_process(
     branch_name: str,
-    node_ids: list[str],
+    profile_kind: str,
+    profile_id: str,
+    context: InfrahubContext,  # noqa: ARG001
 ) -> None:
+    """Process profile refresh when a profile's attributes or relationships change.
+
+    This flow fetches all nodes related to the profile via the `related_nodes`
+    relationship and submits profile refresh workflows for each of them.
+    """
     log = get_run_logger()
+    client = get_client()
 
     await add_tags(branches=[branch_name])
 
-    for node_id in node_ids:
+    profile = await client.get(kind=profile_kind, id=profile_id, branch=branch_name, include=["related_nodes"])
+    related_nodes: RelationshipManager = profile.related_nodes  # type: ignore
+
+    if not related_nodes.peer_ids:
+        log.info(f"No related nodes found for profile {profile_id}")
+        return
+
+    log.info(f"Found {len(related_nodes.peer_ids)} related nodes for profile {profile_id}")
+
+    for node_id in related_nodes.peer_ids:
         log.info(f"Requesting profile refresh for {node_id}")
         await get_workflow().submit_workflow(
-            workflow=PROFILE_REFRESH,
-            parameters={
-                "branch_name": branch_name,
-                "node_id": node_id,
-            },
+            workflow=PROFILE_REFRESH, parameters={"branch_name": branch_name, "node_id": node_id}
         )

infrahub/profiles/triggers.py

@@ -0,0 +1,22 @@
+from infrahub.events.branch_action import BranchDeletedEvent
+from infrahub.events.schema_action import SchemaUpdatedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import PROFILE_REFRESH_SETUP
+
+TRIGGER_PROFILE_REFRESH_SETUP = BuiltinTriggerDefinition(
+    name="profile-refresh-setup-all",
+    trigger=EventTrigger(events={SchemaUpdatedEvent.event_name, BranchDeletedEvent.event_name}),
+    actions=[
+        ExecuteWorkflow(
+            workflow=PROFILE_REFRESH_SETUP,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "event_name": "{{ event.event }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

infrahub/proposed_change/tasks.py

@@ -622,6 +622,7 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
 
     log = get_run_logger()
     client = get_client()
+    client.request_context = context.to_request_context()
 
     artifact_definition = await client.get(
         kind=CoreArtifactDefinition,
@@ -781,6 +782,7 @@ async def run_generator_as_check(model: RunGeneratorAsCheckModel, context: Infra
     await add_tags(branches=[model.branch_name], nodes=[model.proposed_change], db_change=True)
 
     client = get_client()
+    client.request_context = context.to_request_context()
     log = get_run_logger()
 
     repository = await get_initialized_repo(
@@ -859,7 +861,7 @@ async def run_generator_as_check(model: RunGeneratorAsCheckModel, context: Infra
     if check:
         check.created_at.value = Timestamp().to_string()
         check.conclusion.value = conclusion.value
-        await check.save()
+        await check.save(request_context=context.to_request_context())
     else:
         check = await client.create(
             kind=InfrahubKind.GENERATORCHECK,
@@ -925,6 +927,7 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
 
     log = get_run_logger()
     client = get_client()
+    client.request_context = context.to_request_context()
 
     proposed_change = await client.get(kind=InfrahubKind.PROPOSEDCHANGE, id=model.proposed_change)
 

infrahub/tasks/artifact.py

@@ -13,6 +13,7 @@ from infrahub.workers.dependencies import get_client
 async def define_artifact(model: CheckArtifactCreate | RequestArtifactGenerate) -> tuple[InfrahubNode, bool]:
     """Return an artifact together with a flag to indicate if the artifact is created now or already existed."""
     client = get_client()
+    client.request_context = model.context.to_request_context()
     created = False
     if model.artifact_id:
         artifact = await client.get(kind=InfrahubKind.ARTIFACT, id=model.artifact_id, branch=model.branch_name)

infrahub/transformations/tasks.py

@@ -33,7 +33,7 @@ async def transform_python(message: TransformPythonData) -> Any:
         location=message.transform_location,
         data=message.data,
         convert_query_response=message.convert_query_response,
-    )  # type: ignore[misc]
+    )  # type: ignore[call-overload]
 
     return transformed_data
 
@@ -54,6 +54,6 @@ async def transform_render_jinja2_template(message: TransformJinjaTemplateData)
 
     rendered_template = await repo.render_jinja2_template.with_options(timeout_seconds=message.timeout)(
         commit=message.commit, location=message.template_location, data={"data": message.data}
-    )  # type: ignore[misc]
+    )  # type: ignore[call-overload]
 
     return rendered_template

infrahub/trigger/catalogue.py

@@ -6,6 +6,7 @@ from infrahub.computed_attribute.triggers import (
 )
 from infrahub.display_labels.triggers import TRIGGER_DISPLAY_LABELS_ALL_SCHEMA
 from infrahub.hfid.triggers import TRIGGER_HFID_ALL_SCHEMA
+from infrahub.profiles.triggers import TRIGGER_PROFILE_REFRESH_SETUP
 from infrahub.schema.triggers import TRIGGER_SCHEMA_UPDATED
 from infrahub.trigger.models import TriggerDefinition
 from infrahub.webhook.triggers import TRIGGER_WEBHOOK_DELETE, TRIGGER_WEBHOOK_SETUP_UPDATE
@@ -17,6 +18,7 @@ builtin_triggers: list[TriggerDefinition] = [
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
     TRIGGER_DISPLAY_LABELS_ALL_SCHEMA,
     TRIGGER_HFID_ALL_SCHEMA,
+    TRIGGER_PROFILE_REFRESH_SETUP,
     TRIGGER_SCHEMA_UPDATED,
     TRIGGER_WEBHOOK_DELETE,
     TRIGGER_WEBHOOK_SETUP_UPDATE,