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

infrahub/core/schema/attribute_parameters.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Any, Self
+from typing import Self
 
 from pydantic import ConfigDict, Field, model_validator
 
@@ -24,33 +24,6 @@ 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

@@ -70,7 +70,7 @@ class AttributeSchema(GeneratedAttributeSchema):
 
     @property
     def support_profiles(self) -> bool:
-        return self.read_only is False and self.optional is True
+        return self.read_only is False and self.unique is False
 
     def get_id(self) -> str:
         if self.id is None:
@@ -114,20 +114,13 @@ 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.
-
-        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.
-        """
+        """Override parameters class if using base AttributeParameters class and should be using a subclass"""
         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.convert_from(value)
-        if isinstance(value, dict):
-            return expected_parameters_class.convert_from_dict(source_data=value)
+            return expected_parameters_class(**value.model_dump())
         return value
 
     @model_validator(mode="after")
@@ -175,7 +168,7 @@ class AttributeSchema(GeneratedAttributeSchema):
 
     def update_from_generic(self, other: AttributeSchema) -> None:
         fields_to_exclude = ("id", "order_weight", "branch", "inherited")
-        for name in self.model_fields:
+        for name in self.__class__.model_fields:
             if name in fields_to_exclude:
                 continue
             if getattr(self, name) != getattr(other, name):
@@ -245,6 +238,19 @@ class TextAttributeSchema(AttributeSchema):
         json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
     )
 
+    @model_validator(mode="after")
+    def reconcile_parameters(self) -> Self:
+        if self.regex != self.parameters.regex:
+            final_regex = self.parameters.regex if self.parameters.regex is not None else self.regex
+            self.regex = self.parameters.regex = final_regex
+        if self.min_length != self.parameters.min_length:
+            final_min_length = self.parameters.min_length if self.parameters.min_length is not None else self.min_length
+            self.min_length = self.parameters.min_length = final_min_length
+        if self.max_length != self.parameters.max_length:
+            final_max_length = self.parameters.max_length if self.parameters.max_length is not None else self.max_length
+            self.max_length = self.parameters.max_length = final_max_length
+        return self
+
     def get_regex(self) -> str | None:
         return self.parameters.regex
 

infrahub/core/schema/manager.py

@@ -6,6 +6,7 @@ from cachetools import LRUCache
 from infrahub_sdk.schema import BranchSchema as SDKBranchSchema
 
 from infrahub import lock
+from infrahub.core.constants import SYSTEM_USER_ID, MetadataOptions
 from infrahub.core.manager import NodeManager
 from infrahub.core.models import (
     HashableModelDiff,
@@ -178,15 +179,18 @@ class SchemaManager(NodeManager):
         diff: SchemaDiff | None = None,
         limit: list[str] | None = None,
         update_db: bool = True,
+        user_id: str = SYSTEM_USER_ID,
     ) -> None:
         branch = await registry.get_branch(branch=branch, db=db)
 
         updated_schema = None
         if update_db:
             if diff:
-                schema_diff = await self.update_schema_to_db(schema=schema, db=db, branch=branch, diff=diff)
+                schema_diff = await self.update_schema_to_db(
+                    schema=schema, db=db, branch=branch, diff=diff, user_id=user_id
+                )
             else:
-                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit)
+                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, user_id=user_id)
                 # After updating the schema into the db
                 # we need to pull a fresh version because some default value are managed/generated within the node object
                 schema_diff = None
@@ -216,6 +220,7 @@ class SchemaManager(NodeManager):
         schema: SchemaBranch,
         db: InfrahubDatabase,
         diff: SchemaDiff,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> SchemaBranchDiff:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
@@ -226,7 +231,7 @@ class SchemaManager(NodeManager):
         added_generics = []
         for item_kind in diff.added.keys():
             item = schema.get(name=item_kind, duplicate=False)
-            node = await self.load_node_to_db(node=item, branch=branch, db=db)
+            node = await self.load_node_to_db(node=item, branch=branch, db=db, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 added_nodes.append(item_kind)
@@ -238,9 +243,11 @@ class SchemaManager(NodeManager):
         for item_kind, item_diff in diff.changed.items():
             item = schema.get(name=item_kind, duplicate=False)
             if item_diff:
-                node = await self.update_node_in_db_based_on_diff(node=item, branch=branch, db=db, diff=item_diff)
+                node = await self.update_node_in_db_based_on_diff(
+                    node=item, branch=branch, db=db, diff=item_diff, user_id=user_id
+                )
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 changed_nodes.append(item_kind)
@@ -251,7 +258,7 @@ class SchemaManager(NodeManager):
         removed_generics = []
         for item_kind in diff.removed.keys():
             item = schema.get(name=item_kind, duplicate=False)
-            node = await self.delete_node_in_db(node=item, branch=branch, db=db)
+            node = await self.delete_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
             schema.delete(name=item_kind)
             if item.is_node_schema:
                 removed_nodes.append(item_kind)
@@ -273,6 +280,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         branch: Branch | str | None = None,
         limit: list[str] | None = None,
+        user_id: str = SYSTEM_USER_ID,
     ) -> None:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
 
@@ -283,16 +291,17 @@ class SchemaManager(NodeManager):
                 continue
             item = schema.get(name=item_kind, duplicate=False)
             if not item.id:
-                node = await self.load_node_to_db(node=item, branch=branch, db=db)
+                node = await self.load_node_to_db(node=item, branch=branch, db=db, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
 
     async def load_node_to_db(
         self,
         node: NodeSchema | GenericSchema,
         db: InfrahubDatabase,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Load a Node with its attributes and its relationships to the database."""
