infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub/core/relationship/model.py

@@ -381,14 +381,33 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
 
         node = await self.get_node(db=db)
 
+        flag_properties_to_update = {}
+        for prop_name in self._flag_properties:
+            if prop_name not in properties_to_update:
+                continue
+            value = getattr(self, prop_name)
+            if value is not None:
+                flag_properties_to_update[prop_name] = value
+
+        node_properties_to_update = {}
+        for prop_name in self._node_properties:
+            if prop_name not in properties_to_update:
+                continue
+            if value := getattr(self, f"{prop_name}_id"):
+                node_properties_to_update[prop_name] = value
+
+        if not flag_properties_to_update and not node_properties_to_update:
+            return
+
         query = await RelationshipUpdatePropertyQuery.init(
             db=db,
+            branch=branch,
             source=node,
             rel=self,
-            properties_to_update=properties_to_update,
-            data=data,
-            branch=branch,
             at=update_at,
+            flag_properties_to_update=flag_properties_to_update,
+            node_properties_to_update=node_properties_to_update,
+            rel_node_id=data.rel_node_id,
         )
         await query.execute(db=db)
 
@@ -440,7 +459,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
                 self.set_peer(value=peer)
 
         if not self.peer_id and self.peer_hfid:
-            peer_schema = db.schema.get(name=self.schema.peer, branch=self.branch)
+            peer_schema = db.schema.get(name=self.schema.peer, branch=self.branch, duplicate=False)
             kind = (
                 self.data["kind"]
                 if isinstance(self.data, dict) and "kind" in self.data and peer_schema.is_generic_schema
@@ -570,7 +589,9 @@ class RelationshipValidatorList:
         ValidationError: If the number of relationships is not within the min and max count.
     """
 
-    def __init__(self, *relationships: Relationship, name: str, min_count: int = 0, max_count: int = 0) -> None:
+    def __init__(
+        self, *relationships: Relationship, name: str, min_count: int | None = 0, max_count: int | None = 0
+    ) -> None:
         """Initialize list for Relationship but with validation against min/max count.
 
         Args:
@@ -580,8 +601,14 @@ class RelationshipValidatorList:
         Raises:
             ValidationError: The number of relationships is not within the min and max count.
         """
-        if max_count < min_count:
+        if max_count is not None and min_count is not None and max_count < min_count:
             raise ValidationError({"msg": "max_count must be greater than min_count"})
+
+        if max_count is None:
+            max_count = 0
+        if min_count is None:
+            min_count = 0
+
         self.min_count: int = min_count
         self.max_count: int = max_count
         self.name = name
@@ -726,15 +753,22 @@ class RelationshipManager:
         # TODO Ideally this information should come from the Schema
         self.rel_class = Relationship
 
-        self._relationships: RelationshipValidatorList = RelationshipValidatorList(
-            name=self.schema.name,
-            min_count=0 if self.schema.optional else self.schema.min_count,
-            max_count=self.schema.max_count,
-        )
+        self._relationships: RelationshipValidatorList = self._get_init_relationships()
         self._relationship_id_details: RelationshipUpdateDetails | None = None
         self.has_fetched_relationships: bool = False
         self.lock = asyncio.Lock()
 
+    def _get_init_relationships(self) -> RelationshipValidatorList:
+        min_count = self.schema.min_count
+        max_count: int | None = self.schema.max_count if self.schema.max_count > 0 else None
+        if self.schema.optional:
+            min_count = 0
+        return RelationshipValidatorList(
+            name=self.schema.name,
+            min_count=min_count,
+            max_count=max_count,
+        )
+
     @classmethod
     async def init(
         cls,
@@ -909,6 +943,19 @@ class RelationshipManager:
             return registry.get_global_branch()
         return self.branch
 
+    async def get_db_peers(
+        self, db: InfrahubDatabase, at: Timestamp | None = None, branch_agnostic: bool = False
+    ) -> list[RelationshipPeerData]:
+        query = await RelationshipGetPeerQuery.init(
+            db=db,
+            source=self.node,
+            at=at or self.at,
+            rel=self.rel_class(schema=self.schema, branch=self.branch, node=self.node),
+            branch_agnostic=branch_agnostic,
+        )
+        await query.execute(db=db)
+        return list(query.get_peers())
+
     async def fetch_relationship_ids(
         self,
         db: InfrahubDatabase,
@@ -926,16 +973,9 @@ class RelationshipManager:
 
         current_peer_ids = [rel.get_peer_id() for rel in self._relationships]
 
-        query = await RelationshipGetPeerQuery.init(
-            db=db,
-            source=self.node,
-            at=at or self.at,
-            rel=self.rel_class(schema=self.schema, branch=self.branch, node=self.node),
-            branch_agnostic=branch_agnostic,
-        )
-        await query.execute(db=db)
+        peers = await self.get_db_peers(db=db, at=at, branch_agnostic=branch_agnostic)
 
-        peers_database: dict = {str(peer.peer_id): peer for peer in query.get_peers()}
+        peers_database: dict = {str(peer.peer_id): peer for peer in peers}
         peer_ids = list(peers_database.keys())
 
         # Calculate which peer should be added or removed

infrahub/core/schema/attribute_schema.py

@@ -202,7 +202,6 @@ class AttributeSchema(GeneratedAttributeSchema):
         param_prefix: str | None = None,
         db: InfrahubDatabase | None = None,
         partial_match: bool = False,
-        support_profiles: bool = False,
     ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
         if self.enum:
             filter_value = self.convert_enum_to_value(filter_value)
@@ -217,7 +216,6 @@ class AttributeSchema(GeneratedAttributeSchema):
             param_prefix=param_prefix,
             db=db,
             partial_match=partial_match,
-            support_profiles=support_profiles,
         )
 
 

infrahub/core/schema/basenode_schema.py

@@ -9,7 +9,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, overload
 
 from infrahub_sdk.utils import compare_lists, intersection
-from pydantic import field_validator
+from pydantic import ConfigDict, field_validator
 
 from infrahub.core.constants import HashableModelState, RelationshipCardinality, RelationshipKind
 from infrahub.core.models import HashableModel, HashableModelDiff
@@ -19,6 +19,7 @@ from .generated.base_node_schema import GeneratedBaseNodeSchema
 from .relationship_schema import RelationshipSchema
 
 if TYPE_CHECKING:
+    from pydantic.config import JsonDict
     from typing_extensions import Self
 
     from infrahub.core.schema import GenericSchema, NodeSchema
@@ -26,6 +27,7 @@ if TYPE_CHECKING:
 
 
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
+NODE_PROPERTY_ATTRIBUTES = ["display_label", "human_friendly_id"]
 INHERITED = "INHERITED"
 
 OPTIONAL_TEXT_FIELDS = [
@@ -39,10 +41,43 @@ OPTIONAL_TEXT_FIELDS = [
 ]
 
 
+def _json_schema_extra(schema: JsonDict) -> None:
+    """
+    Mutate the generated JSON Schema in place to:
+      - allow `null` for `display_labels`
+      - mark the non-null branch as deprecated
+    """
+    props = schema.get("properties")
+    if not isinstance(props, dict):
+        return
+    dl = props.get("display_labels")
+    if not isinstance(dl, dict):
+        return
+
+    if "anyOf" in dl:
+        dl["anyOf"] = [
+            {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "deprecationMessage": "display_labels are deprecated use display_label instead",
+                },
+            },
+            {"type": "null"},
+        ]
+
+
 class BaseNodeSchema(GeneratedBaseNodeSchema):
     _exclude_from_hash: list[str] = ["attributes", "relationships"]
     _sort_by: list[str] = ["namespace", "name"]
 
+    model_config = ConfigDict(extra="forbid", json_schema_extra=_json_schema_extra)
+
+    @property
+    def is_schema_node(self) -> bool:
+        """Tell if this node represent a part of the schema. Not to confuse this with `is_node_schema`."""
+        return self.namespace == "Schema"
+
     @property
     def is_node_schema(self) -> bool:
         return False
@@ -240,6 +275,11 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         return None
 
     def get_attribute(self, name: str) -> AttributeSchema:
+        if name == "human_friendly_id":
+            return AttributeSchema(name="human_friendly_id", kind="List", optional=True, branch=self.branch)
+        if name == "display_label":
+            return AttributeSchema(name="display_label", kind="Text", optional=True, branch=self.branch)
+
         for item in self.attributes:
             if item.name == name:
                 return item
@@ -329,7 +369,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
     @property
     def valid_input_names(self) -> list[str]:
-        return self.attribute_names + self.relationship_names + NODE_METADATA_ATTRIBUTES
+        return self.attribute_names + self.relationship_names + NODE_METADATA_ATTRIBUTES + NODE_PROPERTY_ATTRIBUTES
 
     @property
     def valid_local_names(self) -> list[str]:

infrahub/core/schema/definitions/core/__init__.py

@@ -29,6 +29,7 @@ from .core import core_node, core_task_target
 from .generator import core_generator_definition, core_generator_instance
 from .graphql_query import core_graphql_query
 from .group import (
+    core_generator_aware_group,
     core_generator_group,
     core_graphql_query_group,
     core_group,
@@ -128,6 +129,7 @@ core_models_mixed: dict[str, list] = {
         core_group_action,
         core_standard_group,
         core_generator_group,
+        core_generator_aware_group,
         core_graphql_query_group,
         core_repository_group,
         builtin_tag,

infrahub/core/schema/definitions/core/generator.py

@@ -33,6 +33,8 @@ core_generator_definition = NodeSchema(
         Attr(name="file_path", kind="Text"),
         Attr(name="class_name", kind="Text"),
         Attr(name="convert_query_response", kind="Boolean", optional=True, default_value=False),
+        Attr(name="execute_in_proposed_change", kind="Boolean", optional=True, default_value=True),
+        Attr(name="execute_after_merge", kind="Boolean", optional=True, default_value=True),
     ],
     relationships=[
         Rel(

infrahub/core/schema/definitions/core/group.py

@@ -70,10 +70,10 @@ core_standard_group = NodeSchema(
 core_generator_group = NodeSchema(
     name="GeneratorGroup",
     namespace="Core",
-    description="Group of nodes that are created by a generator.",
+    description="Group of nodes that are created by a generator. (local)",
     include_in_menu=False,
     icon="mdi:state-machine",
-    label="Generator Group",
+    label="Generator Group (local)",
     default_filter="name__value",
     order_by=["name__value"],
     display_labels=["name__value"],
@@ -82,6 +82,20 @@ core_generator_group = NodeSchema(
     generate_profile=False,
 )
 
+core_generator_aware_group = NodeSchema(
+    name="GeneratorAwareGroup",
+    namespace="Core",
+    description="Group of nodes that are created by a generator. (Aware)",
+    include_in_menu=False,
+    icon="mdi:state-machine",
+    label="Generator Group (aware)",
+    default_filter="name__value",
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AWARE,
+    inherit_from=[InfrahubKind.GENERICGROUP],
+    generate_profile=False,
+)
 
 core_graphql_query_group = NodeSchema(
     name="GraphQLQueryGroup",

infrahub/core/schema/definitions/core/repository.py

@@ -282,5 +282,12 @@ core_generic_repository = GenericSchema(
             cardinality=Cardinality.MANY,
             order_weight=12000,
         ),
+        Rel(
+            name="groups_objects",
+            peer=InfrahubKind.REPOSITORYGROUP,
+            optional=True,
+            cardinality=Cardinality.MANY,
+            order_weight=13000,
+        ),
     ],
 )

infrahub/core/schema/definitions/internal.py

@@ -179,7 +179,9 @@ class SchemaNode(BaseModel):
     default_filter: str | None = None
     attributes: list[SchemaAttribute]
     relationships: list[SchemaRelationship]
+    display_label: str | None = None
     display_labels: list[str]
+    uniqueness_constraints: list[list[str]] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -194,7 +196,9 @@ class SchemaNode(BaseModel):
                 if attribute.name not in ["id", "attributes", "relationships"]
             ],
             "relationships": [relationship.to_dict() for relationship in self.relationships],
+            "display_label": self.display_label,
             "display_labels": self.display_labels,
+            "uniqueness_constraints": self.uniqueness_constraints,
         }
 
     def without_duplicates(self, other: SchemaNode) -> SchemaNode:
@@ -292,11 +296,18 @@ base_node_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},
         ),
+        SchemaAttribute(
+            name="display_label",
+            kind="Text",
+            description="Attribute or Jinja2 template to use to generate the display label",
+            optional=True,
+            extra={"update": UpdateSupport.ALLOWED},
+        ),
         SchemaAttribute(
             name="display_labels",
             kind="List",
             internal_kind=str,
-            description="List of attributes to use to generate the display label",
+            description="List of attributes to use to generate the display label (deprecated)",
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},
         ),
@@ -465,6 +476,7 @@ attribute_schema = SchemaNode(
     include_in_menu=False,
     default_filter=None,
     display_labels=["name__value"],
+    uniqueness_constraints=[["name__value", "node"]],
     attributes=[
         SchemaAttribute(
             name="id",
@@ -669,6 +681,7 @@ relationship_schema = SchemaNode(
     include_in_menu=False,
     default_filter=None,
     display_labels=["name__value"],
+    uniqueness_constraints=[["name__value", "node"]],
     attributes=[
         SchemaAttribute(
             name="id",

infrahub/core/schema/generated/base_node_schema.py

@@ -58,9 +58,14 @@ class GeneratedBaseNodeSchema(HashableModel):
         description="Human friendly and unique identifier for the object.",
         json_schema_extra={"update": "allowed"},
     )
+    display_label: str | None = Field(
+        default=None,
+        description="Attribute or Jinja2 template to use to generate the display label",
+        json_schema_extra={"update": "allowed"},
+    )
     display_labels: list[str] | None = Field(
         default=None,
-        description="List of attributes to use to generate the display label",
+        description="List of attributes to use to generate the display label (deprecated)",
         json_schema_extra={"update": "allowed"},
     )
     include_in_menu: bool | None = Field(

infrahub/core/schema/node_schema.py

@@ -90,6 +90,7 @@ class NodeSchema(GeneratedNodeSchema):
 
         properties_to_inherit = [
             "human_friendly_id",
+            "display_label",
             "display_labels",
             "default_filter",
             "menu_placement",
@@ -129,10 +130,12 @@ class NodeSchema(GeneratedNodeSchema):
                 item_idx = existing_inherited_relationships[relationship.name]
                 self.relationships[item_idx].update_from_generic(other=new_relationship)
 
-    def get_hierarchy_schema(self, db: InfrahubDatabase, branch: Branch | str | None = None) -> GenericSchema:
+    def get_hierarchy_schema(
+        self, db: InfrahubDatabase, branch: Branch | str | None = None, duplicate: bool = False
+    ) -> GenericSchema:
         if not self.hierarchy:
             raise ValueError("The node is not part of a hierarchy")
-        schema = db.schema.get(name=self.hierarchy, branch=branch)
+        schema = db.schema.get(name=self.hierarchy, branch=branch, duplicate=duplicate)
         if not isinstance(schema, GenericSchema):
             raise TypeError
         return schema

infrahub/core/schema/relationship_schema.py

@@ -91,7 +91,6 @@ class RelationshipSchema(GeneratedRelationshipSchema):
         include_match: bool = True,
         param_prefix: str | None = None,
         partial_match: bool = False,
-        support_profiles: bool = False,  # noqa: ARG002
     ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
         """Generate Query String Snippet to filter the right node."""
 

infrahub/core/schema/schema_branch.py

@@ -18,6 +18,7 @@ from infrahub.computed_attribute.constants import VALID_KINDS as VALID_COMPUTED_
 from infrahub.core.constants import (
     OBJECT_TEMPLATE_NAME_ATTR,
     OBJECT_TEMPLATE_RELATIONSHIP_NAME,
+    PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
     RESERVED_ATTR_GEN_NAMES,
     RESERVED_ATTR_REL_NAMES,
     RESTRICTED_NAMESPACES,
@@ -65,6 +66,8 @@ from ... import config
 from ..constants.schema import PARENT_CHILD_IDENTIFIER
 from .constants import INTERNAL_SCHEMA_NODE_KINDS, SchemaNamespace
 from .schema_branch_computed import ComputedAttributes
+from .schema_branch_display import DisplayLabels
+from .schema_branch_hfid import HFIDs
 
 log = get_logger()
 
@@ -76,6 +79,8 @@ class SchemaBranch:
         name: str | None = None,
         data: dict[str, dict[str, str]] | None = None,
         computed_attributes: ComputedAttributes | None = None,
+        display_labels: DisplayLabels | None = None,
+        hfids: HFIDs | None = None,
     ):
         self._cache: dict[str, NodeSchema | GenericSchema] = cache
         self.name: str | None = name
@@ -84,6 +89,8 @@ class SchemaBranch:
         self.profiles: dict[str, str] = {}
         self.templates: dict[str, str] = {}
         self.computed_attributes = computed_attributes or ComputedAttributes()
+        self.display_labels = display_labels or DisplayLabels()
+        self.hfids = hfids or HFIDs()
 
         if data:
             self.nodes = data.get("nodes", {})
@@ -269,6 +276,8 @@ class SchemaBranch:
             data=copy.deepcopy(self.to_dict()),
             cache=self._cache,
             computed_attributes=self.computed_attributes.duplicate(),
+            display_labels=self.display_labels.duplicate(),
+            hfids=self.hfids.duplicate(),
         )
 
     def set(self, name: str, schema: MainSchemaTypes) -> str:
@@ -503,6 +512,9 @@ class SchemaBranch:
         self.process_post_validation()
 
     def process_pre_validation(self) -> None:
+        self.process_nodes_state()
+        self.process_attributes_state()
+        self.process_relationships_state()
         self.generate_identifiers()
         self.process_default_values()
         self.process_deprecations()
@@ -528,6 +540,7 @@ class SchemaBranch:
         self.validate_identifiers()
         self.sync_uniqueness_constraints_and_unique_attributes()
         self.validate_uniqueness_constraints()
+        self.validate_display_label()
         self.validate_display_labels()
         self.validate_order_by()
         self.validate_default_filters()
@@ -751,6 +764,35 @@ class SchemaBranch:
                         element_name=element_name,
                     )
 
+    def validate_display_label(self) -> None:
+        self.display_labels = DisplayLabels()
+        for name in self.all_names:
+            node_schema = self.get(name=name, duplicate=False)
+
+            if node_schema.display_label is None and node_schema.display_labels:
+                update_candidate = self.get(name=name, duplicate=True)
+                if len(node_schema.display_labels) == 1:
+                    # If the previous display_labels consist of a single attribute convert
+                    # it to an attribute based display label
+                    converted_display_label = node_schema.display_labels[0]
+                    if "__" not in converted_display_label:
+                        # Previously we allowed defining a raw attribute name as a component of a
+                        # display_label, if this is the case we need to append '__value'
+                        converted_display_label = f"{converted_display_label}__value"
+                    update_candidate.display_label = converted_display_label
+                else:
+                    # If the previous display label consists of multiple attributes
+                    # convert it to a Jinja2 based display label
+                    update_candidate.display_label = " ".join(
+                        [f"{{{{ {display_label} }}}}" for display_label in node_schema.display_labels]
+                    )
+                self.set(name=name, schema=update_candidate)
+
+            if not node_schema.display_label:
+                continue
+
+            self._validate_display_label(node=node_schema)
+
     def validate_display_labels(self) -> None:
         for name in self.all_names:
             node_schema = self.get(name=name, duplicate=False)
@@ -848,6 +890,7 @@ class SchemaBranch:
         return False
 
     def validate_human_friendly_id(self) -> None:
+        self.hfids = HFIDs()
         for name in self.generic_names_without_templates + self.node_names:
             node_schema = self.get(name=name, duplicate=False)
 
@@ -859,7 +902,14 @@ class SchemaBranch:
             # Mapping relationship identifiers -> list of attributes paths
             rel_schemas_to_paths: dict[str, tuple[MainSchemaTypes, list[str]]] = {}
 
+            visited_paths: list[str] = []
             for hfid_path in node_schema.human_friendly_id:
+                if config.SETTINGS.main.schema_strict_mode and hfid_path in visited_paths:
+                    raise ValidationError(
+                        f"HFID of {node_schema.kind} cannot use the same path more than once: {hfid_path}"
+                    )
+
+                visited_paths.append(hfid_path)
                 schema_path = self.validate_schema_path(
                     node_schema=node_schema,
                     path=hfid_path,
@@ -874,6 +924,11 @@ class SchemaBranch:
                         rel_schemas_to_paths[rel_identifier] = (schema_path.related_schema, [])
                     rel_schemas_to_paths[rel_identifier][1].append(schema_path.attribute_path_as_str)
 
+                if node_schema.is_node_schema and node_schema.namespace not in ["Schema", "Internal"]:
+                    self.hfids.register_hfid_schema_path(
+                        kind=node_schema.kind, schema_path=schema_path, hfid=node_schema.human_friendly_id
+                    )
+
             if config.SETTINGS.main.schema_strict_mode:
                 # For every relationship referred within hfid, check whether the combination of attributes is unique is the peer schema node
                 for related_schema, attrs_paths in rel_schemas_to_paths.values():
@@ -1136,6 +1191,50 @@ class SchemaBranch:
                             node=node_schema, attribute=attribute, generic=generic_schema
                         )
 
+    def _validate_display_label(self, node: MainSchemaTypes) -> None:
+        if not node.display_label:
+            return
+
+        if not any(c in node.display_label for c in "{}"):
+            schema_path = self.validate_schema_path(
+                node_schema=node,
+                path=node.display_label,
+                allowed_path_types=SchemaElementPathType.ATTR_WITH_PROP,
+                element_name="display_label - non Jinja2",
+            )
+            if schema_path.attribute_schema and node.is_node_schema and node.namespace not in ["Internal", "Schema"]:
+                self.display_labels.register_attribute_based_display_label(
+                    kind=node.kind, attribute_name=schema_path.attribute_schema.name
+                )
+            return
+
+        jinja_template = Jinja2Template(template=node.display_label)
+        try:
+            variables = jinja_template.get_variables()
+            jinja_template.validate(restricted=config.SETTINGS.security.restrict_untrusted_jinja2_filters)
+        except (JinjaTemplateOperationViolationError, JinjaTemplateError) as exc:
+            raise ValueError(
+                f"{node.kind}: display_label is set to a jinja2 template, but has an invalid template: {exc.message}"
+            ) from exc
+
+        allowed_path_types = (
+            SchemaElementPathType.ATTR_WITH_PROP
+            | SchemaElementPathType.REL_ONE_MANDATORY_ATTR_WITH_PROP
+            | SchemaElementPathType.REL_ONE_ATTR_WITH_PROP
+        )
+        for variable in variables:
+            schema_path = self.validate_schema_path(
+                node_schema=node, path=variable, allowed_path_types=allowed_path_types, element_name="display_label"
+            )
+
+            if schema_path.is_type_attribute and schema_path.active_attribute_schema.name == "display_label":
+                raise ValueError(f"{node.kind}: display_label the '{variable}' variable is a reference to itself")
+
+            if node.is_node_schema and node.namespace not in ["Internal", "Schema"]:
+                self.display_labels.register_template_schema_path(
+                    kind=node.kind, schema_path=schema_path, template=node.display_label
+                )
+
     def _validate_computed_attribute(self, node: NodeSchema, attribute: AttributeSchema) -> None:
         if not attribute.computed_attribute or attribute.computed_attribute.kind == ComputedAttributeKind.USER:
             return
@@ -1611,6 +1710,42 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
+    def process_relationships_state(self) -> None:
+        for name in self.node_names + self.generic_names_without_templates:
+            node = self.get(name=name, duplicate=False)
+            if node.id or (not node.id and not node.relationships):
+                continue
+
+            filtered_relationships = [
+                relationship for relationship in node.relationships if relationship.state != HashableModelState.ABSENT
+            ]
+            if len(filtered_relationships) == len(node.relationships):
+                continue
+            updated_node = node.duplicate()
+            updated_node.relationships = filtered_relationships
+            self.set(name=name, schema=updated_node)
+
+    def process_attributes_state(self) -> None:
+        for name in self.node_names + self.generic_names_without_templates:
+            node = self.get(name=name, duplicate=False)
+            if not node.attributes:
+                continue
+
+            filtered_attributes = [
+                attribute for attribute in node.attributes if attribute.state != HashableModelState.ABSENT
+            ]
+            if len(filtered_attributes) == len(node.attributes):
+                continue
+            updated_node = node.duplicate()
+            updated_node.attributes = filtered_attributes
+            self.set(name=name, schema=updated_node)
+
+    def process_nodes_state(self) -> None:
+        for name in self.node_names + self.generic_names_without_templates:
+            node = self.get(name=name, duplicate=False)
+            if not node.id and node.state == HashableModelState.ABSENT:
+                self.delete(name=name)
+
     def _generate_weight_generics(self) -> None:
         """Generate order_weight for all generic schemas."""
         for name in self.generic_names:
@@ -1934,7 +2069,7 @@ class SchemaBranch:
 
             profiles_rel_settings: dict[str, Any] = {
                 "name": "profiles",
-                "identifier": "node__profile",
+                "identifier": PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
                 "peer": InfrahubKind.PROFILE,
                 "kind": RelationshipKind.PROFILE,
                 "cardinality": RelationshipCardinality.MANY,
@@ -1997,7 +2132,7 @@ class SchemaBranch:
             relationships=[
                 RelationshipSchema(
                     name="related_nodes",
-                    identifier="node__profile",
+                    identifier=PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
                     peer=node.kind,
                     kind=RelationshipKind.PROFILE,
                     cardinality=RelationshipCardinality.MANY,