infrahub-server 1.7.0b0__py3-none-any.whl → 1.7.1__py3-none-any.whl

infrahub/core/order.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Self
+
+from pydantic import BaseModel, model_validator
+
+from infrahub.constants.enums import OrderDirection  # noqa: TC001
+from infrahub.exceptions import ValidationError
+
+# Metadata field name constants
+METADATA_CREATED_AT = "created_at"
+METADATA_CREATED_BY = "created_by"
+METADATA_UPDATED_AT = "updated_at"
+METADATA_UPDATED_BY = "updated_by"
+
+
+class NodeMetaOrder(BaseModel):
+    created_at: OrderDirection | None = None
+    updated_at: OrderDirection | None = None
+
+
+class OrderModel(BaseModel):
+    disable: bool | None = None
+    node_metadata: NodeMetaOrder | None = None
+
+    @model_validator(mode="after")
+    def validate_metadata(self) -> Self:
+        if self.node_metadata and self.node_metadata.created_at and self.node_metadata.updated_at:
+            raise ValidationError("Cannot order by both created_at and updated_at simultaneously.")
+        return self

infrahub/core/protocols.py

@@ -221,6 +221,7 @@ class CoreValidator(CoreNode):
 class CoreWebhook(CoreNode):
     name: String
     event_type: Enum
+    active: Boolean
     branch_scope: Dropdown
     node_kind: StringOptional
     description: StringOptional

infrahub/core/protocols_base.py

@@ -106,3 +106,7 @@ class CoreNode(Protocol):
     ) -> dict: ...
     async def render_display_label(self, db: InfrahubDatabase | None = None) -> str: ...
     async def from_graphql(self, data: dict, db: InfrahubDatabase) -> bool: ...
+    def _get_created_at(self) -> Timestamp | None: ...
+    def _get_created_by(self) -> str | None: ...
+    def _get_updated_at(self) -> Timestamp | None: ...
+    def _get_updated_by(self) -> str | None: ...

infrahub/core/query/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
@@ -160,7 +159,7 @@ def cleanup_return_labels(labels: list[str]) -> list[str]:
 
 
 class QueryResult:
-    def __init__(self, data: list[Neo4jNode | Neo4jRelationship | list[Neo4jNode]], labels: list[str]):
+    def __init__(self, data: list[Neo4jNode | Neo4jRelationship | list[Neo4jNode]], labels: list[str]) -> None:
         self.data = data
         self.labels = labels
         self.branch_score: int = 0
@@ -336,7 +335,7 @@ class QueryStat:
         return cls(**data)
 
 
-class Query(ABC):
+class Query:
     name: str = "base-query"
     type: QueryType
 
@@ -353,7 +352,7 @@ class Query(ABC):
         order_by: list[str] | None = None,
         branch_agnostic: bool = False,
         user_id: str = SYSTEM_USER_ID,
-    ):
+    ) -> None:
         if branch:
             self.branch = branch
 
@@ -405,8 +404,12 @@ class Query(ABC):
 
         return query
 
-    @abstractmethod
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+        # Avoid using this method for new queries and look at migrating older queries. The
+        # problem here is that we loose so much information with the `**kwargs` we should instead
+        # populate this information via the constructor and anything done within the existing query_init methods
+        # could either be handled within __init__ or via dedicated methods within each Query class where appropriate,
+        # i.e. things might need to happend in a certain order or we just want to separate the logic better.
         raise NotImplementedError
 
     def get_context(self) -> dict[str, str]:

infrahub/core/query/attribute.py

@@ -31,7 +31,7 @@ class AttributeQuery(Query):
         at: Timestamp | str | None = None,
         branch: Branch | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.attr = attr
         self.attr_id = attr_id or attr.db_id
 
@@ -171,7 +171,7 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
         prop_name: str,
         prop_id: str | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.prop_name = prop_name
         self.prop_id = prop_id
 
@@ -246,7 +246,7 @@ class AttributeClearNodePropertyQuery(AttributeQuery):
         self,
         prop_name: str,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.prop_name = prop_name
 
         super().__init__(**kwargs)

infrahub/core/query/branch.py

@@ -17,7 +17,7 @@ class DeleteBranchRelationshipsQuery(Query):
 
     type: QueryType = QueryType.WRITE
 
-    def __init__(self, branch_name: str, **kwargs: Any):
+    def __init__(self, branch_name: str, **kwargs: Any) -> None:
         self.branch_name = branch_name
         super().__init__(**kwargs)
 

