infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/schema/schema_branch_computed.py

@@ -42,6 +42,17 @@ class ComputedAttributeTarget(BaseModel):
         return hash((self.kind, self.attribute, tuple(self.filter_keys)))
 
 
+class ComputedAttributeTriggerNode(BaseModel):
+    kind: str
+    attributes: list[str] = Field(default_factory=list)
+    relationships: list[str] = Field(default_factory=list)
+    targets_self: bool = Field(default=False)
+
+    @property
+    def fields(self) -> list[str]:
+        return self.attributes + self.relationships
+
+
 class RegisteredNodeComputedAttribute(BaseModel):
     local_fields: dict[str, list[ComputedAttributeTarget]] = Field(
         default_factory=dict,
@@ -129,17 +140,17 @@ class ComputedAttributes:
             if schema_path.active_attribute_schema.name not in trigger_node.local_fields:
                 trigger_node.local_fields[schema_path.active_attribute_schema.name] = []
 
-            trigger_node.local_fields[schema_path.active_attribute_schema.name].append(source_attribute)
+            trigger_node.local_fields[schema_path.active_attribute_schema.name].append(deepcopy(source_attribute))
         elif schema_path.is_type_relationship:
             if schema_path.active_attribute_schema.name not in trigger_node.local_fields:
                 trigger_node.local_fields[schema_path.active_attribute_schema.name] = []
 
-            trigger_node.local_fields[schema_path.active_attribute_schema.name].append(source_attribute)
+            trigger_node.local_fields[schema_path.active_attribute_schema.name].append(deepcopy(source_attribute))
 
             if schema_path.active_relationship_schema.name not in trigger_node.relationships:
                 trigger_node.relationships[schema_path.active_relationship_schema.name] = []
 
-            trigger_node.relationships[schema_path.active_relationship_schema.name].append(source_attribute)
+            trigger_node.relationships[schema_path.active_relationship_schema.name].append(deepcopy(source_attribute))
 
             if source_attribute.kind not in self._computed_jinja2_attribute_map:
                 self._computed_jinja2_attribute_map[source_attribute.kind] = RegisteredNodeComputedAttribute()
@@ -153,7 +164,7 @@ class ComputedAttributes:
                 ] = []
             self._computed_jinja2_attribute_map[source_attribute.kind].local_fields[
                 schema_path.active_relationship_schema.name
-            ].append(source_attribute)
+            ].append(deepcopy(source_attribute))
 
     def get_impacted_jinja2_targets(self, kind: str, updates: list[str] | None = None) -> list[ComputedAttributeTarget]:
         if mapping := self._computed_jinja2_attribute_map.get(kind):
@@ -172,3 +183,29 @@ class ComputedAttributes:
                     mapping[local_field].add(node)
 
         return {key: list(value) for key, value in mapping.items()}
+
+    def get_jinja2_trigger_nodes(self) -> dict[ComputedAttributeTarget, list[ComputedAttributeTriggerNode]]:
+        working_map: dict[ComputedAttributeTarget, dict[str, ComputedAttributeTriggerNode]] = {}
+        for node_kind, registered_computed_attribute in self._computed_jinja2_attribute_map.items():
+            for local_field, computed_attribute_targets in registered_computed_attribute.local_fields.items():
+                for computed_attribute_target in computed_attribute_targets:
+                    if computed_attribute_target not in working_map:
+                        working_map[computed_attribute_target] = {}
+                    if node_kind not in working_map[computed_attribute_target]:
+                        working_map[computed_attribute_target][node_kind] = ComputedAttributeTriggerNode(kind=node_kind)
+                    working_map[computed_attribute_target][node_kind].attributes.append(local_field)
+                    if computed_attribute_target.kind == node_kind:
+                        working_map[computed_attribute_target][node_kind].targets_self = True
+            for relationship, computed_attribute_targets in registered_computed_attribute.relationships.items():
+                for computed_attribute_target in computed_attribute_targets:
+                    if computed_attribute_target not in working_map:
+                        working_map[computed_attribute_target] = {}
+                    if node_kind not in working_map[computed_attribute_target]:
+                        working_map[computed_attribute_target][node_kind] = ComputedAttributeTriggerNode(kind=node_kind)
+                    working_map[computed_attribute_target][node_kind].relationships.append(relationship)
+                    if computed_attribute_target.kind == node_kind:
+                        working_map[computed_attribute_target][node_kind].targets_self = True
+
+        return {
+            computed_attribute_target: list(nodes.values()) for computed_attribute_target, nodes in working_map.items()
+        }

