infrahub-server 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

infrahub/core/query/resource_manager.py

@@ -1,24 +1,74 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Generator
 
-from pydantic import BaseModel, ConfigDict
-
 from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind, RelationshipStatus
-from infrahub.core.query import Query, QueryType
+from infrahub.core.query import Query, QueryResult, QueryType
 
 if TYPE_CHECKING:
     from infrahub.core.protocols import CoreNumberPool
     from infrahub.database import InfrahubDatabase
 
 
-class NumberPoolIdentifierData(BaseModel):
-    model_config = ConfigDict(frozen=True)
+@dataclass(frozen=True)
+class NumberPoolIdentifierData:
+    """Result containing a pool reservation value and its identifier."""
 
     value: int
     identifier: str
 
+    @classmethod
+    def from_db(cls, result: QueryResult) -> NumberPoolIdentifierData:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            value=result.get_as_type("value", return_type=int),
+            identifier=result.get_as_type("identifier", return_type=str),
+        )
+
+
+@dataclass(frozen=True)
+class PoolIdentifierResult:
+    """Result from pool identifier queries containing allocation and identifier data."""
+
+    allocated_uuid: str
+    """UUID of the allocated resource (address or prefix)."""
+
+    identifier: str
+    """Identifier used for the reservation."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> PoolIdentifierResult:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            allocated_uuid=result.get_as_type("allocated_uuid", str),
+            identifier=result.get_as_type("identifier", str),
+        )
+
+
+@dataclass(frozen=True)
+class NumberPoolAllocatedResult:
+    """Result from NumberPoolGetAllocated containing allocated number info."""
+
+    id: str
+    """UUID of the node with the allocated number."""
+
+    branch: str
+    """Branch where the allocation exists."""
+
+    value: int
+    """The allocated number value."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> NumberPoolAllocatedResult:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            id=result.get_as_type("id", str),
+            branch=result.get_as_type("branch", str),
+            value=result.get_as_type("value", int),
+        )
+
 
 class IPAddressPoolGetIdentifiers(Query):
     name = "ipaddresspool_get_identifiers"
@@ -44,7 +94,15 @@ class IPAddressPoolGetIdentifiers(Query):
         WHERE allocated.uuid in $addresses
         """ % {"ipaddress_pool": InfrahubKind.IPADDRESSPOOL}
         self.add_to_query(query)
-        self.return_labels = ["allocated", "reservation"]
+        self.return_labels = ["allocated.uuid AS allocated_uuid", "reservation.identifier AS identifier"]
+
+    def get_data(self) -> list[PoolIdentifierResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of PoolIdentifierResult containing allocation and identifier data.
+        """
+        return [PoolIdentifierResult.from_db(result) for result in self.get_results()]
 
 
 class IPAddressPoolGetReserved(Query):
@@ -159,6 +217,14 @@ class NumberPoolGetAllocated(Query):
         self.return_labels = ["n.uuid as id", "hv.branch as branch", "av.value as value"]
         self.order_by = ["av.value"]
 