infrahub/core/query/delete.py

@@ -11,7 +11,7 @@ class DeleteAfterTimeQuery(Query):
     insert_return: bool = False
     type: QueryType = QueryType.WRITE
 
-    def __init__(self, timestamp: Timestamp, **kwargs: Any):
+    def __init__(self, timestamp: Timestamp, **kwargs: Any) -> None:
         self.timestamp = timestamp
         super().__init__(**kwargs)
 

infrahub/core/query/diff.py

@@ -26,7 +26,7 @@ class DiffQuery(Query):
         diff_from: Timestamp | str = None,
         diff_to: Timestamp | str = None,
         **kwargs,
-    ):
+    ) -> None:
         """A diff is always in the context of a branch"""
 
         if not diff_from and branch.is_default:
@@ -59,7 +59,7 @@ class DiffCountChanges(Query):
         diff_from: Timestamp,
         diff_to: Timestamp,
         **kwargs,
-    ):
+    ) -> None:
         self.branch_names = branch_names
         self.diff_from = diff_from
         self.diff_to = diff_to
@@ -122,7 +122,7 @@ class DiffCalculationQuery(DiffQuery):
         current_node_field_specifiers: NodeFieldSpecifierMap | None = None,
         new_node_field_specifiers: NodeFieldSpecifierMap | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.base_branch = base_branch
         self.diff_branch_from_time = diff_branch_from_time
         self.current_node_field_specifiers = current_node_field_specifiers

infrahub/core/query/ipam.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Iterable
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.graph.schema import GraphAttributeIPHostNode, GraphAttributeIPNetworkNode
 from infrahub.core.ipam.constants import AllIPTypes, IPAddressType, IPNetworkType
-from infrahub.core.query import QueryType
+from infrahub.core.query import QueryResult, QueryType
 from infrahub.core.registry import registry
 from infrahub.core.utils import convert_ip_to_binary_str
 
@@ -57,7 +57,7 @@ class IPPrefixSubnetFetch(Query):
         obj: IPNetworkType,
         namespace: Node | str | None = None,
         **kwargs,
-    ):
+    ) -> None:
         self.obj = obj
         self.namespace_id = _get_namespace_id(namespace)
 
@@ -146,7 +146,7 @@ class IPPrefixIPAddressFetch(Query):
         obj: IPNetworkType,
         namespace: Node | str | None = None,
         **kwargs,
-    ):
+    ) -> None:
         self.obj = obj
         self.namespace_id = _get_namespace_id(namespace)
 
