infrahub-server 1.6.0b0__py3-none-any.whl → 1.6.2__py3-none-any.whl

infrahub/core/migrations/graph/m048_undelete_rel_props.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.migrations.graph.m041_deleted_dup_edges import DeleteDuplicatedRelationshipEdges
+from infrahub.core.migrations.shared import ArbitraryMigration, MigrationResult, get_migration_console
+from infrahub.core.query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+class UndeleteRelationshipProperties(Query):
+    """
+    Find Relationship vertices that are missing IS_VISIBLE and/or IS_PROTECTED edges linking them to Boolean vertices
+
+    Use the existing IS_RELATED edges to determine when the IS_VISIBLE/IS_PROTECTED edges should exist on each branch
+    and add the missing edges
+
+    Sets IS_VISIBLE to TRUE and IS_PROTECTED to FALSE
+    """
+
+    name = "undelete_relationship_properties"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        query = """
+// --------------
+// find all Relationships that are missing IS_VISIBLE/IS_PROTECTED edges
+// --------------
+MATCH (rel:Relationship)-[:IS_RELATED]-()
+WHERE NOT exists((rel)-[:IS_VISIBLE]->())
+OR NOT exists((rel)-[:IS_PROTECTED]->())
+WITH DISTINCT rel
+WITH rel, exists((rel)-[:IS_VISIBLE]->()) AS has_visible, exists((rel)-[:IS_PROTECTED]->()) AS has_protected
+WHERE has_visible = FALSE OR has_protected = FALSE
+
+// --------------
+// one row for each branch the Relationship has changes on
+// --------------
+CALL (rel) {
+    MATCH (rel)-[e:IS_RELATED]-()
+    RETURN DISTINCT e.branch AS branch
+}
+
+// --------------
+// get the earliest from edge on this branch, if any
+// --------------
+CALL (rel, branch) {
+    OPTIONAL MATCH (rel)-[e:IS_RELATED {status: "active", branch: branch}]-()
+    // ignore schema kind/inheritance migration edges
+    WHERE NOT exists((rel)-[:IS_RELATED {status: "deleted", branch: branch, from: e.from}]-())
+    RETURN e AS earliest_from_edge
+    ORDER BY e.from ASC
+    LIMIT 1
+}
+
+// --------------
+// get the latest to time on this branch, if any
+// --------------
+CALL (rel, branch) {
+    OPTIONAL MATCH (rel)-[e:IS_RELATED {status: "active", branch: branch}]-()
+    // ignore schema kind/inheritance migration edges
+    WHERE NOT exists((rel)-[:IS_RELATED {status: "active", branch: branch, from: e.to}]-())
+    RETURN e.to AS latest_to_time
+    ORDER BY e.to DESC
+    LIMIT 1
+}
+
+// --------------
+// get the latest deleted edge on this branch, if any
+// --------------
+CALL (rel, branch) {
+    OPTIONAL MATCH (rel)-[deleted_e:IS_RELATED {status: "deleted", branch: branch}]-()
+    // ignore schema kind/inheritance migration edges
+    WHERE NOT exists((rel)-[:IS_RELATED {status: "active", branch: branch, from: deleted_e.from}]-())
+    RETURN deleted_e AS latest_deleted_edge
+    ORDER BY deleted_e.from DESC
+    LIMIT 1
+}
+
+// --------------
+// add active IS_VISIBLE edge on the branch, if necessary
+// --------------
+CALL (rel, earliest_from_edge, latest_to_time, has_visible) {
+    WITH *, has_visible
+    WHERE has_visible = FALSE
+    AND earliest_from_edge IS NOT NULL
+    MERGE (bool:Boolean {value: TRUE})
+    CREATE (rel)-[new_edge:IS_VISIBLE]->(bool)
+    SET new_edge = properties(earliest_from_edge)
+    SET new_edge.to = latest_to_time
+}
+// --------------
+// add deleted IS_VISIBLE edge on the branch, if necessary
+// --------------
+CALL (rel, latest_deleted_edge, has_visible) {
+    WITH *, has_visible
+    WHERE has_visible = FALSE
+    AND latest_deleted_edge IS NOT NULL
+    MERGE (bool:Boolean {value: TRUE})
+    CREATE (rel)-[new_edge:IS_VISIBLE]->(bool)
+    SET new_edge = properties(latest_deleted_edge)
+}
+// --------------
+// add active IS_PROTECTED edge on the branch, if necessary
+// --------------
+CALL (rel, earliest_from_edge, latest_to_time, has_protected) {
+    WITH *, has_protected
+    WHERE has_protected = FALSE
+    AND earliest_from_edge IS NOT NULL
+    MERGE (bool:Boolean {value: FALSE})
+    CREATE (rel)-[new_edge:IS_PROTECTED]->(bool)
+    SET new_edge = properties(earliest_from_edge)
+    SET new_edge.to = latest_to_time
+}
+// --------------
+// add deleted IS_PROTECTED edge on the branch, if necessary
+// --------------
+CALL (rel, latest_deleted_edge, has_protected) {
+    WITH *, has_protected
+    WHERE has_protected = FALSE
+    AND latest_deleted_edge IS NOT NULL
+    MERGE (bool:Boolean {value: FALSE})
+    CREATE (rel)-[new_edge:IS_PROTECTED]->(bool)
+    SET new_edge = properties(latest_deleted_edge)
+}
+        """
+        self.add_to_query(query)
+
+
+class Migration048(ArbitraryMigration):
+    """
+    Fix Relationship vertices that are missing IS_VISIBLE and/or IS_PROTECTED edges.
+
+    This can happen due to a bug in Migration041 that deleted these edges incorrectly.
+    """
+
+    name: str = "048_undelete_rel_props"
+    minimum_version: int = 47
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        console = get_migration_console()
+
+        console.log("Deleting duplicate edges for all Relationships", end="...")
+        delete_duplicate_edges_query = await DeleteDuplicatedRelationshipEdges.init(
+            db=db, migrated_kind_nodes_only=False
+        )
+        await delete_duplicate_edges_query.execute(db=db)
+        console.log("done")
+
+        console.log("Undeleting Relationship properties", end="...")
+        undelete_rel_props_query = await UndeleteRelationshipProperties.init(db=db)
+        await undelete_rel_props_query.execute(db=db)
+        console.log("done")
+
+        return MigrationResult()

