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

infrahub/database/index.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
-from .constants import EntityType, IndexType  # noqa: TC001
+from infrahub.constants.database import EntityType, IndexType  # noqa: TC001
 
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase

infrahub/database/memgraph.py

@@ -1,13 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from infrahub.constants.database import EntityType, IndexType
 
-from .constants import EntityType, IndexType
 from .index import IndexInfo, IndexItem, IndexManagerBase
-from .manager import DatabaseManager
-
-if TYPE_CHECKING:
-    from . import InfrahubDatabase
 
 
 class IndexNodeMemgraph(IndexItem):
@@ -51,9 +46,3 @@ class IndexManagerMemgraph(IndexManagerBase):
             )
 
         return results
-
-
-class DatabaseManagerMemgraph(DatabaseManager):
-    def __init__(self, db: InfrahubDatabase) -> None:
-        super().__init__(db=db)
-        self.index = IndexManagerMemgraph(db=db)

infrahub/database/neo4j.py

@@ -1,15 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
+from infrahub.constants.database import EntityType, IndexType
 from infrahub.core.query import QueryType
 
-from .constants import EntityType, IndexType
 from .index import IndexInfo, IndexItem, IndexManagerBase
-from .manager import DatabaseManager
-
-if TYPE_CHECKING:
-    from . import InfrahubDatabase
 
 
 class IndexRelNeo4j(IndexItem):
@@ -68,9 +62,3 @@ class IndexManagerNeo4j(IndexManagerBase):
             )
 
         return results
-
-
-class DatabaseManagerNeo4j(DatabaseManager):
-    def __init__(self, db: InfrahubDatabase) -> None:
-        super().__init__(db=db)
-        self.index = IndexManagerNeo4j(db=db)

infrahub/git/integrator.py

@@ -10,6 +10,7 @@ import ujson
 import yaml
 from infrahub_sdk import InfrahubClient  # noqa: TC002
 from infrahub_sdk.exceptions import ValidationError
+from infrahub_sdk.node import InfrahubNode
 from infrahub_sdk.protocols import (
     CoreArtifact,
     CoreArtifactDefinition,
@@ -53,7 +54,6 @@ if TYPE_CHECKING:
     import types
 
     from infrahub_sdk.checks import InfrahubCheck
-    from infrahub_sdk.node import InfrahubNode
     from infrahub_sdk.schema.repository import InfrahubRepositoryArtifactDefinitionConfig
     from infrahub_sdk.transforms import InfrahubTransform
 
@@ -123,6 +123,10 @@ class TransformPythonInformation(BaseModel):
     timeout: int
     """Timeout for the function."""
 
+    convert_query_response: bool = Field(
+        ..., description="Indicate if the transform should convert the query response to InfrahubNode objects"
+    )
+
 
 class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
     """
@@ -874,6 +878,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                     file_path=file_path,
                     query=str(graphql_query.id),
                     timeout=transform_class.timeout,
+                    convert_query_response=transform.convert_query_response,
                 )
             )
 
@@ -1005,6 +1010,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             "file_path": transform.file_path,
             "class_name": transform.class_name,
             "timeout": transform.timeout,
+            "convert_query_response": transform.convert_query_response,
         }
         create_payload = self.sdk.schema.generate_payload_create(
             schema=schema,
@@ -1028,6 +1034,9 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         if existing_transform.timeout.value != local_transform.timeout:
             existing_transform.timeout.value = local_transform.timeout
 
+        if existing_transform.convert_query_response.value != local_transform.convert_query_response:
+            existing_transform.convert_query_response.value = local_transform.convert_query_response
+
         await existing_transform.save()
 
     @classmethod
@@ -1038,6 +1047,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             existing_transform.query.id != local_transform.query
             or existing_transform.file_path.value != local_transform.file_path
             or existing_transform.timeout.value != local_transform.timeout
+            or existing_transform.convert_query_response.value != local_transform.convert_query_response
         ):
             return False
         return True
@@ -1129,7 +1139,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
     @task(name="python-transform-execute", task_run_name="Execute Python Transform", cache_policy=NONE)  # type: ignore[arg-type]
     async def execute_python_transform(
-        self, branch_name: str, commit: str, location: str, client: InfrahubClient, data: dict | None = None
+        self,
+        branch_name: str,
+        commit: str,
+        location: str,
+        client: InfrahubClient,
+        convert_query_response: bool,
+        data: dict | None = None,
     ) -> Any:
         """Execute A Python Transform stored in the repository."""
         log = get_run_logger()
@@ -1159,7 +1175,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
             transform_class: type[InfrahubTransform] = getattr(module, class_name)
 
-            transform = transform_class(root_directory=commit_worktree.directory, branch=branch_name, client=client)
+            transform = transform_class(
+                root_directory=commit_worktree.directory,
+                branch=branch_name,
+                client=client,
+                convert_query_response=convert_query_response,
+                infrahub_node=InfrahubNode,
+            )
             return await transform.run(data=data)
 
         except ModuleNotFoundError as exc:
@@ -1216,6 +1238,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 location=transformation_location,
                 data=response,
                 client=self.sdk,
+                convert_query_response=transformation.convert_query_response.value,
             )  # type: ignore[misc]
 
         if definition.content_type.value == ContentType.APPLICATION_JSON.value and isinstance(artifact_content, dict):
@@ -1275,6 +1298,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 location=message.transform_location,
                 data=response,
                 client=self.sdk,
+                convert_query_response=message.convert_query_response,
             )  # type: ignore[misc]
 
         if message.content_type == ContentType.APPLICATION_JSON.value and isinstance(artifact_content, dict):

infrahub/git/models.py

@@ -29,6 +29,10 @@ class RequestArtifactGenerate(BaseModel):
     repository_name: str = Field(..., description="The name of the Repository")
     repository_kind: str = Field(..., description="The kind of the Repository")
     branch_name: str = Field(..., description="The branch where the check is run")
+    convert_query_response: bool = Field(
+        default=False,
+        description="Indicate if the query response should be converted to InfrahubNode objects for Python transforms",
+    )
     target_id: str = Field(..., description="The ID of the target object for this artifact")
     target_kind: str = Field(..., description="The kind of the target object for this artifact")
     target_name: str = Field(..., description="Name of the artifact target")

infrahub/git/tasks.py

@@ -339,10 +339,12 @@ async def generate_request_artifact_definition(
         )
     transform_location = ""
 
+    convert_query_response = False
     if transform.typename == InfrahubKind.TRANSFORMJINJA2:
         transform_location = transform.template_path.value
     elif transform.typename == InfrahubKind.TRANSFORMPYTHON:
         transform_location = f"{transform.file_path.value}::{transform.class_name.value}"
+        convert_query_response = transform.convert_query_response.value
 
     for relationship in group.members.peers:
         member = relationship.peer
@@ -368,6 +370,7 @@ async def generate_request_artifact_definition(
             target_name=member.display_label,
             target_kind=member.get_kind(),
             timeout=transform.timeout.value,
+            convert_query_response=convert_query_response,
             context=context,
         )
 

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/graphql/mutations/computed_attribute.py

@@ -71,7 +71,11 @@ class UpdateComputedAttribute(Mutation):
 
         if not (
             target_node := await NodeManager.get_one(
-                db=graphql_context.db, kind=node_schema.kind, id=str(data.id), branch=graphql_context.branch
+                db=graphql_context.db,
+                kind=node_schema.kind,
+                id=str(data.id),
+                branch=graphql_context.branch,
+                fields={target_attribute.name: None},
             )
         ):
             raise NodeNotFoundError(

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,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/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(