@@ -242,11 +242,53 @@ async def get_ip_addresses(
     return query.get_addresses()
 
 
+@dataclass(frozen=True)
+class IPPrefixUtilizationResult:
+    """Result from IPPrefixUtilization containing prefix child allocation data."""
+
+    prefix_uuid: str
+    """UUID of the parent prefix node."""
+
+    child_uuid: str
+    """UUID of the child node (prefix or address)."""
+
+    child_kind: str
+    """Kind/type of the child node."""
+
+    child_labels: tuple[str, ...]
+    """Labels of the child node (used to determine if IPADDRESS or IPPREFIX)."""
+
+    ip_value: str
+    """IP value (address or prefix) of the child."""
+
+    prefixlen: int
+    """Prefix length of the child IP value."""
+
+    branch: str
+    """Branch name where this allocation exists."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> IPPrefixUtilizationResult:
+        """Convert raw QueryResult to typed dataclass."""
+        pfx = result.get_node("pfx")
+        child = result.get_node("child")
+        av = result.get_node("av")
+        return cls(
+            prefix_uuid=str(pfx.get("uuid")),
+            child_uuid=str(child.get("uuid")),
+            child_kind=child.get("kind"),
+            child_labels=tuple(child.labels),
+            ip_value=av.get("value"),
+            prefixlen=av.get("prefixlen"),
+            branch=str(result.get("branch")),
+        )
+
+
 class IPPrefixUtilization(Query):
     name = "ipprefix_utilization_prefix"
     type = QueryType.READ
 
-    def __init__(self, ip_prefixes: list[str], allocated_kinds: list[str], **kwargs):
+    def __init__(self, ip_prefixes: list[str], allocated_kinds: list[str], **kwargs) -> None:
         self.ip_prefixes = ip_prefixes
         self.allocated_kinds: list[str] = []
         self.allocated_kinds_rel: list[str] = []
@@ -315,6 +357,55 @@ class IPPrefixUtilization(Query):
         self.return_labels = ["pfx", "child", "av", "branch_level", "branch"]
         self.add_to_query(query)
 
+    def get_data(self) -> list[IPPrefixUtilizationResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of IPPrefixUtilizationResult containing prefix child allocation data.
+        """
+        return [IPPrefixUtilizationResult.from_db(result) for result in self.get_results()]
+
+
+@dataclass(frozen=True)
+class IPPrefixReconcileQueryResult:
+    """Result from IPPrefixReconcileQuery containing IP reconciliation data."""
+
+    ip_node_uuid: str | None
+    """UUID of the IP node being reconciled, or None if not found."""
+
+    current_parent_uuid: str | None
+    """UUID of the current parent prefix, or None if no parent exists."""
+
+    calculated_parent_uuid: str | None
+    """UUID of the calculated correct parent prefix, or None if should be top-level."""
+
+    current_children_uuids: tuple[str, ...]
+    """UUIDs of current child prefixes/addresses."""
+
+    calculated_children_uuids: tuple[str, ...]
+    """UUIDs of calculated correct child prefixes/addresses."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> IPPrefixReconcileQueryResult:
+        """Convert raw QueryResult to typed dataclass."""
+
+        def get_optional_node_uuid(label: str) -> str | None:
+            """Extract UUID from an optional node (may be None from OPTIONAL MATCH)."""
+            node = result.get(label)
+            return str(node.get("uuid")) if node and node.get("uuid") else None
+
+        def get_collection_uuids(label: str) -> tuple[str, ...]:
+            """Extract UUIDs from a node collection (may contain None from COLLECT)."""
+            return tuple(str(n.get("uuid")) for n in result.get_node_collection(label) if n and n.get("uuid"))
+
+        return cls(
+            ip_node_uuid=get_optional_node_uuid("ip_node"),
+            current_parent_uuid=get_optional_node_uuid("current_parent"),
+            calculated_parent_uuid=get_optional_node_uuid("new_parent"),
+            current_children_uuids=get_collection_uuids("current_children"),
+            calculated_children_uuids=get_collection_uuids("new_children"),
+        )
+
 
 class IPPrefixReconcileQuery(Query):
     name = "ip_prefix_reconcile"
@@ -326,7 +417,7 @@ class IPPrefixReconcileQuery(Query):
         namespace: Node | str | None = None,
         node_uuid: str | None = None,
         **kwargs,
-    ):
+    ) -> None:
         self.ip_value = ip_value
         self.ip_uuid = node_uuid
         self.namespace_id = _get_namespace_id(namespace)
@@ -702,44 +793,14 @@ class IPPrefixReconcileQuery(Query):
         self.order_by = ["ip_node.uuid"]
         self.return_labels = ["ip_node", "current_parent", "current_children", "new_parent", "new_children"]
 
-    def _get_uuid_from_query(self, node_name: str) -> str | None:
-        results = list(self.get_results())
-        if not results:
-            return None
-        result = results[0]
-        node = result.get(node_name)
-        if not node:
-            return None
-        node_uuid = node.get("uuid")
-        if node_uuid:
-            return str(node_uuid)
-        return None
+    def get_data(self) -> IPPrefixReconcileQueryResult | None:
+        """Return single result as typed dataclass instance.
 
-    def _get_uuids_from_query_list(self, alias_name: str) -> list[str]:
+        Returns:
+            IPPrefixReconcileQueryResult containing reconciliation data,
+            or None if no results found.
+        """
         results = list(self.get_results())
         if not results:
-            return []
-        result = results[0]
-        element_uuids = []
-        for element in result.get(alias_name):
-            if not element:
-                continue
-            element_uuid = element.get("uuid")
-            if element_uuid:
-                element_uuids.append(str(element_uuid))
-        return element_uuids
-
-    def get_ip_node_uuid(self) -> str | None:
-        return self._get_uuid_from_query("ip_node")
-
-    def get_current_parent_uuid(self) -> str | None:
-        return self._get_uuid_from_query("current_parent")
-
-    def get_calculated_parent_uuid(self) -> str | None:
-        return self._get_uuid_from_query("new_parent")
-
-    def get_current_children_uuids(self) -> list[str]:
-        return self._get_uuids_from_query_list("current_children")
-
-    def get_calculated_children_uuids(self) -> list[str]:
-        return self._get_uuids_from_query_list("new_children")
+            return None
+        return IPPrefixReconcileQueryResult.from_db(results[0])