infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.2__py3-none-any.whl

infrahub/webhook/models.py

@@ -1,64 +1,175 @@
+from __future__ import annotations
+
 import base64
 import hashlib
 import hmac
-from datetime import datetime, timezone
-from math import floor
-from typing import Any, Optional, Union
-from uuid import uuid4
+from typing import TYPE_CHECKING, Any
+from uuid import UUID, uuid4
 
-from infrahub_sdk.protocols import CoreTransformPython
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, computed_field
+from typing_extensions import Self
 
+from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind
+from infrahub.core.timestamp import Timestamp
+from infrahub.events.utils import get_all_infrahub_node_kind_events
 from infrahub.git.repository import InfrahubReadOnlyRepository, InfrahubRepository
-from infrahub.services import InfrahubServices
-from infrahub.transformations.constants import DEFAULT_TRANSFORM_TIMEOUT
+from infrahub.trigger.constants import NAME_SEPARATOR
+from infrahub.trigger.models import EventTrigger, ExecuteWorkflow, TriggerDefinition, TriggerType
+from infrahub.workflows.catalogue import WEBHOOK_PROCESS
+
+if TYPE_CHECKING:
+    from httpx import Response
+    from infrahub_sdk.protocols import CoreCustomWebhook, CoreStandardWebhook, CoreTransformPython, CoreWebhook
+
+    from infrahub.core.protocols import CoreWebhook as CoreWebhookNode
+    from infrahub.services import InfrahubServices
+
+
+class WebhookTriggerDefinition(TriggerDefinition):
+    id: str
+    type: TriggerType = TriggerType.WEBHOOK
+
+    def generate_name(self) -> str:
+        return f"{self.type.value}{NAME_SEPARATOR}{self.id}"
 
+    @classmethod
+    def generate_name_from_id(cls, id: str) -> str:
+        return f"{TriggerType.WEBHOOK.value}{NAME_SEPARATOR}{id}"
 
-class SendWebhookData(BaseModel):
-    """Sent a webhook to an external source."""
+    @classmethod
+    def from_object(cls, obj: CoreWebhook | CoreWebhookNode) -> Self:
+        event_trigger = EventTrigger()
+        if obj.event_type.value == "all":
+            event_trigger.events.add("infrahub.*")
+        else:
+            event_trigger.events.add(obj.event_type.value)
+
+        if obj.branch_scope.value == "default_branch":
+            event_trigger.match_related = {
+                "prefect.resource.role": "infrahub.branch",
+                "infrahub.resource.label": registry.default_branch,
+            }
+        elif obj.branch_scope.value == "other_branches":
+            event_trigger.match_related = {
+                "prefect.resource.role": "infrahub.branch",
+                "infrahub.resource.label": f"!{registry.default_branch}",
+            }
+
+        if obj.node_kind.value and obj.event_type.value in get_all_infrahub_node_kind_events():
+            event_trigger.match = {"infrahub.node.kind": obj.node_kind.value}
+
+        definition = cls(
+            id=obj.id,
+            name=obj.name.value,
+            trigger=event_trigger,
+            actions=[
+                ExecuteWorkflow(
+                    workflow=WEBHOOK_PROCESS,
+                    parameters={
+                        "webhook_id": obj.id,
+                        "webhook_name": obj.name.value,
+                        "webhook_kind": obj.get_kind(),
+                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                        "event_id": "{{ event.id }}",
+                        "event_type": "{{ event.event }}",
+                        "event_occured_at": "{{ event.occurred }}",
+                        "event_payload": {
+                            "__prefect_kind": "json",
+                            "value": {"__prefect_kind": "jinja", "template": "{{ event.payload | tojson }}"},
+                        },
+                    },
+                ),
+            ],
+        )
+
+        return definition
 
