infrahub-server 1.7.0rc0__py3-none-any.whl → 1.7.2__py3-none-any.whl

infrahub/core/query/node.py

@@ -2180,6 +2180,134 @@ WITH %(tracked_vars)s,
         return [str(result.get("n.uuid")) for result in self.get_results()]
 
 
+@dataclass(frozen=True)
+class NodeGetListByAttributeValueQueryResult:
+    """Result from NodeGetListByAttributeValueQuery."""
+
+    uuid: str
+    kind: str
+
+
+class NodeGetListByAttributeValueQuery(Query):
+    """Query to find nodes by searching attribute values.
+
+    This query is optimized for search operations by starting from the AttributeValueIndexed
+    nodes and using a TEXT index for efficient CONTAINS searches. This approach is more
+    efficient than the standard NodeGetListQuery when searching for values across all nodes.
+    """
+
+    name = "node_get_list_by_attribute_value"
+    type = QueryType.READ
+
+    def __init__(
+        self,
+        search_value: str,
+        kinds: list[str] | None = None,
+        partial_match: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        self.search_value = search_value
+        self.kinds = kinds
+        self.partial_match = partial_match
+
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.order_by = ["n.uuid"]
+        self.return_labels = ["DISTINCT n.uuid as uuid", "n.kind as kind"]
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(
+            at=self.at, branch_agnostic=self.branch_agnostic
+        )
+        self.params.update(branch_params)
+
+        # Build search values for case-insensitive matching without using toLower/toString
+        # which would disable index lookup. We search for four case variations:
+        # 1. Original (as provided), 2. lowercase, 3. UPPERCASE, 4. Title Case (first char upper, rest lower)
+        search_original = self.search_value
+        search_lower = self.search_value.lower()
+        search_upper = self.search_value.upper()
+        search_title = self.search_value.capitalize()
+
+        # Build the search predicate based on partial_match
+        # We avoid toLower/toString to allow TEXT index usage
+        if self.partial_match:
+            # Use CONTAINS with multiple case variations to leverage TEXT index
+            search_predicate = (
+                "(av.value CONTAINS $search_original OR av.value CONTAINS $search_lower "
+                "OR av.value CONTAINS $search_upper OR av.value CONTAINS $search_title)"
+            )
+        else:
+            # Exact match with case variations
+            search_predicate = (
+                "(av.value = $search_original OR av.value = $search_lower "
+                "OR av.value = $search_upper OR av.value = $search_title)"
+            )
+
+        self.params["search_original"] = search_original
+        self.params["search_lower"] = search_lower
+        self.params["search_upper"] = search_upper
+        self.params["search_title"] = search_title
+
+        # Build kind filter if specified
+        kind_filter = ""
+        if self.kinds:
+            kind_filter = "AND any(l IN labels(n) WHERE l in $kinds)"
+            self.params["kinds"] = self.kinds
+
+        # The query starts from AttributeValueIndexed nodes to leverage the TEXT index
+        # This approach is more efficient for search operations as it:
+        # 1. Starts from AttributeValueIndexed nodes (smaller set when filtered)
+        # 2. Traverses from matching values back to their owning nodes
+        # 3. Filters nodes by branch and status
+        query = """
+        // --------------------------
+        // start with all possible Node-Attribute-AttributeValue combinations
+        // --------------------------
+        MATCH (av:AttributeValueIndexed)<-[:HAS_VALUE]-(attr:Attribute)<-[:HAS_ATTRIBUTE]-(n)
+        WHERE %(search_predicate)s %(kind_filter)s
+        WITH DISTINCT n, attr, av
+        // --------------------------
+        // filter HAS_VALUE edges
+        // --------------------------
+        CALL (av, attr) {
+            MATCH (av)<-[r:HAS_VALUE]-(attr)
+            WHERE %(branch_filter)s
+            RETURN r
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        WITH n, attr
+        WHERE r.status = "active"
+        // --------------------------
+        // filter HAS_ATTRIBUTE edges
+        // --------------------------
+        CALL (n, attr) {
+            MATCH (attr)<-[r:HAS_ATTRIBUTE]-(n)
+            WHERE %(branch_filter)s
+            RETURN r
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        WITH n, attr, r
+        WHERE r.status = "active"
+        """ % {
+            "search_predicate": search_predicate,
+            "kind_filter": kind_filter,
+            "branch_filter": branch_filter,
+        }
+
+        self.add_to_query(query)
+
+    def get_data(self) -> Generator[NodeGetListByAttributeValueQueryResult, None, None]:
+        """Yield results as typed dataclass instances."""
+        for result in self.get_results():
+            yield NodeGetListByAttributeValueQueryResult(
+                uuid=result.get_as_str("uuid"),
+                kind=result.get_as_str("kind"),
+            )
+
+
 class NodeGetHierarchyQuery(Query):
     name = "node_get_hierarchy"
     type = QueryType.READ

infrahub/core/query/resource_manager.py

@@ -70,6 +70,21 @@ class NumberPoolAllocatedResult:
         )
 
 
