infrahub-server 1.4.13__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/core/query/relationship.py

@@ -350,17 +350,20 @@ class RelationshipUpdatePropertyQuery(RelationshipQuery):
 
     def __init__(
         self,
-        properties_to_update: list[str],
-        data: RelationshipPeerData,
+        rel_node_id: str,
+        flag_properties_to_update: dict[str, bool],
+        node_properties_to_update: dict[str, str],
         **kwargs,
     ):
-        self.properties_to_update = properties_to_update
-        self.data = data
-
+        self.rel_node_id = rel_node_id
+        if not flag_properties_to_update and not node_properties_to_update:
+            raise ValueError("Either flag_properties_to_update or node_properties_to_update must be set")
+        self.flag_properties_to_update = flag_properties_to_update
+        self.node_properties_to_update = node_properties_to_update
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
-        self.params["rel_node_id"] = self.data.rel_node_id
+        self.params["rel_node_id"] = self.rel_node_id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["at"] = self.at.to_string()
@@ -370,36 +373,51 @@ class RelationshipUpdatePropertyQuery(RelationshipQuery):
         """
         self.add_to_query(query)
 
-        self.query_add_all_flag_property_merge()
         self.query_add_all_node_property_merge()
+        self.query_add_all_flag_property_merge()
 
-        self.query_add_all_flag_property_create()
         self.query_add_all_node_property_create()
+        self.query_add_all_flag_property_create()
 
     def query_add_all_flag_property_merge(self) -> None:
-        for prop_name in self.rel._flag_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_flag_property_merge(name=prop_name)
+        for prop_name, prop_value in self.flag_properties_to_update.items():
+            self.query_add_flag_property_merge(name=prop_name, value=prop_value)
 
-    def query_add_flag_property_merge(self, name: str) -> None:
+    def query_add_flag_property_merge(self, name: str, value: bool) -> None:
         self.add_to_query("MERGE (prop_%s:Boolean { value: $prop_%s })" % (name, name))
-        self.params[f"prop_{name}"] = getattr(self.rel, name)
+        self.params[f"prop_{name}"] = value
         self.return_labels.append(f"prop_{name}")
 
     def query_add_all_node_property_merge(self) -> None:
-        for prop_name in self.rel._node_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_node_property_merge(name=prop_name)
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at)
+        self.params.update(branch_params)
 
-    def query_add_node_property_merge(self, name: str) -> None:
-        self.add_to_query("MERGE (prop_%s:Node { uuid: $prop_%s })" % (name, name))
-        self.params[f"prop_{name}"] = getattr(self.rel, f"{name}_id")
-        self.return_labels.append(f"prop_{name}")
+        for prop_name, prop_value in self.node_properties_to_update.items():
+            self.params[f"prop_{prop_name}"] = prop_value
+            if self.branch.is_default or self.branch.is_global:
+                node_query = """
+            MATCH (prop_%(prop_name)s:Node {uuid: $prop_%(prop_name)s })-[r_%(prop_name)s:IS_PART_OF]->(:Root)
+            WHERE r_%(prop_name)s.branch IN $branch0
+            AND r_%(prop_name)s.status = "active"
+            AND r_%(prop_name)s.from <= $at AND (r_%(prop_name)s.to IS NULL OR r_%(prop_name)s.to > $at)
+            WITH *
+            LIMIT 1
+                """ % {"prop_name": prop_name}
+            else:
+                node_query = """
+            MATCH (prop_%(prop_name)s:Node {uuid: $prop_%(prop_name)s })-[r_%(prop_name)s:IS_PART_OF]->(:Root)
+            WHERE all(r in [r_%(prop_name)s] WHERE %(branch_filter)s)
+            ORDER BY r_%(prop_name)s.branch_level DESC, r_%(prop_name)s.from DESC, r_%(prop_name)s.status ASC
+            LIMIT 1
+            WITH *
+            WHERE r_%(prop_name)s.status = "active"
+                """ % {"branch_filter": branch_filter, "prop_name": prop_name}
+            self.add_to_query(node_query)
+            self.return_labels.append(f"prop_{prop_name}")
 
     def query_add_all_flag_property_create(self) -> None:
-        for prop_name in self.rel._flag_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_flag_property_create(name=prop_name)
+        for prop_name in self.flag_properties_to_update:
+            self.query_add_flag_property_create(name=prop_name)
 
     def query_add_flag_property_create(self, name: str) -> None:
         query = """
