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

infrahub/git_credential/helper.py

@@ -3,9 +3,9 @@ import sys
 
 import typer
 from infrahub_sdk import Config, InfrahubClientSync
+from infrahub_sdk.protocols import CoreGenericRepository
 
 from infrahub import config
-from infrahub.core.constants import InfrahubKind
 
 logging.getLogger("httpx").setLevel(logging.ERROR)
 app = typer.Typer()
@@ -51,7 +51,7 @@ def get(
         raise typer.Exit(1) from exc
 
     client = InfrahubClientSync(config=Config(address=config.SETTINGS.main.internal_address, insert_tracker=True))
-    repo = client.get(kind=InfrahubKind.GENERICREPOSITORY, location__value=location)
+    repo = client.get(kind=CoreGenericRepository.__name__, location__value=location)
 
     if not repo:
         print("Repository not found in the database.")

infrahub/message_bus/operations/requests/proposed_change.py

@@ -319,6 +319,9 @@ query GatherArtifactDefinitions {
               file_path {
                 value
               }
+              convert_query_response {
+                value
+              }
             }
             repository {
               node {
@@ -526,6 +529,9 @@ def _parse_artifact_definitions(definitions: list[dict]) -> list[ProposedChangeA
         elif artifact_definition.transform_kind == InfrahubKind.TRANSFORMPYTHON:
             artifact_definition.class_name = definition["node"]["transformation"]["node"]["class_name"]["value"]
             artifact_definition.file_path = definition["node"]["transformation"]["node"]["file_path"]["value"]
+            artifact_definition.convert_query_response = definition["node"]["transformation"]["node"][
+                "convert_query_response"
+            ]["value"]
 
         parsed.append(artifact_definition)
 

infrahub/message_bus/types.py

@@ -96,6 +96,9 @@ class ProposedChangeArtifactDefinition(BaseModel):
     class_name: str = Field(default="")
     content_type: str
     file_path: str = Field(default="")
+    convert_query_response: bool = Field(
+        default=False, description="Convert query response to InfrahubNode objects for Python based transforms"
+    )
     timeout: int
 
     @property

infrahub/patch/queries/consolidate_duplicated_nodes.py

@@ -0,0 +1,109 @@
+from ..models import EdgeToAdd, EdgeToDelete, PatchPlan, VertexToDelete
+from .base import PatchQuery
+
+
+class ConsolidateDuplicatedNodesPatchQuery(PatchQuery):
+    """
+    Find any groups of nodes with the same labels and properties, move all the edges to one of the duplicated nodes,
+    then delete the other duplicated nodes
+    """
+
+    @property
+    def name(self) -> str:
+        return "consolidate-duplicated-nodes"
+
+    async def plan(self) -> PatchPlan:
+        query = """
+//------------
+// Find nodes with the same labels and UUID
+//------------
+MATCH (n:Node)
+WITH n.uuid AS node_uuid, count(*) as num_nodes_with_uuid
+WHERE num_nodes_with_uuid > 1
+WITH DISTINCT node_uuid
+MATCH (n:Node {uuid: node_uuid})
+CALL {
+    WITH n
+    WITH labels(n) AS n_labels
+    UNWIND n_labels AS n_label
+    WITH n_label
+    ORDER BY n_label ASC
+    RETURN collect(n_label) AS sorted_labels
+}
+WITH n.uuid AS n_uuid, sorted_labels, collect(n) AS duplicate_nodes
+WHERE size(duplicate_nodes) > 1
+WITH n_uuid, head(duplicate_nodes) AS node_to_keep, tail(duplicate_nodes) AS nodes_to_delete
+UNWIND nodes_to_delete AS node_to_delete
+//------------
+// Find the edges that we need to move to the selected node_to_keep
+//------------
+CALL {
+    WITH node_to_keep, node_to_delete
+    MATCH (node_to_delete)-[edge_to_delete]->(peer)
+    RETURN {
+        from_id: %(id_func_name)s(node_to_keep),
+        to_id: %(id_func_name)s(peer),
+        edge_type: type(edge_to_delete),
+        after_props: properties(edge_to_delete)
+    } AS edge_to_create
+    UNION
+    WITH node_to_keep, node_to_delete
+    MATCH (node_to_delete)<-[edge_to_delete]-(peer)
+    RETURN {
+        from_id: %(id_func_name)s(peer),
+        to_id: %(id_func_name)s(node_to_keep),
+        edge_type: type(edge_to_delete),
+        after_props: properties(edge_to_delete)
+    } AS edge_to_create
+}
+WITH node_to_delete, collect(edge_to_create) AS edges_to_create
+//------------
+// Find the edges that we need to remove from the duplicated nodes
+//------------
+CALL {
+    WITH node_to_delete
+    MATCH (node_to_delete)-[e]->(peer)
+    RETURN {
+        db_id: %(id_func_name)s(e),
+        from_id: %(id_func_name)s(node_to_delete),
+        to_id: %(id_func_name)s(peer),
+        edge_type: type(e),
+        before_props: properties(e)
+    } AS edge_to_delete
+    UNION
+    WITH node_to_delete
+    MATCH (node_to_delete)<-[e]-(peer)
+    RETURN {
+        db_id: %(id_func_name)s(e),
+        from_id: %(id_func_name)s(peer),
+        to_id: %(id_func_name)s(node_to_delete),
+        edge_type: type(e),
+        before_props: properties(e)
+    } AS edge_to_delete
+}
+WITH node_to_delete, edges_to_create, collect(edge_to_delete) AS edges_to_delete
+RETURN
+    {db_id: %(id_func_name)s(node_to_delete), labels: labels(node_to_delete), before_props: properties(node_to_delete)} AS vertex_to_delete,
+    edges_to_create,
+    edges_to_delete
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        results = await self.db.execute_query(query=query)
+        vertices_to_delete: list[VertexToDelete] = []
+        edges_to_delete: list[EdgeToDelete] = []
+        edges_to_add: list[EdgeToAdd] = []
+        for result in results:
+            serial_vertex_to_delete = result.get("vertex_to_delete")
+            if serial_vertex_to_delete:
+                vertex_to_delete = VertexToDelete(**serial_vertex_to_delete)
+                vertices_to_delete.append(vertex_to_delete)
+            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_create in result.get("edges_to_create"):
+                edges_to_add.append(EdgeToAdd(**serial_edge_to_create))
+        return PatchPlan(
+            name=self.name,
+            vertices_to_delete=vertices_to_delete,
+            edges_to_add=edges_to_add,
+            edges_to_delete=edges_to_delete,
+        )

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,7 @@ 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.graph.index import attr_value_index, 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,6 +58,8 @@ 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())
+    if config.SETTINGS.experimental_features.value_db_index:
+        node_indexes.append(attr_value_index)
     database.manager.index.init(nodes=node_indexes, rels=rel_indexes)
 
     build_component_registry()

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/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_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)