@@ -313,7 +322,7 @@ class SchemaManager(NodeManager):
         schema_dict = node.model_dump(exclude={"id", "state", "filters", "relationships", "attributes"})
         obj = await Node.init(schema=node_schema, branch=branch, db=db)
         await obj.new(**schema_dict, db=db)
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
         new_node.id = obj.id
 
         # Then create the Attributes and the relationships
@@ -324,7 +333,7 @@ class SchemaManager(NodeManager):
             for item in node.attributes:
                 if item.inherited is False:
                     new_attr = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db
+                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
                     )
                 else:
                     new_attr = item.duplicate()
@@ -333,7 +342,7 @@ class SchemaManager(NodeManager):
             for item in node.relationships:
                 if item.inherited is False:
                     new_rel = await self.create_relationship_in_db(
-                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db
+                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
                     )
                 else:
                     new_rel = item.duplicate()
@@ -347,6 +356,7 @@ class SchemaManager(NodeManager):
         self,
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database."""
@@ -374,7 +384,7 @@ class SchemaManager(NodeManager):
         await obj.relationships.update(
             db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"]
         )
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
 
         # Then Update the Attributes and the relationships
 
@@ -382,25 +392,24 @@ class SchemaManager(NodeManager):
             ids=[item.id for item in node.local_attributes + node.local_relationships if item.id],
             db=db,
             branch=branch,
-            include_owner=True,
-            include_source=True,
+            include_metadata=MetadataOptions.LINKED_NODES,
         )
 
         for item in node.local_attributes:
             if item.id and item.id in items:
-                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db)
+                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
             elif not item.id:
                 new_attr = await self.create_attribute_in_db(
-                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj
+                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                 )
                 new_node.attributes.append(new_attr)
 
         for item in node.local_relationships:
             if item.id and item.id in items:
-                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db)
+                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
             elif not item.id:
                 new_rel = await self.create_relationship_in_db(
-                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj
+                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                 )
                 new_node.relationships.append(new_rel)
 
@@ -413,6 +422,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         diff: HashableModelDiff,
         node: NodeSchema | GenericSchema,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database based on a HashableModelDiff."""
@@ -466,8 +476,7 @@ class SchemaManager(NodeManager):
                 ids=list(item_ids),
                 db=db,
                 branch=branch,
-                include_owner=True,
-                include_source=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
             )
         if missing_field_names:
             missing_attrs = await self.query(
@@ -475,16 +484,14 @@ class SchemaManager(NodeManager):
                 branch=branch,
                 schema=attribute_schema,
                 filters={"name__values": missing_field_names, "node__id": node.id},
-                include_owner=True,
-                include_source=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
             )
             missing_rels = await self.query(
                 db=db,
                 branch=branch,
                 schema=relationship_schema,
                 filters={"name__values": missing_field_names, "node__id": node.id},
-                include_owner=True,
-                include_source=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
             )
             items.update({field.id: field for field in missing_attrs + missing_rels})
 
@@ -494,21 +501,21 @@ class SchemaManager(NodeManager):
         if diff_relationships:
             await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id])
 
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
 
         if diff_attributes:
             for item in node.local_attributes:
                 # if item is in changed and has no ID, then it is being overridden from a generic and must be added
                 if item.name in diff_attributes.added or (item.name in diff_attributes.changed and item.id is None):
                     created_item = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj
+                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                     )
                     new_attr = new_node.get_attribute(name=item.name)
                     new_attr.id = created_item.id
                 elif item.name in diff_attributes.changed and item.id and item.id in items:
-                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db)
+                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
                 elif item.name in diff_attributes.removed and item.id and item.id in items:
-                    await items[item.id].delete(db=db)
+                    await items[item.id].delete(db=db, user_id=user_id)
                 elif (
                     (item.name in diff_attributes.removed or item.name in diff_attributes.changed)
                     and item.id
@@ -523,14 +530,14 @@ class SchemaManager(NodeManager):
                     item.name in diff_relationships.changed and item.id is None
                 ):
                     created_rel = await self.create_relationship_in_db(
-                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj
+                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                     )
                     new_rel = new_node.get_relationship(name=item.name)
                     new_rel.id = created_rel.id
                 elif item.name in diff_relationships.changed and item.id and item.id in items:
-                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db)
+                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
                 elif item.name in diff_relationships.removed and item.id and item.id in items:
-                    await items[item.id].delete(db=db)
+                    await items[item.id].delete(db=db, user_id=user_id)
                 elif (
                     (item.name in diff_relationships.removed or item.name in diff_relationships.changed)
                     and item.id
@@ -548,7 +555,7 @@ class SchemaManager(NodeManager):
         if field_names_to_remove:
             for field_schema in items.values():
                 if field_schema.name.value in field_names_to_remove:
-                    await field_schema.delete(db=db)
+                    await field_schema.delete(db=db, user_id=user_id)
 
         # Save back the node with the (potentially) newly created IDs in the SchemaManager
         self.set(name=new_node.kind, schema=new_node, branch=branch.name)
@@ -558,6 +565,7 @@ class SchemaManager(NodeManager):
         self,
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> None:
         """Delete the node with its attributes and relationships."""
@@ -573,47 +581,59 @@ class SchemaManager(NodeManager):
 
         # First delete the attributes and the relationships
         for attr_schema_node in (await obj.attributes.get_peers(db=db)).values():
-            await attr_schema_node.delete(db=db)
+            await attr_schema_node.delete(db=db, user_id=user_id)
         for rel_schema_node in (await obj.relationships.get_peers(db=db)).values():
-            await rel_schema_node.delete(db=db)
+            await rel_schema_node.delete(db=db, user_id=user_id)
 
-        await obj.delete(db=db)
+        await obj.delete(db=db, user_id=user_id)
 
     @staticmethod
     async def create_attribute_in_db(
-        schema: NodeSchema, item: AttributeSchema, branch: Branch, parent: Node, db: InfrahubDatabase
+        schema: NodeSchema,
+        item: AttributeSchema,
+        branch: Branch,
+        parent: Node,
+        db: InfrahubDatabase,
+        user_id: str,
     ) -> AttributeSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.to_node(), node=parent, db=db)
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
-    async def update_attribute_in_db(item: AttributeSchema, attr: Node, db: InfrahubDatabase) -> None:
+    async def update_attribute_in_db(item: AttributeSchema, attr: Node, db: InfrahubDatabase, user_id: str) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(attr, key).value = value
-        await attr.save(db=db)
+        await attr.save(db=db, user_id=user_id)
 
     @staticmethod
     async def create_relationship_in_db(
-        schema: NodeSchema, item: RelationshipSchema, branch: Branch, parent: Node, db: InfrahubDatabase
+        schema: NodeSchema,
+        item: RelationshipSchema,
+        branch: Branch,
+        parent: Node,
+        db: InfrahubDatabase,
+        user_id: str,
     ) -> RelationshipSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.model_dump(exclude={"id", "state", "filters"}), node=parent, db=db)
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
-    async def update_relationship_in_db(item: RelationshipSchema, rel: Node, db: InfrahubDatabase) -> None:
+    async def update_relationship_in_db(
+        item: RelationshipSchema, rel: Node, db: InfrahubDatabase, user_id: str
+    ) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(rel, key).value = value
-        await rel.save(db=db)
+        await rel.save(db=db, user_id=user_id)
 
     async def load_schema(
         self,

infrahub/core/schema/relationship_schema.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 from pydantic import BaseModel
 
 from infrahub import config
-from infrahub.core.constants import RelationshipDirection
+from infrahub.core.constants import RelationshipDirection, RelationshipKind
 from infrahub.core.query import QueryNode, QueryRel, QueryRelDirection
 from infrahub.core.relationship import Relationship
 from infrahub.exceptions import InitializationError
@@ -36,6 +36,10 @@ class RelationshipSchema(GeneratedRelationshipSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    @property
+    def support_profiles(self) -> bool:
+        return self.read_only is False and self.kind in {RelationshipKind.GENERIC, RelationshipKind.ATTRIBUTE}
+
     def to_dict(self) -> dict:
         data = self.model_dump(exclude_unset=True, exclude_none=True)
         for field_name, value in data.items():
@@ -75,7 +79,7 @@ class RelationshipSchema(GeneratedRelationshipSchema):
 
     def update_from_generic(self, other: RelationshipSchema) -> None:
         fields_to_exclude = ("id", "order_weight", "branch", "inherited", "filters")
-        for name in self.model_fields:
+        for name in self.__class__.model_fields:
             if name in fields_to_exclude:
                 continue
             if getattr(self, name) != getattr(other, name):

infrahub/core/schema/schema_branch.py

@@ -54,7 +54,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
-from infrahub.core.schema.attribute_parameters import NumberPoolParameters, TextAttributeParameters
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
 from infrahub.core.schema.attribute_schema import get_attribute_schema_class_for_kind
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
@@ -236,8 +236,8 @@ class SchemaBranch:
             if diff_node.has_diff:
                 schema_diff.changed[key] = diff_node
 
-        reversed_map_local = dict(map(reversed, local_kind_id_map.items()))
-        reversed_map_other = dict(map(reversed, other_kind_id_map.items()))
+        reversed_map_local: dict[str | None, str] = {v: k for k, v in local_kind_id_map.items()}
+        reversed_map_other: dict[str | None, str] = {v: k for k, v in other_kind_id_map.items()}
 
         for shared_id in shared_ids:
             local_node = self.get(name=reversed_map_local[shared_id], duplicate=False)
@@ -501,76 +501,11 @@ class SchemaBranch:
 
         return fields or None
 
-    def _text_attr_needs_reconciliation(self, attr: AttributeSchema) -> bool:
-        """Check if a Text attribute needs reconciliation between deprecated fields and parameters."""
-        if not isinstance(attr.parameters, TextAttributeParameters):
-            return False
-        return (
-            attr.regex != attr.parameters.regex
-            or attr.min_length != attr.parameters.min_length
-            or attr.max_length != attr.parameters.max_length
-        )
-
-    def _reconcile_text_attr(self, attr: AttributeSchema) -> None:
-        """Reconcile a single Text attribute's deprecated fields with parameters.
-
-        Parameters take precedence over deprecated top-level fields when both are set.
-        """
-        if not isinstance(attr.parameters, TextAttributeParameters):
-            return
-
-        # Sync regex: parameters takes precedence
-        if attr.parameters.regex is not None:
-            attr.regex = attr.parameters.regex
-        elif attr.regex is not None:
-            attr.parameters.regex = attr.regex
-
-        # Sync min_length: parameters takes precedence
-        if attr.parameters.min_length is not None:
-            attr.min_length = attr.parameters.min_length
-        elif attr.min_length is not None:
-            attr.parameters.min_length = attr.min_length
-
-        # Sync max_length: parameters takes precedence
-        if attr.parameters.max_length is not None:
-            attr.max_length = attr.parameters.max_length
-        elif attr.max_length is not None:
-            attr.parameters.max_length = attr.max_length
-
-    def _reconcile_text_attribute_parameters(self, schema: SchemaRoot | None = None) -> None:
-        """Reconcile regex, min_length, max_length between deprecated fields and parameters for Text attributes.
-
-        Args:
-            schema: If provided, reconcile incoming schema data before merging.
-                   If None, reconcile already-loaded schemas (e.g., from database).
-        """
-        if schema:
-            # Incoming schema: modify in place
-            for item in schema.nodes + schema.generics:
-                for attr in item.attributes:
-                    self._reconcile_text_attr(attr)
-            return
-
-        # Loaded schemas: need to duplicate before modifying
-        for name in self.all_names:
-            node = self.get(name=name, duplicate=False)
-
-            if not any(self._text_attr_needs_reconciliation(attr) for attr in node.attributes):
-                continue
-
-            node = node.duplicate()
-            for attr in node.attributes:
-                self._reconcile_text_attr(attr)
-            self.set(name=name, schema=node)
-
     def load_schema(self, schema: SchemaRoot) -> None:
         """Load a SchemaRoot object and store all NodeSchema or GenericSchema.
 
         In the current implementation, if a schema object present in the SchemaRoot already exist, it will be overwritten.
         """
-        # Reconcile deprecated text attribute parameters before merging
-        self._reconcile_text_attribute_parameters(schema)
-
         for item in schema.nodes + schema.generics:
             try:
                 if item.id:
@@ -610,7 +545,6 @@ class SchemaBranch:
         self.generate_identifiers()
         self.process_default_values()
         self.process_deprecations()
-        self._reconcile_text_attribute_parameters()
         self.process_cardinality_counts()
         self.process_inheritance()
         self.process_hierarchy()
@@ -2225,6 +2159,45 @@ class SchemaBranch:
 
             self.set(name=node_name, schema=node)
 
+    def add_relationships_to_profile(self, profile: ProfileSchema, node: NodeSchema | GenericSchema) -> None:
+        # Remove previous relationships to account for new ones
+        profile.relationships = [r for r in profile.relationships if r.kind == RelationshipKind.PROFILE]
+
+        for relationship in node.relationships:
+            if not relationship.support_profiles:
+                continue
+
+            # Ignore relationship if it is part of a uniqueness constraint
+            ignore_relationship = False
+            for constraint in node.uniqueness_constraints or []:
+                if relationship.name in constraint:
+                    ignore_relationship = True
+                    break
+            if ignore_relationship:
+                continue
+
+            identifier = (
+                f"profile_{relationship.identifier}"
+                if relationship.identifier
+                else self._generate_identifier_string(profile.kind, relationship.peer)
+            )
+
+            profile.relationships.append(
+                RelationshipSchema(
+                    name=relationship.name,
+                    peer=relationship.peer,
+                    kind=relationship.kind,
+                    cardinality=relationship.cardinality,
+                    direction=relationship.direction,
+                    branch=relationship.branch,
+                    identifier=identifier,
+                    min_count=relationship.min_count,
+                    max_count=relationship.max_count,
+                    label=relationship.label,
+                    inherited=False,
+                )
+            )
+
     def manage_profile_schemas(self) -> None:
         if not self.has(name=InfrahubKind.PROFILE):
             # TODO: This logic is actually only for testing purposes as since 1.0.9 CoreProfile is loaded in db.
@@ -2244,6 +2217,7 @@ class SchemaBranch:
                 continue
 
             profile = self.generate_profile_from_node(node=node)
+            self.add_relationships_to_profile(profile=profile, node=node)
             self.set(name=profile.kind, schema=profile)
             profile_schema_kinds.add(profile.kind)
 
@@ -2318,13 +2292,13 @@ class SchemaBranch:
         core_name_attr = core_profile_schema.get_attribute(name="profile_name")
         name_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_name_attr.kind)
         profile_name_attr = name_attr_schema_class(
-            **core_name_attr.model_dump(exclude=["id", "inherited"]),
+            **core_name_attr.model_dump(exclude={"id", "inherited"}),
         )
         profile_name_attr.branch = node.branch
         core_priority_attr = core_profile_schema.get_attribute(name="profile_priority")
         priority_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_priority_attr.kind)
         profile_priority_attr = priority_attr_schema_class(
-            **core_priority_attr.model_dump(exclude=["id", "inherited"]),
+            **core_priority_attr.model_dump(exclude={"id", "inherited"}),
         )
         profile_priority_attr.branch = node.branch
         profile = ProfileSchema(
@@ -2369,7 +2343,7 @@ class SchemaBranch:
             attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
             attr = attr_schema_class(
                 optional=True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "default_value", "inherited"]),
+                **node_attr.model_dump(exclude={"id", "unique", "optional", "read_only", "default_value", "inherited"}),
             )
             profile.attributes.append(attr)
 
@@ -2513,9 +2487,7 @@ class SchemaBranch:
         )
         core_name_attr = core_template_schema.get_attribute(name=OBJECT_TEMPLATE_NAME_ATTR)
         name_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_name_attr.kind)
-        template_name_attr = name_attr_schema_class(
-            **core_name_attr.model_dump(exclude=["id", "inherited"]),
-        )
+        template_name_attr = name_attr_schema_class(**core_name_attr.model_dump(exclude={"id", "inherited"}))
         template_name_attr.branch = node.branch
 
         template: TemplateSchema | GenericSchema
@@ -2574,7 +2546,7 @@ class SchemaBranch:
             attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
             attr = attr_schema_class(
                 optional=node_attr.optional if is_autogenerated_subtemplate else True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "order_weight"]),
+                **node_attr.model_dump(exclude={"id", "unique", "optional", "read_only", "order_weight"}),
             )
             template.attributes.append(attr)