@@ -411,9 +429,8 @@ class RelationshipUpdatePropertyQuery(RelationshipQuery):
         self.add_to_query(query)
 
     def query_add_all_node_property_create(self) -> None:
-        for prop_name in self.rel._node_properties:
-            if prop_name in self.properties_to_update:
-                self.query_add_node_property_create(name=prop_name)
+        for prop_name in self.node_properties_to_update:
+            self.query_add_node_property_create(name=prop_name)
 
     def query_add_node_property_create(self, name: str) -> None:
         query = """
@@ -1019,6 +1036,7 @@ class RelationshipCountPerNodeQuery(Query):
         """ % {"branch_filter": branch_filter, "path": path}
 
         self.add_to_query(query)
+        self.order_by = ["peer_node.uuid"]
         self.return_labels = ["peer_node.uuid", "COUNT(peer_node.uuid) as nbr_peers"]
 
     async def get_count_per_peer(self) -> dict[str, int]:

infrahub/core/query/subquery.py

@@ -25,12 +25,8 @@ async def build_subquery_filter(
     partial_match: bool = False,
     optional_match: bool = False,
     result_prefix: str = "filter",
-    support_profiles: bool = False,
     extra_tail_properties: dict[str, str] | None = None,
 ) -> tuple[str, dict[str, Any], str]:
-    support_profiles = (
-        support_profiles and field and field.is_attribute and filter_name in ("value", "values", "isnull")
-    )
     params = {}
     prefix = f"{result_prefix}{subquery_idx}"
 
@@ -52,7 +48,6 @@ async def build_subquery_filter(
         param_prefix=prefix,
         db=db,
         partial_match=partial_match,
-        support_profiles=support_profiles,
     )
     params.update(field_params)
 
@@ -109,10 +104,8 @@ async def build_subquery_order(
     branch: Branch = None,
     subquery_idx: int = 1,
     result_prefix: str | None = None,
-    support_profiles: bool = False,
     extra_tail_properties: dict[str, str] | None = None,
 ) -> tuple[str, dict[str, Any], str]:
-    support_profiles = support_profiles and field and field.is_attribute and order_by in ("value", "values")
     params = {}
     prefix = result_prefix or f"order{subquery_idx}"
 
@@ -124,7 +117,6 @@ async def build_subquery_order(
         filter_value=None,
         branch=branch,
         param_prefix=prefix,
-        support_profiles=support_profiles,
     )
     params.update(field_params)
 

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)
 
@@ -426,15 +445,20 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         )
         await delete_query.execute(db=db)
 
-    async def resolve(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None:
+    async def resolve(self, db: InfrahubDatabase, at: Timestamp | None = None, fields: list[str] | None = None) -> None:
         """Resolve the peer of the relationship."""
 
+        fields = fields or []
+        query_fields = dict.fromkeys(fields)
+        if "display_label" not in query_fields:
+            query_fields["display_label"] = None
+
         if self._peer is not None:
             return
 
         if self.peer_id and not is_valid_uuid(self.peer_id):
             peer = await registry.manager.get_one_by_default_filter(
-                db=db, id=self.peer_id, branch=self.branch, kind=self.schema.peer, fields={"display_label": None}
+                db=db, id=self.peer_id, branch=self.branch, kind=self.schema.peer, fields=query_fields
             )
             if peer:
                 self.set_peer(value=peer)
@@ -451,7 +475,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
                 hfid=self.peer_hfid,
                 branch=self.branch,
                 kind=kind,
-                fields={"display_label": None},
+                fields=query_fields,
                 raise_on_error=True,
             )
             self.set_peer(value=peer)
@@ -570,7 +594,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 +606,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 +758,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 +948,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 +978,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
@@ -1102,9 +1147,9 @@ class RelationshipManager:
 
         return True
 
-    async def resolve(self, db: InfrahubDatabase) -> None:
+    async def resolve(self, db: InfrahubDatabase, fields: list[str] | None = None) -> None:
         for rel in self._relationships:
