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

infrahub/api/transformation.py

@@ -88,6 +88,7 @@ async def transform_python(
         branch=branch_params.branch.name,
         transform_location=f"{transform.file_path.value}::{transform.class_name.value}",
         timeout=transform.timeout.value,
+        convert_query_response=transform.convert_query_response.value or False,
         data=data,
     )
 

infrahub/artifacts/models.py

@@ -12,6 +12,10 @@ class CheckArtifactCreate(BaseModel):
     content_type: str = Field(..., description="Content type of the artifact")
     transform_type: str = Field(..., description="The type of transform associated with this artifact")
     transform_location: str = Field(..., description="The transforms location within the repository")
+    convert_query_response: bool = Field(
+        default=False,
+        description="Indicate if the query response should be converted to InfrahubNode objects for Python transforms",
+    )
     repository_id: str = Field(..., description="The unique ID of the Repository")
     repository_name: str = Field(..., description="The name of the Repository")
     repository_kind: str = Field(..., description="The kind of the Repository")

infrahub/cli/db.py

@@ -412,7 +412,7 @@ async def update_core_schema(
             update_db=True,
         )
         default_branch.update_schema_hash()
-        rprint("The Core Schema has been updated")
+        rprint("The Core Schema has been updated, make sure to rebase any open branches after the upgrade")
         if debug:
             rprint(f"New schema hash: {default_branch.active_schema_hash.main}")
         await default_branch.save(db=dbt)

infrahub/computed_attribute/tasks.py