+@dataclass(frozen=True)
+class NumberPoolFreeData:
+    value: int
+    is_free: bool
+    is_last: bool
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> NumberPoolFreeData:
+        return cls(
+            value=result.get_as_type("value", return_type=int),
+            is_free=result.get_as_type("is_free", return_type=bool),
+            is_last=result.get_as_type("is_last", return_type=bool),
+        )
+
+
 class IPAddressPoolGetIdentifiers(Query):
     name = "ipaddresspool_get_identifiers"
     type = QueryType.READ
@@ -393,7 +408,9 @@ class NumberPoolGetUsed(Query):
                 n.uuid = res.identifier AND
                 attr.name = $attribute_name AND
                 all(r in [res, hv, ha] WHERE (%(branch_filter)s))
-            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC, res.from DESC, hv.from DESC, ha.from DESC
+            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC,
+                res.from DESC, hv.from DESC, ha.from DESC,
+                res.status ASC, hv.status ASC, ha.status ASC
             RETURN (res.status = "active" AND hv.status = "active" AND ha.status = "active") AS is_active
             LIMIT 1
         }
@@ -419,6 +436,102 @@ class NumberPoolGetUsed(Query):
             yield NumberPoolIdentifierData.from_db(result)
 
 
+class NumberPoolGetFree(Query):
+    name = "number_pool_get_free"
+    type = QueryType.READ
+
+    def __init__(
+        self,
+        pool: CoreNumberPool,
+        min_value: int | None = None,
+        max_value: int | None = None,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        self.pool = pool
+        self.min_value = min_value
+        self.max_value = max_value
+
+        super().__init__(**kwargs)  # type: ignore[arg-type]
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["pool_id"] = self.pool.get_id()
+        # Use min_value/max_value if provided, otherwise use pool's start_range/end_range
+        self.params["start_range"] = self.min_value if self.min_value is not None else self.pool.start_range.value
+        self.params["end_range"] = self.max_value if self.max_value is not None else self.pool.end_range.value
+        self.limit = 1  # Query only works at returning a single, free entry
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(
+            at=self.at.to_string(), branch_agnostic=self.branch_agnostic
+        )
+
+        self.params.update(branch_params)
+        self.params["attribute_name"] = self.pool.node_attribute.value
+
+        query = """
+        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValueIndexed)
+        WHERE toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
+        CALL (pool, res, av) {
+            MATCH (pool)-[res]->(av)<-[hv:HAS_VALUE]-(attr:Attribute)<-[ha:HAS_ATTRIBUTE]-(n:%(node)s)
+            WHERE
+                n.uuid = res.identifier AND
+                attr.name = $attribute_name AND
+                all(r in [res, hv, ha] WHERE (%(branch_filter)s))
+            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC,
+                res.from DESC, hv.from DESC, ha.from DESC,
+                res.status ASC, hv.status ASC, ha.status ASC
+            RETURN (res.status = "active" AND hv.status = "active" AND ha.status = "active") AS is_active
+            LIMIT 1
+        }
+        WITH av, res, is_active
+        WHERE is_active = True
+        WITH DISTINCT toInteger(av.value) AS used_value
+        ORDER BY used_value ASC
+        WITH [$start_range - 1] + collect(used_value) AS nums
+        UNWIND range(0, size(nums) - 1) AS idx
+        CALL (nums, idx) {
+            WITH nums[idx] AS curr, idx - 1 + $start_range AS expected
+            RETURN expected AS number, expected <> curr AS is_free, idx = size(nums) - 1 AS is_last
+        }
+        WITH number, is_free, is_last
+        WHERE is_free = true OR is_last = true
+        WITH number AS free_number, is_free, is_last
+        """ % {
+            "branch_filter": branch_filter,
+            "number_pool": InfrahubKind.NUMBERPOOL,
+            "node": self.pool.node.value,
+        }
+
+        self.add_to_query(query)
+        self.return_labels = ["free_number as value", "is_free", "is_last"]
+        self.order_by = ["value"]
+
+    def get_free_data(self) -> NumberPoolFreeData | None:
+        if not self.results:
+            return None
+
+        return NumberPoolFreeData.from_db(result=self.results[0])
+
+    def get_result_value(self) -> int | None:
+        """Get the free number from query results, handling edge cases.
+
+        Returns:
+            The free number if found, None if pool is exhausted in queried range.
+        """
+        result_data = self.get_free_data()
+        if result_data is None:
+            # No reservations in range - return start_range
+            if self.params["start_range"] <= self.params["end_range"]:
+                return self.params["start_range"]
+            return None
+
+        if result_data.is_free:
+            return result_data.value
+        # is_last=True and is_free=False means all numbers up to value are used
+        if result_data.is_last and result_data.value < self.params["end_range"]:
+            return result_data.value + 1
+        return None
+
+
 class NumberPoolSetReserved(Query):
     name = "numberpool_set_reserved"
     type = QueryType.WRITE

infrahub/core/relationship/model.py

@@ -652,7 +652,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin, MetadataInterface):
             destination_id=peer.id,
             status="active",
             direction=self.schema.direction.value,
