infrahub-server 1.3.7__py3-none-any.whl → 1.4.0__py3-none-any.whl

infrahub/core/validators/uniqueness/query.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants.relationship_label import RELATIONSHIP_TO_VALUE_LABEL
+from infrahub.core.graph.schema import GraphAttributeValueIndexedNode, GraphAttributeValueNode
 from infrahub.core.query import Query, QueryType
+from infrahub.types import is_large_attribute_type
 
 from .model import QueryAttributePathValued, QueryRelationshipPathValued
 
@@ -40,6 +42,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
             items="relationships(active_path)", item_names=["branch", "branch_level"]
         )
 
+        attrs_include_large_type = False
         attribute_names = set()
         attr_paths, attr_paths_with_value, attr_values = [], [], []
         for attr_path in self.query_request.unique_attribute_paths:
@@ -49,12 +52,19 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 raise ValueError(
                     f"{attr_path.property_name} is not a valid property for a uniqueness constraint"
                 ) from exc
+            if is_large_attribute_type(attr_path.attribute_kind):
+                attrs_include_large_type = True
             attribute_names.add(attr_path.attribute_name)
             if attr_path.value:
                 attr_paths_with_value.append((attr_path.attribute_name, property_rel_name, attr_path.value))
                 attr_values.append(attr_path.value)
             else:
                 attr_paths.append((attr_path.attribute_name, property_rel_name))
+        attr_value_label = (
+            GraphAttributeValueNode.get_default_label()
+            if attrs_include_large_type
+            else GraphAttributeValueIndexedNode.get_default_label()
+        )
 
         relationship_names = set()
         relationship_attr_paths = []
@@ -112,11 +122,11 @@ class NodeUniqueAttributeConstraintQuery(Query):
         """ % {"node_kind": self.query_request.kind}
 
         attr_paths_with_value_subquery = """