@@ -113,6 +113,7 @@ async def process_transform(
             location=f"{transform.file_path.value}::{transform.class_name.value}",
             data=data,
             client=service.client,
+            convert_query_response=transform.convert_query_response.value,
         )  # type: ignore[misc]
 
         await service.client.execute_graphql(

infrahub/config.py

@@ -23,7 +23,7 @@ from pydantic import (
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from typing_extensions import Self
 
-from infrahub.database.constants import DatabaseType
+from infrahub.constants.database import DatabaseType
 from infrahub.exceptions import InitializationError, ProcessingError
 
 if TYPE_CHECKING:
@@ -629,6 +629,7 @@ class AnalyticsSettings(BaseSettings):
 class ExperimentalFeaturesSettings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="INFRAHUB_EXPERIMENTAL_")
     graphql_enums: bool = False
+    value_db_index: bool = False
 
 
 class SecuritySettings(BaseSettings):

infrahub/core/constants/__init__.py

@@ -150,6 +150,7 @@ class ContentType(InfrahubStringEnum):
     APPLICATION_JSON = "application/json"
     APPLICATION_YAML = "application/yaml"
     APPLICATION_XML = "application/xml"
+    APPLICATION_HCL = "application/hcl"
     TEXT_PLAIN = "text/plain"
     TEXT_MARKDOWN = "text/markdown"
     TEXT_CSV = "text/csv"

infrahub/core/graph/index.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from infrahub.database.constants import IndexType
+from infrahub.constants.database import IndexType
 from infrahub.database.index import IndexItem
 
 node_indexes: list[IndexItem] = [
@@ -17,6 +17,8 @@ node_indexes: list[IndexItem] = [
     IndexItem(name="diff_node_uuid", label="DiffNode", properties=["uuid"], type=IndexType.TEXT),
 ]
 
+attr_value_index = IndexItem(name="attr_value", label="AttributeValue", properties=["value"], type=IndexType.RANGE)
+
 rel_indexes: list[IndexItem] = [
     IndexItem(name="attr_from", label="HAS_ATTRIBUTE", properties=["from"], type=IndexType.RANGE),
     IndexItem(name="attr_branch", label="HAS_ATTRIBUTE", properties=["branch"], type=IndexType.RANGE),

infrahub/core/manager.py

@@ -1229,20 +1229,31 @@ class NodeManager:
         if not prefetch_relationships and not fields:
             return
         cardinality_one_identifiers_by_kind: dict[str, dict[str, RelationshipDirection]] | None = None
-        all_identifiers: list[str] | None = None
+        outbound_identifiers: set[str] | None = None
+        inbound_identifiers: set[str] | None = None
+        bidirectional_identifiers: set[str] | None = None
         if not prefetch_relationships:
             cardinality_one_identifiers_by_kind = _get_cardinality_one_identifiers_by_kind(
                 nodes=nodes_by_id.values(), fields=fields or {}
             )
-            all_identifiers_set: set[str] = set()
+            outbound_identifiers = set()
+            inbound_identifiers = set()
+            bidirectional_identifiers = set()
             for identifier_direction_map in cardinality_one_identifiers_by_kind.values():
-                all_identifiers_set.update(identifier_direction_map.keys())
-            all_identifiers = list(all_identifiers_set)
+                for identifier, direction in identifier_direction_map.items():
+                    if direction is RelationshipDirection.OUTBOUND:
+                        outbound_identifiers.add(identifier)
+                    elif direction is RelationshipDirection.INBOUND:
+                        inbound_identifiers.add(identifier)
+                    elif direction is RelationshipDirection.BIDIR:
+                        bidirectional_identifiers.add(identifier)
 
         query = await NodeListGetRelationshipsQuery.init(
             db=db,
             ids=list(nodes_by_id.keys()),
-            relationship_identifiers=all_identifiers,
+            outbound_identifiers=None if outbound_identifiers is None else list(outbound_identifiers),
+            inbound_identifiers=None if inbound_identifiers is None else list(inbound_identifiers),
+            bidirectional_identifiers=None if bidirectional_identifiers is None else list(bidirectional_identifiers),
             branch=branch,
             at=at,
             branch_agnostic=branch_agnostic,

infrahub/core/migrations/graph/m014_remove_index_attr_value.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Sequence
 
+from infrahub.constants.database import IndexType
 from infrahub.core.migrations.shared import MigrationResult
 from infrahub.core.query import Query  # noqa: TC001
 from infrahub.database import DatabaseType
-from infrahub.database.constants import IndexType
 from infrahub.database.index import IndexItem
 
 from ..shared import GraphMigration
@@ -29,13 +29,12 @@ class Migration014(GraphMigration):
         if db.db_type != DatabaseType.NEO4J:
             return result
 
-        async with db.start_transaction() as ts:
-            try:
-                ts.manager.index.init(nodes=[INDEX_TO_DELETE], rels=[])
-                await ts.manager.index.drop()
-            except Exception as exc:
-                result.errors.append(str(exc))
-                return result
+        try:
+            db.manager.index.init(nodes=[INDEX_TO_DELETE], rels=[])
+            await db.manager.index.drop()
+        except Exception as exc:
+            result.errors.append(str(exc))
+            return result
 
         return result
 

infrahub/core/protocols.py

@@ -478,6 +478,7 @@ class CoreTransformJinja2(CoreTransformation):
 class CoreTransformPython(CoreTransformation):
     file_path: String
     class_name: String
+    convert_query_response: BooleanOptional
 
 
 class CoreUserValidator(CoreValidator):

infrahub/core/query/node.py

@@ -649,51 +649,118 @@ class NodeListGetRelationshipsQuery(Query):
     type: QueryType = QueryType.READ
     insert_return: bool = False
 
-    def __init__(self, ids: list[str], relationship_identifiers: list[str] | None = None, **kwargs):
+    def __init__(
+        self,
+        ids: list[str],
+        outbound_identifiers: list[str] | None = None,
+        inbound_identifiers: list[str] | None = None,
+        bidirectional_identifiers: list[str] | None = None,
+        **kwargs,
+    ):
         self.ids = ids
-        self.relationship_identifiers = relationship_identifiers
+        self.outbound_identifiers = outbound_identifiers
+        self.inbound_identifiers = inbound_identifiers
+        self.bidirectional_identifiers = bidirectional_identifiers
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
-        self.params["relationship_identifiers"] = self.relationship_identifiers
+        self.params["outbound_identifiers"] = self.outbound_identifiers
+        self.params["inbound_identifiers"] = self.inbound_identifiers
+        self.params["bidirectional_identifiers"] = self.bidirectional_identifiers
 
         rels_filter, rels_params = self.branch.get_query_filter_path(at=self.at, branch_agnostic=self.branch_agnostic)
         self.params.update(rels_params)
 
         query = """
         MATCH (n:Node) WHERE n.uuid IN $ids
-        MATCH paths_in = ((n)<-[r1:IS_RELATED]-(rel:Relationship)<-[r2:IS_RELATED]-(peer))
-        WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
-        AND all(r IN relationships(paths_in) WHERE (%(filters)s))
-        AND n.uuid <> peer.uuid
-        RETURN n, rel, peer, r1, r2, "inbound" as direction
-        UNION
-        MATCH (n:Node) WHERE n.uuid IN $ids
-        MATCH paths_out = ((n)-[r1:IS_RELATED]->(rel:Relationship)-[r2:IS_RELATED]->(peer))
-        WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
-        AND all(r IN relationships(paths_out) WHERE (%(filters)s))
-        AND n.uuid <> peer.uuid
-        RETURN n, rel, peer, r1, r2, "outbound" as direction
-        UNION
-        MATCH (n:Node) WHERE n.uuid IN $ids
-        MATCH paths_bidir = ((n)-[r1:IS_RELATED]->(rel:Relationship)<-[r2:IS_RELATED]-(peer))
-        WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
-        AND all(r IN relationships(paths_bidir) WHERE (%(filters)s))
-        AND n.uuid <> peer.uuid
-        RETURN n, rel, peer, r1, r2, "bidirectional" as direction
+        CALL {
+            WITH n
+            MATCH (n)<-[:IS_RELATED]-(rel:Relationship)<-[:IS_RELATED]-(peer)
+            WHERE ($inbound_identifiers IS NULL OR rel.name in $inbound_identifiers)
+            AND n.uuid <> peer.uuid
+            WITH DISTINCT n, rel, peer
+            CALL {
+                WITH n, rel, peer
+                MATCH (n)<-[r:IS_RELATED]-(rel)
+                WHERE (%(filters)s)
+                WITH n, rel, peer, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH n, rel, peer, r AS r1
+                WHERE r1.status = "active"
+                MATCH (rel)<-[r:IS_RELATED]-(peer)
+                WHERE (%(filters)s)
+                WITH r1, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH r1, r AS r2
+                WHERE r2.status = "active"
+                RETURN 1 AS is_active
+            }
+            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "inbound" as direction
+            UNION
+            WITH n
+            MATCH (n)-[:IS_RELATED]->(rel:Relationship)-[:IS_RELATED]->(peer)
+            WHERE ($outbound_identifiers IS NULL OR rel.name in $outbound_identifiers)
+            AND n.uuid <> peer.uuid
+            WITH DISTINCT n, rel, peer
+            CALL {
+                WITH n, rel, peer
+                MATCH (n)-[r:IS_RELATED]->(rel)
+                WHERE (%(filters)s)
+                WITH n, rel, peer, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH n, rel, peer, r AS r1
+                WHERE r1.status = "active"
+                MATCH (rel)-[r:IS_RELATED]->(peer)
+                WHERE (%(filters)s)
+                WITH r1, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH r1, r AS r2
+                WHERE r2.status = "active"
+                RETURN 1 AS is_active
+            }
+            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "outbound" as direction
+            UNION
+            WITH n
+            MATCH (n)-[:IS_RELATED]->(rel:Relationship)<-[:IS_RELATED]-(peer)
+            WHERE ($bidirectional_identifiers IS NULL OR rel.name in $bidirectional_identifiers)
+            AND n.uuid <> peer.uuid
+            WITH DISTINCT n, rel, peer
+            CALL {
+                WITH n, rel, peer
+                MATCH (n)-[r:IS_RELATED]->(rel)
+                WHERE (%(filters)s)
+                WITH n, rel, peer, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH n, rel, peer, r AS r1
+                WHERE r1.status = "active"
+                MATCH (rel)<-[r:IS_RELATED]-(peer)
+                WHERE (%(filters)s)
+                WITH r1, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH r1, r AS r2
+                WHERE r2.status = "active"
+                RETURN 1 AS is_active
+            }
+            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "bidirectional" as direction
+        }
+        RETURN DISTINCT n_uuid, rel_name, peer_uuid, direction
         """ % {"filters": rels_filter}
-
         self.add_to_query(query)
-
-        self.return_labels = ["n", "rel", "peer", "r1", "r2", "direction"]
+        self.return_labels = ["n_uuid", "rel_name", "peer_uuid", "direction"]
 
     def get_peers_group_by_node(self) -> GroupedPeerNodes:
         gpn = GroupedPeerNodes()
-        for result in self.get_results_group_by(("n", "uuid"), ("rel", "name"), ("peer", "uuid")):
-            node_id = result.get("n").get("uuid")
-            rel_name = result.get("rel").get("name")
-            peer_id = result.get("peer").get("uuid")
+        for result in self.get_results():
+            node_id = result.get("n_uuid")
+            rel_name = result.get("rel_name")
+            peer_id = result.get("peer_uuid")
             direction = str(result.get("direction"))
             direction_enum = {
                 "inbound": RelationshipDirection.INBOUND,

infrahub/core/schema/definitions/core/builtin.py

@@ -1,6 +1,4 @@
-from infrahub.core.constants import (
-    BranchSupportType,
-)
+from infrahub.core.constants import BranchSupportType
 
 from ...attribute_schema import AttributeSchema as Attr
 from ...node_schema import NodeSchema
@@ -8,7 +6,7 @@ from ...node_schema import NodeSchema
 builtin_tag = NodeSchema(
     name="Tag",
     namespace="Builtin",
-    description="Standard Tag object to attached to other objects to provide some context.",
+    description="Standard Tag object to attach to other objects to provide some context.",
     include_in_menu=True,
     icon="mdi:tag-multiple",
     label="Tag",

infrahub/core/schema/definitions/core/transform.py

@@ -92,5 +92,6 @@ core_transform_python = NodeSchema(
     attributes=[
         Attr(name="file_path", kind="Text"),
         Attr(name="class_name", kind="Text"),
+        Attr(name="convert_query_response", kind="Boolean", optional=True, default_value=False),
     ],
 )

infrahub/core/validators/aggregated_checker.py

@@ -97,9 +97,9 @@ class AggregatedConstraintChecker:
                 error_detail_str += f"={data_path.value!r}"
                 error_detail_str_list.append(error_detail_str)
             if data_path.peer_id:
-                error_detail_str += f"{data_path.field_name}.id={data_path.peer_id}"
+                error_detail_str = f"{data_path.field_name}.id={data_path.peer_id}"
                 error_detail_str_list.append(error_detail_str)
-            if error_detail_str:
+            if error_detail_str_list:
                 error_str += " The error relates to field "
                 error_str += ",".join(error_detail_str_list)
                 error_str += "."

infrahub/core/validators/uniqueness/query.py

@@ -39,7 +39,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
         )
 
         attribute_names = set()
-        attr_paths, attr_paths_with_value = [], []
+        attr_paths, attr_paths_with_value, attr_values = [], [], []
         for attr_path in self.query_request.unique_attribute_paths:
             try:
                 property_rel_name = self.attribute_property_map[attr_path.property_name or "value"]
@@ -50,6 +50,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
             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))
 
@@ -57,6 +58,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
         relationship_attr_paths = []
         relationship_only_attr_paths = []
         relationship_only_attr_values = []
+        relationship_attr_values = []
         relationship_attr_paths_with_value = []
         for rel_path in self.query_request.relationship_attribute_paths:
             relationship_names.add(rel_path.identifier)
@@ -64,6 +66,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 relationship_attr_paths_with_value.append(
                     (rel_path.identifier, rel_path.attribute_name, rel_path.value)
                 )
+                relationship_attr_values.append(rel_path.value)
             elif rel_path.attribute_name:
                 relationship_attr_paths.append((rel_path.identifier, rel_path.attribute_name))
             else:
@@ -87,12 +90,14 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 "node_kind": self.query_request.kind,
                 "attr_paths": attr_paths,
                 "attr_paths_with_value": attr_paths_with_value,
+                "attr_values": attr_values,
                 "attribute_names": list(attribute_names),
                 "relationship_names": list(relationship_names),
                 "relationship_attr_paths": relationship_attr_paths,
                 "relationship_attr_paths_with_value": relationship_attr_paths_with_value,
                 "relationship_only_attr_paths": relationship_only_attr_paths,
                 "relationship_only_attr_values": relationship_only_attr_values,
+                "relationship_attr_values": relationship_attr_values,
                 "min_count_required": self.min_count_required,
             }
         )
@@ -101,7 +106,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
         MATCH attr_path = (start_node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[r:HAS_VALUE]->(attr_value:AttributeValue)
         WHERE attr.name in $attribute_names
             AND ([attr.name, type(r)] in $attr_paths
-            OR [attr.name, type(r), attr_value.value] in $attr_paths_with_value)
+            OR (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}
 
@@ -109,7 +114,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
         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)
         WHERE relationship_node.name in $relationship_names
             AND ([relationship_node.name, rel_attr.name] in $relationship_attr_paths
-            OR [relationship_node.name, rel_attr.name, rel_attr_value.value] in $relationship_attr_paths_with_value)
+            OR (rel_attr_value.value in $relationship_attr_values AND [relationship_node.name, rel_attr.name, rel_attr_value.value] in $relationship_attr_paths_with_value))
         RETURN start_node, rel_path as potential_path, relationship_node.name as rel_identifier, rel_attr.name as potential_attr, rel_attr_value.value as potential_attr_value
         """ % {"node_kind": self.query_request.kind}
 

infrahub/database/__init__.py

@@ -26,13 +26,13 @@ from opentelemetry import trace
 from typing_extensions import Self
 
 from infrahub import config, lock
+from infrahub.constants.database import DatabaseType, Neo4jRuntime
 from infrahub.core import registry
 from infrahub.core.query import QueryType
 from infrahub.exceptions import DatabaseError
 from infrahub.log import get_logger
 from infrahub.utils import InfrahubStringEnum
 
-from .constants import DatabaseType, Neo4jRuntime
 from .memgraph import DatabaseManagerMemgraph
 from .metrics import CONNECTION_POOL_USAGE, QUERY_EXECUTION_METRICS, TRANSACTION_RETRIES
 from .neo4j import DatabaseManagerNeo4j
@@ -44,8 +44,6 @@ if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes, NodeSchema
     from infrahub.core.schema.schema_branch import SchemaBranch
 
-    from .manager import DatabaseManager
-
 validated_database = {}
 R = TypeVar("R")
 
@@ -134,7 +132,6 @@ class InfrahubDatabase:
         mode: InfrahubDatabaseMode = InfrahubDatabaseMode.DRIVER,
         db_type: DatabaseType | None = None,
         default_neo4j_runtime: Neo4jRuntime = Neo4jRuntime.DEFAULT,
-        db_manager: DatabaseManager | None = None,
         schemas: list[SchemaBranch] | None = None,
         session: AsyncSession | None = None,
         session_mode: InfrahubDatabaseSessionMode = InfrahubDatabaseSessionMode.WRITE,
@@ -161,10 +158,7 @@ class InfrahubDatabase:
         else:
             self.db_type = config.SETTINGS.database.db_type
 
-        if db_manager:
-            self.manager = db_manager
-            self.manager.db = self
-        elif self.db_type == DatabaseType.NEO4J:
+        if self.db_type == DatabaseType.NEO4J:
             self.manager = DatabaseManagerNeo4j(db=self)
         elif self.db_type == DatabaseType.MEMGRAPH:
             self.manager = DatabaseManagerMemgraph(db=self)
@@ -228,7 +222,6 @@ class InfrahubDatabase:
             db_type=self.db_type,
             default_neo4j_runtime=self.default_neo4j_runtime,
             schemas=schemas or self._schemas.values(),
-            db_manager=self.manager,
             driver=self._driver,
             session_mode=session_mode,
             queries_names_to_config=self.queries_names_to_config,
@@ -243,7 +236,6 @@ class InfrahubDatabase:
             db_type=self.db_type,
             default_neo4j_runtime=self.default_neo4j_runtime,
             schemas=schemas or self._schemas.values(),
-            db_manager=self.manager,
             driver=self._driver,
             session=self._session,
             session_mode=self._session_mode,

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

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from .constants import EntityType, IndexType
+from infrahub.constants.database import EntityType, IndexType
+
 from .index import IndexInfo, IndexItem, IndexManagerBase
 from .manager import DatabaseManager
 

infrahub/database/neo4j.py

@@ -2,9 +2,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
 

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,
         )