infrahub-server 1.2.11__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/core/validators/attribute/length.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.validators.enum import ConstraintIdentifier
 
 from ..interface import ConstraintCheckerInterface
 from ..shared import AttributeSchemaValidatorQuery
@@ -23,13 +24,12 @@ class AttributeLengthUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params.update(branch_params)
 
         self.params["attr_name"] = self.attribute_schema.name
-        self.params["min_length"] = self.attribute_schema.min_length
-        self.params["max_length"] = self.attribute_schema.max_length
+        self.params["min_length"] = self.attribute_schema.get_min_length()
+        self.params["max_length"] = self.attribute_schema.get_max_length()
 
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
                 r in relationships(path)
@@ -40,7 +40,6 @@ class AttributeLengthUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND (
             (toInteger($min_length) IS NOT NULL AND size(attribute_value) < toInteger($min_length))
@@ -79,14 +78,21 @@ class AttributeLengthChecker(ConstraintCheckerInterface):
         return "attribute.length.update"
 
     def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
-        return request.constraint_name in ("attribute.min_length.update", "attribute.max_length.update")
+        return request.constraint_name in (
+            "attribute.min_length.update",
+            "attribute.max_length.update",
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE.value,
+        )
 
     async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
         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.min_length is None and attribute_schema.max_length is True:
+        min_length = attribute_schema.get_min_length()
+        max_length = attribute_schema.get_max_length()
+        if min_length is None and max_length is None:
             return grouped_data_paths_list
 
         for query_class in self.query_classes:

infrahub/core/validators/attribute/min_max.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.constants import PathType
+from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
+from infrahub.core.validators.enum import ConstraintIdentifier
+
+from ..interface import ConstraintCheckerInterface
+from ..shared import AttributeSchemaValidatorQuery
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
+
+class AttributeNumberUpdateValidatorQuery(AttributeSchemaValidatorQuery):
+    name: str = "attribute_constraints_number_validator"
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
+        self.params.update(branch_params)
+
+        if not isinstance(self.attribute_schema.parameters, NumberAttributeParameters):
+            raise ValueError("attribute parameters are not a NumberAttributeParameters")
+
+        self.params["attr_name"] = self.attribute_schema.name
+        self.params["min_value"] = self.attribute_schema.parameters.min_value
+        self.params["max_value"] = self.attribute_schema.parameters.max_value
+        self.params["excluded_values"] = self.attribute_schema.parameters.get_excluded_single_values()
+        self.params["excluded_ranges"] = self.attribute_schema.parameters.get_excluded_ranges()
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
+            WHERE all(
+                r in relationships(path)
+                WHERE %(branch_filter)s
+            )
+            RETURN path as full_path, n as node, rv as value_relationship, av.value as attribute_value
+            ORDER BY rv.branch_level DESC, ra.branch_level DESC, rr.branch_level DESC, rv.from DESC, ra.from DESC, rr.from DESC
+            LIMIT 1
+        }
+        WITH full_path, node, attribute_value, value_relationship
+        WHERE all(r in relationships(full_path) WHERE r.status = "active")
+        AND (
+            (toInteger($min_value) IS NOT NULL AND attribute_value < toInteger($min_value))
+            OR (toInteger($max_value) IS NOT NULL AND attribute_value > toInteger($max_value))
+            OR (size($excluded_values) > 0 AND attribute_value IN $excluded_values)
+            OR (size($excluded_ranges) > 0 AND any(range in $excluded_ranges WHERE attribute_value >= range[0] AND attribute_value <= range[1]))
+        )
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+
+        self.add_to_query(query)
+        self.return_labels = ["node.uuid", "value_relationship", "attribute_value"]
+
+    async def get_paths(self) -> GroupedDataPaths:
+        grouped_data_paths = GroupedDataPaths()
+        for result in self.results:
+            grouped_data_paths.add_data_path(
+                DataPath(
+                    branch=str(result.get("value_relationship").get("branch")),
+                    path_type=PathType.ATTRIBUTE,
+                    node_id=str(result.get("node.uuid")),
+                    field_name=self.attribute_schema.name,
+                    kind=self.node_schema.kind,
+                    value=result.get("attribute_value"),
+                ),
+            )
+
+        return grouped_data_paths
+
+
+class AttributeNumberChecker(ConstraintCheckerInterface):
+    query_classes = [AttributeNumberUpdateValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "attribute.number.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name in (
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE.value,
+        )
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        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 not isinstance(attribute_schema.parameters, NumberAttributeParameters):
+            raise ValueError("attribute parameters are not a NumberAttributeParameters")
+
+        if (
+            attribute_schema.parameters.min_value is None
+            and attribute_schema.parameters.max_value is None
+            and attribute_schema.parameters.excluded_values is None
+        ):
+            return grouped_data_paths_list
+
+        for query_class in self.query_classes:
+            # TODO add exception handling
+            query = await query_class.init(
+                db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+        return grouped_data_paths_list

infrahub/core/validators/attribute/number_pool.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.constants import PathType
+from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.core.validators.enum import ConstraintIdentifier
+
+from ..interface import ConstraintCheckerInterface
+from ..shared import AttributeSchemaValidatorQuery
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
+
+class AttributeNumberPoolUpdateValidatorQuery(AttributeSchemaValidatorQuery):
+    name: str = "attribute_constraints_numberpool_validator"
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
+        self.params.update(branch_params)
+
+        if not isinstance(self.attribute_schema.parameters, NumberPoolParameters):
+            raise ValueError("attribute parameters are not a NumberPoolParameters")
+
+        self.params["attr_name"] = self.attribute_schema.name
+        self.params["start_range"] = self.attribute_schema.parameters.start_range
+        self.params["end_range"] = self.attribute_schema.parameters.end_range
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
+            WHERE all(
+                r in relationships(path)
+                WHERE %(branch_filter)s
+            )
+            RETURN path as full_path, n as node, rv as value_relationship, av.value as attribute_value
+            ORDER BY rv.branch_level DESC, ra.branch_level DESC, rr.branch_level DESC, rv.from DESC, ra.from DESC, rr.from DESC
+            LIMIT 1
+        }
+        WITH full_path, node, attribute_value, value_relationship
+        WHERE all(r in relationships(full_path) WHERE r.status = "active")
+        AND (
+            (toInteger($start_range) IS NOT NULL AND attribute_value < toInteger($start_range))
+            OR (toInteger($end_range) IS NOT NULL AND attribute_value > toInteger($end_range))
+        )
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+
+        self.add_to_query(query)
+        self.return_labels = ["node.uuid", "value_relationship", "attribute_value"]
+
+    async def get_paths(self) -> GroupedDataPaths:
+        grouped_data_paths = GroupedDataPaths()
+        for result in self.results:
+            grouped_data_paths.add_data_path(
+                DataPath(
+                    branch=str(result.get("value_relationship").get("branch")),
+                    path_type=PathType.ATTRIBUTE,
+                    node_id=str(result.get("node.uuid")),
+                    field_name=self.attribute_schema.name,
+                    kind=self.node_schema.kind,
+                    value=result.get("attribute_value"),
+                ),
+            )
+
+        return grouped_data_paths
+
+
+class AttributeNumberPoolChecker(ConstraintCheckerInterface):
+    query_classes = [AttributeNumberPoolUpdateValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "attribute.number.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name in (
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE.value,
+        )
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        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 not isinstance(attribute_schema.parameters, NumberPoolParameters):
+            raise ValueError("attribute parameters are not a NumberPoolParameters")
+
+        for query_class in self.query_classes:
+            # TODO add exception handling
+            query = await query_class.init(
+                db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+        return grouped_data_paths_list

infrahub/core/validators/attribute/optional.py

@@ -27,8 +27,7 @@ class AttributeOptionalUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
                 r in relationships(path)
@@ -39,7 +38,6 @@ class AttributeOptionalUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND (attribute_value IS NULL OR attribute_value = $null_value)
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
@@ -86,7 +84,6 @@ class AttributeOptionalChecker(ConstraintCheckerInterface):
             return grouped_data_paths_list
 
         for query_class in self.query_classes:
-            # TODO add exception handling
             query = await query_class.init(
                 db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
             )

infrahub/core/validators/attribute/regex.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import NULL_VALUE, PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.validators.enum import ConstraintIdentifier
 
 from ..interface import ConstraintCheckerInterface
 from ..shared import AttributeSchemaValidatorQuery
@@ -23,12 +24,11 @@ class AttributeRegexUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params.update(branch_params)
 
         self.params["attr_name"] = self.attribute_schema.name
-        self.params["attr_value_regex"] = self.attribute_schema.regex
+        self.params["attr_value_regex"] = self.attribute_schema.get_regex()
         self.params["null_value"] = NULL_VALUE
         query = """
         MATCH p = (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
                 r in relationships(path)
@@ -39,7 +39,6 @@ class AttributeRegexUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value <> $null_value
         AND NOT attribute_value =~ $attr_value_regex
@@ -79,14 +78,14 @@ class AttributeRegexChecker(ConstraintCheckerInterface):
         return "attribute.regex.update"
 
     def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
-        return request.constraint_name == self.name
+        return request.constraint_name in (self.name, ConstraintIdentifier.ATTRIBUTE_PARAMETERS_REGEX_UPDATE.value)
 
     async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
         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 not attribute_schema.regex:
+        if not attribute_schema.get_regex():
             return grouped_data_paths_list
 
         for query_class in self.query_classes:

infrahub/core/validators/attribute/unique.py

@@ -31,12 +31,10 @@ class AttributeUniqueUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         query = """
         MATCH (potential_node:Node)
         WHERE $node_kind IN LABELS(potential_node)
-        CALL {
-            WITH potential_node
+        CALL (potential_node) {
             MATCH potential_path = (potential_node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })-[potential_value_relationship:HAS_VALUE]-(potential_value:AttributeValue)
             WHERE all(r IN relationships(potential_path) WHERE (%(branch_filter)s))
             WITH
-                potential_node,
                 potential_value,
                 potential_value_relationship,
                 potential_path,

infrahub/core/validators/determiner.py

@@ -1,14 +1,20 @@
+from typing import TYPE_CHECKING, Any
+
 from infrahub.core.constants import RelationshipKind, SchemaPathType
 from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.diff.model.path import NodeDiffFieldSummary
 from infrahub.core.models import SchemaUpdateConstraintInfo
 from infrahub.core.path import SchemaPath
 from infrahub.core.schema import AttributeSchema, MainSchemaTypes
+from infrahub.core.schema.attribute_parameters import AttributeParameters
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.schema.schema_branch import SchemaBranch
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
 from infrahub.log import get_logger
 
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
 LOG = get_logger(__name__)
 
 
@@ -133,7 +139,17 @@ class ConstraintValidatorDeterminer:
         self, schema: MainSchemaTypes, field: AttributeSchema | RelationshipSchema
     ) -> list[SchemaUpdateConstraintInfo]:
         constraints: list[SchemaUpdateConstraintInfo] = []
-        for prop_name, prop_field_info in field.model_fields.items():
+        prop_details_list: list[tuple[str, FieldInfo, Any]] = []
+        for p_name, p_info in field.model_fields.items():
+            p_value = getattr(field, p_name)
+            if isinstance(p_value, AttributeParameters):
+                for parameter_name, parameter_field_info in p_value.model_fields.items():
+                    parameter_value = getattr(p_value, parameter_name)
+                    prop_details_list.append((f"{p_name}.{parameter_name}", parameter_field_info, parameter_value))
+            else:
+                prop_details_list.append((p_name, p_info, p_value))
+
+        for prop_name, prop_field_info, prop_value in prop_details_list:
             if not prop_field_info.json_schema_extra or not isinstance(prop_field_info.json_schema_extra, dict):
                 continue
 
@@ -141,7 +157,7 @@ class ConstraintValidatorDeterminer:
             if prop_field_update != UpdateSupport.VALIDATE_CONSTRAINT.value:
                 continue
 
-            if getattr(field, prop_name) is None:
+            if prop_value is None:
                 continue
 
             path_type = SchemaPathType.ATTRIBUTE

infrahub/core/validators/enum.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class ConstraintIdentifier(str, Enum):
+    ATTRIBUTE_PARAMETERS_REGEX_UPDATE = "attribute.parameters.regex.update"
+    ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE = "attribute.parameters.min_length.update"
+    ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE = "attribute.parameters.max_length.update"
+    ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE = "attribute.parameters.min_value.update"
+    ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE = "attribute.parameters.max_value.update"
+    ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE = "attribute.parameters.excluded_values.update"
+    ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE = "attribute.parameters.end_range.update"
+    ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE = "attribute.parameters.start_range.update"

infrahub/core/validators/node/hierarchy.py

@@ -59,8 +59,7 @@ class NodeHierarchyUpdateValidatorQuery(SchemaValidatorQuery):
         # ruff: noqa: E501
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rroot:IS_PART_OF]-(n)
             WHERE all(r in relationships(path) WHERE %(branch_filter)s)
             RETURN path as full_path, n as active_node