-            await rel.resolve(db=db)
+            await rel.resolve(db=db, fields=fields)
 
     async def remove_locally(
         self,

infrahub/core/schema/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import uuid
+from enum import Enum
 from typing import Any, TypeAlias
 
 from infrahub_sdk.utils import deep_merge_dict
@@ -44,6 +45,21 @@ class SchemaExtension(HashableModel):
     nodes: list[NodeExtensionSchema] = Field(default_factory=list)
 
 
+class SchemaWarningType(Enum):
+    DEPRECATION = "deprecation"
+
+
+class SchemaWarningKind(BaseModel):
+    kind: str = Field(..., description="The kind impacted by the warning")
+    field: str | None = Field(default=None, description="The attribute or relationship impacted by the warning")
+
+
+class SchemaWarning(BaseModel):
+    type: SchemaWarningType = Field(..., description="The type of warning")
+    kinds: list[SchemaWarningKind] = Field(default_factory=list, description="The kinds impacted by the warning")
+    message: str = Field(..., description="The message that describes the warning")
+
+
 class SchemaRoot(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -80,6 +96,46 @@ class SchemaRoot(BaseModel):
 
         return errors
 
+    def gather_warnings(self) -> list[SchemaWarning]:
+        models = self.nodes + self.generics
+        warnings: list[SchemaWarning] = []
+        for model in models:
+            if model.display_labels is not None:
+                warnings.append(
+                    SchemaWarning(
+                        type=SchemaWarningType.DEPRECATION,
+                        kinds=[SchemaWarningKind(kind=model.kind)],
+                        message="display_labels are deprecated, use display_label instead",
+                    )
+                )
+            if model.default_filter is not None:
+                warnings.append(
+                    SchemaWarning(
+                        type=SchemaWarningType.DEPRECATION,
+                        kinds=[SchemaWarningKind(kind=model.kind)],
+                        message="default_filter is deprecated",
+                    )
+                )
+            for attribute in model.attributes:
+                if attribute.max_length is not None:
+                    warnings.append(
+                        SchemaWarning(
+                            type=SchemaWarningType.DEPRECATION,
+                            kinds=[SchemaWarningKind(kind=model.kind, field=attribute.name)],
+                            message="Use of 'max_length' on attributes is deprecated, use parameters instead",
+                        )
+                    )
+                if attribute.min_length is not None:
+                    warnings.append(
+                        SchemaWarning(
+                            type=SchemaWarningType.DEPRECATION,
+                            kinds=[SchemaWarningKind(kind=model.kind, field=attribute.name)],
+                            message="Use of 'min_length' on attributes is deprecated, use parameters instead",
+                        )
+                    )
+
+        return warnings
+
     def generate_uuid(self) -> None:
         """Generate UUID for all nodes, attributes & relationships
         Mainly useful during unit tests."""

infrahub/core/schema/attribute_schema.py

@@ -68,6 +68,10 @@ class AttributeSchema(GeneratedAttributeSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    @property
+    def support_profiles(self) -> bool:
+        return self.read_only is False and self.optional is True
+
     def get_id(self) -> str:
         if self.id is None:
             raise InitializationError("The attribute schema has not been saved yet and doesn't have an id")
@@ -202,7 +206,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 +220,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/check.py

@@ -29,7 +29,7 @@ core_check_definition = NodeSchema(
         Attr(name="description", kind="Text", optional=True),
         Attr(name="file_path", kind="Text"),
         Attr(name="class_name", kind="Text"),
-        Attr(name="timeout", kind="Number", default_value=10),
+        Attr(name="timeout", kind="Number", default_value=60),
         Attr(name="parameters", kind="JSON", optional=True),
     ],
     relationships=[

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/core/transform.py

@@ -29,7 +29,7 @@ core_transform = GenericSchema(
         Attr(name="name", kind="Text", unique=True),
         Attr(name="label", kind="Text", optional=True),
         Attr(name="description", kind="Text", optional=True),
-        Attr(name="timeout", kind="Number", default_value=10),
+        Attr(name="timeout", kind="Number", default_value=60),
     ],
     relationships=[
         Rel(

infrahub/core/schema/definitions/internal.py

@@ -179,6 +179,7 @@ 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
 
@@ -195,6 +196,7 @@ 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,
         }
@@ -294,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},
         ),
@@ -559,7 +568,7 @@ attribute_schema = SchemaNode(
             "Mainly relevant for internal object.",
             default_value=False,
             optional=True,
-            extra={"update": UpdateSupport.ALLOWED},
+            extra={"update": UpdateSupport.MIGRATION_REQUIRED},
         ),
         SchemaAttribute(
             name="unique",
@@ -576,7 +585,7 @@ attribute_schema = SchemaNode(
             default_value=False,
             override_default_value=False,
             optional=True,
-            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+            extra={"update": UpdateSupport.MIGRATION_REQUIRED},
         ),
         SchemaAttribute(
             name="branch",