-            branch_level=self.branch.hierarchy_level,
+            branch_level=branch.hierarchy_level,
             branch_support=self.schema.branch.value if self.schema.branch else None,
             hierarchical=self.schema.hierarchical,
             is_protected=self.is_protected,
@@ -1181,6 +1181,7 @@ class RelationshipManager:
         db: InfrahubDatabase,
         process_delete: bool = True,
         user_id: str = SYSTEM_USER_ID,
+        at: Timestamp | None = None,
     ) -> bool:
         """Replace and Update the list of relationships with this one."""
         if not isinstance(data, list):
@@ -1189,6 +1190,7 @@ class RelationshipManager:
             list_data = data
 
         await self._validate_hierarchy()
+        update_at = Timestamp(at)
 
         # Reset the list of relationship and save the previous one to see if we can reuse some
         previous_relationships = {rel.peer_id: rel for rel in await self.get_relationships(db=db) if rel.peer_id}
@@ -1211,7 +1213,7 @@ class RelationshipManager:
                 if previous_relationships:
                     if process_delete:
                         for rel in previous_relationships.values():
-                            await rel.delete(db=db, user_id=user_id)
+                            await rel.delete(db=db, at=update_at, user_id=user_id)
                     changed = True
                 continue
 
@@ -1231,7 +1233,11 @@ class RelationshipManager:
             # If the item is not present in the previous list of relationship, we create a new one.
             self._relationships.append(
                 await self.rel_class(
-                    schema=self.schema, branch=self.branch, source_kind=self.node.get_kind(), at=self.at, node=self.node
+                    schema=self.schema,
+                    branch=self.branch,
+                    source_kind=self.node.get_kind(),
+                    at=update_at,
+                    node=self.node,
                 ).new(db=db, data=item)
             )
             changed = True

infrahub/core/schema/attribute_parameters.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Self
+from typing import Any, Self
 
 from pydantic import ConfigDict, Field, model_validator
 
@@ -24,6 +24,33 @@ def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParamete
 class AttributeParameters(HashableModel):
     model_config = ConfigDict(extra="forbid")
 