infrahub/core/models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import hashlib
 from typing import TYPE_CHECKING, Any
 
@@ -359,7 +360,7 @@ class SchemaUpdateValidationResult(BaseModel):
 
     def validate_migrations(self, migration_map: dict[str, Any]) -> None:
         for migration in self.migrations:
-            if migration_map.get(migration.migration_name, None) is None:
+            if migration_map.get(migration.migration_name) is None:
                 self.errors.append(
                     SchemaUpdateValidationError(
                         path=migration.path,
@@ -370,7 +371,7 @@ class SchemaUpdateValidationResult(BaseModel):
 
     def validate_constraints(self, validator_map: dict[str, Any]) -> None:
         for constraint in self.constraints:
-            if validator_map.get(constraint.constraint_name, None) is None:
+            if validator_map.get(constraint.constraint_name) is None:
                 self.errors.append(
                     SchemaUpdateValidationError(
                         path=constraint.path,
@@ -578,11 +579,9 @@ class HashableModel(BaseModel):
 
         for field_name in other.model_fields.keys():
             if not hasattr(self, field_name):
-                try:
-                    setattr(self, field_name, getattr(other, field_name))
-                except ValueError:
+                with contextlib.suppress(ValueError):
                     # handles the case where self and other are different types and other has fields that self does not
-                    pass
+                    setattr(self, field_name, getattr(other, field_name))
                 continue
 
             attr_other = getattr(other, field_name)

infrahub/core/node/__init__.py

@@ -170,7 +170,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return self._human_friendly_id is not None
 
     async def add_human_friendly_id(self, db: InfrahubDatabase) -> None:
-        if not self._schema.human_friendly_id or self._human_friendly_id:
+        if self._human_friendly_id:
             return
 
         self._human_friendly_id = HumanFriendlyIdentifier(
@@ -179,11 +179,8 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         await self._human_friendly_id.compute(db=db, node=self)
 
     async def get_display_label(self, db: InfrahubDatabase) -> str:
-        if self._display_label:
-            if isinstance(self._display_label._value, str):
-                return self._display_label._value
-            if self._display_label._value:
-                return self._display_label._value.value
+        if self._display_label and (value := self._display_label.get_value(node=self, at=self._at)):
+            return value
 
         return await self.render_display_label(db=db)
 
@@ -191,7 +188,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return self._display_label is not None
 
     async def add_display_label(self, db: InfrahubDatabase) -> None:
-        if not self._schema.display_label or self._display_label:
+        if self._display_label:
             return
 
         self._display_label = DisplayLabel(node_schema=self._schema, template=self._schema.display_label)
@@ -467,15 +464,21 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         for attribute_name in template._attributes:
             if attribute_name in list(fields) + [OBJECT_TEMPLATE_NAME_ATTR]:
                 continue
-            attr_value = getattr(template, attribute_name).value
+            attr = getattr(template, attribute_name)
+            attr_value = attr.value
             if attr_value is not None:
-                fields[attribute_name] = {"value": attr_value, "source": template.id}
+                # Preserve is_from_profile flag when copying from template
+                field_data = {"value": attr_value, "source": attr.source_id or template.id}
+                if attr.is_from_profile:
+                    field_data["is_from_profile"] = True
+                fields[attribute_name] = field_data
 
         for relationship_name in template._relationships:
             relationship_schema = template._schema.get_relationship(name=relationship_name)
             if (
                 relationship_name in list(fields)
-                or relationship_schema.kind not in [RelationshipKind.ATTRIBUTE, RelationshipKind.GENERIC]
+                or relationship_schema.kind
+                not in [RelationshipKind.ATTRIBUTE, RelationshipKind.GENERIC, RelationshipKind.PROFILE]
                 or relationship_name == OBJECT_TEMPLATE_RELATIONSHIP_NAME
             ):
                 continue
@@ -570,7 +573,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     self,
                     rel_schema.name,
                     await generator_method(
-                        db=db, name=rel_schema.name, schema=rel_schema, data=fields.get(rel_schema.name, None)
+                        db=db, name=rel_schema.name, schema=rel_schema, data=fields.get(rel_schema.name)
                     ),
                 )
             except ValidationError as exc:
@@ -600,7 +603,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     self,
                     attr_schema.name,
                     await generator_method(
-                        db=db, name=attr_schema.name, schema=attr_schema, data=fields.get(attr_schema.name, None)
+                        db=db, name=attr_schema.name, schema=attr_schema, data=fields.get(attr_schema.name)
                     ),
                 )
                 if not self._existing:
@@ -1088,7 +1091,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
             if key in self._relationships:
                 rel: RelationshipManager = getattr(self, key)
-                changed |= await rel.update(db=db, data=value)
+                changed |= await rel.update(db=db, data=value, process_delete=process_pools)
 
         return changed
 

infrahub/core/node/create.py

@@ -58,18 +58,34 @@ async def extract_peer_data(
             except ValueError:
                 pass
 
-        obj_peer_data[attr_name] = {"value": template_attr.value, "source": template_peer.id}
+        # If the template attribute comes from a profile, preserve the profile as the source
+        # Otherwise, use the template itself as the source
+        source_id = template_attr.source_id or template_peer.id
+        attr_data = {"value": template_attr.value, "source": source_id}
+        if template_attr.is_from_profile:
+            attr_data["is_from_profile"] = True
+        obj_peer_data[attr_name] = attr_data
 
     for rel in template_peer.get_schema().relationship_names:
         rel_manager: RelationshipManager = getattr(template_peer, rel)
-
-        if rel_manager.schema.name not in obj_peer_schema.relationship_names:
+        if (
+            rel_manager.schema.kind
+            not in [
+                RelationshipKind.COMPONENT,
+                RelationshipKind.PARENT,
+                RelationshipKind.PROFILE,
+                RelationshipKind.ATTRIBUTE,
+            ]
+            or rel_manager.schema.name not in obj_peer_schema.relationship_names
+        ):
             continue
 
         peers_map = await rel_manager.get_peers(db=db)
-        if rel_manager.schema.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT] and list(
-            peers_map.keys()
-        ) == [current_template.id]:
+        if rel_manager.schema.kind in [
+            RelationshipKind.COMPONENT,
+            RelationshipKind.PARENT,
+            RelationshipKind.PROFILE,
+        ] and list(peers_map.keys()) == [current_template.id]:
             obj_peer_data[rel] = {"id": parent_obj.id}
             continue
 
@@ -80,7 +96,13 @@ async def extract_peer_data(
                 continue
             rel_peer_ids.append({"id": peer_id})
 
-        obj_peer_data[rel] = rel_peer_ids
+        # Only set the relationship data if there are actual peers to set
+        if rel_peer_ids:
+            obj_peer_data[rel] = rel_peer_ids
+
+        if rel_manager.schema.kind == RelationshipKind.PROFILE:
+            profiles = list(await rel_manager.get_peers(db=db))
+            obj_peer_data[rel] = profiles
 
     return obj_peer_data
 
@@ -125,6 +147,12 @@ async def handle_template_relationships(
             await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
             await obj_peer.save(db=db)
 
+            template_profile_ids = await get_profile_ids(db=db, obj=template_relationship_peer)
+            if template_profile_ids:
+                node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+                await node_profiles_applier.apply_profiles(node=obj_peer)
+                await obj_peer.save(db=db)
+
             await handle_template_relationships(
                 db=db,
                 branch=branch,
@@ -136,7 +164,7 @@ async def handle_template_relationships(
             )
 
 
-async def get_profile_ids(db: InfrahubDatabase, obj: Node) -> set[str]:
+async def get_profile_ids(db: InfrahubDatabase, obj: Node | CoreObjectTemplate) -> set[str]:
     if not hasattr(obj, "profiles"):
         return set()
     profile_rels = await obj.profiles.get_relationships(db=db)

infrahub/core/node/proposed_change.py

@@ -1,11 +1,13 @@
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
 from infrahub.core.constants.infrahubkind import THREADCOMMENT
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
-from infrahub.core.protocols import CoreProposedChange as CoreProposedChangeProtocol
 from infrahub.database import InfrahubDatabase
 
+if TYPE_CHECKING:
+    from infrahub.core.protocols import CoreProposedChange as CoreProposedChangeProtocol
+
 
 class CoreProposedChange(Node):
     async def to_graphql(
@@ -29,7 +31,7 @@ class CoreProposedChange(Node):
         if fields:
             if "total_comments" in fields:
                 total_comments = 0
-                proposed_change = cast(CoreProposedChangeProtocol, self)
+                proposed_change = cast("CoreProposedChangeProtocol", self)
                 change_comments = await proposed_change.comments.get_relationships(db=db)
                 total_comments += len(change_comments)
 

infrahub/core/node/standard.py

@@ -72,7 +72,7 @@ class StandardNode(BaseModel):
         response: dict[str, Any] = {"id": self.uuid}
 
         for field_name in fields.keys():
-            if field_name in ["id"]:
+            if field_name == "id":
                 continue
             if field_name == "__typename":
                 response[field_name] = self.get_type()

infrahub/core/protocols.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Protocol, runtime_checkable
+from typing import TYPE_CHECKING
 
 from infrahub.core.protocols_base import CoreNode
 
@@ -16,22 +16,16 @@ if TYPE_CHECKING:
         DateTime,
         DateTimeOptional,
         Dropdown,
-        DropdownOptional,
         HashedPassword,
-        HashedPasswordOptional,
         Integer,
         IntegerOptional,
         IPHost,
-        IPHostOptional,
         IPNetwork,
-        IPNetworkOptional,
         JSONAttribute,
         JSONAttributeOptional,
-        ListAttribute,
         ListAttributeOptional,
         String,
         StringOptional,
-        URLOptional,
     )
     from infrahub.core.relationship import RelationshipManager
 

infrahub/core/query/attribute.py

@@ -373,7 +373,7 @@ async def default_attribute_query_filter(
         if property_name not in [v.value for v in NodeProperty]:
             raise ValueError(f"filter {filter_name}: {filter_value}, {property_name} is not a valid property")
 
-        if property_attr not in ["id"]:
+        if property_attr != "id":
             raise ValueError(f"filter {filter_name}: {filter_value}, {property_attr} is supported")
 
         clean_filter_name = f"{property_name}_{property_attr}"

infrahub/core/query/node.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from collections import defaultdict
 from copy import copy
 from dataclasses import dataclass
@@ -12,6 +13,7 @@ from infrahub.core import registry
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
     PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
+    PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
     AttributeDBNodeType,
     RelationshipDirection,
     RelationshipHierarchyDirection,
@@ -623,7 +625,8 @@ class NodeListGetAttributeQuery(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
-        self.params["profile_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
+        self.params["profile_node_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
+        self.params["profile_template_relationship_name"] = PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
             at=self.at, branch_agnostic=self.branch_agnostic
@@ -632,7 +635,10 @@ class NodeListGetAttributeQuery(Query):
 
         query = """
         MATCH (n:Node) WHERE n.uuid IN $ids
-        WITH n, exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_relationship_name})) AS might_use_profile
+        WITH n, (
+            exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_node_relationship_name})) OR
+            exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_template_relationship_name}))
+        ) AS might_use_profile
         MATCH (n)-[:HAS_ATTRIBUTE]-(a:Attribute)
         """
         if self.fields:
@@ -1134,10 +1140,8 @@ class NodeGetListQuery(Query):
             self._variables_to_track.append(variable)
 
     def _untrack_variable(self, variable: str) -> None:
-        try:
+        with contextlib.suppress(ValueError):
             self._variables_to_track.remove(variable)
-        except ValueError:
-            ...
 
     def _get_tracked_variables(self) -> list[str]:
         return self._variables_to_track

infrahub/core/relationship/model.py

@@ -912,6 +912,8 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: type[PeerType],
         branch_agnostic: bool = ...,
+        include_source: bool = ...,
+        include_owner: bool = ...,
     ) -> Mapping[str, PeerType]: ...
 
     @overload
@@ -920,6 +922,8 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: None = None,
         branch_agnostic: bool = ...,
+        include_source: bool = ...,
+        include_owner: bool = ...,
     ) -> Mapping[str, Node]: ...
 
     async def get_peers(
@@ -927,11 +931,18 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: type[PeerType] | None = None,  # noqa: ARG002
         branch_agnostic: bool = False,
+        include_source: bool = False,
+        include_owner: bool = False,
     ) -> Mapping[str, Node | PeerType]:
         rels = await self.get_relationships(db=db, branch_agnostic=branch_agnostic)
         peer_ids = [rel.peer_id for rel in rels if rel.peer_id]
         nodes = await registry.manager.get_many(
-            db=db, ids=peer_ids, branch=self.branch, branch_agnostic=branch_agnostic
+            db=db,
+            ids=peer_ids,
+            branch=self.branch,
+            branch_agnostic=branch_agnostic,
+            include_source=include_source,
+            include_owner=include_owner,
         )
         return nodes
 
@@ -1061,7 +1072,12 @@ class RelationshipManager:
 
         return self._relationships.as_list()
 
-    async def update(self, data: list[str | Node] | dict[str, Any] | str | Node | None, db: InfrahubDatabase) -> bool:
+    async def update(
+        self,
+        data: list[str | Node] | dict[str, Any] | str | Node | None,
+        db: InfrahubDatabase,
+        process_delete: bool = True,
+    ) -> bool:
         """Replace and Update the list of relationships with this one."""
         if not isinstance(data, list):
             list_data: Sequence[str | Node | dict[str, Any] | None] = [data]
@@ -1087,8 +1103,9 @@ class RelationshipManager:
 
             if item is None:
                 if previous_relationships:
-                    for rel in previous_relationships.values():
-                        await rel.delete(db=db)
+                    if process_delete:
+                        for rel in previous_relationships.values():
+                            await rel.delete(db=db)
                     changed = True
                 continue
 

infrahub/core/schema/generic_schema.py

@@ -51,4 +51,4 @@ class GenericSchema(GeneratedGenericSchema):
     def _get_field_names_for_diff(self) -> list[str]:
         """Exclude used_by from the diff for generic nodes"""
         fields = super()._get_field_names_for_diff()
-        return [field for field in fields if field not in ["used_by"]]
+        return [field for field in fields if field != "used_by"]

infrahub/core/schema/manager.py

@@ -774,10 +774,15 @@ class SchemaManager(NodeManager):
         """Return non active branches that were purged."""
 
         hashes_to_keep: set[str] = set()
+        branch_processed: set[str] = set()
         for active_branch in active_branches:
-            if branch := self._branches.get(active_branch):
-                nodes = branch.get_all(include_internal=True, duplicate=False)
-                hashes_to_keep.update([node.get_hash() for node in nodes.values()])
+            branch_hash = self._branch_hash_by_name.get(active_branch)
+            if not branch_hash or branch_hash not in branch_processed:
+                if branch_hash:
+                    branch_processed.add(branch_hash)
+                if branch := self._branches.get(active_branch):
+                    nodes = branch.get_all(include_internal=True, duplicate=False)
+                    hashes_to_keep.update([node.get_hash() for node in nodes.values()])
 
         removed_branches: list[str] = []
         for branch_name in list(self._branches.keys()):