@@ -70,8 +69,7 @@ class NodeHierarchyUpdateValidatorQuery(SchemaValidatorQuery):
         WITH full_path, active_node
         WITH full_path, active_node
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH path = (active_node)%(to_children)s-[hrel1:IS_RELATED]-%(to_parent)s(:Relationship {name: "parent__child"})%(to_children)s-[hrel2:IS_RELATED]-%(to_parent)s(peer:Node)
             WHERE all(
                 r in relationships(path)
@@ -91,8 +89,7 @@ class NodeHierarchyUpdateValidatorQuery(SchemaValidatorQuery):
             collect([branch_level_sum, from_times, active_relationship_count, hierarchy_path, deepest_branch_name]) as enriched_paths,
             start_node,
             peer_node
-        CALL {
-            WITH enriched_paths, peer_node
+        CALL (enriched_paths, peer_node) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[3] as current_path, path_to_check[4] as branch_name, peer_node as current_peer
             ORDER BY

infrahub/core/validators/query.py

@@ -20,8 +20,7 @@ class NodeNotPresentValidatorQuery(SchemaValidatorQuery):
 
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)
             WHERE all(
                 r in relationships(path)
@@ -32,7 +31,6 @@ class NodeNotPresentValidatorQuery(SchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, root_relationship
-        WITH full_path, node, root_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
 

infrahub/core/validators/relationship/count.py

@@ -50,8 +50,7 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         query = """
         // get the nodes on these branches nodes
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rroot:IS_PART_OF]-(n)
             WHERE all(r in relationships(path) WHERE %(branch_filter)s)
             RETURN path as full_path, n as active_node
@@ -60,11 +59,9 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         }
         // filter to only the active nodes
         WITH full_path, active_node
-        WITH full_path, active_node
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         // get the relationships using the given identifier for each node
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH path = (active_node)-[rrel1:IS_RELATED]-(rel:Relationship { name: $relationship_id })-[rrel2:IS_RELATED]-(peer:Node)
             WHERE ($relationship_direction <> "outbound" OR (startNode(rrel1) = active_node AND startNode(rrel2) = rel))
             AND ($relationship_direction <> "inbound" OR (startNode(rrel1) = rel AND startNode(rrel2) = peer))
@@ -87,8 +84,7 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             start_node,
             peer_node
         // make sure to only use the latest version of this particular path
-        CALL {
-            WITH enriched_paths, peer_node
+        CALL (enriched_paths, peer_node) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[3] as current_path, path_to_check[4] as branch_name, peer_node as current_peer
             ORDER BY
@@ -100,8 +96,7 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         }
         // filter to only the current active paths
         WITH collect([current_peer, current_path]) as peers_and_paths, start_node, branch_name
-        CALL {
-            WITH peers_and_paths
+        CALL (peers_and_paths) {
             UNWIND peers_and_paths AS peer_and_path
             WITH peer_and_path
             WHERE all(r in relationships(peer_and_path[1]) WHERE r.status = "active")
@@ -109,9 +104,8 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         }
         // sum all the relationships across branches and identify the violators
         WITH collect([branch_name, num_relationships_on_branch]) as branches_and_counts, start_node
-        CALL {
-            WITH start_node, branches_and_counts
-            WITH start_node, branches_and_counts, reduce(rel_total = 0, bnc in branches_and_counts | rel_total + bnc[1]) AS total_relationships_count
+        CALL (start_node, branches_and_counts) {
+            WITH reduce(rel_total = 0, bnc in branches_and_counts | rel_total + bnc[1]) AS total_relationships_count
             WHERE
                 (toInteger($min_count) IS NOT NULL AND total_relationships_count < toInteger($min_count))
                 OR (toInteger($max_count) IS NOT NULL AND total_relationships_count > toInteger($max_count))

infrahub/core/validators/relationship/optional.py

@@ -30,8 +30,7 @@ class RelationshipOptionalUpdateValidatorQuery(RelationshipSchemaValidatorQuery)
         // Query all Active Nodes of type
         // and store their UUID in uuids_active_node
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(n)
             WHERE %(branch_filter)s
             RETURN n as n1, r as r1
@@ -44,8 +43,7 @@ class RelationshipOptionalUpdateValidatorQuery(RelationshipSchemaValidatorQuery)
         // identifier all nodes with at least one active member for this relationship
         // and store their UUID in uuids_with_rel
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n, uuids_active_node
+        CALL (n, uuids_active_node) {
             MATCH path = (n)-[r:IS_RELATED]-(:Relationship { name: $relationship_id })
             WHERE %(branch_filter)s
             RETURN n as n1, r as r1