-    webhook_id: str = Field(..., description="The unique ID of the webhook")
-    event_type: str = Field(..., description="The event type")
-    event_data: dict = Field(..., description="The data tied to the event")
+
+class EventContext(BaseModel):
+    id: str = Field(..., description="The internal id of the event")
+    branch: str | None = Field(None, description="The branch associated with the event")
+    account_id: str | None = Field(None, description="The id of the account associated with the event")
+    occured_at: str = Field(..., description="The time when the event occurred")
+    event: str = Field(..., description="The event type")
+
+    @classmethod
+    def from_event(cls, event_id: str, event_type: str, event_occured_at: str, event_payload: dict[str, Any]) -> Self:
+        """Extract the context from the raw event we are getting from Prefect."""
+
+        infrahub_context: dict[str, Any] = event_payload.get("context", {})
+        account_info: dict[str, Any] = infrahub_context.get("account", {})
+        branch_info: dict[str, Any] = infrahub_context.get("branch", {})
+
+        return cls(
+            id=event_id,
+            branch=branch_info.get("name")
+            if branch_info and branch_info.get("name") != registry.get_global_branch().name
+            else None,
+            account_id=account_info.get("account_id"),
+            occured_at=event_occured_at,
+            event=event_type,
+        )
 
 
 class Webhook(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
-    service: InfrahubServices = Field(...)
+    name: str = Field(...)
     url: str = Field(...)
     event_type: str = Field(...)
-    data: dict[str, Any] = Field(...)
     validate_certificates: bool = Field(...)
     _payload: Any = None
-    _headers: Optional[dict[str, Any]] = None
+    _headers: dict[str, Any] | None = None
 
-    async def _prepare_payload(self) -> None:
-        self._payload = {"event_type": self.event_type, "data": self.data}
+    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:  # noqa: ARG002
+        self._payload = {"data": data, **context.model_dump()}
 
     def _assign_headers(self) -> None:
         self._headers = {}
 
+    @computed_field  # type: ignore[prop-decorator]
     @property
     def webhook_type(self) -> str:
         return self.__class__.__name__
 
-    async def send(self) -> None:
-        await self._prepare_payload()
+    async def prepare(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
+        await self._prepare_payload(data=data, context=context, service=service)
         self._assign_headers()
-        await self.service.http.post(url=self.url, json=self._payload, headers=self._headers)
+
+    async def send(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> Response:
+        await self.prepare(data=data, context=context, service=service)
+        return await service.http.post(url=self.url, json=self.get_payload(), headers=self._headers)
+
+    def get_payload(self) -> dict[str, Any]:
+        return self._payload
+
+    def to_cache(self) -> dict[str, Any]:
+        return self.model_dump()
+
+    @classmethod
+    def from_cache(cls, data: dict[str, Any]) -> Self:
+        return cls(**data)
 
 
 class CustomWebhook(Webhook):
     """Custom webhook"""
 
+    @classmethod
+    def from_object(cls, obj: CoreCustomWebhook) -> Self:
+        return cls(
+            name=obj.name.value,
+            url=obj.url.value,
+            event_type=obj.event_type.value,
+            validate_certificates=obj.validate_certificates.value or False,
+        )
+
 
 class StandardWebhook(Webhook):
-    shared_key: bytes = Field(...)
+    shared_key: str = Field(...)
 
-    def _assign_headers(self) -> None:
-        message_id = f"msg_{uuid4().hex}"
-        timestamp = str(floor(datetime.now(tz=timezone.utc).timestamp()))
+    def _assign_headers(self, uuid: UUID | None = None, at: Timestamp | None = None) -> None:
+        message_id = f"msg_{uuid.hex}" if uuid else f"msg_{uuid4().hex}"
+        timestamp = str(at.to_timestamp()) if at else str(Timestamp().to_timestamp())
         payload = self._payload or {}
         unsigned_data = f"{message_id}.{timestamp}.{payload}".encode()
         signature = self._sign(data=unsigned_data)
@@ -72,7 +183,17 @@ class StandardWebhook(Webhook):
         }
 
     def _sign(self, data: bytes) -> bytes:
-        return hmac.new(key=self.shared_key, msg=data, digestmod=hashlib.sha256).digest()
+        return hmac.new(key=self.shared_key.encode(), msg=data, digestmod=hashlib.sha256).digest()
+
+    @classmethod
+    def from_object(cls, obj: CoreStandardWebhook) -> Self:
+        return cls(
+            name=obj.name.value,
+            url=obj.url.value,
+            event_type=obj.event_type.value,
+            validate_certificates=obj.validate_certificates.value or False,
+            shared_key=obj.shared_key.value,
+        )
 
 
 class TransformWebhook(Webhook):
@@ -82,37 +203,48 @@ class TransformWebhook(Webhook):
     transform_name: str = Field(...)
     transform_class: str = Field(...)
     transform_file: str = Field(...)
+    transform_timeout: int = Field(...)
 
-    async def _prepare_payload(self) -> None:
-        repo: Union[InfrahubReadOnlyRepository, InfrahubRepository]
+    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
+        repo: InfrahubReadOnlyRepository | InfrahubRepository
         if self.repository_kind == InfrahubKind.READONLYREPOSITORY:
             repo = await InfrahubReadOnlyRepository.init(
                 id=self.repository_id,
                 name=self.repository_name,
-                client=self.service.client,
-                service=self.service,
+                client=service.client,
+                service=service,
             )
         else:
             repo = await InfrahubRepository.init(
                 id=self.repository_id,
                 name=self.repository_name,
-                client=self.service.client,
-                service=self.service,
+                client=service.client,
+                service=service,
             )
 
-        default_branch = repo.default_branch
-        commit = repo.get_commit_value(branch_name=default_branch)
-
-        timeout = DEFAULT_TRANSFORM_TIMEOUT
-        if transform := await self.service.client.get(
-            kind=CoreTransformPython, name__value=self.transform_name, raise_when_missing=False
-        ):
-            timeout = transform.timeout.value
+        branch = context.branch or repo.default_branch
+        commit = repo.get_commit_value(branch_name=branch)
 
-        self._payload = await repo.execute_python_transform.with_options(timeout_seconds=timeout)(
-            branch_name=default_branch,
+        self._payload = await repo.execute_python_transform.with_options(timeout_seconds=self.transform_timeout)(
+            branch_name=branch,
             commit=commit,
             location=f"{self.transform_file}::{self.transform_class}",
-            data={"event_type": self.event_type, "data": self.data},
-            client=self.service.client,
+            data={"data": data, **context.model_dump()},
+            client=service.client,
+        )  # type: ignore[misc]
+
+    @classmethod
+    def from_object(cls, obj: CoreCustomWebhook, transform: CoreTransformPython) -> Self:
+        return cls(
+            name=obj.name.value,
+            url=obj.url.value,
+            event_type=obj.event_type.value,
+            validate_certificates=obj.validate_certificates.value or False,
+            repository_id=transform.repository.id,
+            repository_name=transform.repository.peer.name.value,
+            repository_kind=transform.repository.peer.get_kind(),
+            transform_name=transform.name.value,
+            transform_class=transform.class_name.value,
+            transform_file=transform.file_path.value,
+            transform_timeout=transform.timeout.value,
         )

infrahub/webhook/tasks.py

@@ -1,182 +1,181 @@
-from datetime import timedelta
-from typing import TYPE_CHECKING, Any
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import ujson
-from infrahub_sdk.protocols import CoreCustomWebhook, CoreStandardWebhook, CoreTransformPython
-from prefect import flow
+from infrahub_sdk import InfrahubClient  # noqa: TC002  needed for prefect flow
+from infrahub_sdk.protocols import CoreTransformPython, CoreWebhook
+from prefect import flow, task
 from prefect.automations import AutomationCore
+from prefect.cache_policies import NONE
 from prefect.client.orchestration import get_client
-from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
-from prefect.events.actions import RunDeployment
-from prefect.events.schemas.automations import EventTrigger, Posture
-from prefect.events.schemas.events import ResourceSpecification
 from prefect.logging import get_run_logger
 
-from infrahub.core.constants import MutationAction
-from infrahub.exceptions import NodeNotFoundError
-from infrahub.services import InfrahubServices
-from infrahub.workflows.catalogue import WEBHOOK_SEND, WEBHOOK_TRIGGER
+from infrahub.message_bus.types import KVTTL
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.trigger.models import TriggerType
+from infrahub.trigger.setup import setup_triggers
+from infrahub.workflows.utils import add_tags
 
-from .constants import AUTOMATION_NAME_RUN
-from .models import CustomWebhook, SendWebhookData, StandardWebhook, TransformWebhook, Webhook
+from .gather import gather_trigger_webhook
+from .models import CustomWebhook, EventContext, StandardWebhook, TransformWebhook, Webhook, WebhookTriggerDefinition
 
 if TYPE_CHECKING:
-    from prefect.events.schemas.automations import Automation
+    from httpx import Response
 
+WEBHOOK_MAP: dict[str, type[Webhook]] = {
+    "StandardWebhook": StandardWebhook,
+    "CustomWebhook": CustomWebhook,
+    "TransformWebhook": TransformWebhook,
+}
 
-@flow(name="event-send-webhook", flow_run_name="Send Webhook")
-async def send_webhook(model: SendWebhookData, service: InfrahubServices) -> None:
-    log = get_run_logger()
 
-    webhook_definition = await service.cache.get(key=f"webhook:active:{model.webhook_id}")
-    if not webhook_definition:
-        log.warning("Webhook not found")
-        raise NodeNotFoundError(
-            node_type="Webhook", identifier=model.webhook_id, message="The requested Webhook was not found"
+@task(name="webhook-send", task_run_name="Send Standard Webhook {webhook.name}", cache_policy=NONE, retries=3)
+async def webhook_send(
+    webhook: Webhook, context: EventContext, event_data: dict, service: InfrahubServices
+) -> Response:
+    response = await webhook.send(data=event_data, context=context, service=service)
+    response.raise_for_status()
+    return response
+
+
+@task(name="webhook-convert-node", task_run_name="Convert node to webhook", cache_policy=NONE)
+async def convert_node_to_webhook(webhook_node: CoreWebhook, client: InfrahubClient) -> Webhook:
+    webhook_kind = webhook_node.get_kind()
+
+    if webhook_kind not in ["CoreStandardWebhook", "CoreCustomWebhook"]:
+        raise ValueError(f"Unsupported webhook kind: {webhook_kind}")
+
+    if webhook_kind == "CoreStandardWebhook":
+        return StandardWebhook.from_object(obj=webhook_node)
+
+    # Processing Custom Webhook
+    if webhook_node.transformation.id:
+        transform = await client.get(
+            kind=CoreTransformPython,
+            id=webhook_node.transformation.id,
+            prefetch_relationships=True,
+            include=["name", "class_name", "file_path", "repository"],
         )
+        return TransformWebhook.from_object(obj=webhook_node, transform=transform)
+
+    return CustomWebhook.from_object(obj=webhook_node)
+
+
+@flow(name="webhook-process", flow_run_name="Send webhook for {webhook_name}")
+async def webhook_process(
+    webhook_id: str,
+    webhook_name: str,  # noqa: ARG001
+    webhook_kind: str,
+    event_id: str,
+    event_type: str,
+    event_occured_at: str,
+    event_payload: dict,
+    service: InfrahubServices,
+    branch_name: str | None = None,
+) -> None:
+    log = get_run_logger()
+
+    if branch_name:
+        await add_tags(branches=[branch_name])
+
+    webhook_data_str = await service.cache.get(key=f"webhook:{webhook_id}")
+    if not webhook_data_str:
+        log.info(f"Webhook {webhook_id} not found in cache")
+        webhook_node = await service.client.get(kind=webhook_kind, id=webhook_id)
+        webhook = await convert_node_to_webhook(webhook_node=webhook_node, client=service.client)
+        webhook_data = webhook.to_cache()
+        await service.cache.set(key=f"webhook:{webhook_id}", value=ujson.dumps(webhook_data), expires=KVTTL.TWO_HOURS)
+
+    else:
+        webhook_data = ujson.loads(webhook_data_str)
+
+        if webhook_data["webhook_type"] not in WEBHOOK_MAP:
+            raise ValueError(f"Unsupported webhook kind: {webhook_data['webhook_type']}")
+
+        webhook_class = WEBHOOK_MAP[webhook_data["webhook_type"]]
+        webhook = webhook_class.from_cache(webhook_data)
 
-    webhook_data = ujson.loads(webhook_definition)
-    payload: dict[str, Any] = {"event_type": model.event_type, "data": model.event_data, "service": service}
-    webhook_map: dict[str, type[Webhook]] = {
-        "standard": StandardWebhook,
-        "custom": CustomWebhook,
-        "transform": TransformWebhook,
-    }
-    webhook_class = webhook_map[webhook_data["webhook_type"]]
-    payload.update(webhook_data["webhook_configuration"])
-    webhook = webhook_class(**payload)
-    await webhook.send()
+    webhook_context = EventContext.from_event(
+        event_id=event_id,
+        event_type=event_type,
+        event_occured_at=event_occured_at,
+        event_payload=event_payload,
+    )
+    event_data = event_payload.get("data", {})
+    response = await webhook_send(webhook=webhook, context=webhook_context, event_data=event_data, service=service)
+    log.info(f"Successfully sent webhook to {response.url} with status {response.status_code}")
 
-    log.info("Successfully sent webhook")
 
+@flow(name="webhook-setup-automation-all", flow_run_name="Configure all webhooks")
+async def configure_webhook_all(service: InfrahubServices) -> None:
+    log = get_run_logger()
+
+    triggers = await gather_trigger_webhook(db=service.database)
 
-@flow(name="webhook-trigger-actions", flow_run_name="Trigger configured webhooks")
-async def trigger_webhooks(event_type: str, event_data: dict, service: InfrahubServices) -> None:
-    webhooks = await service.cache.list_keys(filter_pattern="webhook:active:*")
-    for webhook in webhooks:
-        webhook_id = webhook.split(":")[-1]
-        model = SendWebhookData(webhook_id=webhook_id, event_type=event_type, event_data=event_data)
-        await service.workflow.submit_workflow(workflow=WEBHOOK_SEND, parameters={"model": model})
+    async with get_client(sync_client=False) as prefect_client:
+        await setup_triggers(
+            client=prefect_client,
+            triggers=triggers,
+            trigger_type=TriggerType.WEBHOOK,
+        )  # type: ignore[misc]
 
+    log.info(f"{len(triggers)} Webhooks automation configuration completed")
 
-@flow(name="webhook-setup-automations", flow_run_name="Configuration webhook automation and populate cache")
-async def configure_webhooks(service: InfrahubServices) -> None:
+
+@flow(name="webhook-setup-automation-one", flow_run_name="Configurate webhook for {webhook_name}")
+async def configure_webhook_one(
+    webhook_name: str,  # noqa: ARG001
+    event_data: dict,
+    service: InfrahubServices,
+) -> None:
     log = get_run_logger()
 
-    log.debug("Refreshing webhook configuration")
-    standard_webhooks = await service.client.all(kind=CoreStandardWebhook)
-    custom_webhooks = await service.client.all(kind=CoreCustomWebhook)
-
-    expected_webhooks = []
-    for webhook in standard_webhooks:
-        webhook_key = f"webhook:active:{webhook.id}"
-        expected_webhooks.append(webhook_key)
-        standard_payload = {
-            "webhook_type": "standard",
-            "webhook_configuration": {
-                "url": webhook.url.value,
-                "shared_key": webhook.shared_key.value,
-                "validate_certificates": webhook.validate_certificates.value,
-            },
-        }
-        await service.cache.set(key=webhook_key, value=ujson.dumps(standard_payload))
-
-    for webhook in custom_webhooks:
-        webhook_key = f"webhook:active:{webhook.id}"
-        expected_webhooks.append(webhook_key)
-        payload: dict[str, Any] = {
-            "webhook_type": "custom",
-            "webhook_configuration": {
-                "url": webhook.url.value,
-                "validate_certificates": webhook.validate_certificates.value,
-            },
-        }
-        if webhook.transformation.id:
-            transform = await service.client.get(
-                kind=CoreTransformPython,
-                id=webhook.transformation.id,
-                prefetch_relationships=True,
-                populate_store=True,
-                include=["name", "class_name", "file_path", "repository"],
-            )
-            payload["webhook_type"] = "transform"
-            payload["webhook_configuration"]["transform_name"] = transform.name.value
-            payload["webhook_configuration"]["transform_class"] = transform.class_name.value
-            payload["webhook_configuration"]["transform_file"] = transform.file_path.value
-            payload["webhook_configuration"]["repository_id"] = transform.repository.id
-            payload["webhook_configuration"]["repository_name"] = transform.repository.peer.name.value
-
-        await service.cache.set(key=webhook_key, value=ujson.dumps(payload))
-
-    cached_webhooks = await service.cache.list_keys(filter_pattern="webhook:active:*")
-    for cached_webhook in cached_webhooks:
-        if cached_webhook not in expected_webhooks:
-            await service.cache.delete(key=cached_webhook)
-
-    has_webhooks = bool(expected_webhooks)
-
-    async with get_client(sync_client=False) as client:
-        deployments = {
-            item.name: item
-            for item in await client.read_deployments(
-                deployment_filter=DeploymentFilter(
-                    name=DeploymentFilterName(
-                        any_=[
-                            WEBHOOK_TRIGGER.name,
-                        ]
-                    )
-                )
-            )
-        }
-        if WEBHOOK_TRIGGER.name not in deployments:
-            raise ValueError("Unable to find the deployment for WEBHOOK_TRIGGER")
-
-        deployment_id_webhook_trigger = deployments[WEBHOOK_TRIGGER.name].id
-
-        webhook_configure_automation: Automation | None = None
-        automations = await client.read_automations_by_name(name=AUTOMATION_NAME_RUN)
-        if automations:
-            webhook_configure_automation = automations[0]
-
-        if not has_webhooks:
-            if webhook_configure_automation:
-                await client.delete_automation(automation_id=webhook_configure_automation.id)
-            return
+    webhook = await service.client.get(kind=CoreWebhook, id=event_data["node_id"])
+    trigger = WebhookTriggerDefinition.from_object(webhook)
+
+    async with get_client(sync_client=False) as prefect_client:
+        # Query the deployment associated with the trigger to have its ID
+        deployment_name = trigger.get_deployment_names()[0]
+        deployment = await prefect_client.read_deployment_by_name(name=f"{deployment_name}/{deployment_name}")
 
         automation = AutomationCore(
-            name=AUTOMATION_NAME_RUN,
-            description="Trigger all configured webhooks on mutations",
+            name=trigger.generate_name(),
+            description=trigger.get_description(),
             enabled=True,
-            trigger=EventTrigger(
-                posture=Posture.Reactive,
-                expect={"infrahub.node.*"},
-                within=timedelta(0),
-                match=ResourceSpecification(
-                    {
-                        "infrahub.node.action": MutationAction.available_types(),
-                    }
-                ),
-                threshold=1,
-            ),
-            actions=[
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_webhook_trigger,
-                    parameters={
-                        "event_type": "{{ event.resource['infrahub.node.kind'] }}.{{ event.resource['infrahub.node.action'] }}",
-                        "event_data": {
-                            "__prefect_kind": "json",
-                            "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['data'] | tojson }}"},
-                        },
-                    },
-                    job_variables={},
-                ),
-            ],
+            trigger=trigger.trigger.get_prefect(),
+            actions=[action.get(deployment.id) for action in trigger.actions],
         )
 
-        if webhook_configure_automation:
-            await client.update_automation(automation_id=webhook_configure_automation.id, automation=automation)
-            log.info(f"{AUTOMATION_NAME_RUN} Updated")
+        existing_automations = await prefect_client.read_automations_by_name(trigger.generate_name())
+        existing_automation = existing_automations[0] if existing_automations else None
+
+        if existing_automation:
+            await prefect_client.update_automation(automation_id=existing_automation.id, automation=automation)
+            log.info(f"Automation {trigger.generate_name()} updated")
         else:
-            await client.create_automation(automation=automation)
-            log.info(f"{AUTOMATION_NAME_RUN} Created")
+            await prefect_client.create_automation(automation=automation)
+            log.info(f"Automation {trigger.generate_name()} created")
+
+        await service.cache.delete(key=f"webhook:{webhook.id}")
+
+
+@flow(name="webhook-delete-automation", flow_run_name="Delete webhook automation for {webhook_name}")
+async def delete_webhook_automation(
+    webhook_id: str,
+    webhook_name: str,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    log = get_run_logger()
+
+    async with get_client(sync_client=False) as prefect_client:
+        automation_name = WebhookTriggerDefinition.generate_name_from_id(id=webhook_id)
+
+        existing_automations = await prefect_client.read_automations_by_name(automation_name)
+        existing_automation = existing_automations[0] if existing_automations else None
+
+        if existing_automation:
+            await prefect_client.delete_automation(automation_id=existing_automation.id)
+            log.info(f"Automation {automation_name} deleted")
+
+        await service.cache.delete(key=f"webhook:{webhook_id}")