-        MATCH attr_path = (start_node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[r:HAS_VALUE]->(attr_value:AttributeValue)
+        MATCH attr_path = (start_node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[r:HAS_VALUE]->(attr_value:%(attr_value_label)s)
         WHERE attr.name in $attribute_names AND attr_value.value in $attr_values
             AND [attr.name, type(r), attr_value.value] in $attr_paths_with_value
         RETURN start_node, attr_path as potential_path, NULL as rel_identifier, attr.name as potential_attr, attr_value.value as potential_attr_value
-        """ % {"node_kind": self.query_request.kind}
+        """ % {"node_kind": self.query_request.kind, "attr_value_label": attr_value_label}
 
         relationship_attr_paths_subquery = """
         MATCH rel_path = (start_node:%(node_kind)s)-[:IS_RELATED]-(relationship_node:Relationship)-[:IS_RELATED]-(related_n:Node)-[:HAS_ATTRIBUTE]->(rel_attr:Attribute)-[:HAS_VALUE]->(rel_attr_value:AttributeValue)
@@ -262,8 +272,20 @@ class UniquenessValidationQuery(Query):
         self.node_ids_to_exclude = node_ids_to_exclude
         super().__init__(**kwargs)
 
+    def _is_attribute_large_type(self, db: InfrahubDatabase, node_kind: str, attribute_name: str) -> bool:
+        """Determine if an attribute is a large type that should use AttributeValue instead of AttributeValueIndexed."""
+        node_schema = db.schema.get(node_kind, branch=self.branch, duplicate=False)
+        attr_schema = node_schema.get_attribute(attribute_name)
+        return is_large_attribute_type(attr_schema.kind)
+
     def _build_attr_subquery(
-        self, node_kind: str, attr_path: QueryAttributePathValued, index: int, branch_filter: str, is_first_query: bool
+        self,
+        node_kind: str,
+        attr_path: QueryAttributePathValued,
+        index: int,
+        branch_filter: str,
+        is_first_query: bool,
+        is_large_type: bool,
     ) -> tuple[str, dict[str, str | int | float | bool]]:
         attr_name_var = f"attr_name_{index}"
         attr_value_var = f"attr_value_{index}"
@@ -271,8 +293,16 @@ class UniquenessValidationQuery(Query):
             first_query_filter = "WHERE $node_ids_to_exclude IS NULL OR NOT node.uuid IN $node_ids_to_exclude"
         else:
             first_query_filter = ""
+
+        # Determine the appropriate label based on attribute type
+        attr_value_label = (
+            GraphAttributeValueNode.get_default_label()
+            if is_large_type
+            else GraphAttributeValueIndexedNode.get_default_label()
+        )
+
         attribute_query = """
-MATCH (node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+MATCH (node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:%(attr_value_label)s {value: $%(attr_value_var)s})
 %(first_query_filter)s
 WITH DISTINCT node
 CALL (node) {
@@ -300,6 +330,7 @@ CALL (node) {
             "attr_value_var": attr_value_var,
             "branch_filter": branch_filter,
             "index": index,
+            "attr_value_label": attr_value_label,
         }
         params: dict[str, str | int | float | bool] = {
             attr_name_var: attr_path.attribute_name,
@@ -314,6 +345,7 @@ CALL (node) {
         index: int,
         branch_filter: str,
         is_first_query: bool,
+        is_large_type: bool = False,
     ) -> tuple[str, dict[str, str | int | float | bool]]:
         params: dict[str, str | int | float | bool] = {}
         rel_attr_query = ""
@@ -321,6 +353,14 @@ CALL (node) {
         if rel_path.attribute_name and rel_path.attribute_value:
             attr_name_var = f"attr_name_{index}"
             attr_value_var = f"attr_value_{index}"
+
+            # Determine the appropriate label based on relationship attribute type
+            rel_attr_value_label = (
+                GraphAttributeValueNode.get_default_label()
+                if is_large_type
+                else GraphAttributeValueIndexedNode.get_default_label()
+            )
+
             rel_attr_query = """
     MATCH (peer)-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})
     WHERE %(branch_filter)s
@@ -330,19 +370,25 @@ CALL (node) {
     LIMIT 1
     WITH attr, is_active
     WHERE is_active = TRUE
-    MATCH (attr)-[r:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+    MATCH (attr)-[r:HAS_VALUE]->(:%(rel_attr_value_label)s {value: $%(attr_value_var)s})
     WHERE %(branch_filter)s
     WITH r
     ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
     LIMIT 1
     WITH r
     WHERE r.status = "active"
-            """ % {"attr_name_var": attr_name_var, "attr_value_var": attr_value_var, "branch_filter": branch_filter}
+            """ % {
+                "attr_name_var": attr_name_var,
+                "attr_value_var": attr_value_var,
+                "branch_filter": branch_filter,
+                "rel_attr_value_label": rel_attr_value_label,
+            }
             rel_attr_match = (
-                "-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})"
+                "-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:%(rel_attr_value_label)s {value: $%(attr_value_var)s})"
                 % {
                     "attr_name_var": attr_name_var,
                     "attr_value_var": attr_value_var,
+                    "rel_attr_value_label": rel_attr_value_label,
                 }
             )
             params[attr_name_var] = rel_path.attribute_name
@@ -426,12 +472,16 @@ CALL (node) {
         for index, schema_path in enumerate(self.query_request.unique_valued_paths):
             is_first_query = index == 0
             if isinstance(schema_path, QueryAttributePathValued):
+                is_large_type = self._is_attribute_large_type(
+                    db=db, node_kind=self.query_request.kind, attribute_name=schema_path.attribute_name
+                )
                 subquery, params = self._build_attr_subquery(
                     node_kind=self.query_request.kind,
                     attr_path=schema_path,
                     index=index,
                     branch_filter=branch_filter,
                     is_first_query=is_first_query,
+                    is_large_type=is_large_type,
                 )
             else:
                 subquery, params = self._build_rel_subquery(

infrahub/database/__init__.py

@@ -295,7 +295,8 @@ class InfrahubDatabase:
         traceback: TracebackType | None,
     ) -> None:
         if self._mode == InfrahubDatabaseMode.SESSION:
-            return await self._session.close()
+            await self._session.close()
+            return
 
         if self._mode == InfrahubDatabaseMode.TRANSACTION:
             if exc_type is not None:

infrahub/events/__init__.py

@@ -3,6 +3,17 @@ from .branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedE
 from .group_action import GroupMemberAddedEvent, GroupMemberRemovedEvent
 from .models import EventMeta, InfrahubEvent
 from .node_action import NodeCreatedEvent, NodeDeletedEvent, NodeUpdatedEvent
+from .proposed_change_action import (
+    ProposedChangeApprovalRevokedEvent,
+    ProposedChangeApprovalsRevokedEvent,
+    ProposedChangeApprovedEvent,
+    ProposedChangeMergedEvent,
+    ProposedChangeRejectedEvent,
+    ProposedChangeRejectionRevokedEvent,
+    ProposedChangeReviewRequestedEvent,
+    ProposedChangeThreadCreatedEvent,
+    ProposedChangeThreadUpdatedEvent,
+)
 from .repository_action import CommitUpdatedEvent
 from .validator_action import ValidatorFailedEvent, ValidatorPassedEvent, ValidatorStartedEvent
 
@@ -21,6 +32,15 @@ __all__ = [
     "NodeCreatedEvent",
     "NodeDeletedEvent",
     "NodeUpdatedEvent",
+    "ProposedChangeApprovalRevokedEvent",
+    "ProposedChangeApprovalsRevokedEvent",
+    "ProposedChangeApprovedEvent",
+    "ProposedChangeMergedEvent",
+    "ProposedChangeRejectedEvent",
+    "ProposedChangeRejectionRevokedEvent",
+    "ProposedChangeReviewRequestedEvent",
+    "ProposedChangeThreadCreatedEvent",
+    "ProposedChangeThreadUpdatedEvent",
     "ValidatorFailedEvent",
     "ValidatorPassedEvent",
     "ValidatorStartedEvent",

infrahub/events/constants.py

@@ -1 +1,8 @@
+from enum import Enum
+
 EVENT_NAMESPACE = "infrahub"
+
+
+class EventSortOrder(str, Enum):
+    ASC = "asc"
+    DESC = "desc"

infrahub/events/generator.py

@@ -1,14 +1,16 @@
 from infrahub.context import InfrahubContext
 from infrahub.core.branch import Branch
 from infrahub.core.changelog.models import RelationshipChangelogGetter
-from infrahub.core.constants import MutationAction
+from infrahub.core.constants import InfrahubKind, MutationAction
 from infrahub.core.node import Node
+from infrahub.core.protocols import CoreProposedChange
 from infrahub.database import InfrahubDatabase
 from infrahub.events.node_action import NodeDeletedEvent, NodeMutatedEvent, NodeUpdatedEvent, get_node_event
 from infrahub.groups.parsers import GroupNodeMutationParser
 from infrahub.worker import WORKER_IDENTITY
 
 from .models import EventMeta, InfrahubEvent
+from .proposed_change_action import ProposedChangeThreadCreatedEvent, ProposedChangeThreadUpdatedEvent
 
 
 async def generate_node_mutation_events(
@@ -68,4 +70,29 @@ async def generate_node_mutation_events(
 
     group_parser = GroupNodeMutationParser(db=db, branch=branch)
     group_events = await group_parser.group_events_from_node_actions(events=events)
-    return events + group_events
+
+    specific_events: list[InfrahubEvent] = []
+    if (kind := node.get_kind()) in [
+        InfrahubKind.CHANGETHREAD,
+        InfrahubKind.OBJECTTHREAD,
+        InfrahubKind.ARTIFACTTHREAD,
+        InfrahubKind.FILETHREAD,
+    ]:
+        proposed_change: CoreProposedChange = await node.change.get_peer(db=db, peer_type=CoreProposedChange)  # type: ignore[attr-defined]
+        action_to_event_map = {
+            MutationAction.CREATED: ProposedChangeThreadCreatedEvent,
+            MutationAction.UPDATED: ProposedChangeThreadUpdatedEvent,
+        }
+        if action in action_to_event_map:
+            specific_events.append(
+                action_to_event_map[action](
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    thread_id=node.id,
+                    thread_kind=kind,
+                    meta=EventMeta.from_context(context=context),
+                )
+            )
+
+    return events + group_events + specific_events

infrahub/events/proposed_change_action.py

@@ -0,0 +1,203 @@
+from typing import ClassVar
+
+from pydantic import Field
+
+from infrahub.core.constants import InfrahubKind, MutationAction
+
+from .constants import EVENT_NAMESPACE
+from .models import InfrahubEvent
+
+
+class ProposedChangeEvent(InfrahubEvent):
+    proposed_change_id: str = Field(..., description="The ID of the proposed change")
+    proposed_change_name: str = Field(..., description="The name of the proposed change")
+    proposed_change_state: str = Field(..., description="The state of the proposed change")
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            "prefect.resource.id": f"infrahub.proposed_change.{self.proposed_change_id}",
+            "infrahub.node.kind": InfrahubKind.PROPOSEDCHANGE,
+            "infrahub.node.id": self.proposed_change_id,
+            "infrahub.proposed_change.name": self.proposed_change_name,
+            "infrahub.proposed_change.state": self.proposed_change_state,
+            "infrahub.branch.name": self.meta.context.branch.name,
+        }
+
+
+class ProposedChangeReviewEvent(ProposedChangeEvent):
+    reviewer_account_id: str = Field(..., description="The ID of the user who reviewed the proposed change")
+    reviewer_account_name: str = Field(..., description="The name of the user who reviewed the proposed change")
+    reviewer_decision: str = Field(..., description="The decision made by the reviewer")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.reviewer_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.reviewer_account_id,
+                "infrahub.reviewer.account.name": self.reviewer_account_name,
+            }
+        )
+        return related
+
+    def get_resource(self) -> dict[str, str]:
+        return {**super().get_resource(), "infrahub.proposed_change.reviewer_decision": self.reviewer_decision}
+
+
+class ProposedChangeReviewRevokedEvent(ProposedChangeEvent):
+    reviewer_account_id: str = Field(..., description="The ID of the user who reviewed the proposed change")
+    reviewer_account_name: str = Field(..., description="The name of the user who reviewed the proposed change")
+    reviewer_former_decision: str = Field(..., description="The former decision made by the reviewer")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.reviewer_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.reviewer_account_id,
+                "infrahub.reviewer.account.name": self.reviewer_account_name,
+            }
+        )
+        return related
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            **super().get_resource(),
+            "infrahub.proposed_change.reviewer_former_decision": self.reviewer_former_decision,
+        }
+
+
+class ProposedChangeMergedEvent(ProposedChangeEvent):
+    """Event generated when a proposed change has been merged"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.merged"
+
+    merged_by_account_id: str = Field(..., description="The ID of the user who merged the proposed change")
+    merged_by_account_name: str = Field(..., description="The name of the user who merged the proposed change")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.merged_by_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.merged_by_account_id,
+                "infrahub.merged_by.account.name": self.merged_by_account_name,
+            }
+        )
+        return related
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            **super().get_resource(),
+            "infrahub.proposed_change.merged_by_account_id": self.merged_by_account_id,
+            "infrahub.proposed_change.merged_by_account_name": self.merged_by_account_name,
+        }
+
+
+class ProposedChangeReviewRequestedEvent(ProposedChangeEvent):
+    """Event generated when a proposed change has been flagged for review"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.review_requested"
+
+    requested_by_account_id: str = Field(
+        ..., description="The ID of the user who requested the proposed change to be reviewed"
+    )
+    requested_by_account_name: str = Field(
+        ..., description="The name of the user who requested the proposed change to be reviewed"
+    )
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.requested_by_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.requested_by_account_id,
+                "infrahub.requested_by.account.name": self.requested_by_account_name,
+            }
+        )
+        return related
+
+
+class ProposedChangeApprovedEvent(ProposedChangeReviewEvent):
+    """Event generated when a proposed change has been approved"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.approved"
+
+
+class ProposedChangeRejectedEvent(ProposedChangeReviewEvent):
+    """Event generated when a proposed change has been rejected"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.rejected"
+
+
+class ProposedChangeApprovalRevokedEvent(ProposedChangeReviewRevokedEvent):
+    """Event generated when a proposed change approval has been revoked"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.approval_revoked"
+
+
+class ProposedChangeRejectionRevokedEvent(ProposedChangeReviewRevokedEvent):
+    """Event generated when a proposed change rejection has been revoked"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.rejection_revoked"
+
+
+class ProposedChangeApprovalsRevokedEvent(ProposedChangeEvent):
+    reviewer_accounts: dict[str, str] = Field(
+        default_factory=dict, description="ID to name map of accounts whose approval was revoked"
+    )
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.approvals_revoked"
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        for account_id, account_name in self.reviewer_accounts.items():
+            related.append(
+                {
+                    "prefect.resource.id": account_id,
+                    "prefect.resource.role": "infrahub.related.node",
+                    "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                    "infrahub.node.id": account_id,
+                    "infrahub.reviewer.account.name": account_name,
+                }
+            )
+        return related
+
+
+class ProposedChangeThreadEvent(ProposedChangeEvent):
+    thread_id: str = Field(..., description="The ID of the thread that was created or updated")
+    thread_kind: str = Field(..., description="The name of the thread that was created or updated")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.thread_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": self.thread_kind,
+                "infrahub.node.id": self.thread_id,
+            }
+        )
+        return related
+
+
+class ProposedChangeThreadCreatedEvent(ProposedChangeThreadEvent):
+    """Event generated when a thread has been created in a proposed change"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change_thread.created"
+    action: MutationAction = MutationAction.CREATED
+
+
+class ProposedChangeThreadUpdatedEvent(ProposedChangeThreadEvent):
+    """Event generated when a thread has been updated in a proposed change"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change_thread.updated"
+    action: MutationAction = MutationAction.UPDATED

infrahub/generators/tasks.py

@@ -21,25 +21,29 @@ from infrahub.generators.models import (
 )
 from infrahub.git.base import extract_repo_file_information
 from infrahub.git.repository import get_initialized_repo
-from infrahub.services import InfrahubServices  # noqa: TC001 needed for prefect flow
+from infrahub.workers.dependencies import get_client, get_workflow
 from infrahub.workflows.catalogue import REQUEST_GENERATOR_DEFINITION_RUN, REQUEST_GENERATOR_RUN
 from infrahub.workflows.utils import add_tags
 
 if TYPE_CHECKING:
     from collections.abc import Coroutine
 
+    from infrahub_sdk.client import InfrahubClient
+
 
 @flow(
     name="generator-run",
     flow_run_name="Run generator {model.generator_definition.definition_name}",
 )
-async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -> None:
+async def run_generator(model: RequestGeneratorRun) -> None:
     await add_tags(branches=[model.branch_name], nodes=[model.target_id])
 
+    client = get_client()
+
     repository = await get_initialized_repo(
+        client=client,
         repository_id=model.repository_id,
         name=model.repository_name,
-        service=service,
         repository_kind=model.repository_kind,
         commit=model.commit,
     )
@@ -60,7 +64,7 @@ async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -
         repo_directory=repository.directory_root,
         worktree_directory=commit_worktree.directory,
     )
-    generator_instance = await _define_instance(model=model, service=service)
+    generator_instance = await _define_instance(model=model, client=client)
 
     try:
         generator_class = generator_definition.load_class(
@@ -69,7 +73,7 @@ async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -
 
         generator = generator_class(
             query=generator_definition.query,
-            client=service.client,
+            client=client,
             branch=model.branch_name,
             params=model.variables,
             generator_instance=generator_instance.id,
@@ -87,11 +91,9 @@ async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -
 
 
 @task(name="generator-define-instance", task_run_name="Define Instance", cache_policy=NONE)  # type: ignore[arg-type]
-async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices) -> CoreGeneratorInstance:
+async def _define_instance(model: RequestGeneratorRun, client: InfrahubClient) -> CoreGeneratorInstance:
     if model.generator_instance:
-        instance = await service.client.get(
-            kind=CoreGeneratorInstance, id=model.generator_instance, branch=model.branch_name
-        )
+        instance = await client.get(kind=CoreGeneratorInstance, id=model.generator_instance, branch=model.branch_name)
         instance.status.value = GeneratorInstanceStatus.PENDING.value
         await instance.update(do_full_update=True)
 
@@ -99,7 +101,7 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
         async with lock.registry.get(
             f"{model.target_id}-{model.generator_definition.definition_id}", namespace="generator"
         ):
-            instances = await service.client.filters(
+            instances = await client.filters(
                 kind=CoreGeneratorInstance,
                 definition__ids=[model.generator_definition.definition_id],
                 object__ids=[model.target_id],
@@ -110,7 +112,7 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
                 instance.status.value = GeneratorInstanceStatus.PENDING.value
                 await instance.update(do_full_update=True)
             else:
-                instance = await service.client.create(
+                instance = await client.create(
                     kind=CoreGeneratorInstance,
                     branch=model.branch_name,
                     data={
@@ -125,10 +127,10 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
 
 
 @flow(name="generator-definition-run", flow_run_name="Run all generators")
-async def run_generator_definition(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
+async def run_generator_definition(branch: str, context: InfrahubContext) -> None:
     await add_tags(branches=[branch])
 
-    generators = await service.client.filters(
+    generators = await get_client().filters(
         kind=InfrahubKind.GENERATORDEFINITION, prefetch_relationships=True, populate_store=True, branch=branch
     )
 
@@ -150,7 +152,7 @@ async def run_generator_definition(branch: str, context: InfrahubContext, servic
 
     for generator_definition in generator_definitions:
         model = RequestGeneratorDefinitionRun(branch=branch, generator_definition=generator_definition)
-        await service.workflow.submit_workflow(
+        await get_workflow().submit_workflow(
             workflow=REQUEST_GENERATOR_DEFINITION_RUN, context=context, parameters={"model": model}
         )
 
@@ -160,11 +162,13 @@ async def run_generator_definition(branch: str, context: InfrahubContext, servic
     flow_run_name="Execute generator {model.generator_definition.definition_name}",
 )
 async def request_generator_definition_run(
-    model: RequestGeneratorDefinitionRun, context: InfrahubContext, service: InfrahubServices
+    model: RequestGeneratorDefinitionRun, context: InfrahubContext
 ) -> State[Any]:
     await add_tags(branches=[model.branch], nodes=[model.generator_definition.definition_id])
 
-    group = await service.client.get(
+    client = get_client()
+
+    group = await client.get(
         kind=InfrahubKind.GENERICGROUP,
         prefetch_relationships=True,
         populate_store=True,
@@ -173,7 +177,7 @@ async def request_generator_definition_run(
     )
     await group.members.fetch()
 
-    existing_instances = await service.client.filters(
+    existing_instances = await client.filters(
         kind=InfrahubKind.GENERATORINSTANCE,
         definition__ids=[model.generator_definition.definition_id],
         include=["object"],
@@ -183,14 +187,14 @@ async def request_generator_definition_run(
     for instance in existing_instances:
         instance_by_member[instance.object.peer.id] = instance.id
 
-    repository = await service.client.get(
+    repository = await client.get(
         kind=InfrahubKind.REPOSITORY,
         branch=model.branch,
         id=model.generator_definition.repository_id,
         raise_when_missing=False,
     )
     if not repository:
-        repository = await service.client.get(
+        repository = await client.get(
             kind=InfrahubKind.READONLYREPOSITORY,
             branch=model.branch,
             id=model.generator_definition.repository_id,
@@ -219,7 +223,7 @@ async def request_generator_definition_run(
             target_name=member.display_label,
         )
         tasks.append(
-            service.workflow.execute_workflow(
+            get_workflow().execute_workflow(
                 workflow=REQUEST_GENERATOR_RUN, context=context, parameters={"model": request_generator_run_model}
             )
         )

infrahub/git/base.py

@@ -33,7 +33,7 @@ from infrahub.git.constants import BRANCHES_DIRECTORY_NAME, COMMITS_DIRECTORY_NA
 from infrahub.git.directory import get_repositories_directory, initialize_repositories_directory
 from infrahub.git.worktree import Worktree
 from infrahub.log import get_logger
-from infrahub.services import InfrahubServices  # noqa: TC001
+from infrahub.workers.dependencies import get_client
 
 if TYPE_CHECKING:
     from infrahub_sdk.branch import BranchData
@@ -153,9 +153,6 @@ class InfrahubRepositoryBase(BaseModel, ABC):
     )
 
     cache_repo: Repo | None = Field(None, description="Internal cache of the GitPython Repo object")
-    service: InfrahubServices = Field(
-        ..., description="Service object with access to the message queue, the database etc.."
-    )
     is_read_only: bool = Field(False, description="If true, changes will not be synced to remote")
 
     internal_status: str = Field("active", description="Internal status: Active, Inactive, Staging")
@@ -169,10 +166,10 @@ class InfrahubRepositoryBase(BaseModel, ABC):
 
     @property
     def sdk(self) -> InfrahubClient:
-        if self.client:
-            return self.client
+        if not self.client:
+            self.client = get_client()
 
-        return self.service.client
+        return self.client
 
     @property
     def default_branch(self) -> str: