infrahub-server 1.2.10__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/core/query/resource_manager.py

@@ -220,8 +220,7 @@ class NumberPoolGetUsed(Query):
 
         query = """
         MATCH (pool:%(number_pool)s { uuid: $pool_id })
-        CALL {
-            WITH pool
+        CALL (pool) {
             MATCH (pool)-[res:IS_RESERVED]->(av:AttributeValue)<-[hv:HAS_VALUE]-(attr:Attribute)
             WHERE
                 attr.name = $attribute_name

infrahub/core/query/subquery.py

@@ -61,7 +61,7 @@ async def build_subquery_filter(
     where_str = " AND ".join(field_where)
     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")
-    to_return = f"{node_alias} AS {prefix}"
+    to_return = f"{prefix}"
     with_extra = ""
     final_with_extra = ""
     is_isnull = filter_name == "isnull"
@@ -82,7 +82,6 @@ async def build_subquery_filter(
         elif field is not None and field.is_attribute:
             is_active_filter = "(latest_node_details[2]).value = 'NULL'"
     query = f"""
-    WITH {node_alias}
     {match} path = {filter_str}
     WHERE {where_str}
     WITH
@@ -94,7 +93,7 @@ async def build_subquery_filter(
     ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC
     WITH head(collect([is_active, {node_alias}{with_extra}])) AS latest_node_details
     WHERE {is_active_filter}
-    WITH latest_node_details[1] AS {node_alias}{final_with_extra}
+    WITH latest_node_details[1] AS {prefix}{final_with_extra}
     RETURN {to_return}
     """
     return query, params, prefix
@@ -174,7 +173,6 @@ async def build_subquery_order(
         to_return_str_parts.append(f"CASE WHEN is_active = TRUE THEN {expression} ELSE NULL END AS {alias}")
     to_return_str = ", ".join(to_return_str_parts)
     query = f"""
-    WITH {node_alias}
     OPTIONAL MATCH path = {filter_str}
     WHERE {where_str}
     WITH {with_str_to_alias}

infrahub/core/relationship/model.py

@@ -789,6 +789,9 @@ class RelationshipManager:
 
         return len(self._relationships)
 
+    def validate(self) -> None:
+        self._relationships.validate()
+
     @overload
     async def get_peer(
         self,

infrahub/core/schema/__init__.py

@@ -21,7 +21,8 @@ from .profile_schema import ProfileSchema
 from .relationship_schema import RelationshipSchema
 from .template_schema import TemplateSchema
 
-MainSchemaTypes: TypeAlias = NodeSchema | GenericSchema | ProfileSchema | TemplateSchema
+NonGenericSchemaTypes: TypeAlias = NodeSchema | ProfileSchema | TemplateSchema
+MainSchemaTypes: TypeAlias = NonGenericSchemaTypes | GenericSchema
 
 
 # -----------------------------------------------------

infrahub/core/schema/attribute_parameters.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pydantic import Field
+
+from infrahub.core.constants.schema import UpdateSupport
+from infrahub.core.models import HashableModel
+
+
+def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParameters]:
+    return {
+        "Text": TextAttributeParameters,
+        "TextArea": TextAttributeParameters,
+    }.get(kind, AttributeParameters)
+
+
+class AttributeParameters(HashableModel):
+    class Config:
+        extra = "forbid"
+
+
+class TextAttributeParameters(AttributeParameters):
+    regex: str | None = Field(
+        default=None,
+        description="Regular expression that attribute value must match if defined",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    min_length: int | None = Field(
+        default=None,
+        description="Set a minimum number of characters allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    max_length: int | None = Field(
+        default=None,
+        description="Set a maximum number of characters allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )

infrahub/core/schema/attribute_schema.py

@@ -2,15 +2,17 @@ from __future__ import annotations
 
 import enum
 from enum import Enum
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Self
 
-from pydantic import field_validator, model_validator
+from pydantic import Field, ValidationInfo, field_validator, model_validator
 
 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.types import ATTRIBUTE_KIND_LABELS, ATTRIBUTE_TYPES
 
+from .attribute_parameters import AttributeParameters, TextAttributeParameters, get_attribute_parameters_class_for_kind
 from .generated.attribute_schema import GeneratedAttributeSchema
 
 if TYPE_CHECKING:
@@ -21,6 +23,14 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
+def get_attribute_schema_class_for_kind(kind: str) -> type[AttributeSchema]:
+    attribute_schema_class_by_kind: dict[str, type[AttributeSchema]] = {
+        "Text": TextAttributeSchema,
+        "TextArea": TextAttributeSchema,
+    }
+    return attribute_schema_class_by_kind.get(kind, AttributeSchema)
+
+
 class AttributeSchema(GeneratedAttributeSchema):
     _sort_by: list[str] = ["name"]
     _enum_class: type[enum.Enum] | None = None
@@ -53,16 +63,36 @@ class AttributeSchema(GeneratedAttributeSchema):
 
     @model_validator(mode="before")
     @classmethod
-    def validate_dropdown_choices(cls, values: dict[str, Any]) -> dict[str, Any]:
+    def validate_dropdown_choices(cls, values: Any) -> Any:
         """Validate that choices are defined for a dropdown but not for other kinds."""
-        if values.get("kind") != "Dropdown" and values.get("choices"):
-            raise ValueError(f"Can only specify 'choices' for kind=Dropdown: {values['kind']}")
-
-        if values.get("kind") == "Dropdown" and not values.get("choices"):
+        if isinstance(values, dict):
+            kind = values.get("kind")
+            choices = values.get("choices")
+        elif isinstance(values, AttributeSchema):
+            kind = values.kind
+            choices = values.choices
+        else:
+            return values
+        if kind != "Dropdown" and choices:
+            raise ValueError(f"Can only specify 'choices' for kind=Dropdown: {kind}")
+
+        if kind == "Dropdown" and not choices:
             raise ValueError("The property 'choices' is required for kind=Dropdown")
 
         return values
 
+    @field_validator("parameters", mode="before")
+    @classmethod
+    def set_parameters_type(cls, value: Any, info: ValidationInfo) -> Any:
+        """Override parameters class if using base AttributeParameters class and should be using a subclass"""
+        kind = info.data["kind"]
+        expected_parameters_class = get_attribute_parameters_class_for_kind(kind=kind)
+        if value is None:
+            return expected_parameters_class()
+        if not isinstance(value, expected_parameters_class) and isinstance(value, AttributeParameters):
+            return expected_parameters_class(**value.model_dump())
+        return value
+
     def get_class(self) -> type[BaseAttribute]:
         return ATTRIBUTE_TYPES[self.kind].get_infrahub_class()
 
@@ -106,7 +136,7 @@ class AttributeSchema(GeneratedAttributeSchema):
 
     def to_node(self) -> dict[str, Any]:
         fields_to_exclude = {"id", "state", "filters"}
-        fields_to_json = {"computed_attribute"}
+        fields_to_json = {"computed_attribute", "parameters"}
         data = self.model_dump(exclude=fields_to_exclude | fields_to_json)
 
         for field_name in fields_to_json:
@@ -117,6 +147,15 @@ class AttributeSchema(GeneratedAttributeSchema):
 
         return data
 
+    def get_regex(self) -> str | None:
+        return self.regex
+
+    def get_min_length(self) -> int | None:
+        return self.min_length
+
+    def get_max_length(self) -> int | None:
+        return self.max_length
+
     async def get_query_filter(
         self,
         name: str,
@@ -144,3 +183,39 @@ class AttributeSchema(GeneratedAttributeSchema):
             partial_match=partial_match,
             support_profiles=support_profiles,
         )
+
+
+class TextAttributeSchema(AttributeSchema):
+    parameters: TextAttributeParameters = Field(
+        default_factory=TextAttributeParameters,
+        description="Extra parameters specific to text attributes",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+    @model_validator(mode="after")
+    def reconcile_parameters(self) -> Self:
+        if self.regex != self.parameters.regex:
+            final_regex = self.parameters.regex or self.regex
+            if not final_regex:  # falsy parameters.regex override falsy regex
+                final_regex = self.parameters.regex
+            self.regex = self.parameters.regex = final_regex
+        if self.min_length != self.parameters.min_length:
+            final_min_length = self.parameters.min_length or self.min_length
+            if not final_min_length:  # falsy parameters.min_length override falsy min_length
+                final_min_length = self.parameters.min_length
+            self.min_length = self.parameters.min_length = final_min_length
+        if self.max_length != self.parameters.max_length:
+            final_max_length = self.parameters.max_length or self.max_length
+            if not final_max_length:  # falsy parameters.max_length override falsy max_length
+                final_max_length = self.parameters.max_length
+            self.max_length = self.parameters.max_length = final_max_length
+        return self
+
+    def get_regex(self) -> str | None:
+        return self.parameters.regex
+
+    def get_min_length(self) -> int | None:
+        return self.parameters.min_length
+
+    def get_max_length(self) -> int | None:
+        return self.parameters.max_length

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

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,