infrahub-server 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

infrahub/core/query/diff.py

@@ -148,7 +148,14 @@ CALL (diff_path) {
         OR type(base_r_node) <> "IS_RELATED" OR type(base_r_prop) <> "IS_RELATED"
     )
     WITH latest_base_path, base_r_root, base_r_node, base_r_prop
-    ORDER BY base_r_prop.from DESC, base_r_node.from DESC, base_r_root.from DESC
+    // status="active" ordering is for tie-breaking edges added and deleted at the same time, we want the active one
+    ORDER BY
+        base_r_prop.from DESC,
+        base_r_prop.status = "active" DESC,
+        base_r_node.from DESC,
+        base_r_node.status = "active" DESC,
+        base_r_root.from DESC,
+        base_r_root.status = "active" DESC
     LIMIT 1
     RETURN latest_base_path
 }
@@ -172,8 +179,6 @@ CALL (penultimate_path) {
     AND %(id_func)s(peer_r_node) = %(id_func)s(r_node)
     AND [%(id_func)s(n), type(peer_r_node)] <> [%(id_func)s(peer), type(r_peer)]
     AND r_peer.from < $to_time
-    // filter out paths where an earlier from time follows a later from time
-    AND peer_r_node.from <= r_peer.from
     // filter out paths where a base branch edge follows a branch edge
     AND (peer_r_node.branch = $base_branch_name OR r_peer.branch = $branch_name)
     // filter out paths where an active edge follows a deleted edge
@@ -663,6 +668,15 @@ AND ALL(
     AND ((r_pair[0]).status = "active" OR (r_pair[1]).status = "deleted")
     // filter out paths where an earlier from time follows a later from time
     AND (r_pair[0]).from <= (r_pair[1]).from
+    // if both are deleted, then the deeper edge must have been deleted first
+    AND ((r_pair[0]).status = "active" OR (r_pair[1]).status = "active" OR (r_pair[0]).from >= (r_pair[1].from))
+    AND (
+        (r_pair[0]).status = (r_pair[1]).status
+        OR (
+            (r_pair[0]).from <= (r_pair[1]).from
+            AND ((r_pair[0]).to IS NULL OR (r_pair[0]).to >= (r_pair[1]).from)
+        )
+    )
     // require adjacent edge pairs to have overlapping times, but only if on the same branch
     AND (
         (r_pair[0]).branch <> (r_pair[1]).branch

infrahub/core/query/relationship.py

@@ -643,12 +643,9 @@ class RelationshipGetPeerQuery(Query):
 
         arrows = self.schema.get_query_arrows()
 
-        path_str = (
-            f"{arrows.left.start}[:IS_RELATED]{arrows.left.end}(rl){arrows.right.start}[:IS_RELATED]{arrows.right.end}"
-        )
+        path_str = f"{arrows.left.start}[r1:IS_RELATED]{arrows.left.end}(rl){arrows.right.start}[r2:IS_RELATED]{arrows.right.end}"
 
         branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
-        froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")
         query = """
         MATCH (source_node:Node)%(arrow_left_start)s[:IS_RELATED]%(arrow_left_end)s(rl:Relationship { name: $rel_identifier })
         WHERE source_node.uuid IN $source_ids
@@ -659,24 +656,24 @@ class RelationshipGetPeerQuery(Query):
                 $source_kind IN LABELS(source_node) AND
                 peer.uuid <> source_node.uuid AND
                 $peer_kind IN LABELS(peer) AND
-                all(r IN relationships(path) WHERE (%(branch_filter)s))
-            WITH source_node, peer, rl, relationships(path) as rels, %(branch_level)s AS branch_level, %(froms)s AS froms
-            RETURN peer as peer, rels, rl as rl1
-            ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC
+                all(r IN [r1, r2] WHERE (%(branch_filter)s))
+            WITH source_node, peer, rl, r1, r2, %(branch_level)s AS branch_level
+            RETURN peer as peer, r1.status = "active" AND r2.status = "active" AS is_active, [r1, r2] AS rels
+            // status is required as a tiebreaker for migrated-kind nodes
+            ORDER BY branch_level DESC, r2.from DESC, r2.status ASC, r1.from DESC, r1.status ASC
             LIMIT 1
         }
-        WITH peer, rl1 as rl, rels, source_node
+        WITH peer, rl, is_active, rels, source_node
         """ % {
             "path": path_str,
             "branch_filter": branch_filter,
             "branch_level": branch_level_str,
-            "froms": froms_str,
             "arrow_left_start": arrows.left.start,
             "arrow_left_end": arrows.left.end,
         }
 
         self.add_to_query(query)
-        where_clause = ['all(r IN rels WHERE r.status = "active")']
+        where_clause = ["is_active = TRUE"]
         clean_filters = extract_field_filters(field_name=self.schema.name, filters=self.filters)
 
         if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:

infrahub/core/query/resource_manager.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Generator
+
+from pydantic import BaseModel, ConfigDict
 
 from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind, RelationshipStatus
@@ -11,6 +13,13 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
+class NumberPoolIdentifierData(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    value: int
+    identifier: str
+
+
 class IPAddressPoolGetIdentifiers(Query):
     name = "ipaddresspool_get_identifiers"
     type = QueryType.READ
@@ -158,7 +167,7 @@ class NumberPoolGetReserved(Query):
     def __init__(
         self,
         pool_id: str,
-        identifier: str,
+        identifier: str | None = None,
         **kwargs: dict[str, Any],
     ) -> None:
         self.pool_id = pool_id
@@ -176,26 +185,104 @@ class NumberPoolGetReserved(Query):
 
         self.params.update(branch_params)
 
+        # If identifier is not provided, we return all reservations for the pool
+        identifier_filter = ""
+        if self.identifier:
+            identifier_filter = "r.identifier = $identifier AND "
+            self.params["identifier"] = self.identifier
+
         query = """
         MATCH (pool:%(number_pool)s { uuid: $pool_id })-[r:IS_RESERVED]->(reservation:AttributeValue)
         WHERE
-            r.identifier = $identifier
-            AND
+            %(identifier_filter)s
             %(branch_filter)s
-        """ % {"branch_filter": branch_filter, "number_pool": InfrahubKind.NUMBERPOOL}
+        """ % {
+            "branch_filter": branch_filter,
+            "number_pool": InfrahubKind.NUMBERPOOL,
+            "identifier_filter": identifier_filter,
+        }
         self.add_to_query(query)
-        self.return_labels = ["reservation.value"]
+        self.return_labels = ["reservation.value AS value", "r.identifier AS identifier"]
 
     def get_reservation(self) -> int | None:
         result = self.get_result()
         if result:
-            return result.get_as_optional_type("reservation.value", return_type=int)
+            return result.get_as_optional_type("value", return_type=int)
         return None
 
+    def get_reservations(self) -> Generator[NumberPoolIdentifierData]:
+        for result in self.results:
+            yield NumberPoolIdentifierData.model_construct(
+                value=result.get_as_type("value", return_type=int),
+                identifier=result.get_as_type("identifier", return_type=str),
+            )
+
+
+class PoolChangeReserved(Query):
+    """Change the identifier on all pools.
+    This is useful when a node is being converted to a different type and its ID has changed
+    """
+
+    name = "pool_change_reserved"
+    type = QueryType.WRITE
+
+    def __init__(
+        self,
+        existing_identifier: str,
+        new_identifier: str,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        self.existing_identifier = existing_identifier
+        self.new_identifier = new_identifier
+
+        super().__init__(**kwargs)  # type: ignore[arg-type]
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["new_identifier"] = self.new_identifier
+        self.params["existing_identifier"] = self.existing_identifier
+        self.params["at"] = self.at.to_string()
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(
+            at=self.at.to_string(), branch_agnostic=self.branch_agnostic
+        )
+
+        self.params.update(branch_params)
+
+        global_branch = registry.get_global_branch()
+        self.params["rel_prop"] = {
+            "branch": global_branch.name,
+            "branch_level": global_branch.hierarchy_level,
+            "status": RelationshipStatus.ACTIVE.value,
+            "from": self.at.to_string(),
+            "identifier": self.new_identifier,
+        }
+
+        query = """
+        MATCH (pool:Node)-[r:IS_RESERVED]->(resource)
+        WHERE
+            r.identifier = $existing_identifier
+            AND
+            %(branch_filter)s
+        SET r.to = $at
+        CREATE (pool)-[new_rel:IS_RESERVED $rel_prop]->(resource)
+        """ % {"branch_filter": branch_filter}
+        self.add_to_query(query)
+        self.return_labels = ["pool.uuid AS pool_id", "r", "new_rel"]
+
+
+"""
+Important!: The relationship IS_RESERVED for Number is not being cleaned up when the node or the branch is deleted
+I think this is something we should address in the future.
+It works for now because the query has been updated to match the identifier in IS_RESERVED with the UUID of the related node
+But in the future, if we need to use an identifier that is not the UUID, we will need to clean up the relationships
+This will be especially important as we want to support upsert with NumberPool
+"""
+
 
 class NumberPoolGetUsed(Query):
     name = "number_pool_get_used"
     type = QueryType.READ
+    return_model = NumberPoolIdentifierData
 
     def __init__(
         self,
@@ -219,26 +306,36 @@ class NumberPoolGetUsed(Query):
         self.params["attribute_name"] = self.pool.node_attribute.value
 
         query = """
-        MATCH (pool:%(number_pool)s { uuid: $pool_id })
-        CALL (pool) {
-            MATCH (pool)-[res:IS_RESERVED]->(av:AttributeValue)<-[hv:HAS_VALUE]-(attr:Attribute)
+        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValue)
+        WHERE toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
+        CALL (pool, res, av) {
+            MATCH (pool)-[res]->(av)<-[hv:HAS_VALUE]-(attr:Attribute)<-[ha:HAS_ATTRIBUTE]-(n:%(node)s)
             WHERE
-                attr.name = $attribute_name
-                AND
-                toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
-                AND
-                all(r in [res, hv] WHERE (%(branch_filter)s))
-            RETURN av, (res.status = "active" AND hv.status = "active") AS is_active
+                n.uuid = res.identifier AND
+                attr.name = $attribute_name AND
+                all(r in [res, hv, ha] WHERE (%(branch_filter)s))
+            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC, res.from DESC, hv.from DESC, ha.from DESC
+            RETURN (res.status = "active" AND hv.status = "active" AND ha.status = "active") AS is_active
+            LIMIT 1
         }
-        WITH av, is_active
-        WHERE is_active = TRUE
+        WITH av, res, is_active
+        WHERE is_active = True
         """ % {
             "branch_filter": branch_filter,
             "number_pool": InfrahubKind.NUMBERPOOL,
+            "node": self.pool.node.value,
         }
+
         self.add_to_query(query)
-        self.return_labels = ["av.value"]
-        self.order_by = ["av.value"]
+        self.return_labels = ["DISTINCT(av.value) as value", "res.identifier as identifier"]
+        self.order_by = ["value"]
+
+    def iter_results(self) -> Generator[NumberPoolIdentifierData]:
+        for result in self.results:
+            yield self.return_model.model_construct(
+                value=result.get_as_type("value", return_type=int),
+                identifier=result.get_as_type("identifier", return_type=str),
+            )
 
 
 class NumberPoolSetReserved(Query):

infrahub/core/schema/__init__.py

@@ -46,6 +46,7 @@ class SchemaExtension(HashableModel):
 
 class SchemaRoot(BaseModel):
     model_config = ConfigDict(extra="forbid")
+
     version: str | None = Field(default=None)
     generics: list[GenericSchema] = Field(default_factory=list)
     nodes: list[NodeSchema] = Field(default_factory=list)
@@ -93,6 +94,10 @@ class SchemaRoot(BaseModel):
         """Return a new `SchemaRoot` after merging `self` with `schema`."""
         return SchemaRoot.model_validate(deep_merge_dict(dicta=self.model_dump(), dictb=schema.model_dump()))
 
+    def duplicate(self) -> SchemaRoot:
+        """Return a duplicate of the current schema."""
+        return SchemaRoot.model_validate(self.model_dump())
+
 
 internal_schema = internal.to_dict()
 

infrahub/core/schema/attribute_parameters.py

@@ -165,3 +165,9 @@ class NumberPoolParameters(AttributeParameters):
         if self.start_range > self.end_range:
             raise ValueError("`start_range` can't be less than `end_range`")
         return self
+
+    def get_pool_size(self) -> int:
+        """
+        Returns the size of the pool based on the defined ranges.
+        """
+        return self.end_range - self.start_range + 1

infrahub/core/schema/attribute_schema.py

@@ -10,6 +10,7 @@ from infrahub import config
 from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.enums import generate_python_enum
 from infrahub.core.query.attribute import default_attribute_query_filter
+from infrahub.exceptions import InitializationError
 from infrahub.types import ATTRIBUTE_KIND_LABELS, ATTRIBUTE_TYPES
 
 from .attribute_parameters import (
@@ -67,6 +68,11 @@ class AttributeSchema(GeneratedAttributeSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    def get_id(self) -> str:
+        if self.id is None:
+            raise InitializationError("The attribute schema has not been saved yet and doesn't have an id")
+        return self.id
+
     def to_dict(self) -> dict:
         data = self.model_dump(exclude_unset=True, exclude_none=True)
         for field_name, value in data.items():

infrahub/core/schema/manager.py

@@ -535,7 +535,7 @@ class SchemaManager(NodeManager):
         """Delete the node with its attributes and relationships."""
         branch = await registry.get_branch(branch=branch, db=db)
 
-        obj = await self.get_one(id=node.get_id(), branch=branch, db=db)
+        obj = await self.get_one(id=node.get_id(), branch=branch, db=db, prefetch_relationships=True)
         if not obj:
             raise SchemaNotFoundError(
                 branch_name=branch.name,
@@ -544,16 +544,10 @@ class SchemaManager(NodeManager):
             )
 
         # First delete the attributes and the relationships
-        items = await self.get_many(
-            ids=[item.id for item in node.local_attributes + node.local_relationships if item.id],
-            db=db,
-            branch=branch,
-            include_owner=True,
-            include_source=True,
-        )
-
-        for item in items.values():
-            await item.delete(db=db)
+        for attr_schema_node in (await obj.attributes.get_peers(db=db)).values():
+            await attr_schema_node.delete(db=db)
+        for rel_schema_node in (await obj.relationships.get_peers(db=db)).values():
+            await rel_schema_node.delete(db=db)
 
         await obj.delete(db=db)
 

infrahub/core/schema/relationship_schema.py

@@ -9,6 +9,7 @@ from infrahub import config
 from infrahub.core.constants import RelationshipDirection
 from infrahub.core.query import QueryNode, QueryRel, QueryRelDirection
 from infrahub.core.relationship import Relationship
+from infrahub.exceptions import InitializationError
 
 from .generated.relationship_schema import GeneratedRelationshipSchema
 
@@ -57,6 +58,11 @@ class RelationshipSchema(GeneratedRelationshipSchema):
             raise ValueError("RelationshipSchema is not initialized")
         return self.identifier
 
+    def get_id(self) -> str:
+        if not self.id:
+            raise InitializationError("The relationship schema has not been saved yet and doesn't have an id")
+        return self.id
+
     def get_query_arrows(self) -> QueryArrows:
         """Return (in 4 parts) the 2 arrows for the relationship R1 and R2 based on the direction of the relationship."""
 

infrahub/core/schema/schema_branch.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import hashlib
+import keyword
 from collections import defaultdict
 from itertools import chain, combinations
 from typing import Any
@@ -518,6 +519,7 @@ class SchemaBranch:
 
     def process_validate(self) -> None:
         self.validate_names()
+        self.validate_python_keywords()
         self.validate_kinds()
         self.validate_computed_attributes()
         self.validate_attribute_parameters()
@@ -987,6 +989,26 @@ class SchemaBranch:
                 ):
                     raise ValueError(f"{node.kind}: {rel.name} isn't allowed as a relationship name.")
 
+    def validate_python_keywords(self) -> None:
+        """Validate that attribute and relationship names don't use Python keywords."""
+        for name in self.all_names:
+            node = self.get(name=name, duplicate=False)
+
+            # Check for Python keywords in attribute names
+            for attribute in node.attributes:
+                if keyword.iskeyword(attribute.name):
+                    raise ValueError(
+                        f"Python keyword '{attribute.name}' cannot be used as an attribute name on '{node.kind}'"
+                    )
+
+            # Check for Python keywords in relationship names
+            if config.SETTINGS.main.schema_strict_mode:
+                for relationship in node.relationships:
+                    if keyword.iskeyword(relationship.name):
+                        raise ValueError(
+                            f"Python keyword '{relationship.name}' cannot be used as a relationship name on '{node.kind}' when using strict mode"
+                        )
+
     def _validate_common_parent(self, node: NodeSchema, rel: RelationshipSchema) -> None:
         if not rel.common_parent:
             return
@@ -1588,7 +1610,8 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
-    def generate_weight(self) -> None:
+    def _generate_weight_generics(self) -> None:
+        """Generate order_weight for all generic schemas."""
         for name in self.generic_names:
             node = self.get(name=name, duplicate=False)
 
@@ -1606,6 +1629,8 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
+    def _generate_weight_nodes_profiles(self) -> None:
+        """Generate order_weight for all nodes and profiles."""
         for name in self.node_names + self.profile_names:
             node = self.get(name=name, duplicate=False)
 
@@ -1630,6 +1655,33 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
+    def _generate_weight_templates(self) -> None:
+        """Generate order_weight for all templates.
+
+        The order of the fields for the template must respect the order of the node.
+        """
+        for name in self.template_names:
+            template = self.get(name=name, duplicate=True)
+            node = self.get(name=template.name, duplicate=False)
+
+            node_weights = {
+                item.name: item.order_weight
+                for item in node.attributes + node.relationships
+                if item.order_weight is not None
+            }
+
+            for item in template.attributes + template.relationships:
+                if item.order_weight:
+                    continue
+                item.order_weight = node_weights[item.name] + 10000 if item.name in node_weights else None
+
+            self.set(name=name, schema=template)
+
+    def generate_weight(self) -> None:
+        self._generate_weight_generics()
+        self._generate_weight_nodes_profiles()
+        self._generate_weight_templates()
+
     def cleanup_inherited_elements(self) -> None:
         for name in self.node_names:
             node = self.get_node(name=name, duplicate=False)
@@ -2038,25 +2090,34 @@ class SchemaBranch:
                 if relationship.kind not in [RelationshipKind.ATTRIBUTE, RelationshipKind.GENERIC]
                 else relationship.peer
             )
+
+            is_optional = (
+                relationship.optional if is_autogenerated_subtemplate else relationship.kind != RelationshipKind.PARENT
+            )
+            identifier = (
+                f"template_{relationship.identifier}"
+                if relationship.identifier
+                else self._generate_identifier_string(template_schema.kind, rel_template_peer)
+            )
+            label = (
+                f"{relationship.name} template".title()
+                if relationship.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
+                else relationship.name.title()
+            )
+
             template_schema.relationships.append(
                 RelationshipSchema(
                     name=relationship.name,
                     peer=rel_template_peer,
                     kind=relationship.kind,
-                    optional=relationship.optional
-                    if is_autogenerated_subtemplate
-                    else relationship.kind != RelationshipKind.PARENT,
+                    optional=is_optional,
                     cardinality=relationship.cardinality,
                     direction=relationship.direction,
                     branch=relationship.branch,
-                    identifier=f"template_{relationship.identifier}"
-                    if relationship.identifier
-                    else self._generate_identifier_string(template_schema.kind, rel_template_peer),
+                    identifier=identifier,
                     min_count=relationship.min_count,
                     max_count=relationship.max_count,
-                    label=f"{relationship.name} template".title()
-                    if relationship.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
-                    else relationship.name.title(),
+                    label=label,
                     inherited=relationship.inherited,
                 )
             )
@@ -2144,7 +2205,7 @@ class SchemaBranch:
             attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
             attr = attr_schema_class(
                 optional=node_attr.optional if is_autogenerated_subtemplate else True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only"]),
+                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "order_weight"]),
             )
             template.attributes.append(attr)
 

infrahub/core/validators/node/attribute.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub.core import registry
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+
 from ..interface import ConstraintCheckerInterface
 from ..query import NodeNotPresentValidatorQuery
 
@@ -31,10 +34,22 @@ class NodeAttributeAddChecker(ConstraintCheckerInterface):
         grouped_data_paths_list: list[GroupedDataPaths] = []
         if not request.schema_path.field_name:
             raise ValueError("field_name is not defined")
+
         attribute_schema = request.node_schema.get_attribute(name=request.schema_path.field_name)
         if attribute_schema.optional is True or attribute_schema.default_value is not None:
             return grouped_data_paths_list
 
+        # If the attribute is a NumberPool, we need to ensure that the pool is big enough for all existing nodes
+        if attribute_schema.kind == "NumberPool" and isinstance(attribute_schema.parameters, NumberPoolParameters):
+            nbr_nodes = await registry.manager.count(db=self.db, branch=self.branch, schema=request.node_schema)
+            pool_size = attribute_schema.parameters.get_pool_size()
+
+            if pool_size < nbr_nodes:
+                raise ValueError(
+                    f"The size of the NumberPool is smaller than the number of existing nodes {pool_size} < {nbr_nodes}."
+                )
+            return grouped_data_paths_list
+
         for query_class in self.query_classes:
             # TODO add exception handling
             query = await query_class.init(

infrahub/core/validators/tasks.py

@@ -11,9 +11,7 @@ from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.path import SchemaPath  # noqa: TC001
 from infrahub.core.schema import GenericSchema, NodeSchema
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
-from infrahub.core.validators.model import (
-    SchemaConstraintValidatorRequest,
-)
+from infrahub.core.validators.model import SchemaConstraintValidatorRequest, SchemaViolation
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.utils import add_tags
@@ -84,7 +82,17 @@ async def schema_path_validate(
         aggregated_constraint_checker = await component_registry.get_component(
             AggregatedConstraintChecker, db=db, branch=branch
         )
-        violations = await aggregated_constraint_checker.run_constraints(constraint_request)
+        try:
+            violations = await aggregated_constraint_checker.run_constraints(constraint_request)
+        except Exception as exc:
+            violation = SchemaViolation(
+                node_id="unknown",
+                node_kind=node_schema.kind,
+                display_label=f"Error validating {constraint_name} on {node_schema.kind}",
+                full_display_label=f"Error validating {constraint_name} on {node_schema.kind}",
+                message=str(exc),
+            )
+            violations = [violation]
 
         return SchemaValidatorPathResponseData(
             violations=violations, constraint_name=constraint_name, schema_path=schema_path

infrahub/generators/tasks.py

@@ -214,7 +214,7 @@ async def request_generator_definition_run(
             repository_kind=repository.typename,
             branch_name=model.branch,
             query=model.generator_definition.query_name,
-            variables=member.extract(params=model.generator_definition.parameters),
+            variables=await member.extract(params=model.generator_definition.parameters),
             target_id=member.id,
             target_name=member.display_label,
         )

infrahub/git/integrator.py

@@ -1294,7 +1294,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         query: CoreGraphQLQuery,
     ) -> ArtifactGenerateResult:
         """It doesn't look like this is used anywhere today ... we should either remove it or refactor render_artifact below to use this."""
-        variables = target.extract(params=definition.parameters.value)
+        variables = await target.extract(params=definition.parameters.value)
         response = await self.sdk.query_gql_query(
             name=query.name.value,
             variables=variables,

infrahub/git/tasks.py

@@ -365,7 +365,7 @@ async def generate_request_artifact_definition(
             repository_kind=repository.get_kind(),
             branch_name=model.branch,
             query=query.name.value,
-            variables=member.extract(params=artifact_definition.parameters.value),
+            variables=await member.extract(params=artifact_definition.parameters.value),
             target_id=member.id,
             target_name=member.display_label,
             target_kind=member.get_kind(),
@@ -583,7 +583,7 @@ async def trigger_repository_user_checks_definitions(
                 branch_name=model.branch_name,
                 check_definition_id=model.check_definition_id,
                 proposed_change=model.proposed_change,
-                variables=member.extract(params=definition.parameters.value),
+                variables=await member.extract(params=definition.parameters.value),
                 branch_diff=model.branch_diff,
                 timeout=definition.timeout.value,
             )