infrahub-server 1.2.6__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

@@ -54,12 +54,14 @@ from infrahub.services.adapters.message_bus.local import BusSimulator
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 
 from .constants import ERROR_BADGE, FAILED_BADGE, SUCCESS_BADGE
+from .patch import patch_app
 
 if TYPE_CHECKING:
     from infrahub.cli.context import CliContext
     from infrahub.database import InfrahubDatabase
 
 app = AsyncTyper()
+app.add_typer(patch_app, name="patch")
 
 PERMISSIONS_AVAILABLE = ["read", "write", "admin"]
 
@@ -410,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/cli/patch.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+from infrahub_sdk.async_typer import AsyncTyper
+from rich import print as rprint
+
+from infrahub import config
+from infrahub.patch.edge_adder import PatchPlanEdgeAdder
+from infrahub.patch.edge_deleter import PatchPlanEdgeDeleter
+from infrahub.patch.edge_updater import PatchPlanEdgeUpdater
+from infrahub.patch.plan_reader import PatchPlanReader
+from infrahub.patch.plan_writer import PatchPlanWriter
+from infrahub.patch.queries.base import PatchQuery
+from infrahub.patch.runner import (
+    PatchPlanEdgeDbIdTranslator,
+    PatchRunner,
+)
+from infrahub.patch.vertex_adder import PatchPlanVertexAdder
+from infrahub.patch.vertex_deleter import PatchPlanVertexDeleter
+from infrahub.patch.vertex_updater import PatchPlanVertexUpdater
+
+from .constants import ERROR_BADGE, SUCCESS_BADGE
+
+if TYPE_CHECKING:
+    from infrahub.cli.context import CliContext
+    from infrahub.database import InfrahubDatabase
+
+
+patch_app = AsyncTyper(help="Commands for planning, applying, and reverting database patches")
+
+
+def get_patch_runner(db: InfrahubDatabase) -> PatchRunner:
+    return PatchRunner(
+        plan_writer=PatchPlanWriter(),
+        plan_reader=PatchPlanReader(),
+        edge_db_id_translator=PatchPlanEdgeDbIdTranslator(),
+        vertex_adder=PatchPlanVertexAdder(db=db),
+        vertex_deleter=PatchPlanVertexDeleter(db=db),
+        vertex_updater=PatchPlanVertexUpdater(db=db),
+        edge_adder=PatchPlanEdgeAdder(db=db),
+        edge_deleter=PatchPlanEdgeDeleter(db=db),
+        edge_updater=PatchPlanEdgeUpdater(db=db),
+    )
+
+
+@patch_app.command(name="plan")
+async def plan_patch_cmd(
+    ctx: typer.Context,
+    patch_path: str = typer.Argument(
+        help="Path to the file containing the PatchQuery instance to run. Use Python-style dot paths, such as infrahub.cli.patch.queries.base"
+    ),
+    patch_plans_dir: Path = typer.Option(Path("infrahub-patches"), help="Path to patch plans directory"),  # noqa: B008
+    apply: bool = typer.Option(False, help="Apply the patch immediately after creating it"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Create a plan for a given patch and save it in the patch plans directory to be applied/reverted"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    patch_module = importlib.import_module(patch_path)
+    patch_query_class = None
+    patch_query_class_count = 0
+    for _, cls in inspect.getmembers(patch_module, inspect.isclass):
+        if issubclass(cls, PatchQuery) and cls is not PatchQuery:
+            patch_query_class = cls
+            patch_query_class_count += 1
+
+    patch_query_path = f"{PatchQuery.__module__}.{PatchQuery.__name__}"
+    if patch_query_class is None:
+        rprint(f"{ERROR_BADGE} No subclass of {patch_query_path} found in {patch_path}")
+        raise typer.Exit(1)
+    if patch_query_class_count > 1:
+        rprint(
+            f"{ERROR_BADGE} Multiple subclasses of {patch_query_path} found in {patch_path}. Please only define one per file."
+        )
+        raise typer.Exit(1)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    patch_query_instance = patch_query_class(db=dbdriver)
+    async with dbdriver.start_session() as db:
+        patch_runner = get_patch_runner(db=db)
+        patch_plan_dir = await patch_runner.prepare_plan(patch_query_instance, directory=Path(patch_plans_dir))
+        rprint(f"{SUCCESS_BADGE} Patch plan created at {patch_plan_dir}")
+        if apply:
+            await patch_runner.apply(patch_plan_directory=patch_plan_dir)
+            rprint(f"{SUCCESS_BADGE} Patch plan successfully applied")
+
+    await dbdriver.close()
+
+
+@patch_app.command(name="apply")
+async def apply_patch_cmd(
+    ctx: typer.Context,
+    patch_plan_dir: Path = typer.Argument(help="Path to the directory containing a patch plan"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Apply a given patch plan"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    if not patch_plan_dir.exists() or not patch_plan_dir.is_dir():
+        rprint(f"{ERROR_BADGE} patch_plan_dir must be an existing directory")
+        raise typer.Exit(1)
+
+    async with dbdriver.start_session() as db:
+        patch_runner = get_patch_runner(db=db)
+        await patch_runner.apply(patch_plan_directory=patch_plan_dir)
+        rprint(f"{SUCCESS_BADGE} Patch plan successfully applied")
+
+    await dbdriver.close()
+
+
+@patch_app.command(name="revert")
+async def revert_patch_cmd(
+    ctx: typer.Context,
+    patch_plan_dir: Path = typer.Argument(help="Path to the directory containing a patch plan"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Revert a given patch plan"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    db = await context.init_db(retry=1)
+
+    if not patch_plan_dir.exists() or not patch_plan_dir.is_dir():
+        rprint(f"{ERROR_BADGE} patch_plan_dir must be an existing directory")
+        raise typer.Exit(1)
+
+    patch_runner = get_patch_runner(db=db)
+    await patch_runner.revert(patch_plan_directory=patch_plan_dir)
+    rprint(f"{SUCCESS_BADGE} Patch plan successfully reverted")
+
+    await db.close()

infrahub/computed_attribute/models.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 from collections import defaultdict
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
+from infrahub_sdk.graphql import Query
 from prefect.events.schemas.automations import Automation  # noqa: TC002
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 from typing_extensions import Self
 
 from infrahub.core import registry
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.schema import AttributeSchema, NodeSchema  # noqa: TC001
 from infrahub.core.schema.schema_branch_computed import (  # noqa: TC001
     ComputedAttributeTarget,
     ComputedAttributeTriggerNode,
@@ -309,3 +312,80 @@ class ComputedAttrPythonQueryTriggerDefinition(TriggerBranchDefinition):
         )
 
         return definition
+
+
+class ComputedAttrJinja2GraphQLResponse(BaseModel):
+    node_id: str
+    computed_attribute_value: str | None
+    variables: dict[str, Any] = Field(default_factory=dict)
+
+
+class ComputedAttrJinja2GraphQL(BaseModel):
+    node_schema: NodeSchema = Field(..., description="The node kind where the computed attribute is defined")
+    attribute_schema: AttributeSchema = Field(..., description="The computed attribute")
+    variables: list[str] = Field(..., description="The list of variable names used within the computed attribute")
+
+    def render_graphql_query(self, query_filter: str, filter_id: str) -> str:
+        query_fields = self.query_fields
+        query_fields["id"] = None
+        query_fields[self.attribute_schema.name] = {"value": None}
+        query = Query(
+            name="ComputedAttributeFilter",
+            query={
+                self.node_schema.kind: {
+                    "@filters": {query_filter: filter_id},
+                    "edges": {"node": query_fields},
+                }
+            },
+        )
+
+        return query.render()
+
+    @property
+    def query_fields(self) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            if field_name in self.node_schema.attribute_names:
+                output[field_name] = {remainder: None}
+            elif field_name in self.node_schema.relationship_names:
+                related_attribute, related_value = remainder.split("__", maxsplit=1)
+                relationship = self.node_schema.get_relationship(name=field_name)
+                if relationship.cardinality == RelationshipCardinality.ONE:
+                    if field_name not in output:
+                        output[field_name] = {"node": {}}
+                    output[field_name]["node"][related_attribute] = {related_value: None}
+        return output
+
+    def parse_response(self, response: dict[str, Any]) -> list[ComputedAttrJinja2GraphQLResponse]:
+        rendered_response: list[ComputedAttrJinja2GraphQLResponse] = []
+        if kind_payload := response.get(self.node_schema.kind):
+            edges = kind_payload.get("edges", [])
+            for node in edges:
+                if node_response := self.to_node_response(node_dict=node):
+                    rendered_response.append(node_response)
+        return rendered_response
+
+    def to_node_response(self, node_dict: dict[str, Any]) -> ComputedAttrJinja2GraphQLResponse | None:
+        if node := node_dict.get("node"):
+            node_id = node.get("id")
+        else:
+            return None
+
+        computed_attribute = node.get(self.attribute_schema.name, {}).get("value")
+        response = ComputedAttrJinja2GraphQLResponse(node_id=node_id, computed_attribute_value=computed_attribute)
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            response.variables[variable] = None
+            if field_content := node.get(field_name):
+                if field_name in self.node_schema.attribute_names:
+                    response.variables[variable] = field_content.get(remainder)
+                elif field_name in self.node_schema.relationship_names:
+                    relationship = self.node_schema.get_relationship(name=field_name)
+                    if relationship.cardinality == RelationshipCardinality.ONE:
+                        related_attribute, related_value = remainder.split("__", maxsplit=1)
+                        node_content = field_content.get("node") or {}
+                        related_attribute_content = node_content.get(related_attribute) or {}
+                        response.variables[variable] = related_attribute_content.get(related_value)
+
+        return response

infrahub/computed_attribute/tasks.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from infrahub_sdk.protocols import (
-    CoreNode,  # noqa: TC002
-    CoreTransformPython,
-)
+from infrahub_sdk.protocols import CoreTransformPython
 from infrahub_sdk.template import Jinja2Template
 from prefect import flow
 from prefect.client.orchestration import get_client
@@ -28,9 +25,7 @@ from infrahub.workflows.catalogue import (
 from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
 
 from .gather import gather_trigger_computed_attribute_jinja2, gather_trigger_computed_attribute_python
-from .models import (
-    PythonTransformTarget,
-)
+from .models import ComputedAttrJinja2GraphQL, ComputedAttrJinja2GraphQLResponse, PythonTransformTarget
 
 if TYPE_CHECKING:
     from infrahub.core.schema.computed_attribute import ComputedAttribute
@@ -118,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(
@@ -167,49 +163,33 @@ async def trigger_update_python_computed_attributes(
     flow_run_name="Update value for computed attribute {attribute_name}",
 )
 async def update_computed_attribute_value_jinja2(
-    branch_name: str, obj: CoreNode, attribute_name: str, template_value: str, service: InfrahubServices
+    branch_name: str,
+    obj: ComputedAttrJinja2GraphQLResponse,
+    node_kind: str,
+    attribute_name: str,
+    template: Jinja2Template,
+    service: InfrahubServices,
 ) -> None:
     log = get_run_logger()
 
-    await add_tags(branches=[branch_name], nodes=[obj.id], db_change=True)
-
-    jinja_template = Jinja2Template(template=template_value)
-    variables = {}
-    for variable in jinja_template.get_variables():
-        components = variable.split("__")
-        if len(components) == 2:
-            property_name = components[0]
-            property_value = components[1]
-            attribute_property = getattr(obj, property_name)
-            variables[variable] = getattr(attribute_property, property_value)
-        elif len(components) == 3:
-            relationship_name = components[0]
-            property_name = components[1]
-            property_value = components[2]
-            relationship = getattr(obj, relationship_name)
-            try:
-                attribute_property = getattr(relationship.peer, property_name)
-                variables[variable] = getattr(attribute_property, property_value)
-            except ValueError:
-                variables[variable] = ""
-
-    value = await jinja_template.render(variables=variables)
-    existing_value = getattr(obj, attribute_name).value
-    if value == existing_value:
+    await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
+
+    value = await template.render(variables=obj.variables)
+    if value == obj.computed_attribute_value:
         log.debug(f"Ignoring to update {obj} with existing value on {attribute_name}={value}")
         return
 
     await service.client.execute_graphql(
         query=UPDATE_ATTRIBUTE,
         variables={
-            "id": obj.id,
-            "kind": obj.get_kind(),
+            "id": obj.node_id,
+            "kind": node_kind,
             "attribute": attribute_name,
             "value": value,
         },
         branch_name=branch_name,
     )
-    log.info(f"Updating computed attribute {obj.get_kind()}.{attribute_name}='{value}' ({obj.id})")
+    log.info(f"Updating computed attribute {node_kind}.{attribute_name}='{value}' ({obj.node_id})")
 
 
 @flow(
@@ -235,41 +215,43 @@ async def process_jinja2(
         branch_name if branch_name in registry.get_altered_schema_branches() else registry.default_branch
     )
     schema_branch = registry.schema.get_schema_branch(name=target_branch_schema)
-    await service.client.schema.all(branch=branch_name, refresh=True, schema_hash=schema_branch.get_hash())
-
+    node_schema = schema_branch.get_node(name=computed_attribute_kind, duplicate=False)
     computed_macros = [
         attrib
         for attrib in schema_branch.computed_attributes.get_impacted_jinja2_targets(kind=node_kind, updates=updates)
         if attrib.kind == computed_attribute_kind and attrib.attribute.name == computed_attribute_name
     ]
     for computed_macro in computed_macros:
-        found: list[CoreNode] = []
+        found: list[ComputedAttrJinja2GraphQLResponse] = []
+        template_string = "n/a"
+        if computed_macro.attribute.computed_attribute and computed_macro.attribute.computed_attribute.jinja2_template:
+            template_string = computed_macro.attribute.computed_attribute.jinja2_template
+
+        jinja_template = Jinja2Template(template=template_string)
+        variables = jinja_template.get_variables()
+
+        attribute_graphql = ComputedAttrJinja2GraphQL(
+            node_schema=node_schema, attribute_schema=computed_macro.attribute, variables=variables
+        )
+
         for id_filter in computed_macro.node_filters:
-            filters = {id_filter: object_id}
-            nodes: list[CoreNode] = await service.client.filters(
-                kind=computed_macro.kind,
-                branch=branch_name,
-                prefetch_relationships=True,
-                populate_store=True,
-                **filters,
-            )
-            found.extend(nodes)
+            query = attribute_graphql.render_graphql_query(query_filter=id_filter, filter_id=object_id)
+            response = await service.client.execute_graphql(query=query, branch_name=branch_name)
+            output = attribute_graphql.parse_response(response=response)
+            found.extend(output)
 
         if not found:
             log.debug("No nodes found that requires updates")
 
-        template_string = "n/a"
-        if computed_macro.attribute.computed_attribute and computed_macro.attribute.computed_attribute.jinja2_template:
-            template_string = computed_macro.attribute.computed_attribute.jinja2_template
-
         batch = await service.client.create_batch()
         for node in found:
             batch.add(
                 task=update_computed_attribute_value_jinja2,
                 branch_name=branch_name,
                 obj=node,
+                node_kind=node_schema.kind,
                 attribute_name=computed_macro.attribute.name,
-                template_value=template_string,
+                template=jinja_template,
                 service=service,
             )
 

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/node/__init__.py

@@ -29,6 +29,7 @@ from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
 from ...graphql.models import OrderModel
+from ...log import get_logger
 from ..query.relationship import RelationshipDeleteAllQuery
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
@@ -53,6 +54,8 @@ SchemaProtocol = TypeVar("SchemaProtocol")
 #  -
 # ---------------------------------------------------------------------------------------
 
+log = get_logger()
+
 
 class Node(BaseNode, metaclass=BaseNodeMeta):
     @classmethod
@@ -348,7 +351,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             fields.pop("updated_at")
         for field_name in fields.keys():
             if field_name not in self._schema.valid_input_names:
-                errors.append(ValidationError({field_name: f"{field_name} is not a valid input for {self.get_kind()}"}))
+                log.error(f"{field_name} is not a valid input for {self.get_kind()}")
 
         # Backfill fields with the ones from the template if there's one
         await self.handle_object_template(fields=fields, db=db, errors=errors)

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/ipam.py

@@ -367,9 +367,11 @@ class IPPrefixReconcileQuery(Query):
             possible_prefix = tmp_prefix.ljust(self.ip_value.max_prefixlen, "0")
             if possible_prefix not in possible_prefix_map:
                 possible_prefix_map[possible_prefix] = max_prefix_len
-        self.params["possible_prefix_and_length_list"] = [
-            [possible_prefix, max_length] for possible_prefix, max_length in possible_prefix_map.items()
-        ]
+        self.params["possible_prefix_and_length_list"] = []
+        self.params["possible_prefix_list"] = []
+        for possible_prefix, max_length in possible_prefix_map.items():
+            self.params["possible_prefix_and_length_list"].append([possible_prefix, max_length])
+            self.params["possible_prefix_list"].append(possible_prefix)
 
         namespace_query = """
         // ------------------
@@ -386,8 +388,7 @@ class IPPrefixReconcileQuery(Query):
             // ------------------
             // Get IP Prefix node by UUID
             // ------------------
-            MATCH (ip_node {uuid: $node_uuid})
-            WHERE "%(ip_kind)s" IN labels(ip_node)
+            MATCH (ip_node:%(ip_kind)s {uuid: $node_uuid})
             """ % {
                 "ip_kind": InfrahubKind.IPADDRESS
                 if isinstance(self.ip_value, IPAddressType)
@@ -487,6 +488,7 @@ class IPPrefixReconcileQuery(Query):
             -[hvr:HAS_VALUE]->(av:%(ip_prefix_attribute_kind)s)
             WHERE all(r IN relationships(parent_path) WHERE (%(branch_filter)s))
             AND av.version = $ip_version
+            AND av.binary_address IN $possible_prefix_list
             AND any(prefix_and_length IN $possible_prefix_and_length_list WHERE av.binary_address = prefix_and_length[0] AND av.prefixlen <= prefix_and_length[1])
             WITH
                 maybe_new_parent,