+    def get_data(self) -> list[NumberPoolAllocatedResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of NumberPoolAllocatedResult containing allocated number info.
+        """
+        return [NumberPoolAllocatedResult.from_db(result) for result in self.get_results()]
+
 
 class NumberPoolGetReserved(Query):
     name = "numberpool_get_reserved"
@@ -205,17 +271,31 @@ class NumberPoolGetReserved(Query):
         self.return_labels = ["reservation.value AS value", "r.identifier AS identifier"]
 
     def get_reservation(self) -> int | None:
+        """Return the reserved value for a single identifier.
+
+        Returns:
+            The reserved integer value, or None if no reservation exists.
+        """
         result = self.get_result()
         if result:
             return result.get_as_optional_type("value", return_type=int)
         return None
 
+    def get_data(self) -> list[NumberPoolIdentifierData]:
+        """Return all reservations as typed dataclass instances.
+
+        Returns:
+            List of NumberPoolIdentifierData containing value and identifier.
+        """
+        return [NumberPoolIdentifierData.from_db(result) for result in self.get_results()]
+
     def get_reservations(self) -> Generator[NumberPoolIdentifierData]:
-        for result in self.results:
-            yield NumberPoolIdentifierData.model_construct(
-                value=result.get_as_type("value", return_type=int),
-                identifier=result.get_as_type("identifier", return_type=str),
-            )
+        """Yield reservations as typed dataclass instances.
+
+        Yields:
+            NumberPoolIdentifierData for each reservation.
+        """
+        yield from self.get_data()
 
 
 class PoolChangeReserved(Query):
@@ -282,7 +362,6 @@ This will be especially important as we want to support upsert with NumberPool
 class NumberPoolGetUsed(Query):
     name = "number_pool_get_used"
     type = QueryType.READ
-    return_model = NumberPoolIdentifierData
 
     def __init__(
         self,
@@ -331,11 +410,13 @@ class NumberPoolGetUsed(Query):
         self.order_by = ["value"]
 
     def iter_results(self) -> Generator[NumberPoolIdentifierData]:
-        for result in self.results:
-            yield self.return_model.model_construct(
-                value=result.get_as_type("value", return_type=int),
-                identifier=result.get_as_type("identifier", return_type=str),
-            )
+        """Yield used pool values as typed dataclass instances.
+
+        Yields:
+            NumberPoolIdentifierData for each used value in the pool.
+        """
+        for result in self.get_results():
+            yield NumberPoolIdentifierData.from_db(result)
 
 
 class NumberPoolSetReserved(Query):
@@ -405,7 +486,15 @@ class PrefixPoolGetIdentifiers(Query):
         WHERE allocated.uuid in $prefixes
         """ % {"ipaddress_pool": InfrahubKind.IPPREFIXPOOL}
         self.add_to_query(query)
-        self.return_labels = ["allocated", "reservation"]
+        self.return_labels = ["allocated.uuid AS allocated_uuid", "reservation.identifier AS identifier"]
+
+    def get_data(self) -> list[PoolIdentifierResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of PoolIdentifierResult containing allocation and identifier data.
+        """
+        return [PoolIdentifierResult.from_db(result) for result in self.get_results()]
 
 
 class PrefixPoolGetReserved(Query):

infrahub/core/query/standard_node.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, assert_never
 
+from infrahub.constants.enums import OrderByField
 from infrahub.core.query import Query, QueryType
 from infrahub.exceptions import InitializationError
 
 if TYPE_CHECKING:
     from uuid import UUID
 
-    from infrahub.core.node.standard import StandardNode
+    from infrahub.core.node.standard import StandardNode, StandardNodeOrdering
     from infrahub.database import InfrahubDatabase
 
 
@@ -135,11 +136,19 @@ class StandardNodeGetListQuery(Query):
     raw_filter: str | None = None
 
     def __init__(
-        self, node_class: StandardNode, ids: list[str] | None = None, node_name: str | None = None, **kwargs: Any
+        self,
+        node_class: StandardNode,
+        node_ordering: StandardNodeOrdering,
+        ids: list[str] | None = None,
+        node_name: str | None = None,
+        partial_match: bool = False,
+        **kwargs: Any,
     ) -> None:
         self.ids = ids
         self.node_name = node_name
         self.node_class = node_class
+        self.partial_match = partial_match
+        self.node_ordering = node_ordering
 
         super().__init__(**kwargs)
 
@@ -148,9 +157,12 @@ class StandardNodeGetListQuery(Query):
         if self.ids:
             filters.append("n.uuid in $ids_value")
             self.params["ids_value"] = self.ids
-        if self.node_name:
+        if self.node_name and not self.partial_match:
             filters.append("n.name = $name")
             self.params["name"] = self.node_name
+        if self.node_name and self.partial_match:
+            filters.append("toLower(toString(n.name)) CONTAINS toLower(toString($name))")
+            self.params["name"] = self.node_name
         if self.raw_filter:
             filters.append(self.raw_filter)
 
@@ -169,4 +181,12 @@ class StandardNodeGetListQuery(Query):
         self.add_to_query(query)
 
         self.return_labels = ["n"]
-        self.order_by = [f"{db.get_id_function_name()}(n)"]
+        match self.node_ordering.order_by:
+            case OrderByField.ID:
+                self.order_by = [f"{db.get_id_function_name()}(n)"]
+            case OrderByField.CREATED_AT:
+                self.order_by = [f"n.created_at {self.node_ordering.direction.value}"]
+            case OrderByField.UPDATED_AT:
+                self.order_by = [f"n.updated_at {self.node_ordering.direction.value}"]
+            case _:
+                assert_never(self.node_ordering.order_by)

infrahub/core/query/utils.py

@@ -5,16 +5,14 @@ from typing import TYPE_CHECKING
 from infrahub.core.schema import NodeSchema, ProfileSchema, TemplateSchema
 
 if TYPE_CHECKING:
-    from neo4j.graph import Node as Neo4jNode
-
     from infrahub.core.branch import Branch
     from infrahub.database import InfrahubDatabase
 
 
 def find_node_schema(
-    db: InfrahubDatabase, node: Neo4jNode, branch: Branch | str, duplicate: bool = False
+    db: InfrahubDatabase, branch: Branch | str, labels: list[str], duplicate: bool = False
 ) -> NodeSchema | ProfileSchema | TemplateSchema | None:
-    for label in node.labels:
+    for label in labels:
         if db.schema.has(name=label, branch=branch):
             schema = db.schema.get(name=label, branch=branch, duplicate=duplicate)
             if isinstance(schema, NodeSchema | ProfileSchema | TemplateSchema):

infrahub/core/relationship/constraints/count.py

@@ -22,7 +22,7 @@ class NodeToValidate:
 
 
 class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/peer_kind.py

@@ -23,7 +23,7 @@ class NodeToValidate:
 
 
 class RelationshipPeerKindConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/peer_parent.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
 
 class RelationshipPeerParentConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/peer_relatives.py

@@ -25,7 +25,7 @@ class NodeToValidate:
 
 
 class RelationshipPeerRelativesConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/profiles_kind.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 
 
 class RelationshipProfilesKindConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name if branch else registry.default_branch)

infrahub/core/relationship/constraints/profiles_removal.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from infrahub.core import registry
+from infrahub.core.constants import MetadataOptions
+from infrahub.core.manager import NodeManager
+from infrahub.core.schema import NodeSchema, ProfileSchema
+from infrahub.exceptions import ValidationError
+
+from .interface import RelationshipManagerConstraintInterface
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.relationship.model import Relationship, RelationshipManager
+    from infrahub.core.schema import MainSchemaTypes
+    from infrahub.database import InfrahubDatabase
+
+
+class RelationshipProfileRemovalConstraint(RelationshipManagerConstraintInterface):
+    """Constraint that validates removing profiles from a node doesn't violate required relationships.
+
+    This runs in two cases:
+    1. When a node's `profiles` relationship is changed.
+    2. When a profile's `related_nodes` relationship is changed.
+
+    In both cases, it will perform checks only if peers are being removed from the relationship being changed.
+    """
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
+        self.db = db
+        self.branch = branch
+        self.schema_branch = registry.schema.get_schema_branch(branch.name if branch else registry.default_branch)
+
+    def _get_required_attributes_names(self, schema: NodeSchema) -> set[str]:
+        attr_names: set[str] = set()
+        for attr_schema in schema.attributes:
+            if attr_schema.support_profiles and not attr_schema.optional:
+                attr_names.add(attr_schema.name)
+        return attr_names
+
+    def _get_required_relationship_names(self, schema: NodeSchema) -> set[str]:
+        rel_names: set[str] = set()
+        for rel_schema in schema.relationships:
+            if rel_schema.support_profiles and not rel_schema.optional:
+                rel_names.add(rel_schema.name)
+        return rel_names
+
+    async def _validate_profile_removal(
+        self, node: Node, profile_id: str, required_attr_names: set[str], required_rel_names: set[str]
+    ) -> None:
+        for attr_name in required_attr_names:
+            attr = node.get_attribute(name=attr_name)
+            if attr.is_from_profile:
+                source = await attr.get_source(db=self.db)
+                if source and source.id == profile_id:
+                    node_display_label = await node.get_display_label(db=self.db)
+                    node_reference = f"node '{node_display_label}' (ID: {node.get_id()})"
+                    raise ValidationError(
+                        f"Cannot remove profile '{profile_id}' because {node_reference} "
+                        f"inherits required attribute '{attr_name}' from this profile."
+                    )
+
+        for rel_name in required_rel_names:
+            rel_manager = node.get_relationship(name=rel_name)
+
+            relationships: list[Relationship] = await rel_manager.get_relationships(db=self.db)
+            for rel in relationships:
+                if rel.is_from_profile:
+                    source = await rel.get_source(db=self.db)
+                    if source and source.id == profile_id:
+                        node_display_label = await node.get_display_label(db=self.db)
+                        node_reference = f"node '{node_display_label}' (ID: {node.get_id()})"
+                        raise ValidationError(
+                            f"Cannot remove profile '{profile_id}' because {node_reference} "
+                            f"inherits required relationship '{rel_name}' from this profile."
+                        )
+
+    async def _check_node_profiles_removal(
+        self, relm: RelationshipManager, node_schema: NodeSchema, node: Node
+    ) -> None:
+        required_attr_names = self._get_required_attributes_names(schema=node_schema)
+        required_rel_names = self._get_required_relationship_names(schema=node_schema)
+        if not required_attr_names and not required_rel_names:
+            return
+
+        relm_update_details = await relm.fetch_relationship_ids(db=self.db, force_refresh=False)
+        if not relm_update_details.peer_ids_present_database_only:
+            return
+
+        if required_attr_names:
+            # Required to get source for attributes
+            node = await NodeManager.get_one(
+                db=self.db, branch=self.branch, id=node.get_id(), include_metadata=MetadataOptions.SOURCE
+            )
+
+        for profile_id in relm_update_details.peer_ids_present_database_only:
+            await self._validate_profile_removal(
+                node=node,
+                profile_id=profile_id,
+                required_attr_names=required_attr_names,
+                required_rel_names=required_rel_names,
+            )
+
+    async def _check_profile_related_nodes_removal(
+        self, relm: RelationshipManager, profile_schema: ProfileSchema, profile: Node
+    ) -> None:
+        relm_update_details = await relm.fetch_relationship_ids(db=self.db, force_refresh=False)
+        if not relm_update_details.peer_ids_present_database_only:
+            return
+
+        target_kind = profile_schema.get_relationship(name="related_nodes").peer
+        target_schema = self.schema_branch.get_node(name=target_kind, duplicate=False)
+
+        required_attr_names = self._get_required_attributes_names(schema=target_schema)
+        required_rel_names = self._get_required_relationship_names(schema=target_schema)
+        if not required_attr_names and not required_rel_names:
+            return
+
+        nodes = await NodeManager.get_many(
+            db=self.db,
+            branch=self.branch,
+            ids=relm_update_details.peer_ids_present_database_only,
+            include_metadata=MetadataOptions.SOURCE,
+        )
+        for node in nodes.values():
+            await self._validate_profile_removal(
+                node=node,
+                profile_id=profile.get_id(),
+                required_attr_names=required_attr_names,
+                required_rel_names=required_rel_names,
+            )
+
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:
+        if relm.name == "profiles" and isinstance(node_schema, NodeSchema):
+            await self._check_node_profiles_removal(relm=relm, node_schema=node_schema, node=node)
+            return
+
+        if relm.name == "related_nodes" and isinstance(node_schema, ProfileSchema):
+            await self._check_profile_related_nodes_removal(relm=relm, profile_schema=node_schema, profile=node)
+            return
+
+    async def validate_profile_deletion(self, profile: Node, profile_schema: ProfileSchema) -> None:
+        related_nodes_rels = await profile.related_nodes.get_relationships(db=self.db)  # type: ignore[attr-defined]
+        related_node_ids = [rel.peer_id for rel in related_nodes_rels if rel.peer_id]
+
+        if not related_node_ids:
+            return
+
+        target_kind = profile_schema.get_relationship(name="related_nodes").peer
+        target_schema = self.schema_branch.get_node(name=target_kind, duplicate=False)
+
+        required_attr_names = self._get_required_attributes_names(schema=target_schema)
+        required_rel_names = self._get_required_relationship_names(schema=target_schema)
+        if not required_attr_names and not required_rel_names:
+            return
+
+        nodes = await NodeManager.get_many(
+            db=self.db, branch=self.branch, ids=related_node_ids, include_metadata=MetadataOptions.SOURCE
+        )
+        for node in nodes.values():
+            await self._validate_profile_removal(
+                node=node,
+                profile_id=profile.get_id(),
+                required_attr_names=required_attr_names,
+                required_rel_names=required_rel_names,
+            )