infrahub-server 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

infrahub/patch/queries/delete_duplicated_edges.py

@@ -0,0 +1,138 @@
+from ..models import EdgeToDelete, EdgeToUpdate, PatchPlan
+from .base import PatchQuery
+
+
+class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
+    """
+    Find duplicated or overlapping edges of the same status, type, and branch to update and delete
+    - one edge will be kept for each pair of nodes and a given status, type, and branch. it will be
+        updated to have the earliest "from" and "to" times in this group
+    - all the other duplicate/overlapping edges will be deleted
+    """
+
+    @property
+    def name(self) -> str:
+        return "delete-duplicated-edges"
+
+    async def plan(self) -> PatchPlan:
+        query = """
+// ------------
+// Find node pairs that have duplicate edges
+// ------------
+MATCH (node_with_dup_edges:Node)-[edge]->(peer)
+WITH node_with_dup_edges, type(edge) AS edge_type, edge.status AS edge_status, edge.branch AS edge_branch, peer, count(*) AS num_dup_edges
+WHERE num_dup_edges > 1
+WITH DISTINCT node_with_dup_edges, edge_type, edge_branch, peer
+CALL {
+    // ------------
+    // Get the earliest active and deleted edges for this branch
+    // ------------
+    WITH node_with_dup_edges, edge_type, edge_branch, peer
+    MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]->(peer)
+    WHERE type(active_edge) = edge_type
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, active_edge
+    ORDER BY active_edge.from ASC
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, head(collect(active_edge.from)) AS active_from
+    OPTIONAL MATCH (node_with_dup_edges)-[deleted_edge {branch: edge_branch, status: "deleted"}]->(peer)
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_edge
+    ORDER BY deleted_edge.from ASC
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, head(collect(deleted_edge.from)) AS deleted_from
+    // ------------
+    // Plan one active edge update with correct from and to times
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from
+        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+        WHERE type(active_e) = edge_type
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from, active_e
+        ORDER BY %(id_func_name)s(active_e)
+        LIMIT 1
+        WITH active_e, properties(active_e) AS before_props, {from: active_from, to: deleted_from} AS prop_updates
+        RETURN [
+            {
+                db_id: %(id_func_name)s(active_e), before_props: before_props, prop_updates: prop_updates
+            }
+        ] AS active_edges_to_update
+    }
+    // ------------
+    // Plan deletes for all the other active edges of this type on this branch
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer
+        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+        WHERE type(active_e) = edge_type
+        WITH node_with_dup_edges, peer, active_e
+        ORDER BY %(id_func_name)s(active_e)
+        SKIP 1
+        RETURN collect(
+            {
+                db_id: %(id_func_name)s(active_e),
+                from_id: %(id_func_name)s(node_with_dup_edges),
+                to_id: %(id_func_name)s(peer),
+                edge_type: type(active_e),
+                before_props: properties(active_e)
+            }
+        ) AS active_edges_to_delete
+    }
+    // ------------
+    // Plan one deleted edge update with correct from time
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, deleted_from
+        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        WHERE type(deleted_e) = edge_type
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, deleted_from, deleted_e
+        ORDER BY %(id_func_name)s(deleted_e)
+        LIMIT 1
+        WITH deleted_e, properties(deleted_e) AS before_props, {from: deleted_from} AS prop_updates
+        RETURN [
+            {
+                db_id: %(id_func_name)s(deleted_e), before_props: before_props, prop_updates: prop_updates
+            }
+        ] AS deleted_edges_to_update
+    }
+    // ------------
+    // Plan deletes for all the other deleted edges of this type on this branch
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer
+        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        WHERE type(deleted_e) = edge_type
+        WITH node_with_dup_edges, peer, deleted_e
+        ORDER BY %(id_func_name)s(deleted_e)
+        SKIP 1
+        RETURN collect(
+            {
+                db_id: %(id_func_name)s(deleted_e),
+                from_id: %(id_func_name)s(node_with_dup_edges),
+                to_id: %(id_func_name)s(peer),
+                edge_type: type(deleted_e),
+                before_props: properties(deleted_e)
+            }
+        ) AS deleted_edges_to_delete
+    }
+    RETURN
+        active_edges_to_update + deleted_edges_to_update AS edges_to_update,
+        active_edges_to_delete + deleted_edges_to_delete AS edges_to_delete
+}
+RETURN edges_to_update, edges_to_delete
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        results = await self.db.execute_query(query=query)
+        edges_to_delete: list[EdgeToDelete] = []
+        edges_to_update: list[EdgeToUpdate] = []
+        for result in results:
+            for serial_edge_to_delete in result.get("edges_to_delete"):
+                edge_to_delete = EdgeToDelete(**serial_edge_to_delete)
+                edges_to_delete.append(edge_to_delete)
+            for serial_edge_to_update in result.get("edges_to_update"):
+                prop_updates = serial_edge_to_update["prop_updates"]
+                if prop_updates:
+                    serial_edge_to_update["after_props"] = serial_edge_to_update["before_props"] | prop_updates
+                    del serial_edge_to_update["prop_updates"]
+                edge_to_update = EdgeToUpdate(**serial_edge_to_update)
+                edges_to_update.append(edge_to_update)
+        return PatchPlan(
+            name=self.name,
+            edges_to_delete=edges_to_delete,
+            edges_to_update=edges_to_update,
+        )

infrahub/proposed_change/tasks.py

@@ -607,6 +607,7 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, s
                 content_type=model.artifact_definition.content_type,
                 transform_type=model.artifact_definition.transform_kind,
                 transform_location=model.artifact_definition.transform_location,
+                convert_query_response=model.artifact_definition.convert_query_response,
                 repository_id=repository.repository_id,
                 repository_name=repository.repository_name,
                 repository_kind=repository.kind,

infrahub/server.py

@@ -23,7 +23,6 @@ from infrahub import __version__, config
 from infrahub.api import router as api
 from infrahub.api.exception_handlers import generic_api_exception_handler
 from infrahub.components import ComponentType
-from infrahub.core.graph.index import node_indexes, rel_indexes
 from infrahub.core.initialization import initialization
 from infrahub.database import InfrahubDatabase, InfrahubDatabaseMode, get_db
 from infrahub.dependencies.registry import build_component_registry
@@ -58,7 +57,6 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
 
     # Initialize database Driver and load local registry
     database = application.state.db = InfrahubDatabase(mode=InfrahubDatabaseMode.DRIVER, driver=await get_db())
-    database.manager.index.init(nodes=node_indexes, rels=rel_indexes)
 
     build_component_registry()
 
@@ -83,7 +81,7 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
     initialize_lock(service=service)
     # We must initialize DB after initialize lock and initialize lock depends on cache initialization
     async with application.state.db.start_session() as db:
-        await initialization(db=db)
+        await initialization(db=db, add_database_indexes=True)
 
     application.state.service = service
     application.state.response_delay = config.SETTINGS.miscellaneous.response_delay

infrahub/transformations/models.py

@@ -11,6 +11,9 @@ class TransformPythonData(BaseModel):
     branch: str = Field(..., description="The branch to target")
     transform_location: str = Field(..., description="Location of the transform within the repository")
     commit: str = Field(..., description="The commit id to use when generating the artifact")
+    convert_query_response: bool = Field(
+        ..., description="Define if the GraphQL query respose should be converted into InfrahubNode objects"
+    )
     timeout: int = Field(..., description="The timeout value to use when generating the artifact")
 
 

infrahub/transformations/tasks.py

@@ -30,6 +30,7 @@ async def transform_python(message: TransformPythonData, service: InfrahubServic
         location=message.transform_location,
         data=message.data,
         client=service.client,
+        convert_query_response=message.convert_query_response,
     )  # type: ignore[misc]
 
     return transformed_data

infrahub/trigger/models.py

@@ -5,8 +5,11 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from prefect.events.actions import RunDeployment
+from prefect.events.schemas.automations import (
+    Automation,  # noqa: TC002
+    Posture,
+)
 from prefect.events.schemas.automations import EventTrigger as PrefectEventTrigger
-from prefect.events.schemas.automations import Posture
 from prefect.events.schemas.events import ResourceSpecification
 from pydantic import BaseModel, Field
 
@@ -19,6 +22,13 @@ if TYPE_CHECKING:
     from uuid import UUID
 
 
+class TriggerSetupReport(BaseModel):
+    created: list[TriggerDefinition] = Field(default_factory=list)
+    updated: list[TriggerDefinition] = Field(default_factory=list)
+    deleted: list[Automation] = Field(default_factory=list)
+    unchanged: list[TriggerDefinition] = Field(default_factory=list)
+
+
 class TriggerType(str, Enum):
     BUILTIN = "builtin"
     WEBHOOK = "webhook"

infrahub/trigger/setup.py

@@ -5,23 +5,39 @@ from prefect.automations import AutomationCore
 from prefect.cache_policies import NONE
 from prefect.client.orchestration import PrefectClient
 from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
+from prefect.events.schemas.automations import Automation
 
 from infrahub.trigger.models import TriggerDefinition
 
-from .models import TriggerType
+from .models import TriggerSetupReport, TriggerType
 
 if TYPE_CHECKING:
     from uuid import UUID
 
 
+def compare_automations(target: AutomationCore, existing: Automation) -> bool:
+    """Compare an AutomationCore with an existing Automation object to identify if they are identical or not
+
+    Return True if the target is identical to the existing automation
+    """
+
+    target_dump = target.model_dump(exclude_defaults=True, exclude_none=True)
+    existing_dump = existing.model_dump(exclude_defaults=True, exclude_none=True, exclude={"id"})
+
+    return target_dump == existing_dump
+
+
 @task(name="trigger-setup", task_run_name="Setup triggers", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_triggers(
     client: PrefectClient,
     triggers: list[TriggerDefinition],
     trigger_type: TriggerType | None = None,
-) -> None:
+    force_update: bool = False,
+) -> TriggerSetupReport:
     log = get_run_logger()
 
+    report = TriggerSetupReport()
+
     if trigger_type:
         log.info(f"Setting up triggers of type {trigger_type.value}")
     else:
@@ -38,23 +54,24 @@ async def setup_triggers(
         )
     }
     deployments_mapping: dict[str, UUID] = {name: item.id for name, item in deployments.items()}
-    existing_automations = {item.name: item for item in await client.read_automations()}
 
     # If a trigger type is provided, narrow down the list of existing triggers to know which one to delete
+    existing_automations: dict[str, Automation] = {}
     if trigger_type:
-        trigger_automations = [
-            item.name for item in await client.read_automations() if item.name.startswith(trigger_type.value)
-        ]
+        existing_automations = {
+            item.name: item for item in await client.read_automations() if item.name.startswith(trigger_type.value)
+        }
     else:
-        trigger_automations = [item.name for item in await client.read_automations()]
+        existing_automations = {item.name: item for item in await client.read_automations()}
 
     trigger_names = [trigger.generate_name() for trigger in triggers]
+    automation_names = list(existing_automations.keys())
 
-    log.debug(f"{len(trigger_automations)} existing triggers ({trigger_automations})")
-    log.debug(f"{len(trigger_names)}  triggers to configure ({trigger_names})")
+    log.debug(f"{len(automation_names)} existing triggers ({automation_names})")
+    log.debug(f"{len(trigger_names)} triggers to configure ({trigger_names})")
 
-    to_delete = set(trigger_automations) - set(trigger_names)
-    log.debug(f"{len(trigger_names)} triggers to delete ({to_delete})")
+    to_delete = set(automation_names) - set(trigger_names)
+    log.debug(f"{len(to_delete)} triggers to delete ({to_delete})")
 
     # -------------------------------------------------------------
     # Create or Update all triggers
@@ -71,11 +88,16 @@ async def setup_triggers(
         existing_automation = existing_automations.get(trigger.generate_name(), None)
 
         if existing_automation:
-            await client.update_automation(automation_id=existing_automation.id, automation=automation)
-            log.info(f"{trigger.generate_name()} Updated")
+            if force_update or not compare_automations(target=automation, existing=existing_automation):
+                await client.update_automation(automation_id=existing_automation.id, automation=automation)
+                log.info(f"{trigger.generate_name()} Updated")
+                report.updated.append(trigger)
+            else:
+                report.unchanged.append(trigger)
         else:
             await client.create_automation(automation=automation)
             log.info(f"{trigger.generate_name()} Created")
+            report.created.append(trigger)
 
     # -------------------------------------------------------------
     # Delete Triggers that shouldn't be there
@@ -86,5 +108,8 @@ async def setup_triggers(
         if not existing_automation:
             continue
 
+        report.deleted.append(existing_automation)
         await client.delete_automation(automation_id=existing_automation.id)
         log.info(f"{item_to_delete} Deleted")
+
+    return report

infrahub/trigger/tasks.py

@@ -31,7 +31,4 @@ async def trigger_configure_all(service: InfrahubServices) -> None:
         )
 
         async with get_client(sync_client=False) as prefect_client:
-            await setup_triggers(
-                client=prefect_client,
-                triggers=triggers,
-            )
+            await setup_triggers(client=prefect_client, triggers=triggers, force_update=True)

infrahub/webhook/models.py

@@ -204,6 +204,7 @@ class TransformWebhook(Webhook):
     transform_class: str = Field(...)
     transform_file: str = Field(...)
     transform_timeout: int = Field(...)
+    convert_query_response: bool = Field(...)
 
     async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
         repo: InfrahubReadOnlyRepository | InfrahubRepository
@@ -229,6 +230,7 @@ class TransformWebhook(Webhook):
             branch_name=branch,
             commit=commit,
             location=f"{self.transform_file}::{self.transform_class}",
+            convert_query_response=self.convert_query_response,
             data={"data": data, **context.model_dump()},
             client=service.client,
         )  # type: ignore[misc]
@@ -247,4 +249,5 @@ class TransformWebhook(Webhook):
             transform_class=transform.class_name.value,
             transform_file=transform.file_path.value,
             transform_timeout=transform.timeout.value,
+            convert_query_response=transform.convert_query_response.value or False,
         )

infrahub/workflows/initialization.py

@@ -71,7 +71,5 @@ async def setup_task_manager() -> None:
         await setup_worker_pools(client=client)
         await setup_deployments(client=client)
         await setup_triggers(
-            client=client,
-            triggers=builtin_triggers,
-            trigger_type=TriggerType.BUILTIN,
+            client=client, triggers=builtin_triggers, trigger_type=TriggerType.BUILTIN, force_update=True
         )

infrahub_sdk/client.py

@@ -847,9 +847,9 @@ class InfrahubClient(BaseClient):
                     self.store.set(node=node)
         return nodes
 
-    def clone(self) -> InfrahubClient:
+    def clone(self, branch: str | None = None) -> InfrahubClient:
         """Return a cloned version of the client using the same configuration"""
-        return InfrahubClient(config=self.config)
+        return InfrahubClient(config=self.config.clone(branch=branch))
 
     async def execute_graphql(
         self,
@@ -1591,9 +1591,9 @@ class InfrahubClientSync(BaseClient):
         node = InfrahubNodeSync(client=self, schema=schema, branch=branch, data={"id": id})
         node.delete()
 
-    def clone(self) -> InfrahubClientSync:
+    def clone(self, branch: str | None = None) -> InfrahubClientSync:
         """Return a cloned version of the client using the same configuration"""
-        return InfrahubClientSync(config=self.config)
+        return InfrahubClientSync(config=self.config.clone(branch=branch))
 
     def execute_graphql(
         self,

infrahub_sdk/config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from copy import deepcopy
 from typing import Any
 
 from pydantic import Field, field_validator, model_validator
@@ -158,3 +159,19 @@ class Config(ConfigBase):
         elif values.get("recorder") == RecorderType.JSON and "custom_recorder" not in values:
             values["custom_recorder"] = JSONRecorder()
         return values
+
+    def clone(self, branch: str | None = None) -> Config:
+        config: dict[str, Any] = {
+            "default_branch": branch or self.default_branch,
+            "recorder": self.recorder,
+            "custom_recorder": self.custom_recorder,
+            "requester": self.requester,
+            "sync_requester": self.sync_requester,
+            "log": self.log,
+        }
+        covered_keys = list(config.keys())
+        for field in Config.model_fields.keys():
+            if field not in covered_keys:
+                config[field] = deepcopy(getattr(self, field))
+
+        return Config(**config)

infrahub_sdk/ctl/cli_commands.py

@@ -41,6 +41,7 @@ from ..ctl.utils import (
 )
 from ..ctl.validate import app as validate_app
 from ..exceptions import GraphQLError, ModuleImportError
+from ..node import InfrahubNode
 from ..protocols_generator.generator import CodeGenerator
 from ..schema import MainSchemaTypesAll, SchemaRoot
 from ..template import Jinja2Template
@@ -330,7 +331,12 @@ def transform(
         console.print(f"[red]{exc.message}")
         raise typer.Exit(1) from exc
 
-    transform = transform_class(client=client, branch=branch)
+    transform = transform_class(
+        client=client,
+        branch=branch,
+        infrahub_node=InfrahubNode,
+        convert_query_response=transform_config.convert_query_response,
+    )
     # Get data
     query_str = repository_config.get_query(name=transform.query).load_query()
     data = asyncio.run(

infrahub_sdk/ctl/generator.py

@@ -62,7 +62,7 @@ async def run(
         generator = generator_class(
             query=generator_config.query,
             client=client,
-            branch=branch,
+            branch=branch or "",
             params=variables_dict,
             convert_query_response=generator_config.convert_query_response,
             infrahub_node=InfrahubNode,
@@ -91,7 +91,7 @@ async def run(
             generator = generator_class(
                 query=generator_config.query,
                 client=client,
-                branch=branch,
+                branch=branch or "",
                 params=params,
                 convert_query_response=generator_config.convert_query_response,
                 infrahub_node=InfrahubNode,

infrahub_sdk/generator.py

@@ -1,22 +1,19 @@
 from __future__ import annotations
 
 import logging
-import os
 from abc import abstractmethod
 from typing import TYPE_CHECKING
 
-from infrahub_sdk.repository import GitRepoManager
-
 from .exceptions import UninitializedError
+from .operation import InfrahubOperation
 
 if TYPE_CHECKING:
     from .client import InfrahubClient
     from .context import RequestContext
     from .node import InfrahubNode
-    from .store import NodeStore
 
 
-class InfrahubGenerator:
+class InfrahubGenerator(InfrahubOperation):
     """Infrahub Generator class"""
 
     def __init__(
@@ -24,7 +21,7 @@ class InfrahubGenerator:
         query: str,
         client: InfrahubClient,
         infrahub_node: type[InfrahubNode],
-        branch: str | None = None,
+        branch: str = "",
         root_directory: str = "",
         generator_instance: str = "",
         params: dict | None = None,
@@ -33,37 +30,21 @@ class InfrahubGenerator:
         request_context: RequestContext | None = None,
     ) -> None:
         self.query = query
-        self.branch = branch
-        self.git: GitRepoManager | None = None
+
+        super().__init__(
+            client=client,
+            infrahub_node=infrahub_node,
+            convert_query_response=convert_query_response,
+            branch=branch,
+            root_directory=root_directory,
+        )
+
         self.params = params or {}
-        self.root_directory = root_directory or os.getcwd()
         self.generator_instance = generator_instance
-        self._init_client = client.clone()
-        self._init_client.config.default_branch = self._init_client.default_branch = self.branch_name
-        self._init_client.store._default_branch = self.branch_name
         self._client: InfrahubClient | None = None
-        self._nodes: list[InfrahubNode] = []
-        self._related_nodes: list[InfrahubNode] = []
-        self.infrahub_node = infrahub_node
-        self.convert_query_response = convert_query_response
         self.logger = logger if logger else logging.getLogger("infrahub.tasks")
         self.request_context = request_context
 
-    @property
-    def store(self) -> NodeStore:
-        """The store will be populated with nodes based on the query during the collection of data if activated"""
-        return self._init_client.store
-
-    @property
-    def nodes(self) -> list[InfrahubNode]:
-        """Returns nodes collected and parsed during the data collection process if this feature is enables"""
-        return self._nodes
-
-    @property
-    def related_nodes(self) -> list[InfrahubNode]:
-        """Returns nodes collected and parsed during the data collection process if this feature is enables"""
-        return self._related_nodes
-
     @property
     def subscribers(self) -> list[str] | None:
         if self.generator_instance:
@@ -80,20 +61,6 @@ class InfrahubGenerator:
     def client(self, value: InfrahubClient) -> None:
         self._client = value
 
-    @property
-    def branch_name(self) -> str:
-        """Return the name of the current git branch."""
-
-        if self.branch:
-            return self.branch
-
-        if not self.git:
-            self.git = GitRepoManager(self.root_directory)
-
-        self.branch = str(self.git.active_branch)
-
-        return self.branch
-
     async def collect_data(self) -> dict:
         """Query the result of the GraphQL Query defined in self.query and return the result"""
 
@@ -119,27 +86,6 @@ class InfrahubGenerator:
         ) as self.client:
             await self.generate(data=unpacked)
 
-    async def process_nodes(self, data: dict) -> None:
-        if not self.convert_query_response:
-            return
-
-        await self._init_client.schema.all(branch=self.branch_name)
-
-        for kind in data:
-            if kind in self._init_client.schema.cache[self.branch_name].nodes.keys():
-                for result in data[kind].get("edges", []):
-                    node = await self.infrahub_node.from_graphql(
-                        client=self._init_client, branch=self.branch_name, data=result
-                    )
-                    self._nodes.append(node)
-                    await node._process_relationships(
-                        node_data=result, branch=self.branch_name, related_nodes=self._related_nodes
-                    )
-
-        for node in self._nodes + self._related_nodes:
-            if node.id:
-                self._init_client.store.set(node=node)
-
     @abstractmethod
     async def generate(self, data: dict) -> None:
         """Code to run the generator

