infrahub-server 1.2.9rc0__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/core/schema/basenode_schema.py

@@ -13,7 +13,7 @@ from pydantic import field_validator
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
 from infrahub.core.models import HashableModel, HashableModelDiff
 
-from .attribute_schema import AttributeSchema
+from .attribute_schema import AttributeSchema, get_attribute_schema_class_for_kind
 from .generated.base_node_schema import GeneratedBaseNodeSchema
 from .relationship_schema import RelationshipSchema
 
@@ -74,6 +74,30 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         Be careful hash generated from hash() have a salt by default and they will not be the same across run"""
         return hash(self.get_hash())
 
+    @field_validator("attributes", mode="before")
+    @classmethod
+    def set_attribute_type(cls, raw_attributes: Any) -> Any:
+        if not isinstance(raw_attributes, list):
+            return raw_attributes
+        attribute_schemas_with_types: list[Any] = []
+        for raw_attr in raw_attributes:
+            if not isinstance(raw_attr, (dict, AttributeSchema)):
+                attribute_schemas_with_types.append(raw_attr)
+                continue
+            if isinstance(raw_attr, dict):
+                kind = raw_attr.get("kind")
+                attribute_type_class = get_attribute_schema_class_for_kind(kind=kind)
+                attribute_schemas_with_types.append(attribute_type_class(**raw_attr))
+                continue
+
+            expected_attr_schema_class = get_attribute_schema_class_for_kind(kind=raw_attr.kind)
+            if not isinstance(raw_attr, expected_attr_schema_class):
+                final_attr = expected_attr_schema_class(**raw_attr.model_dump())
+            else:
+                final_attr = raw_attr
+            attribute_schemas_with_types.append(final_attr)
+        return attribute_schemas_with_types
+
     def to_dict(self) -> dict:
         data = self.model_dump(
             exclude_unset=True, exclude_none=True, exclude_defaults=True, exclude={"attributes", "relationships"}

infrahub/core/schema/definitions/core/__init__.py

@@ -1,5 +1,17 @@
 from typing import Any
 
+from infrahub.actions.schema import (
+    core_action,
+    core_generator_action,
+    core_group_action,
+    core_group_trigger_rule,
+    core_node_trigger_attribute_match,
+    core_node_trigger_match,
+    core_node_trigger_relationship_match,
+    core_node_trigger_rule,
+    core_trigger_rule,
+)
+
 from ...generic_schema import GenericSchema
 from ...node_schema import NodeSchema
 from .account import (
@@ -63,6 +75,9 @@ from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
 
 core_models_mixed: dict[str, list] = {
     "generics": [
+        core_action,
+        core_trigger_rule,
+        core_node_trigger_match,
         core_node,
         lineage_owner,
         core_profile_schema_definition,
@@ -90,12 +105,18 @@ core_models_mixed: dict[str, list] = {
     ],
     "nodes": [
         menu_item,
+        core_group_action,
         core_standard_group,
         core_generator_group,
         core_graphql_query_group,
         builtin_tag,
         core_account,
         core_account_token,
+        core_generator_action,
+        core_group_trigger_rule,
+        core_node_trigger_rule,
+        core_node_trigger_attribute_match,
+        core_node_trigger_relationship_match,
         core_password_credential,
         core_refresh_token,
         core_proposed_change,

infrahub/core/schema/definitions/internal.py

@@ -31,6 +31,7 @@ from infrahub.core.constants import (
     RelationshipKind,
     UpdateSupport,
 )
+from infrahub.core.schema.attribute_parameters import AttributeParameters
 from infrahub.core.schema.attribute_schema import AttributeSchema
 from infrahub.core.schema.computed_attribute import ComputedAttribute
 from infrahub.core.schema.dropdown import DropdownChoice
@@ -506,21 +507,21 @@ attribute_schema = SchemaNode(
         SchemaAttribute(
             name="regex",
             kind="Text",
-            description="Regex uses to limit the characters allowed in for the attributes.",
+            description="Regex uses to limit the characters allowed in for the attributes. (deprecated: please use parameters.regex instead)",
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
         SchemaAttribute(
             name="max_length",
             kind="Number",
-            description="Set a maximum number of characters allowed for a given attribute.",
+            description="Set a maximum number of characters allowed for a given attribute. (deprecated: please use parameters.max_length instead)",
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
         SchemaAttribute(
             name="min_length",
             kind="Number",
-            description="Set a minimum number of characters allowed for a given attribute.",
+            description="Set a minimum number of characters allowed for a given attribute. (deprecated: please use parameters.min_length instead)",
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
@@ -617,6 +618,15 @@ attribute_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},
         ),
+        SchemaAttribute(
+            name="parameters",
+            kind="JSON",
+            internal_kind=AttributeParameters,
+            optional=True,
+            description="Extra parameters specific to this kind of attribute",
+            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+            default_factory="AttributeParameters",
+        ),
         SchemaAttribute(
             name="deprecation",
             kind="Text",

infrahub/core/schema/generated/attribute_schema.py

@@ -8,6 +8,7 @@ from pydantic import Field
 
 from infrahub.core.constants import AllowOverrideType, BranchSupportType, HashableModelState
 from infrahub.core.models import HashableModel
+from infrahub.core.schema.attribute_parameters import AttributeParameters  # noqa: TC001
 from infrahub.core.schema.computed_attribute import ComputedAttribute  # noqa: TC001
 from infrahub.core.schema.dropdown import DropdownChoice  # noqa: TC001
 
@@ -44,17 +45,17 @@ class GeneratedAttributeSchema(HashableModel):
     )
     regex: str | None = Field(
         default=None,
-        description="Regex uses to limit the characters allowed in for the attributes.",
+        description="Regex uses to limit the characters allowed in for the attributes. (deprecated: please use parameters.regex instead)",
         json_schema_extra={"update": "validate_constraint"},
     )
     max_length: int | None = Field(
         default=None,
-        description="Set a maximum number of characters allowed for a given attribute.",
+        description="Set a maximum number of characters allowed for a given attribute. (deprecated: please use parameters.max_length instead)",
         json_schema_extra={"update": "validate_constraint"},
     )
     min_length: int | None = Field(
         default=None,
-        description="Set a minimum number of characters allowed for a given attribute.",
+        description="Set a minimum number of characters allowed for a given attribute. (deprecated: please use parameters.min_length instead)",
         json_schema_extra={"update": "validate_constraint"},
     )
     label: str | None = Field(
@@ -112,6 +113,11 @@ class GeneratedAttributeSchema(HashableModel):
         description="Type of allowed override for the attribute.",
         json_schema_extra={"update": "allowed"},
     )
+    parameters: AttributeParameters = Field(
+        default_factory=AttributeParameters,
+        description="Extra parameters specific to this kind of attribute",
+        json_schema_extra={"update": "validate_constraint"},
+    )
     deprecation: str | None = Field(
         default=None,
         description="Mark attribute as deprecated and provide a user-friendly message to display",

infrahub/core/schema/schema_branch.py

@@ -49,6 +49,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
+from infrahub.core.schema.attribute_schema import get_attribute_schema_class_for_kind
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
 from infrahub.exceptions import SchemaNotFoundError, ValidationError
@@ -1136,7 +1137,7 @@ class SchemaBranch:
                 self.set(name=name, schema=node)
 
     def process_labels(self) -> None:
-        def check_if_need_to_update_label(node) -> bool:
+        def check_if_need_to_update_label(node: MainSchemaTypes) -> bool:
             if not node.label:
                 return True
             for item in node.relationships + node.attributes:
@@ -1812,12 +1813,14 @@ class SchemaBranch:
     def generate_profile_from_node(self, node: NodeSchema) -> ProfileSchema:
         core_profile_schema = self.get(name=InfrahubKind.PROFILE, duplicate=False)
         core_name_attr = core_profile_schema.get_attribute(name="profile_name")
-        profile_name_attr = AttributeSchema(
+        name_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_name_attr.kind)
+        profile_name_attr = name_attr_schema_class(
             **core_name_attr.model_dump(exclude=["id", "inherited"]),
         )
         profile_name_attr.branch = node.branch
         core_priority_attr = core_profile_schema.get_attribute(name="profile_priority")
-        profile_priority_attr = AttributeSchema(
+        priority_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_priority_attr.kind)
+        profile_priority_attr = priority_attr_schema_class(
             **core_priority_attr.model_dump(exclude=["id", "inherited"]),
         )
         profile_priority_attr.branch = node.branch
@@ -1848,8 +1851,8 @@ class SchemaBranch:
         for node_attr in node.attributes:
             if node_attr.read_only or node_attr.optional is False:
                 continue
-
-            attr = AttributeSchema(
+            attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
+            attr = attr_schema_class(
                 optional=True,
                 **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "default_value", "inherited"]),
             )
@@ -1973,7 +1976,8 @@ class SchemaBranch:
             else self.get(name=InfrahubKind.OBJECTTEMPLATE, duplicate=False)
         )
         core_name_attr = core_template_schema.get_attribute(name=OBJECT_TEMPLATE_NAME_ATTR)
-        template_name_attr = AttributeSchema(
+        name_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_name_attr.kind)
+        template_name_attr = name_attr_schema_class(
             **core_name_attr.model_dump(exclude=["id", "inherited"]),
         )
         template_name_attr.branch = node.branch
@@ -2033,7 +2037,8 @@ class SchemaBranch:
             if node_attr.unique or node_attr.read_only:
                 continue
 
-            attr = AttributeSchema(
+            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"]),
             )
@@ -2050,6 +2055,9 @@ class SchemaBranch:
 
         identified.add(node_schema)
 
+        if node_schema.is_node_schema:
+            identified.update([self.get(name=kind, duplicate=False) for kind in node_schema.inherit_from])
+
         for relationship in node_schema.relationships:
             if (
                 relationship.peer in [InfrahubKind.GENERICGROUP, InfrahubKind.PROFILE]

infrahub/core/validators/__init__.py

@@ -5,6 +5,7 @@ from .attribute.length import AttributeLengthChecker
 from .attribute.optional import AttributeOptionalChecker
 from .attribute.regex import AttributeRegexChecker
 from .attribute.unique import AttributeUniquenessChecker
+from .enum import ConstraintIdentifier
 from .interface import ConstraintCheckerInterface
 from .node.attribute import NodeAttributeAddChecker
 from .node.generate_profile import NodeGenerateProfileChecker
@@ -17,11 +18,14 @@ from .relationship.peer import RelationshipPeerChecker
 from .uniqueness.checker import UniquenessChecker
 
 CONSTRAINT_VALIDATOR_MAP: dict[str, type[ConstraintCheckerInterface] | None] = {
+    "attribute.kind.update": AttributeKindChecker,
     "attribute.regex.update": AttributeRegexChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_REGEX_UPDATE.value: AttributeRegexChecker,
     "attribute.enum.update": AttributeEnumChecker,
-    "attribute.kind.update": AttributeKindChecker,
     "attribute.min_length.update": AttributeLengthChecker,
     "attribute.max_length.update": AttributeLengthChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE.value: AttributeLengthChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE.value: AttributeLengthChecker,
     "attribute.unique.update": AttributeUniquenessChecker,
     "attribute.optional.update": AttributeOptionalChecker,
     "attribute.choices.update": AttributeChoicesChecker,

infrahub/core/validators/attribute/choices.py

@@ -31,8 +31,7 @@ class AttributeChoicesUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 
         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)

infrahub/core/validators/attribute/enum.py

@@ -30,8 +30,7 @@ class AttributeEnumUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params["null_value"] = NULL_VALUE
         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)

infrahub/core/validators/attribute/kind.py

@@ -37,8 +37,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 
         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)

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)
@@ -79,14 +79,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/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)

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)
@@ -79,14 +79,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,7 @@
+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"

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

infrahub/core/validators/relationship/peer.py

@@ -36,8 +36,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         # 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
@@ -45,10 +44,8 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             LIMIT 1
         }
         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)-[rrel1:IS_RELATED]-(rel:Relationship { name: $relationship_id })-[rrel2:IS_RELATED]-(peer:Node)
             WHERE all(
                 r in relationships(path)
@@ -68,8 +65,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             collect([branch_level_sum, from_times, active_relationship_count, relationship_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
@@ -80,7 +76,6 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             LIMIT 1
         }
         WITH start_node, current_peer, branch_name, current_path
-        WITH start_node, current_peer, branch_name, current_path
         WHERE all(r in relationships(current_path) WHERE r.status = "active")
         AND NOT any(label IN LABELS(current_peer) WHERE label IN $allowed_peer_kinds)
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}

infrahub/core/validators/tasks.py

@@ -71,7 +71,7 @@ async def schema_path_validate(
     schema_branch: SchemaBranch,
     service: InfrahubServices,
 ) -> SchemaValidatorPathResponseData:
-    async with service.database.start_session() as db:
+    async with service.database.start_session(read_only=True) as db:
         constraint_request = SchemaConstraintValidatorRequest(
             branch=branch,
             constraint_name=constraint_name,