infrahub-server 1.3.5__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

infrahub/telemetry/tasks.py

@@ -12,16 +12,11 @@ from infrahub import __version__, config
 from infrahub.core import registry, utils
 from infrahub.core.branch import Branch
 from infrahub.core.constants import InfrahubKind
-from infrahub.services import InfrahubServices
+from infrahub.workers.dependencies import get_component, get_database, get_http
 
 from .constants import TELEMETRY_KIND, TELEMETRY_VERSION
 from .database import gather_database_information
-from .models import (
-    TelemetryBranchData,
-    TelemetryData,
-    TelemetrySchemaData,
-    TelemetryWorkerData,
-)
+from .models import TelemetryBranchData, TelemetryData, TelemetrySchemaData, TelemetryWorkerData
 from .task_manager import gather_prefect_information
 from .utils import determine_infrahub_type
 
@@ -37,8 +32,9 @@ async def gather_schema_information(branch: Branch) -> TelemetrySchemaData:
 
 
 @task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)
-async def gather_feature_information(service: InfrahubServices) -> dict[str, int]:
-    async with service.database.start_session(read_only=True) as db:
+async def gather_feature_information() -> dict[str, int]:
+    database = await get_database()
+    async with database.start_session(read_only=True) as db:
         data = {}
         features_to_count = [
             InfrahubKind.ARTIFACT,
@@ -58,11 +54,12 @@ async def gather_feature_information(service: InfrahubServices) -> dict[str, int
 
 
 @task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)
-async def gather_anonymous_telemetry_data(service: InfrahubServices) -> TelemetryData:
+async def gather_anonymous_telemetry_data() -> TelemetryData:
     start_time = time.time()
 
     default_branch = registry.get_branch_from_registry()
-    workers = await service.component.list_workers(branch=default_branch.name, schema_hash=False)
+    component = await get_component()
+    workers = await component.list_workers(branch=default_branch.name, schema_hash=False)
 
     data = TelemetryData(
         deployment_id=registry.id,
@@ -78,9 +75,9 @@ async def gather_anonymous_telemetry_data(service: InfrahubServices) -> Telemetr
         branches=TelemetryBranchData(
             total=len(registry.branch),
         ),
-        features=await gather_feature_information(service=service),
+        features=await gather_feature_information(),
         schema_info=await gather_schema_information(branch=default_branch),
-        database=await gather_database_information(db=service.database),
+        database=await gather_database_information(db=await get_database()),
         prefect=await gather_prefect_information(),
     )
 
@@ -90,14 +87,14 @@ async def gather_anonymous_telemetry_data(service: InfrahubServices) -> Telemetr
 
 
 @task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)
-async def post_telemetry_data(service: InfrahubServices, url: str, payload: dict[str, Any]) -> None:
+async def post_telemetry_data(url: str, payload: dict[str, Any]) -> None:
     """Send the telemetry data to the specified URL, using HTTP POST."""
-    response = await service.http.post(url=url, json=payload)
+    response = await get_http().post(url=url, json=payload)
     response.raise_for_status()
 
 
 @flow(name="anonymous_telemetry_send", flow_run_name="Send anonymous telemetry")
-async def send_telemetry_push(service: InfrahubServices) -> None:
+async def send_telemetry_push() -> None:
     log = get_run_logger()
     if config.SETTINGS.main.telemetry_optout:
         log.info("Skipping, User opted out of this service.")
@@ -105,7 +102,7 @@ async def send_telemetry_push(service: InfrahubServices) -> None:
 
     log.info(f"Pushing anonymous telemetry data to {config.SETTINGS.main.telemetry_endpoint}...")
 
-    data = await gather_anonymous_telemetry_data(service=service)
+    data = await gather_anonymous_telemetry_data()
     data_dict = data.model_dump(mode="json")
     log.info(f"Anonymous usage telemetry gathered in {data.execution_time} seconds. | {data_dict}")
 
@@ -116,4 +113,4 @@ async def send_telemetry_push(service: InfrahubServices) -> None:
         "checksum": hashlib.sha256(json.dumps(data_dict).encode()).hexdigest(),
     }
 
-    await post_telemetry_data(service=service, url=config.SETTINGS.main.telemetry_endpoint, payload=payload)
+    await post_telemetry_data(url=config.SETTINGS.main.telemetry_endpoint, payload=payload)

infrahub/transformations/tasks.py

@@ -4,7 +4,7 @@ from prefect import flow
 
 from infrahub.git.repository import get_initialized_repo
 from infrahub.log import get_logger
-from infrahub.services import InfrahubServices
+from infrahub.workers.dependencies import get_client
 from infrahub.workflows.utils import add_branch_tag
 
 from .models import TransformJinjaTemplateData, TransformPythonData
@@ -13,23 +13,25 @@ log = get_logger()
 
 
 @flow(name="transform_render_python", flow_run_name="Render transform python", persist_result=True)
-async def transform_python(message: TransformPythonData, service: InfrahubServices) -> Any:
+async def transform_python(message: TransformPythonData) -> Any:
     await add_branch_tag(branch_name=message.branch)
 
+    client = get_client()
+
     repo = await get_initialized_repo(
+        client=client,
         repository_id=message.repository_id,
         name=message.repository_name,
-        service=service,
         repository_kind=message.repository_kind,
         commit=message.commit,
     )
 
     transformed_data = await repo.execute_python_transform.with_options(timeout_seconds=message.timeout)(
+        client=client,
         branch_name=message.branch,
         commit=message.commit,
         location=message.transform_location,
         data=message.data,
-        client=service.client,
         convert_query_response=message.convert_query_response,
     )  # type: ignore[misc]
 
@@ -37,13 +39,15 @@ async def transform_python(message: TransformPythonData, service: InfrahubServic
 
 
 @flow(name="transform_render_jinja2_template", flow_run_name="Render transform Jinja2", persist_result=True)
-async def transform_render_jinja2_template(message: TransformJinjaTemplateData, service: InfrahubServices) -> str:
+async def transform_render_jinja2_template(message: TransformJinjaTemplateData) -> str:
     await add_branch_tag(branch_name=message.branch)
 
+    client = get_client()
+
     repo = await get_initialized_repo(
+        client=client,
         repository_id=message.repository_id,
         name=message.repository_name,
-        service=service,
         repository_kind=message.repository_kind,
         commit=message.commit,
     )

infrahub/trigger/tasks.py

@@ -6,16 +6,17 @@ from infrahub.computed_attribute.gather import (
     gather_trigger_computed_attribute_jinja2,
     gather_trigger_computed_attribute_python,
 )
-from infrahub.services import InfrahubServices
 from infrahub.trigger.catalogue import builtin_triggers
 from infrahub.webhook.gather import gather_trigger_webhook
+from infrahub.workers.dependencies import get_database
 
 from .setup import setup_triggers
 
 
 @flow(name="trigger-configure-all", flow_run_name="Configure all triggers")
-async def trigger_configure_all(service: InfrahubServices) -> None:
-    async with service.database.start_session() as db:
+async def trigger_configure_all() -> None:
+    database = await get_database()
+    async with database.start_session() as db:
         webhook_trigger = await gather_trigger_webhook(db=db)
         computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
         (

infrahub/types.py

@@ -379,3 +379,7 @@ def get_attribute_type(kind: str = "Default") -> type[InfrahubDataType]:
     """Return an InfrahubDataType object for a given kind
     If no kind is provided, return the default one."""
     return ATTRIBUTE_TYPES.get(kind, Default)
+
+
+def is_large_attribute_type(kind: str) -> bool:
+    return ATTRIBUTE_TYPES[kind] in LARGE_ATTRIBUTE_TYPES

infrahub/validators/events.py

@@ -3,11 +3,11 @@ from infrahub_sdk.protocols import CoreValidator
 from infrahub.context import InfrahubContext
 from infrahub.events.models import EventMeta
 from infrahub.events.validator_action import ValidatorFailedEvent, ValidatorPassedEvent, ValidatorStartedEvent
-from infrahub.services import InfrahubServices
+from infrahub.services.adapters.event import InfrahubEventService
 
 
 async def send_failed_validator(
-    service: InfrahubServices, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
+    event_service: InfrahubEventService, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
 ) -> None:
     event = ValidatorFailedEvent(
         node_id=validator.id,
@@ -15,11 +15,11 @@ async def send_failed_validator(
         proposed_change_id=proposed_change_id,
         meta=EventMeta.from_context(context=context),
     )
-    await service.event.send(event=event)
+    await event_service.send(event=event)
 
 
 async def send_passed_validator(
-    service: InfrahubServices, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
+    event_service: InfrahubEventService, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
 ) -> None:
     event = ValidatorPassedEvent(
         node_id=validator.id,
@@ -27,11 +27,11 @@ async def send_passed_validator(
         proposed_change_id=proposed_change_id,
         meta=EventMeta.from_context(context=context),
     )
-    await service.event.send(event=event)
+    await event_service.send(event=event)
 
 
 async def send_start_validator(
-    service: InfrahubServices, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
+    event_service: InfrahubEventService, validator: CoreValidator, proposed_change_id: str, context: InfrahubContext
 ) -> None:
     event = ValidatorStartedEvent(
         node_id=validator.id,
@@ -39,4 +39,4 @@ async def send_start_validator(
         proposed_change_id=proposed_change_id,
         meta=EventMeta.from_context(context=context),
     )
-    await service.event.send(event=event)
+    await event_service.send(event=event)

infrahub/validators/tasks.py

@@ -1,10 +1,11 @@
 from typing import Any, TypeVar, cast
 
+from infrahub_sdk.client import InfrahubClient
 from infrahub_sdk.protocols import CoreValidator
 
 from infrahub.context import InfrahubContext
 from infrahub.core.constants import ValidatorConclusion, ValidatorState
-from infrahub.services import InfrahubServices
+from infrahub.workers.dependencies import get_event_service
 
 from .events import send_start_validator
 
@@ -12,7 +13,7 @@ ValidatorType = TypeVar("ValidatorType", bound=CoreValidator)
 
 
 async def start_validator(
-    service: InfrahubServices,
+    client: InfrahubClient,
     validator: CoreValidator | None,
     validator_type: type[ValidatorType],
     proposed_change: str,
@@ -28,14 +29,12 @@ async def start_validator(
         validator = cast(ValidatorType, validator)
     else:
         data["proposed_change"] = proposed_change
-        validator = await service.client.create(
-            kind=validator_type,
-            data=data,
-        )
+        validator = await client.create(kind=validator_type, data=data)
         await validator.save()
 
+    event_service = await get_event_service()
     await send_start_validator(
-        service=service, validator=validator, proposed_change_id=proposed_change, context=context
+        event_service=event_service, validator=validator, proposed_change_id=proposed_change, context=context
     )
 
     return validator

infrahub/webhook/models.py

@@ -11,7 +11,7 @@ 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.constants import GLOBAL_BRANCH_NAME, 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
@@ -21,10 +21,11 @@ from infrahub.workflows.catalogue import WEBHOOK_PROCESS
 
 if TYPE_CHECKING:
     from httpx import Response
+    from infrahub_sdk.client import InfrahubClient
     from infrahub_sdk.protocols import CoreCustomWebhook, CoreStandardWebhook, CoreTransformPython, CoreWebhook
 
     from infrahub.core.protocols import CoreWebhook as CoreWebhookNode
-    from infrahub.services import InfrahubServices
+    from infrahub.services.adapters.http import InfrahubHTTP
 
 
 class WebhookTriggerDefinition(TriggerDefinition):
@@ -104,9 +105,8 @@ class EventContext(BaseModel):
 
         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,
+            # We use `GLOBAL_BRANCH_NAME` constant instead of `registry.get_global_branch().name` to the flow from depending on the registry
+            branch=branch_info.get("name") if branch_info and branch_info.get("name") != GLOBAL_BRANCH_NAME else None,
             account_id=account_info.get("account_id"),
             occured_at=event_occured_at,
             event=event_type,
@@ -121,25 +121,48 @@ class Webhook(BaseModel):
     validate_certificates: bool = Field(...)
     _payload: Any = None
     _headers: dict[str, Any] | None = None
+    shared_key: str | None = Field(default=None, description="Shared key for signing the webhook requests")
 
-    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:  # noqa: ARG002
+    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, client: InfrahubClient) -> None:  # noqa: ARG002
         self._payload = {"data": data, **context.model_dump()}
 
-    def _assign_headers(self) -> None:
-        self._headers = {}
+    def _assign_headers(self, uuid: UUID | None = None, at: Timestamp | None = None) -> None:
+        self._headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        if self.shared_key:
+            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 = json.dumps(self._payload or {})
+            unsigned_data = f"{message_id}.{timestamp}.{payload}".encode()
+            signature = self._sign(data=unsigned_data)
+            self._headers["webhook-id"] = message_id
+            self._headers["webhook-timestamp"] = timestamp
+            self._headers["webhook-signature"] = f"v1,{base64.b64encode(signature).decode('utf-8')}"
 
     @computed_field  # type: ignore[prop-decorator]
     @property
     def webhook_type(self) -> str:
         return self.__class__.__name__
 
-    async def prepare(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
-        await self._prepare_payload(data=data, context=context, service=service)
+    @property
+    def signing_key(self) -> str:
+        """Return the signing key for the webhook."""
+        if self.shared_key:
+            return self.shared_key
+        raise ValueError("Shared key is not set for the webhook")
+
+    async def prepare(self, data: dict[str, Any], context: EventContext, client: InfrahubClient) -> None:
+        await self._prepare_payload(data=data, context=context, client=client)
         self._assign_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)
+    async def send(
+        self, data: dict[str, Any], context: EventContext, http_service: InfrahubHTTP, client: InfrahubClient
+    ) -> Response:
+        await self.prepare(data=data, context=context, client=client)
+        return await http_service.post(url=self.url, json=self.get_payload(), headers=self._headers)
 
     def get_payload(self) -> dict[str, Any]:
         return self._payload
@@ -151,6 +174,9 @@ class Webhook(BaseModel):
     def from_cache(cls, data: dict[str, Any]) -> Self:
         return cls(**data)
 
+    def _sign(self, data: bytes) -> bytes:
+        return hmac.new(key=self.signing_key.encode(), msg=data, digestmod=hashlib.sha256).digest()
+
 
 class CustomWebhook(Webhook):
     """Custom webhook"""
@@ -162,30 +188,11 @@ class CustomWebhook(Webhook):
             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 StandardWebhook(Webhook):
-    shared_key: str = Field(...)
-
-    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 = json.dumps(self._payload or {})
-        unsigned_data = f"{message_id}.{timestamp}.{payload}".encode()
-        signature = self._sign(data=unsigned_data)
-
-        self._headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-            "webhook-id": message_id,
-            "webhook-timestamp": timestamp,
-            "webhook-signature": f"v1,{base64.b64encode(signature).decode('utf-8')}",
-        }
-
-    def _sign(self, data: bytes) -> bytes:
-        return hmac.new(key=self.shared_key.encode(), msg=data, digestmod=hashlib.sha256).digest()
-
     @classmethod
     def from_object(cls, obj: CoreStandardWebhook) -> Self:
         return cls(
@@ -207,22 +214,14 @@ class TransformWebhook(Webhook):
     transform_timeout: int = Field(...)
     convert_query_response: bool = Field(...)
 
-    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
+    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, client: InfrahubClient) -> None:
         repo: InfrahubReadOnlyRepository | InfrahubRepository
         if self.repository_kind == InfrahubKind.READONLYREPOSITORY:
             repo = await InfrahubReadOnlyRepository.init(
-                id=self.repository_id,
-                name=self.repository_name,
-                client=service.client,
-                service=service,
+                id=self.repository_id, name=self.repository_name, client=client
             )
         else:
-            repo = await InfrahubRepository.init(
-                id=self.repository_id,
-                name=self.repository_name,
-                client=service.client,
-                service=service,
-            )
+            repo = await InfrahubRepository.init(id=self.repository_id, name=self.repository_name, client=client)
 
         branch = context.branch or repo.default_branch
         commit = repo.get_commit_value(branch_name=branch)
@@ -233,7 +232,7 @@ class TransformWebhook(Webhook):
             location=f"{self.transform_file}::{self.transform_class}",
             convert_query_response=self.convert_query_response,
             data={"data": data, **context.model_dump()},
-            client=service.client,
+            client=client,
         )  # type: ignore[misc]
 
     @classmethod
@@ -251,4 +250,5 @@ class TransformWebhook(Webhook):
             transform_file=transform.file_path.value,
             transform_timeout=transform.timeout.value,
             convert_query_response=transform.convert_query_response.value or False,
+            shared_key=obj.shared_key.value,
         )

infrahub/webhook/tasks.py

@@ -8,13 +8,13 @@ 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.orchestration import get_client as get_prefect_client
 from prefect.logging import get_run_logger
 
 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_specific
+from infrahub.workers.dependencies import get_cache, get_client, get_database, get_http
 from infrahub.workflows.utils import add_tags
 
 from .gather import gather_trigger_webhook
@@ -23,6 +23,7 @@ from .models import CustomWebhook, EventContext, StandardWebhook, TransformWebho
 if TYPE_CHECKING:
     from httpx import Response
 
+
 WEBHOOK_MAP: dict[str, type[Webhook]] = {
     "StandardWebhook": StandardWebhook,
     "CustomWebhook": CustomWebhook,
@@ -31,10 +32,10 @@ WEBHOOK_MAP: dict[str, type[Webhook]] = {
 
 
 @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)
+async def webhook_send(webhook: Webhook, context: EventContext, event_data: dict) -> Response:
+    http_service = get_http()
+    client = get_client()
+    response = await webhook.send(data=event_data, context=context, http_service=http_service, client=client)
     response.raise_for_status()
     return response
 
@@ -71,21 +72,22 @@ async def webhook_process(
     event_type: str,
     event_occured_at: str,
     event_payload: dict,
-    service: InfrahubServices,
     branch_name: str | None = None,
 ) -> None:
     log = get_run_logger()
+    client = get_client()
+    cache = await get_cache()
 
     if branch_name:
         await add_tags(branches=[branch_name])
 
-    webhook_data_str = await service.cache.get(key=f"webhook:{webhook_id}")
+    webhook_data_str = await 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_node = await client.get(kind=webhook_kind, id=webhook_id)
+        webhook = await convert_node_to_webhook(webhook_node=webhook_node, client=client)
         webhook_data = webhook.to_cache()
-        await service.cache.set(key=f"webhook:{webhook_id}", value=ujson.dumps(webhook_data), expires=KVTTL.TWO_HOURS)
+        await cache.set(key=f"webhook:{webhook_id}", value=ujson.dumps(webhook_data), expires=KVTTL.TWO_HOURS)
 
     else:
         webhook_data = ujson.loads(webhook_data_str)
@@ -103,35 +105,33 @@ async def webhook_process(
         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)
+    response = await webhook_send(webhook=webhook, context=webhook_context, event_data=event_data)
     log.info(f"Successfully sent webhook to {response.url} with status {response.status_code}")
 
 
 @flow(name="webhook-setup-automation-all", flow_run_name="Configure all webhooks")
-async def configure_webhook_all(service: InfrahubServices) -> None:
+async def configure_webhook_all() -> None:
     log = get_run_logger()
 
-    async with service.database.start_session(read_only=True) as db:
+    database = await get_database()
+    async with database.start_session(read_only=True) as db:
         triggers = await gather_trigger_webhook(db=db)
 
     log.info(f"{len(triggers)} Webhooks automation configuration completed")
-    await setup_triggers_specific(
-        gatherer=gather_trigger_webhook, db=service.database, trigger_type=TriggerType.WEBHOOK
-    )  # type: ignore[misc]
+    await setup_triggers_specific(gatherer=gather_trigger_webhook, db=database, trigger_type=TriggerType.WEBHOOK)  # type: ignore[misc]
 
 
 @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()
 
-    webhook = await service.client.get(kind=CoreWebhook, id=event_data["node_id"])
+    webhook = await get_client().get(kind=CoreWebhook, id=event_data["node_id"])
     trigger = WebhookTriggerDefinition.from_object(webhook)
 
-    async with get_client(sync_client=False) as prefect_client:
+    async with get_prefect_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}")
@@ -154,18 +154,18 @@ async def configure_webhook_one(
             await prefect_client.create_automation(automation=automation)
             log.info(f"Automation {trigger.generate_name()} created")
 
-        await service.cache.delete(key=f"webhook:{webhook.id}")
+        cache = await get_cache()
+        await 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:
+    async with get_prefect_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)
@@ -175,4 +175,5 @@ async def delete_webhook_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}")
+        cache = await get_cache()
+        await cache.delete(key=f"webhook:{webhook_id}")