infrahub_sdk/operation.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from .repository import GitRepoManager
+
+if TYPE_CHECKING:
+    from . import InfrahubClient
+    from .node import InfrahubNode
+    from .store import NodeStore
+
+
+class InfrahubOperation:
+    def __init__(
+        self,
+        client: InfrahubClient,
+        infrahub_node: type[InfrahubNode],
+        convert_query_response: bool,
+        branch: str,
+        root_directory: str,
+    ):
+        self.branch = branch
+        self.convert_query_response = convert_query_response
+        self.root_directory = root_directory or os.getcwd()
+        self.infrahub_node = infrahub_node
+        self._nodes: list[InfrahubNode] = []
+        self._related_nodes: list[InfrahubNode] = []
+        self._init_client = client.clone(branch=self.branch_name)
+        self.git: GitRepoManager | None = None
+
+    @property
+    def branch_name(self) -> str:
+        """Return the name of the current git branch."""
+
+        if self.branch:
+            return self.branch
+
+        if not hasattr(self, "git") or not self.git:
+            self.git = GitRepoManager(self.root_directory)
+
+        self.branch = str(self.git.active_branch)
+
+        return self.branch
+
+    @property
+    def store(self) -> NodeStore:
+        """The store will be populated with nodes based on the query during the collection of data if activated"""
+        return self._init_client.store
+
+    @property
+    def nodes(self) -> list[InfrahubNode]:
+        """Returns nodes collected and parsed during the data collection process if this feature is enabled"""
+        return self._nodes
+
+    @property
+    def related_nodes(self) -> list[InfrahubNode]:
+        """Returns nodes collected and parsed during the data collection process if this feature is enabled"""
+        return self._related_nodes
+
+    async def process_nodes(self, data: dict) -> None:
+        if not self.convert_query_response:
+            return
+
+        await self._init_client.schema.all(branch=self.branch_name)
+
+        for kind in data:
+            if kind in self._init_client.schema.cache[self.branch_name].nodes.keys():
+                for result in data[kind].get("edges", []):
+                    node = await self.infrahub_node.from_graphql(
+                        client=self._init_client, branch=self.branch_name, data=result
+                    )
+                    self._nodes.append(node)
+                    await node._process_relationships(
+                        node_data=result, branch=self.branch_name, related_nodes=self._related_nodes
+                    )
+
+        for node in self._nodes + self._related_nodes:
+            if node.id:
+                self._init_client.store.set(node=node)