+    @classmethod
+    def convert_from(cls, source: AttributeParameters) -> Self:
+        """Convert from another AttributeParameters subclass.
+
+        Args:
+            source: The source AttributeParameters instance to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        source_data = source.model_dump()
+        return cls.convert_from_dict(source_data=source_data)
+
+    @classmethod
+    def convert_from_dict(cls, source_data: dict[str, Any]) -> Self:
+        """Convert from a dictionary to the target class.
+
+        Args:
+            source_data: The source dictionary to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        target_fields = set(cls.model_fields.keys())
+        filtered_data = {k: v for k, v in source_data.items() if k in target_fields}
+        return cls(**filtered_data)
+
 
 class TextAttributeParameters(AttributeParameters):
     regex: str | None = Field(

infrahub/core/schema/attribute_schema.py

@@ -114,13 +114,20 @@ class AttributeSchema(GeneratedAttributeSchema):
     @field_validator("parameters", mode="before")
     @classmethod
     def set_parameters_type(cls, value: Any, info: ValidationInfo) -> Any:
-        """Override parameters class if using base AttributeParameters class and should be using a subclass"""
+        """Override parameters class if using base AttributeParameters class and should be using a subclass.
+
+        This validator handles parameter type conversion when an attribute's kind changes.
+        Fields from the source that don't exist in the target are silently dropped.
+        Fields with the same name in both classes are preserved.
+        """
         kind = info.data["kind"]
         expected_parameters_class = get_attribute_parameters_class_for_kind(kind=kind)
         if value is None:
             return expected_parameters_class()
         if not isinstance(value, expected_parameters_class) and isinstance(value, AttributeParameters):
-            return expected_parameters_class(**value.model_dump())
+            return expected_parameters_class.convert_from(value)
+        if isinstance(value, dict):
+            return expected_parameters_class.convert_from_dict(source_data=value)
         return value
 
     @model_validator(mode="after")

infrahub/core/schema/definitions/core/webhook.py

@@ -87,7 +87,6 @@ core_webhook = GenericSchema(
             name="validate_certificates",
             kind="Boolean",
             description="Whether to validate SSL/TLS certificates",
-            default_value=True,
             optional=True,
             order_weight=5000,
         ),

infrahub/core/schema/definitions/internal.py

@@ -182,6 +182,7 @@ class SchemaNode(BaseModel):
     display_label: str | None = None
     display_labels: list[str]
     uniqueness_constraints: list[list[str]] | None = None
+    human_friendly_id: list[str] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -199,6 +200,7 @@ class SchemaNode(BaseModel):
             "display_label": self.display_label,
             "display_labels": self.display_labels,
             "uniqueness_constraints": self.uniqueness_constraints,
+            "human_friendly_id": self.human_friendly_id,
         }
 
     def without_duplicates(self, other: SchemaNode) -> SchemaNode:
@@ -225,7 +227,6 @@ base_node_schema = SchemaNode(
     namespace="Schema",
     branch=BranchSupportType.AWARE.value,
     include_in_menu=False,
-    default_filter="name__value",
     display_labels=["label__value"],
     attributes=[
         SchemaAttribute(
@@ -239,7 +240,7 @@ base_node_schema = SchemaNode(
             name="name",
             kind="Text",
             description="Node name, must be unique within a namespace and must start with an uppercase letter.",
-            unique=True,
+            unique=False,
             regex=str(NODE_NAME_REGEX),
             min_length=DEFAULT_NAME_MIN_LENGTH,
             max_length=DEFAULT_NAME_MAX_LENGTH,
@@ -394,8 +395,9 @@ node_schema = SchemaNode(
     namespace="Schema",
     branch=BranchSupportType.AWARE.value,
     include_in_menu=False,
-    default_filter="name__value",
     display_labels=["label__value"],
+    human_friendly_id=["namespace__value", "name__value"],
+    uniqueness_constraints=[["namespace__value", "name__value"]],
     attributes=base_node_schema.attributes
     + [
         SchemaAttribute(
@@ -898,8 +900,9 @@ generic_schema = SchemaNode(
     namespace="Schema",
     branch=BranchSupportType.AWARE.value,
     include_in_menu=False,
-    default_filter="name__value",
     display_labels=["label__value"],
+    human_friendly_id=["namespace__value", "name__value"],
+    uniqueness_constraints=[["namespace__value", "name__value"]],
     attributes=base_node_schema.attributes
     + [
         SchemaAttribute(