infrahub/core/task/task.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import ConfigDict, Field
 
@@ -19,10 +19,10 @@ class Task(StandardNode):
 
     title: str
     conclusion: TaskConclusion
-    account_id: Optional[str] = Field(default=None, description="The ID of the account that created this task")
+    account_id: str | None = Field(default=None, description="The ID of the account that created this task")
     created_at: str = Field(default_factory=current_timestamp, description="The time when this task was created")
     updated_at: str = Field(default_factory=current_timestamp, description="The time when this task was last updated")
-    related_node: Optional[CoreNode] = Field(default=None, description="The Infrahub node that this object refers to")
+    related_node: CoreNode | None = Field(default=None, description="The Infrahub node that this object refers to")
 
     _exclude_attrs: list[str] = ["id", "uuid", "account_id", "_query", "related_node"]
     _query: type[StandardNodeQuery] = TaskNodeCreateQuery

infrahub/core/task/user_task.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from typing_extensions import Self
 
@@ -27,9 +27,9 @@ class UserTask:
         self,
         title: str,
         db: InfrahubDatabase,
-        account: Optional[CoreGenericAccount] = None,
-        account_id: Optional[str] = None,
-        logger: Optional[Union[BoundLogger, InfrahubLogger]] = None,
+        account: CoreGenericAccount | None = None,
+        account_id: str | None = None,
+        logger: BoundLogger | InfrahubLogger | None = None,
     ) -> None:
         if not account and not account_id:
             raise ValueError("Either account or account_id must be provided to initialize UserTask")
@@ -41,8 +41,8 @@ class UserTask:
             self.account_id = account.id
 
         self.title = title
-        self._task: Optional[Task]
-        self.log: Union[BoundLogger, InfrahubLogger] = logger or get_logger()
+        self._task: Task | None
+        self.log: BoundLogger | InfrahubLogger = logger or get_logger()
         self.db = db
 
     @property
@@ -67,7 +67,7 @@ class UserTask:
         if self._account:
             return False
 
-        account: Optional[CoreGenericAccount] = await registry.manager.get_one(id=self.account_id, db=self.db)
+        account: CoreGenericAccount | None = await registry.manager.get_one(id=self.account_id, db=self.db)
         if not account:
             raise ValueError(f"Unable to find the account associated with {self.account_id}")
         self._account = account
@@ -80,7 +80,7 @@ class UserTask:
 
     @classmethod
     def from_graphql_context(
-        cls, title: str, graphql_context: GraphqlContext, logger: Optional[Union[BoundLogger, InfrahubLogger]] = None
+        cls, title: str, graphql_context: GraphqlContext, logger: BoundLogger | InfrahubLogger | None = None
     ) -> Self:
         if not graphql_context.db or not graphql_context.account_session:
             raise ValueError("db and account_session must be provided to initialize a GraphQLTaskReport")
@@ -97,9 +97,9 @@ class UserTask:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         if exc_type:
             await self.error(message=str(exc_value))
@@ -109,22 +109,22 @@ class UserTask:
         await self.task.save(db=self.db)
 
     async def add_log(
-        self, message: str, severity: Severity = Severity.INFO, db: Optional[InfrahubDatabase] = None
+        self, message: str, severity: Severity = Severity.INFO, db: InfrahubDatabase | None = None
     ) -> None:
         tlog = TaskLog(message=message, severity=severity, task_id=self.task_id)
         await tlog.save(db=db or self.db)
 
-    async def info(self, message: str, db: Optional[InfrahubDatabase] = None, **kwargs: Any) -> None:
+    async def info(self, message: str, db: InfrahubDatabase | None = None, **kwargs: Any) -> None:
         if self.log:
             self.log.info(message, **kwargs)
         await self.add_log(message=message, severity=Severity.INFO, db=db)
 
-    async def warning(self, message: str, db: Optional[InfrahubDatabase] = None, **kwargs: Any) -> None:
+    async def warning(self, message: str, db: InfrahubDatabase | None = None, **kwargs: Any) -> None:
         if self.log:
             self.log.warning(message, **kwargs)
         await self.add_log(message=message, severity=Severity.WARNING, db=db)
 
-    async def error(self, message: str, db: Optional[InfrahubDatabase] = None, **kwargs: Any) -> None:
+    async def error(self, message: str, db: InfrahubDatabase | None = None, **kwargs: Any) -> None:
         if self.log:
             self.log.error(message, **kwargs)
         await self.add_log(message=message, severity=Severity.ERROR, db=db)

infrahub/core/utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ipaddress
 import re
 from inspect import isclass
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import RelationshipStatus
 from infrahub.core.models import NodeKind
@@ -23,10 +23,10 @@ async def add_relationship(
     dst_node_id: str,
     rel_type: str,
     db: InfrahubDatabase,
-    branch_name: Optional[str] = None,
-    branch_level: Optional[int] = None,
-    at: Optional[Timestamp] = None,
-    status=RelationshipStatus.ACTIVE,
+    branch_name: str | None = None,
+    branch_level: int | None = None,
+    at: Timestamp | None = None,
+    status: RelationshipStatus = RelationshipStatus.ACTIVE,
 ) -> Record | None:
     create_rel_query = """
     MATCH (s) WHERE %(id_func)s(s) = $src_node_id
@@ -62,7 +62,9 @@ async def delete_all_relationships_for_branch(branch_name: str, db: InfrahubData
     await db.execute_query(query=query, params=params, name="delete_all_relationships_for_branch")
 
 
-async def update_relationships_to(ids: list[str], db: InfrahubDatabase, to: Timestamp = None) -> list[Record] | None:
+async def update_relationships_to(
+    ids: list[str], db: InfrahubDatabase, to: Timestamp | None = None
+) -> list[Record] | None:
     """Update the "to" field on one or multiple relationships."""
     if not ids:
         return None
@@ -86,9 +88,9 @@ async def get_paths_between_nodes(
     db: InfrahubDatabase,
     source_id: str,
     destination_id: str,
-    relationships: Optional[list[str]] = None,
-    max_length: Optional[int] = None,
-    print_query=False,
+    relationships: list[str] | None = None,
+    max_length: int | None = None,
+    print_query: bool = False,
 ) -> list[Record]:
     """Return all paths between 2 nodes."""
 
@@ -115,7 +117,7 @@ async def get_paths_between_nodes(
     return await db.execute_query(query=query, params=params, name="get_paths_between_nodes", type=QueryType.READ)
 
 
-async def count_relationships(db: InfrahubDatabase, label: Optional[str] = None) -> int:
+async def count_relationships(db: InfrahubDatabase, label: str | None = None) -> int:
     """Return the total number of relationships in the database."""
 
     label_str = f":{label}" if label else ""
@@ -141,7 +143,7 @@ async def get_nodes(db: InfrahubDatabase, label: str) -> list[Neo4jNode]:
     return [result[0] for result in results]
 
 
-async def count_nodes(db: InfrahubDatabase, label: Optional[str] = None) -> int:
+async def count_nodes(db: InfrahubDatabase, label: str | None = None) -> int:
     """Return the total number of nodes of a given label in the database."""
 
     label_str = f":{label}" if label else ""
@@ -183,7 +185,7 @@ def parse_node_kind(kind: str) -> NodeKind:
 
 
 def convert_ip_to_binary_str(
-    obj: Union[ipaddress.IPv6Network, ipaddress.IPv4Network, ipaddress.IPv4Interface, ipaddress.IPv6Interface],
+    obj: ipaddress.IPv6Network | ipaddress.IPv4Network | ipaddress.IPv4Interface | ipaddress.IPv6Interface,
 ) -> str:
     if isinstance(obj, ipaddress.IPv6Network | ipaddress.IPv4Network):
         prefix_bin = f"{int(obj.network_address):b}"
@@ -230,26 +232,26 @@ class _NewClass:
 _all_vars = set(dir(_OldClass) + dir(_NewClass))
 
 
-def props(x) -> dict[str, Any]:
+def props(x: Any) -> dict[str, Any]:
     return {key: vars(x).get(key, getattr(x, key)) for key in dir(x) if key not in _all_vars}
 
 
 class SubclassWithMeta_Meta(type):
     _meta = None
 
-    def __str__(cls):
+    def __str__(cls) -> str:
         if cls._meta:
             return cls._meta.name
         return cls.__name__
 
-    def __repr__(cls):
+    def __repr__(cls) -> str:
         return f"<{cls.__name__} meta={repr(cls._meta)}>"
 
 
 class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
     """This class improves __init_subclass__ to receive automatically the options from meta"""
 
-    def __init_subclass__(cls, **meta_options):
+    def __init_subclass__(cls, **meta_options: dict[str, Any]) -> None:
         """This method just terminates the super() chain"""
         _Meta = getattr(cls, "Meta", None)
         _meta_props = {}
@@ -266,7 +268,7 @@ class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
         abstract = options.pop("abstract", False)
         if abstract:
             assert not options, (
-                "Abstract types can only contain the abstract attribute. " f"Received: abstract, {', '.join(options)}"
+                f"Abstract types can only contain the abstract attribute. Received: abstract, {', '.join(options)}"
             )
         else:
             super_class = super(cls, cls)
@@ -274,5 +276,5 @@ class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
                 super_class.__init_subclass_with_meta__(**options)
 
     @classmethod
-    def __init_subclass_with_meta__(cls, **meta_options) -> None:
+    def __init_subclass_with_meta__(cls, **meta_options: dict[str, Any]) -> None:
         """This method just terminates the super() chain"""

infrahub/core/validators/__init__.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from .attribute.choices import AttributeChoicesChecker
 from .attribute.enum import AttributeEnumChecker
 from .attribute.kind import AttributeKindChecker
@@ -18,7 +16,7 @@ from .relationship.optional import RelationshipOptionalChecker
 from .relationship.peer import RelationshipPeerChecker
 from .uniqueness.checker import UniquenessChecker
 
-CONSTRAINT_VALIDATOR_MAP: dict[str, Optional[type[ConstraintCheckerInterface]]] = {
+CONSTRAINT_VALIDATOR_MAP: dict[str, type[ConstraintCheckerInterface] | None] = {
     "attribute.regex.update": AttributeRegexChecker,
     "attribute.enum.update": AttributeEnumChecker,
     "attribute.kind.update": AttributeKindChecker,

infrahub/core/validators/aggregated_checker.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from itertools import chain
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.core import registry
 from infrahub.exceptions import ValidationError
@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 
 class AggregatedConstraintChecker:
     def __init__(
-        self, constraints: list[ConstraintCheckerInterface], db: InfrahubDatabase, branch: Optional[Branch] = None
+        self, constraints: list[ConstraintCheckerInterface], db: InfrahubDatabase, branch: Branch | None = None
     ):
         self.constraints = constraints
         self.db = db

infrahub/core/validators/attribute/choices.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import NULL_VALUE, PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -75,7 +75,7 @@ class AttributeChoicesUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeChoicesChecker(ConstraintCheckerInterface):
     query_classes = [AttributeChoicesUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/validators/attribute/enum.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import NULL_VALUE, PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -74,7 +74,7 @@ class AttributeEnumUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeEnumChecker(ConstraintCheckerInterface):
     query_classes = [AttributeEnumUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/validators/attribute/kind.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import NULL_VALUE, PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -87,7 +87,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeKindChecker(ConstraintCheckerInterface):
     query_classes = [AttributeKindUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/validators/attribute/length.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -70,7 +70,7 @@ class AttributeLengthUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeLengthChecker(ConstraintCheckerInterface):
     query_classes = [AttributeLengthUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/validators/attribute/optional.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import NULL_VALUE, PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -66,7 +66,7 @@ class AttributeOptionalUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeOptionalChecker(ConstraintCheckerInterface):
     query_classes = [AttributeOptionalUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/validators/attribute/regex.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import NULL_VALUE, PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -70,7 +70,7 @@ class AttributeRegexUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeRegexChecker(ConstraintCheckerInterface):
     query_classes = [AttributeRegexUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/validators/attribute/unique.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -91,7 +91,7 @@ class AttributeUniqueUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeUniquenessChecker(ConstraintCheckerInterface):
     query_classes = [AttributeUniqueUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None) -> None:
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/validators/checks_runner.py

@@ -1,14 +1,21 @@
 import asyncio
 from typing import Any, Coroutine
 
-from infrahub_sdk.node import InfrahubNode
+from infrahub_sdk.protocols import CoreValidator
 
+from infrahub.context import InfrahubContext
 from infrahub.core.constants import ValidatorConclusion, ValidatorState
 from infrahub.core.timestamp import Timestamp
+from infrahub.services import InfrahubServices
+from infrahub.validators.events import send_failed_validator, send_passed_validator
 
 
 async def run_checks_and_update_validator(
-    checks: list[Coroutine[Any, None, ValidatorConclusion]], validator: InfrahubNode
+    checks: list[Coroutine[Any, None, ValidatorConclusion]],
+    validator: CoreValidator,
+    context: InfrahubContext,
+    service: InfrahubServices,
+    proposed_change_id: str,
 ) -> None:
     """
     Execute a list of checks coroutines, and set validator fields accordingly.
@@ -22,11 +29,17 @@ async def run_checks_and_update_validator(
     validator.completed_at.value = ""
     await validator.save()
 
+    failed_early = False
+
     for earliest_task in asyncio.as_completed(checks):
         result = await earliest_task
         if validator.conclusion.value != ValidatorConclusion.FAILURE.value and result == ValidatorConclusion.FAILURE:
             validator.conclusion.value = ValidatorConclusion.FAILURE.value
+            failed_early = True
             await validator.save()
+            await send_failed_validator(
+                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+            )
             # Continue to iterate to wait for the end of all checks
 
     validator.state.value = ValidatorState.COMPLETED.value
@@ -35,3 +48,13 @@ async def run_checks_and_update_validator(
         validator.conclusion.value = ValidatorConclusion.SUCCESS.value
 
     await validator.save()
+
+    if not failed_early:
+        if validator.conclusion.value == ValidatorConclusion.SUCCESS.value:
+            await send_passed_validator(
+                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+            )
+        else:
+            await send_failed_validator(
+                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+            )

infrahub/core/validators/determiner.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 from infrahub.core.constants import RelationshipKind, SchemaPathType
 from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.diff.model.path import NodeDiffFieldSummary
@@ -132,7 +130,7 @@ class ConstraintValidatorDeterminer:
         return constraints
 
     async def _get_constraints_for_one_field(
-        self, schema: MainSchemaTypes, field: Union[AttributeSchema, RelationshipSchema]
+        self, schema: MainSchemaTypes, field: AttributeSchema | RelationshipSchema
     ) -> list[SchemaUpdateConstraintInfo]:
         constraints: list[SchemaUpdateConstraintInfo] = []
         for prop_name, prop_field_info in field.model_fields.items():

infrahub/core/validators/interface.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
-from infrahub.core.path import GroupedDataPaths
+if TYPE_CHECKING:
+    from infrahub.core.path import GroupedDataPaths
 
-from .model import SchemaConstraintValidatorRequest
+    from .model import SchemaConstraintValidatorRequest
 
 
 class ConstraintCheckerInterface(ABC):

infrahub/core/validators/model.py

@@ -1,17 +1,36 @@
-from typing import Union
+from typing import Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_serializer
 
 from infrahub.core.branch import Branch
 from infrahub.core.path import SchemaPath
 from infrahub.core.schema import GenericSchema, NodeSchema
+from infrahub.core.schema.schema_branch import SchemaBranch
 
 
 class SchemaConstraintValidatorRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
     branch: Branch = Field(..., description="The name of the branch to target")
     constraint_name: str = Field(..., description="The name of the constraint to validate")
-    node_schema: Union[NodeSchema, GenericSchema] = Field(..., description="Schema of Node or Generic to validate")
+    node_schema: NodeSchema | GenericSchema = Field(..., description="Schema of Node or Generic to validate")
     schema_path: SchemaPath = Field(..., description="SchemaPath to the element of the schema to validate")
+    schema_branch: SchemaBranch = Field(..., description="SchemaBranch of the element to validate")
+
+    @model_serializer()
+    def serialize_model(self) -> dict[str, Any]:
+        return {
+            "branch": self.branch.model_dump(),
+            "constraint_name": self.constraint_name,
+            "node_schema": self.node_schema.model_dump(),
+            "schema_path": self.schema_path.model_dump(),
+            "schema_branch": self.schema_branch.to_dict_schema_object(),
+        }
+
+    @field_validator("schema_branch", mode="before")
+    @classmethod
+    def validate_schema_branch(cls, value: Any) -> SchemaBranch:
+        return SchemaBranch.validate(data=value)
 
 
 class SchemaViolation(BaseModel):

infrahub/core/validators/models/validate_migration.py

@@ -1,4 +1,6 @@
-from pydantic import BaseModel, ConfigDict, Field
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_serializer
 
 from infrahub.core.branch import Branch
 from infrahub.core.models import SchemaUpdateConstraintInfo
@@ -9,13 +11,24 @@ from infrahub.message_bus import InfrahubResponseData
 
 
 class SchemaValidateMigrationData(BaseModel):
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True, json_encoders={SchemaBranch: SchemaBranch.to_dict_schema_object}
-    )
+    model_config = ConfigDict(arbitrary_types_allowed=True)
     branch: Branch
     schema_branch: SchemaBranch
     constraints: list[SchemaUpdateConstraintInfo]
 
+    @model_serializer()
+    def serialize_model(self) -> dict[str, Any]:
+        return {
+            "branch": self.branch.model_dump(),
+            "schema_branch": self.schema_branch.to_dict_schema_object(),
+            "constraints": [constraint.model_dump() for constraint in self.constraints],
+        }
+
+    @field_validator("schema_branch", mode="before")
+    @classmethod
+    def validate_schema_branch(cls, value: Any) -> SchemaBranch:
+        return SchemaBranch.validate(data=value)
+
 
 class SchemaValidatorPathResponseData(InfrahubResponseData):
     violations: list[SchemaViolation] = Field(default_factory=list)

infrahub/core/validators/node/attribute.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from ..interface import ConstraintCheckerInterface
 from ..query import NodeNotPresentValidatorQuery
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 class NodeAttributeAddChecker(ConstraintCheckerInterface):
     query_classes = [NodeNotPresentValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch