infrahub-server 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

infrahub/core/query/diff.py

@@ -568,17 +568,26 @@ WITH CASE
     ELSE [[$new_node_field_specifiers, $branch_from_time], [$current_node_field_specifiers, $from_time]]
 END AS diff_filter_params_list
 UNWIND diff_filter_params_list AS diff_filter_params
+WITH diff_filter_params[0] AS node_field_specifiers_list, diff_filter_params[1] AS from_time
 CALL {
-    WITH diff_filter_params
-    WITH diff_filter_params[0] AS node_field_specifiers_list, diff_filter_params[1] AS from_time
+    // -------------------------------------
+    // These lists contain duplicate data, but vastly improve querying speed below
+    // -------------------------------------
+    WITH node_field_specifiers_list
+    UNWIND node_field_specifiers_list AS nfs
+    WITH nfs[0] AS uuid, nfs[1] AS field_name
+    WITH collect(DISTINCT uuid) as uuids, collect(DISTINCT field_name) AS field_names
+    RETURN uuids AS node_ids_list, field_names AS field_names_list
+}
+CALL {
+    WITH node_field_specifiers_list, node_ids_list, from_time
     CALL {
-        WITH node_field_specifiers_list, from_time
-        WITH reduce(node_ids = [], nfs IN node_field_specifiers_list | node_ids + [nfs[0]]) AS node_ids_list, from_time
+        WITH node_field_specifiers_list, from_time, node_ids_list
         // -------------------------------------
         // Identify nodes added/removed on branch
         // -------------------------------------
         MATCH (q:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(p:Node)
-        WHERE (node_ids_list IS NULL OR p.uuid IN node_ids_list)
+        WHERE (size(node_ids_list) = 0 OR p.uuid IN node_ids_list)
         AND (from_time <= diff_rel.from < $to_time)
         AND (diff_rel.to IS NULL OR (from_time <= diff_rel.to < $to_time))
         AND p.branch_support = $branch_aware
@@ -647,20 +656,20 @@ CALL {
     }
     RETURN diff_path
     UNION
-    WITH diff_filter_params
-    WITH diff_filter_params[0] AS node_field_specifiers_list, diff_filter_params[1] AS from_time
+    WITH node_field_specifiers_list, node_ids_list, field_names_list, from_time
     CALL {
-        WITH node_field_specifiers_list, from_time
+        WITH node_field_specifiers_list, node_ids_list, field_names_list, from_time
         // -------------------------------------
         // Identify attributes/relationships added/removed on branch
         // -------------------------------------
         CALL {
-            WITH node_field_specifiers_list, from_time
+            WITH node_field_specifiers_list, node_ids_list, field_names_list, from_time
             MATCH (root:Root)<-[r_root:IS_PART_OF]-(p:Node)-[diff_rel:HAS_ATTRIBUTE {branch: $branch_name}]->(q:Attribute)
             // exclude attributes and relationships under added/removed nodes b/c they are covered above
-            WHERE (node_field_specifiers_list IS NULL OR [p.uuid, q.name] IN node_field_specifiers_list)
-            AND r_root.branch IN [$branch_name, $base_branch_name, $global_branch_name]
+            WHERE r_root.branch IN [$branch_name, $base_branch_name, $global_branch_name]
             AND q.branch_support = $branch_aware
+            AND (size(node_ids_list) = 0 OR p.uuid IN node_ids_list)
+            AND (size(field_names_list) = 0 OR q.name IN field_names_list)
             // if p has a different type of branch support and was addded within our timeframe
             AND (r_root.from < from_time OR p.branch_support = $branch_agnostic)
             AND r_root.status = "active"
@@ -669,14 +678,16 @@ CALL {
             AND (diff_rel.to IS NULL OR (from_time <= diff_rel.to < $to_time))
             AND r_root.from <= diff_rel.from
             AND (r_root.to IS NULL OR diff_rel.branch <> r_root.branch OR r_root.to >= diff_rel.from)
+            AND (node_field_specifiers_list IS NULL OR [p.uuid, q.name] IN node_field_specifiers_list)
             RETURN root, r_root, p, diff_rel, q
             UNION ALL
-            WITH node_field_specifiers_list, from_time
+            WITH node_field_specifiers_list, node_ids_list, field_names_list, from_time
             MATCH (root:Root)<-[r_root:IS_PART_OF]-(p:Node)-[diff_rel:IS_RELATED {branch: $branch_name}]-(q:Relationship)
             // exclude attributes and relationships under added/removed nodes b/c they are covered above
-            WHERE (node_field_specifiers_list IS NULL OR [p.uuid, q.name] IN node_field_specifiers_list)
-            AND r_root.branch IN [$branch_name, $base_branch_name, $global_branch_name]
+            WHERE r_root.branch IN [$branch_name, $base_branch_name, $global_branch_name]
             AND q.branch_support = $branch_aware
+            AND (size(node_ids_list) = 0 OR p.uuid IN node_ids_list)
+            AND (size(field_names_list) = 0 OR q.name IN field_names_list)
             // if p has a different type of branch support and was addded within our timeframe
             AND (r_root.from < from_time OR p.branch_support = $branch_agnostic)
             // get attributes and relationships added on the branch during the timeframe
@@ -684,6 +695,7 @@ CALL {
             AND (diff_rel.to IS NULL OR (from_time <= diff_rel.to < $to_time))
             AND r_root.from <= diff_rel.from
             AND (r_root.to IS NULL OR diff_rel.branch <> r_root.branch OR r_root.to >= diff_rel.from)
+            AND (node_field_specifiers_list IS NULL OR [p.uuid, q.name] IN node_field_specifiers_list)
             RETURN root, r_root, p, diff_rel, q
         }
         WITH root, r_root, p, diff_rel, q, from_time
@@ -762,19 +774,19 @@ CALL {
     }
     RETURN mid_diff_path AS diff_path
     UNION
-    WITH diff_filter_params
-    WITH diff_filter_params[0] AS node_field_specifiers_list, diff_filter_params[1] AS from_time
+    WITH node_field_specifiers_list, node_ids_list, field_names_list, from_time
     CALL {
-        WITH node_field_specifiers_list, from_time
+        WITH node_field_specifiers_list, node_ids_list, field_names_list, from_time
         // -------------------------------------
         // Identify properties added/removed on branch
         // -------------------------------------
         MATCH diff_rel_path = (root:Root)<-[r_root:IS_PART_OF]-(n:Node)-[r_node]-(p)-[diff_rel {branch: $branch_name}]->(q)
-        WHERE (node_field_specifiers_list IS NULL OR [n.uuid, p.name] IN node_field_specifiers_list)
-        AND (
+        WHERE (
             (from_time <= diff_rel.from < $to_time)
             OR (from_time <= diff_rel.to < $to_time)
         )
+        AND (size(node_ids_list) = 0 OR n.uuid IN node_ids_list)
+        AND (size(field_names_list) = 0 OR p.name IN field_names_list)
         // exclude attributes and relationships under added/removed nodes, attrs, and rels b/c they are covered above
         AND ALL(
             r in [r_root, r_node]
@@ -785,6 +797,7 @@ CALL {
         AND type(diff_rel) IN ["IS_VISIBLE", "IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE"]
         AND any(l in labels(q) WHERE l in ["Boolean", "Node", "AttributeValue"])
         AND type(r_node) IN ["HAS_ATTRIBUTE", "IS_RELATED"]
+        AND (node_field_specifiers_list IS NULL OR [n.uuid, p.name] IN node_field_specifiers_list)
         AND ALL(
             r_pair IN [[r_root, r_node], [r_node, diff_rel]]
             // filter out paths where a base branch edge follows a branch edge

infrahub/core/query/ipam.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import ipaddress
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Iterable, Optional, Union
+from typing import TYPE_CHECKING, Iterable
 
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.ipam.constants import AllIPTypes, IPAddressType, IPNetworkType
@@ -38,7 +38,7 @@ class IPAddressData:
 
 
 def _get_namespace_id(
-    namespace: Optional[Union[Node, str]] = None,
+    namespace: Node | str | None = None,
 ) -> str:
     if namespace and isinstance(namespace, str):
         return namespace
@@ -54,7 +54,7 @@ class IPPrefixSubnetFetch(Query):
     def __init__(
         self,
         obj: IPNetworkType,
-        namespace: Optional[Union[Node, str]] = None,
+        namespace: Node | str | None = None,
         **kwargs,
     ):
         self.obj = obj
@@ -97,8 +97,7 @@ class IPPrefixSubnetFetch(Query):
             AND av.binary_address STARTS WITH $prefix_binary
             AND av.prefixlen > $maxprefixlen
             AND av.version = $ip_version
-            AND all(r IN relationships(path2) WHERE (%(branch_filter)s))
-        // TODO Need to check for delete nodes
+            AND all(r IN relationships(path2) WHERE (%(branch_filter)s) and r.status = "active")
         WITH
             collect([pfx, av]) as all_prefixes_and_value,
             collect(pfx) as all_prefixes
@@ -146,7 +145,7 @@ class IPPrefixIPAddressFetch(Query):
     def __init__(
         self,
         obj: IPNetworkType,
-        namespace: Optional[Union[Node, str]] = None,
+        namespace: Node | str | None = None,
         **kwargs,
     ):
         self.obj = obj
@@ -189,7 +188,7 @@ class IPPrefixIPAddressFetch(Query):
             AND av.binary_address STARTS WITH $prefix_binary
             AND av.prefixlen >= $maxprefixlen
             AND av.version = $ip_version
-            AND all(r IN relationships(path2) WHERE (%(branch_filter)s))
+            AND all(r IN relationships(path2) WHERE (%(branch_filter)s) and r.status = "active")
         """ % {
             "ns_label": InfrahubKind.IPNAMESPACE,
             "node_label": InfrahubKind.IPADDRESS,
@@ -216,9 +215,9 @@ class IPPrefixIPAddressFetch(Query):
 async def get_subnets(
     db: InfrahubDatabase,
     ip_prefix: IPNetworkType,
-    namespace: Optional[Union[Node, str]] = None,
-    branch: Optional[Union[Branch, str]] = None,
-    at: Optional[Union[Timestamp, str]] = None,
+    namespace: Node | str | None = None,
+    branch: Branch | str | None = None,
+    at: Timestamp | str | None = None,
     branch_agnostic: bool = False,
 ) -> Iterable[IPPrefixData]:
     branch = await registry.get_branch(db=db, branch=branch)
@@ -232,9 +231,9 @@ async def get_subnets(
 async def get_ip_addresses(
     db: InfrahubDatabase,
     ip_prefix: IPNetworkType,
-    namespace: Optional[Union[Node, str]] = None,
-    branch: Optional[Union[Branch, str]] = None,
-    at=None,
+    namespace: Node | str | None = None,
+    branch: Branch | str | None = None,
+    at: Timestamp | str | None = None,
     branch_agnostic: bool = False,
 ) -> Iterable[IPAddressData]:
     branch = await registry.get_branch(db=db, branch=branch)
@@ -249,8 +248,17 @@ class IPPrefixUtilization(Query):
     name = "ipprefix_utilization_prefix"
     type = QueryType.READ
 
-    def __init__(self, ip_prefixes: list[str], **kwargs):
+    def __init__(self, ip_prefixes: list[str], allocated_kinds: list[str], **kwargs):
         self.ip_prefixes = ip_prefixes
+        self.allocated_kinds: list[str] = []
+        self.allocated_kinds_rel: list[str] = []
+
+        for kind in sorted(allocated_kinds):
+            self.allocated_kinds.append(f'"{kind}"')
+            self.allocated_kinds_rel.append(
+                {InfrahubKind.IPADDRESS: '"ip_prefix__ip_address"', InfrahubKind.IPPREFIX: '"parent__child"'}[kind]
+            )
+
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:
@@ -266,8 +274,8 @@ class IPPrefixUtilization(Query):
         CALL {{
             WITH pfx
             MATCH (pfx)-[r_rel1:IS_RELATED]-(rl:Relationship)<-[r_rel2:IS_RELATED]-(child:Node)
-            WHERE rl.name IN ["parent__child", "ip_prefix__ip_address"]
-            AND any(l IN labels(child) WHERE l in ["{InfrahubKind.IPPREFIX}", "{InfrahubKind.IPADDRESS}"])
+            WHERE rl.name IN [{", ".join(self.allocated_kinds_rel)}]
+            AND any(l IN labels(child) WHERE l IN [{", ".join(self.allocated_kinds)}])
             AND ({rel_filter("r_rel1")})
             AND ({rel_filter("r_rel2")})
             RETURN r_rel1, rl, r_rel2, child
@@ -319,8 +327,8 @@ class IPPrefixReconcileQuery(Query):
     def __init__(
         self,
         ip_value: AllIPTypes,
-        namespace: Optional[Union[Node, str]] = None,
-        node_uuid: Optional[str] = None,
+        namespace: Node | str | None = None,
+        node_uuid: str | None = None,
         **kwargs,
     ):
         self.ip_value = ip_value
@@ -584,7 +592,7 @@ class IPPrefixReconcileQuery(Query):
         self.add_to_query(get_new_children_query)
         self.return_labels = ["ip_node", "current_parent", "current_children", "new_parent", "new_children"]
 
-    def _get_uuid_from_query(self, node_name: str) -> Optional[str]:
+    def _get_uuid_from_query(self, node_name: str) -> str | None:
         results = list(self.get_results())
         if not results:
             return None
@@ -611,13 +619,13 @@ class IPPrefixReconcileQuery(Query):
                 element_uuids.append(str(element_uuid))
         return element_uuids
 
-    def get_ip_node_uuid(self) -> Optional[str]:
+    def get_ip_node_uuid(self) -> str | None:
         return self._get_uuid_from_query("ip_node")
 
-    def get_current_parent_uuid(self) -> Optional[str]:
+    def get_current_parent_uuid(self) -> str | None:
         return self._get_uuid_from_query("current_parent")
 
-    def get_calculated_parent_uuid(self) -> Optional[str]:
+    def get_calculated_parent_uuid(self) -> str | None:
         return self._get_uuid_from_query("new_parent")
 
     def get_current_children_uuids(self) -> list[str]:

infrahub/core/query/node.py

@@ -1,19 +1,25 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from copy import copy
 from dataclasses import dataclass
 from dataclasses import field as dataclass_field
 from enum import Enum
 from typing import TYPE_CHECKING, Any, AsyncIterator, Generator, Optional, Union
 
 from infrahub import config
-from infrahub.core.constants import AttributeDBNodeType, RelationshipDirection, RelationshipHierarchyDirection
+from infrahub.core.constants import (
+    AttributeDBNodeType,
+    RelationshipDirection,
+    RelationshipHierarchyDirection,
+)
 from infrahub.core.query import Query, QueryResult, QueryType
 from infrahub.core.query.subquery import build_subquery_filter, build_subquery_order
 from infrahub.core.query.utils import find_node_schema
 from infrahub.core.schema.attribute_schema import AttributeSchema
 from infrahub.core.utils import build_regex_attrs, extract_field_filters
 from infrahub.exceptions import QueryError
+from infrahub.graphql.models import OrderModel
 
 if TYPE_CHECKING:
     from neo4j.graph import Node as Neo4jNode
@@ -804,7 +810,12 @@ class NodeGetListQuery(Query):
     type = QueryType.READ
 
     def __init__(
-        self, schema: NodeSchema, filters: Optional[dict] = None, partial_match: bool = False, **kwargs: Any
+        self,
+        schema: NodeSchema,
+        filters: Optional[dict] = None,
+        partial_match: bool = False,
+        order: OrderModel | None = None,
+        **kwargs: Any,
     ) -> None:
         self.schema = schema
         self.filters = filters
@@ -812,8 +823,30 @@ class NodeGetListQuery(Query):
         self._variables_to_track = ["n", "rb"]
         self._validate_filters()
 
+        # Force disabling order when `limit` is 1 as it simplifies the query a lot.
+        if "limit" in kwargs and kwargs["limit"] == 1:
+            if order is None:
+                order = OrderModel(disable=True)
+            else:
+                order = copy(order)
+                order.disable = True
+
+        self.order = order
+
         super().__init__(**kwargs)
 
+    @property
+    def has_filters(self) -> bool:
+        if not self.filters or self.has_filter_by_id:
+            return False
+        return True
+
+    @property
+    def has_filter_by_id(self) -> bool:
+        if self.filters and "id" in self.filters:
+            return True
+        return False
+
     def _validate_filters(self) -> None:
         if not self.filters:
             return
@@ -844,52 +877,74 @@ class NodeGetListQuery(Query):
         self.order_by = []
 
         self.return_labels = ["n.uuid", "rb.branch", f"{db.get_id_function_name()}(rb) as rb_id"]
-        where_clause_elements = []
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
             at=self.at, branch_agnostic=self.branch_agnostic
         )
         self.params.update(branch_params)
 
-        query = """
-        MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
-            MATCH (root:Root)<-[r:IS_PART_OF]-(n)
+        # The initial subquery is used to filter out deleted nodes because we can have multiple valid results per branch
+        #   and we need to filter out the one that have been deleted in the branch.
+        # If we are on the default branch, the subquery is not required because only one valid result is expected at a given time
+        if not self.branch.is_default:
+            topquery = """
+            MATCH (n:%(node_kind)s)
+            CALL {
+                WITH n
+                MATCH (root:Root)<-[r:IS_PART_OF]-(n)
+                WHERE %(branch_filter)s
+                RETURN r
+                ORDER BY r.branch_level DESC, r.from DESC
+                LIMIT 1
+            }
+            WITH n, r as rb
+            WHERE rb.status = "active"
+            """ % {"branch_filter": branch_filter, "node_kind": self.schema.kind}
+            self.add_to_query(topquery)
+        else:
+            topquery = """
+            MATCH (root:Root)<-[r:IS_PART_OF]-(n:%(node_kind)s)
             WHERE %(branch_filter)s
-            RETURN r
-            ORDER BY r.branch_level DESC, r.from DESC
-            LIMIT 1
-        }
-        WITH n, r as rb
-        WHERE rb.status = "active"
-        """ % {"branch_filter": branch_filter, "node_kind": self.schema.kind}
-        self.add_to_query(query)
-        use_simple = False
-        if self.filters and "id" in self.filters:
-            use_simple = True
-            where_clause_elements.append("n.uuid = $uuid")
+            WITH n, r as rb
+            WHERE rb.status = "active"
+            """ % {"branch_filter": branch_filter, "node_kind": self.schema.kind}
+            self.add_to_query(topquery)
+
+        if self.has_filter_by_id and self.filters:
             self.params["uuid"] = self.filters["id"]
-        if not self.filters and not self.schema.order_by:
-            use_simple = True
+            self.add_to_query(" AND n.uuid = $uuid")
+            return
+
+        disable_order = not self.schema.order_by or (self.order is not None and self.order.disable)
+        if not self.has_filters and disable_order:
+            # Always order by uuid to guarantee pagination, see https://github.com/opsmill/infrahub/pull/4704.
             self.order_by = ["n.uuid"]
-        if use_simple:
-            if where_clause_elements:
-                self.add_to_query(" AND " + " AND ".join(where_clause_elements))
             return
 
         if self.filters and "ids" in self.filters:
             self.add_to_query("AND n.uuid IN $node_ids")
             self.params["node_ids"] = self.filters["ids"]
 
-        field_attribute_requirements = self._get_field_requirements()
+        field_attribute_requirements = self._get_field_requirements(disable_order=disable_order)
         use_profiles = any(far for far in field_attribute_requirements if far.supports_profile)
         await self._add_node_filter_attributes(
             db=db, field_attribute_requirements=field_attribute_requirements, branch_filter=branch_filter
         )
-        await self._add_node_order_attributes(
-            db=db, field_attribute_requirements=field_attribute_requirements, branch_filter=branch_filter
-        )
+
+        if not disable_order:
+            await self._add_node_order_attributes(
+                db=db, field_attribute_requirements=field_attribute_requirements, branch_filter=branch_filter
+            )
+            for far in field_attribute_requirements:
+                if not far.is_order:
+                    continue
+                if far.supports_profile:
+                    self.order_by.append(far.final_value_query_variable)
+                    continue
+                self.order_by.append(far.node_value_query_variable)
+
+        # Always order by uuid to guarantee pagination, see https://github.com/opsmill/infrahub/pull/4704.
+        self.order_by.append("n.uuid")
 
         if use_profiles:
             await self._add_profiles_per_node_query(db=db, branch_filter=branch_filter)
@@ -899,15 +954,6 @@ class NodeGetListQuery(Query):
             await self._add_profile_rollups(field_attribute_requirements=field_attribute_requirements)
 
         self._add_final_filter(field_attribute_requirements=field_attribute_requirements)
-        self.order_by = []
-        for far in field_attribute_requirements:
-            if not far.is_order:
-                continue
-            if far.supports_profile:
-                self.order_by.append(far.final_value_query_variable)
-                continue
-            self.order_by.append(far.node_value_query_variable)
-        self.order_by.append("n.uuid")
 
     async def _add_node_filter_attributes(
         self,
@@ -1154,7 +1200,7 @@ class NodeGetListQuery(Query):
             where_str = "WHERE " + " AND ".join(where_parts)
         self.add_to_query(where_str)
 
-    def _get_field_requirements(self) -> list[FieldAttributeRequirement]:
+    def _get_field_requirements(self, disable_order: bool) -> list[FieldAttributeRequirement]:
         internal_filters = ["any", "attribute", "relationship"]
         field_requirements_map: dict[tuple[str, str], FieldAttributeRequirement] = {}
         index = 1
@@ -1176,7 +1222,8 @@ class NodeGetListQuery(Query):
                         types=[FieldAttributeRequirementType.FILTER],
                     )
                     index += 1
-        if not self.schema.order_by:
+
+        if disable_order:
             return list(field_requirements_map.values())
 
         for order_by_path in self.schema.order_by:
@@ -1214,12 +1261,14 @@ class NodeGetHierarchyQuery(Query):
         direction: RelationshipHierarchyDirection,
         node_schema: Union[NodeSchema, GenericSchema],
         filters: Optional[dict] = None,
+        hierarchical_ordering: bool = False,
         **kwargs: Any,
     ) -> None:
         self.filters = filters or {}
         self.direction = direction
         self.node_id = node_id
         self.node_schema = node_schema
+        self.hierarchical_ordering = hierarchical_ordering
 
         super().__init__(**kwargs)
 
@@ -1322,6 +1371,8 @@ class NodeGetHierarchyQuery(Query):
         # ----------------------------------------------------------------------------
         # ORDER Results
         # ----------------------------------------------------------------------------
+        if self.hierarchical_ordering:
+            return
         if hasattr(hierarchy_schema, "order_by") and hierarchy_schema.order_by:
             order_cnt = 1
 

infrahub/core/schema/generated/attribute_schema.py

@@ -8,8 +8,8 @@ from pydantic import Field
 
 from infrahub.core.constants import AllowOverrideType, HashableModelState
 from infrahub.core.models import HashableModel
-from infrahub.core.schema.computed_attribute import ComputedAttribute  # noqa: TCH001
-from infrahub.core.schema.dropdown import DropdownChoice  # noqa: TCH001
+from infrahub.core.schema.computed_attribute import ComputedAttribute  # noqa: TC001
+from infrahub.core.schema.dropdown import DropdownChoice  # noqa: TC001
 
 if TYPE_CHECKING:
     from infrahub.core.constants import BranchSupportType

infrahub/core/schema/generated/base_node_schema.py

@@ -8,8 +8,8 @@ from pydantic import Field
 
 from infrahub.core.constants import BranchSupportType, HashableModelState
 from infrahub.core.models import HashableModel
-from infrahub.core.schema.attribute_schema import AttributeSchema  # noqa: TCH001
-from infrahub.core.schema.relationship_schema import RelationshipSchema  # noqa: TCH001
+from infrahub.core.schema.attribute_schema import AttributeSchema  # noqa: TC001
+from infrahub.core.schema.relationship_schema import RelationshipSchema  # noqa: TC001
 
 
 class GeneratedBaseNodeSchema(HashableModel):

infrahub/core/schema/generated/relationship_schema.py

@@ -14,7 +14,7 @@ from infrahub.core.constants import (
     RelationshipDeleteBehavior,
     RelationshipDirection,
     RelationshipKind,
-)
+)  # noqa: TC001
 from infrahub.core.models import HashableModel
 
 

infrahub/core/schema/schema_branch_computed.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, Field
 
-from infrahub.core.schema import AttributeSchema  # noqa: TCH001
+from infrahub.core.schema import AttributeSchema  # noqa: TC001
 
 if TYPE_CHECKING:
     from infrahub.core.schema import NodeSchema, SchemaAttributePath

infrahub/core/task/task_log.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING
 
 from pydantic import ConfigDict, Field
 
-from infrahub.core.constants import Severity  # noqa: TCH001
+from infrahub.core.constants import Severity  # noqa: TC001
 from infrahub.core.node.standard import StandardNode
 from infrahub.core.query.task_log import TaskLogNodeCreateQuery
 from infrahub.core.timestamp import current_timestamp

infrahub/core/validators/attribute/kind.py

@@ -67,7 +67,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             if value in (None, NULL_VALUE):
                 continue
             try:
-                infrahub_attribute_class.validate(
+                infrahub_attribute_class.validate_format(
                     value=result.get("attribute_value"), name=self.attribute_schema.name, schema=self.attribute_schema
                 )
             except ValidationError:

infrahub/core/validators/interface.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from typing import List
 
 from infrahub.core.path import GroupedDataPaths
 
@@ -15,4 +14,4 @@ class ConstraintCheckerInterface(ABC):
     def supports(self, request: SchemaConstraintValidatorRequest) -> bool: ...
 
     @abstractmethod
-    async def check(self, request: SchemaConstraintValidatorRequest) -> List[GroupedDataPaths]: ...
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]: ...

infrahub/core/validators/models/violation.py

@@ -1,17 +1,4 @@
-from typing import Union
-
-from pydantic import BaseModel, Field
-
-from infrahub.core.branch import Branch
-from infrahub.core.path import SchemaPath
-from infrahub.core.schema import GenericSchema, NodeSchema
-
-
-class SchemaConstraintValidatorRequest(BaseModel):
-    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")
-    schema_path: SchemaPath = Field(..., description="SchemaPath to the element of the schema to validate")
+from pydantic import BaseModel
 
 
 class SchemaViolation(BaseModel):

infrahub/core/validators/shared.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 from typing import Any, Union
 
-from infrahub.core.path import GroupedDataPaths, SchemaPath  # noqa: TCH001
+from infrahub.core.path import GroupedDataPaths, SchemaPath  # noqa: TC001
 from infrahub.core.query import Query, QueryType
-from infrahub.core.schema import AttributeSchema, GenericSchema, NodeSchema, RelationshipSchema  # noqa: TCH001
+from infrahub.core.schema import AttributeSchema, GenericSchema, NodeSchema, RelationshipSchema  # noqa: TC001
 
 
 class SchemaValidatorQuery(Query):

infrahub/core/validators/tasks.py

@@ -5,9 +5,9 @@ from prefect import flow, task
 from prefect.cache_policies import NONE
 from prefect.logging import get_run_logger
 
-from infrahub.core.branch import Branch  # noqa: TCH001
-from infrahub.core.path import SchemaPath  # noqa: TCH001
-from infrahub.core.schema import GenericSchema, NodeSchema  # noqa: TCH001
+from infrahub.core.branch import Branch  # noqa: TC001
+from infrahub.core.path import SchemaPath  # noqa: TC001
+from infrahub.core.schema import GenericSchema, NodeSchema  # noqa: TC001
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
 from infrahub.core.validators.model import (
     SchemaConstraintValidatorRequest,
@@ -32,11 +32,14 @@ async def schema_validate_migrations(message: SchemaValidateMigrationData) -> li
     log.info(f"{len(message.constraints)} constraint(s) to validate")
     # NOTE this task is a good candidate to add a progress bar
     for constraint in message.constraints:
+        schema = message.schema_branch.get(name=constraint.path.schema_kind)
+        if not isinstance(schema, (GenericSchema, NodeSchema)):
+            continue
         batch.add(
             task=schema_path_validate,
             branch=message.branch,
             constraint_name=constraint.constraint_name,
-            node_schema=message.schema_branch.get(name=constraint.path.schema_kind),
+            node_schema=schema,
             schema_path=constraint.path,
         )
 

infrahub/core/validators/uniqueness/index.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 from collections import defaultdict
 from typing import TYPE_CHECKING, Any, Iterable, Optional
 
-from infrahub.core.constants import NULL_VALUE
-
 if TYPE_CHECKING:
     from infrahub.core.query import QueryResult
     from infrahub.core.schema import SchemaAttributePath, SchemaAttributePathValue
@@ -49,13 +47,13 @@ class UniquenessQueryResultsIndex:
             if relationship_identifier:
                 if relationship_identifier not in self._relationship_index:
                     self._relationship_index[relationship_identifier] = defaultdict(set)
-                if attr_value and attr_value != NULL_VALUE and node_id:
+                if attr_value and node_id:
                     self._relationship_index[relationship_identifier][attr_value].add(node_id)
                     self._node_index[node_id][relationship_identifier] = attr_value
             elif attr_name:
                 if attr_name not in self._attribute_index:
                     self._attribute_index[attr_name] = defaultdict(set)
-                if attr_value and attr_value != NULL_VALUE and node_id:
+                if attr_value and node_id:
                     self._attribute_index[attr_name][attr_value].add(node_id)
                     self._node_index[node_id][attr_name] = attr_value