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

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,
+    ) -> None:
         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/action_checker.py

@@ -125,7 +125,7 @@ class ActionRule:
 
 
 class ActionRulesEvaluator:
-    def __init__(self, rules: list[ActionRule]):
+    def __init__(self, rules: list[ActionRule]) -> None:
         self.rules = rules
 
     async def evaluate(

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/services/__init__.py

@@ -54,7 +54,7 @@ class InfrahubServices:
         message_bus: InfrahubMessageBus | None = None,
         workflow: InfrahubWorkflow | None = None,
         component: InfrahubComponent | None = None,
-    ):
+    ) -> None:
         """
         This method should not be called directly, use `new` instead for a proper initialization.
         """

infrahub/services/adapters/cache/nats.py

@@ -23,7 +23,7 @@ class NATSCache(InfrahubCache):
         jetstream: nats.js.JetStreamContext,
         kv: dict[int, nats.js.kv.KeyValue],
         kv_buckets: dict[str, KVTTL],
-    ):
+    ) -> None:
         self.connection = connection
         self.jetstream = jetstream
         self.kv = kv

infrahub/services/adapters/cache/redis.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
+from redis import UsernamePasswordCredentialProvider
 
 from infrahub import config
 from infrahub.services.adapters.cache import InfrahubCache
@@ -13,10 +14,16 @@ if TYPE_CHECKING:
 
 class RedisCache(InfrahubCache):
     def __init__(self) -> None:
+        credential_provider: UsernamePasswordCredentialProvider | None = None
+        if config.SETTINGS.cache.username and config.SETTINGS.cache.password:
+            credential_provider = UsernamePasswordCredentialProvider(
+                username=config.SETTINGS.cache.username, password=config.SETTINGS.cache.password
+            )
         self.connection = redis.Redis(
             host=config.SETTINGS.cache.address,
             port=config.SETTINGS.cache.service_port,
             db=config.SETTINGS.cache.database,
+            credential_provider=credential_provider,
             ssl=config.SETTINGS.cache.tls_enabled,
             ssl_cert_reqs="optional" if not config.SETTINGS.cache.tls_insecure else "none",
             ssl_check_hostname=not config.SETTINGS.cache.tls_insecure,

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,

infrahub/trigger/models.py

@@ -101,6 +101,7 @@ class TriggerType(StrEnum):
     COMPUTED_ATTR_PYTHON_QUERY = "computed_attr_python_query"
     DISPLAY_LABEL_JINJA2 = "display_label_jinja2"
     HUMAN_FRIENDLY_ID = "human_friendly_id"
+    PROFILE = "profile"
     # OBJECT = "object"
 
     @property

infrahub/trigger/setup.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Awaitable, Callable
+from typing import TYPE_CHECKING, Awaitable, Callable, Sequence
 
 from prefect import get_run_logger, task
 from prefect.automations import AutomationCore
@@ -46,7 +46,7 @@ def compare_automations(
 
 @task(name="trigger-setup-specific", task_run_name="Setup triggers of a specific kind", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_triggers_specific(
-    gatherer: Callable[[InfrahubDatabase | None], Awaitable[list[TriggerDefinition]]],
+    gatherer: Callable[[InfrahubDatabase | None], Awaitable[Sequence[TriggerDefinition]]],
     trigger_type: TriggerType,
     db: InfrahubDatabase | None = None,
 ) -> TriggerSetupReport:
@@ -69,7 +69,7 @@ async def setup_triggers_specific(
 @task(name="trigger-setup", task_run_name="Setup triggers", cache_policy=NONE)
 async def setup_triggers(
     client: PrefectClient,
-    triggers: list[TriggerDefinition],
+    triggers: Sequence[TriggerDefinition],
     trigger_type: TriggerType | None = None,
     force_update: bool = False,
 ) -> TriggerSetupReport:

infrahub/trigger/tasks.py

@@ -8,6 +8,7 @@ from infrahub.computed_attribute.gather import (
 )
 from infrahub.display_labels.gather import gather_trigger_display_labels_jinja2
 from infrahub.hfid.gather import gather_trigger_hfid
+from infrahub.profiles.gather import gather_trigger_profile_refresh
 from infrahub.trigger.catalogue import builtin_triggers
 from infrahub.webhook.gather import gather_trigger_webhook
 from infrahub.workers.dependencies import get_database
@@ -28,6 +29,7 @@ async def trigger_configure_all() -> None:
             computed_attribute_python_query_triggers,
         ) = await gather_trigger_computed_attribute_python(db=db)
         action_rules = await gather_trigger_action_rules(db=db)
+        profile_refresh_triggers = await gather_trigger_profile_refresh()
         triggers = (
             computed_attribute_j2_triggers
             + computed_attribute_python_triggers
@@ -35,6 +37,7 @@ async def trigger_configure_all() -> None:
             + display_label_triggers
             + human_friendly_id_triggers
             + builtin_triggers
+            + profile_refresh_triggers
             + webhook_trigger
             + action_rules
         )

infrahub/validators/tasks.py

@@ -29,6 +29,7 @@ async def start_validator[ValidatorType: CoreValidator](
         validator = cast("ValidatorType", validator)
     else:
         data["proposed_change"] = proposed_change
+        client.request_context = context.to_request_context()
         validator = await client.create(kind=validator_type, data=data)
         await validator.save()
 

infrahub/webhook/gather.py

@@ -13,5 +13,5 @@ from .models import WebhookTriggerDefinition
 @task(name="gather-trigger-webhook", task_run_name="Gather webhook triggers", cache_policy=NONE)
 async def gather_trigger_webhook(db: InfrahubDatabase) -> list[WebhookTriggerDefinition]:
     webhooks = await NodeManager.query(db=db, schema=CoreWebhook)
-    triggers = [WebhookTriggerDefinition.from_object(webhook) for webhook in webhooks]
+    triggers = [WebhookTriggerDefinition.from_object(webhook) for webhook in webhooks if webhook.active.value]
     return triggers

infrahub/webhook/models.py

@@ -233,7 +233,7 @@ class TransformWebhook(Webhook):
             convert_query_response=self.convert_query_response,
             data={"data": {"data": data, **context.model_dump()}},
             client=client,
-        )  # type: ignore[misc]
+        )  # type: ignore[call-overload]
 
     @classmethod
     def from_object(cls, obj: CoreCustomWebhook, transform: CoreTransformPython) -> Self: