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

infrahub/core/attribute.py

@@ -36,7 +36,7 @@ from .schema.attribute_parameters import NumberAttributeParameters
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.node import Node
-    from infrahub.core.schema import AttributeSchema
+    from infrahub.core.schema import AttributeSchema, MainSchemaTypes
     from infrahub.database import InfrahubDatabase
 
 
@@ -324,7 +324,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         save_at = Timestamp(at)
 
-        if not self.id or self.is_from_profile:
+        if not self.id:
             return None
 
         return await self._update(at=save_at, db=db)
@@ -395,7 +395,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         Get the current value
          - If the value is the same, do nothing
-         - If the value is inherited and is different, raise error (for now just ignore)
          - If the value is different, create new node and update relationship
 
         """
@@ -470,28 +469,32 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         # ---------- Update the Node Properties ----------
         for prop_name in self._node_properties:
-            if getattr(self, f"{prop_name}_id") and not (
-                prop_name in current_attr_data.node_properties
-                and current_attr_data.node_properties[prop_name].uuid == getattr(self, f"{prop_name}_id")
-            ):
-                previous_attribute_node_property = current_attr_data.node_properties.get(prop_name)
-                previous_value = None
-                if previous_attribute_node_property:
-                    previous_value = previous_attribute_node_property.uuid
+            current_prop_id = getattr(self, f"{prop_name}_id")
+            database_prop_id: str | None = None
+            if prop_name in current_attr_data.node_properties:
+                database_prop_id = current_attr_data.node_properties[prop_name].uuid
+            needs_update = current_prop_id is not None and current_prop_id != database_prop_id
+            needs_clear = self.is_clear(prop_name) and database_prop_id
+
+            if not needs_update and not needs_clear:
+                continue
 
-                changelog.add_property(
-                    name=prop_name,
-                    value_current=getattr(self, f"{prop_name}_id"),
-                    value_previous=previous_value,
-                )
+            changelog.add_property(
+                name=prop_name,
+                value_current=current_prop_id,
+                value_previous=database_prop_id,
+            )
+
+            if needs_update:
                 query = await AttributeUpdateNodePropertyQuery.init(
-                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=getattr(self, f"{prop_name}_id")
+                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=current_prop_id
                 )
                 await query.execute(db=db)
 
-                rel = current_attr_result.get(f"rel_{prop_name}")
-                if rel and rel.get("branch") == branch.name:
-                    await update_relationships_to([rel.element_id], to=update_at, db=db)
+            # set the to time on the previously active edge
+            rel = current_attr_result.get(f"rel_{prop_name}")
+            if rel and rel.get("branch") == branch.name:
+                await update_relationships_to([rel.element_id], to=update_at, db=db)
 
         if changelog.has_updates:
             return changelog
@@ -627,7 +630,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             return AttributeDBNodeType.DEFAULT
         return AttributeDBNodeType.INDEXED
 
-    def get_create_data(self) -> AttributeCreateData:
+    def get_create_data(self, node_schema: MainSchemaTypes) -> AttributeCreateData:
         branch = self.branch
         hierarchy_level = branch.hierarchy_level
         if self.schema.branch == BranchSupportType.AGNOSTIC:
@@ -642,7 +645,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             branch=branch.name,
             status="active",
             branch_level=hierarchy_level,
-            branch_support=self.schema.branch.value,
+            branch_support=self.schema.branch.value if self.schema.branch is not None else node_schema.branch,
             content=self.to_db(),
             is_default=self.is_default,
             is_protected=self.is_protected,

infrahub/core/branch/models.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Optional, Self, Union
 
 from pydantic import Field, field_validator
 
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
 )
@@ -21,8 +22,6 @@ from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import BranchNotFoundError, InitializationError, ValidationError
 
-from .enums import BranchStatus
-
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
@@ -485,6 +484,7 @@ class Branch(StandardNode):
         # FIXME, we must ensure that there is no conflict before rebasing a branch
         #   Otherwise we could endup with a complicated situation
         self.branched_from = at.to_string()
+        self.status = BranchStatus.OPEN
         await self.save(db=db)
 
         # Update the branch in the registry after the rebase

infrahub/core/branch/needs_rebase_status.py

@@ -0,0 +1,11 @@
+from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
+
+
+def raise_needs_rebase_error(branch_name: str) -> None:
+    raise ValueError(f"Branch {branch_name} must be rebased before any updates can be made")
+
+
+def check_need_rebase_status(branch: Branch) -> None:
+    if branch.status == BranchStatus.NEED_REBASE:
+        raise_needs_rebase_error(branch_name=branch.name)

infrahub/core/branch/tasks.py

@@ -33,6 +33,7 @@ from infrahub.events.branch_action import BranchCreatedEvent, BranchDeletedEvent
 from infrahub.events.models import EventMeta, InfrahubEvent
 from infrahub.events.node_action import get_node_event
 from infrahub.exceptions import BranchNotFoundError, ValidationError
+from infrahub.generators.constants import GeneratorDefinitionRunSource
 from infrahub.graphql.mutations.models import BranchCreateModel  # noqa: TC001
 from infrahub.workers.dependencies import get_component, get_database, get_event_service, get_workflow
 from infrahub.workflows.catalogue import (
@@ -345,7 +346,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
     async with database.start_session() as db:
         try:
             await Branch.get_by_name(db=db, name=model.name)
-            raise ValueError(f"The branch {model.name}, already exist")
+            raise ValidationError(f"The branch {model.name} already exists")
         except BranchNotFoundError:
             pass
 
@@ -356,7 +357,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
             obj = Branch(**data_dict)
         except pydantic.ValidationError as exc:
             error_msgs = [f"invalid field {error['loc'][0]}: {error['msg']}" for error in exc.errors()]
-            raise ValueError("\n".join(error_msgs)) from exc
+            raise ValidationError("\n".join(error_msgs)) from exc
 
         async with lock.registry.local_schema_lock():
             # Copy the schema from the origin branch and set the hash and the schema_changed_at value
@@ -437,7 +438,7 @@ async def post_process_branch_merge(source_branch: str, target_branch: str, cont
         await get_workflow().submit_workflow(
             workflow=TRIGGER_GENERATOR_DEFINITION_RUN,
             context=context,
-            parameters={"branch": target_branch},
+            parameters={"branch": target_branch, "source": GeneratorDefinitionRunSource.MERGE},
         )
 
         for diff_root in branch_diff_roots:

infrahub/core/changelog/models.py

@@ -560,7 +560,7 @@ class RelationshipChangelogGetter:
 
         for peer in relationship.peers:
             if peer.peer_status == DiffAction.ADDED:
-                peer_schema = schema_branch.get(name=peer.peer_kind)
+                peer_schema = schema_branch.get(name=peer.peer_kind, duplicate=False)
                 secondaries.extend(
                     self._process_added_peers(
                         peer_id=peer.peer_id,
@@ -572,7 +572,7 @@ class RelationshipChangelogGetter:
                 )
 
             elif peer.peer_status == DiffAction.REMOVED:
-                peer_schema = schema_branch.get(name=peer.peer_kind)
+                peer_schema = schema_branch.get(name=peer.peer_kind, duplicate=False)
                 secondaries.extend(
                     self._process_removed_peers(
                         peer_id=peer.peer_id,
@@ -596,11 +596,7 @@ class RelationshipChangelogGetter:
         secondaries: list[NodeChangelog] = []
         peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
         if peer_relation:
-            node_changelog = NodeChangelog(
-                node_id=peer_id,
-                node_kind=peer_kind,
-                display_label="n/a",
-            )
+            node_changelog = NodeChangelog(node_id=peer_id, node_kind=peer_kind, display_label="n/a")
             if peer_relation.cardinality == RelationshipCardinality.ONE:
                 node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
                     name=peer_relation.name,
@@ -634,11 +630,7 @@ class RelationshipChangelogGetter:
         secondaries: list[NodeChangelog] = []
         peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
         if peer_relation:
-            node_changelog = NodeChangelog(
-                node_id=peer_id,
-                node_kind=peer_kind,
-                display_label="n/a",
-            )
+            node_changelog = NodeChangelog(node_id=peer_id, node_kind=peer_kind, display_label="n/a")
             if peer_relation.cardinality == RelationshipCardinality.ONE:
                 node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
                     name=peer_relation.name,

infrahub/core/constants/__init__.py

@@ -387,3 +387,4 @@ DEFAULT_REL_IDENTIFIER_LENGTH = 128
 
 OBJECT_TEMPLATE_RELATIONSHIP_NAME = "object_template"
 OBJECT_TEMPLATE_NAME_ATTR = "template_name"
+PROFILE_NODE_RELATIONSHIP_IDENTIFIER = "node__profile"

infrahub/core/constants/infrahubkind.py

@@ -28,6 +28,7 @@ GENERATORDEFINITION = "CoreGeneratorDefinition"
 GENERATORINSTANCE = "CoreGeneratorInstance"
 GENERATORVALIDATOR = "CoreGeneratorValidator"
 GENERATORGROUP = "CoreGeneratorGroup"
+GENERATORAWAREGROUP = "CoreGeneratorAwareGroup"
 GENERICGROUP = "CoreGroup"
 GLOBALPERMISSION = "CoreGlobalPermission"
 GRAPHQLQUERY = "CoreGraphQLQuery"

infrahub/core/convert_object_type/object_conversion.py

@@ -0,0 +1,201 @@
+from typing import Any, assert_never
+
+from infrahub_sdk.convert_object_type import ConversionFieldInput, ConversionFieldValue
+
+from infrahub.core.attribute import BaseAttribute
+from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
+from infrahub.core.constants import BranchSupportType, RelationshipCardinality
+from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
+from infrahub.core.node.create import create_node
+from infrahub.core.query.relationship import GetAllPeersIds
+from infrahub.core.query.resource_manager import PoolChangeReserved
+from infrahub.core.relationship import RelationshipManager
+from infrahub.core.schema import NodeSchema
+from infrahub.core.timestamp import Timestamp
+from infrahub.database import InfrahubDatabase
+from infrahub.message_bus.messages import RefreshRegistryBranches
+from infrahub.tasks.registry import update_branch_registry
+from infrahub.workers.dependencies import get_message_bus
+
+
+def _get_conversion_field_raw_value(conv_field_value: ConversionFieldValue) -> Any:
+    if conv_field_value.attribute_value is not None:
+        return conv_field_value.attribute_value
+    if conv_field_value.peer_id is not None:
+        return conv_field_value.peer_id
+    if conv_field_value.peers_ids is not None:
+        return conv_field_value.peers_ids
+    raise ValueError("ConversionFieldValue has not been validated correctly.")
+
+
+async def get_out_rels_peers_ids(node: Node, db: InfrahubDatabase, at: Timestamp) -> list[str]:
+    all_peers_ids: list[str] = []
+    for name in node._relationships:
+        relm: RelationshipManager = getattr(node, name)
+        peers = await relm.get_db_peers(db=db, at=at)
+        all_peers_ids.extend([str(peer.peer_id) for peer in peers])
+    return all_peers_ids
+
+
+async def build_data_new_node(db: InfrahubDatabase, mapping: dict[str, ConversionFieldInput], node: Node) -> dict:
+    """Value of a given field on the target kind to convert is either an input source attribute/relationship of the source node,
+    or a raw value."""
+
+    data = {}
+    for dest_field_name, conv_field_input in mapping.items():
+        if conv_field_input.source_field is not None:
+            # Fetch the value of the corresponding field from the node being converted.
+            item = getattr(node, conv_field_input.source_field)
+            if isinstance(item, BaseAttribute):
+                data[dest_field_name] = item.value
+            elif isinstance(item, RelationshipManager):
+                if item.schema.cardinality == RelationshipCardinality.ONE:
+                    peer = await item.get_peer(db=db)
+                    if peer is not None:
+                        data[dest_field_name] = {"id": peer.id}
+                    # else, relationship is optional, and if the target relationship is mandatory an error will be raised during creation
+                elif item.schema.cardinality == RelationshipCardinality.MANY:
+                    data[dest_field_name] = [{"id": peer.id} for _, peer in (await item.get_peers(db=db)).items()]
+                else:
+                    assert_never(item.schema.cardinality)
+        elif conv_field_input.data is not None:
+            data[dest_field_name] = _get_conversion_field_raw_value(conv_field_input.data)
+        elif conv_field_input.use_default_value is True:
+            pass  # default value will be used automatically when creating the node
+        else:
+            raise ValueError("ConversionFieldInput has not been validated correctly.")
+    return data
+
+
+async def get_unidirectional_rels_peers_ids(
+    node: Node, branch: Branch, db: InfrahubDatabase, at: Timestamp
+) -> list[str]:
+    """
+    Returns peers ids of nodes connected to input `node` through an incoming unidirectional relationship.
+    """
+
+    out_rels_identifier = [rel.identifier for rel in node.get_schema().relationships]
+    branch_agnostic = node.get_schema().branch == BranchSupportType.AGNOSTIC
+    query = await GetAllPeersIds.init(
+        db=db,
+        node_id=node.id,
+        branch=branch,
+        exclude_identifiers=out_rels_identifier,
+        branch_agnostic=branch_agnostic,
+        at=at,
+    )
+    await query.execute(db=db)
+    return query.get_peers_uuids()
+
+
+async def _get_other_active_branches(db: InfrahubDatabase) -> list[Branch]:
+    branches = await Branch.get_list(db=db)
+    return [branch for branch in branches if not (branch.is_global or branch.is_default)]
+
+
+def _has_pass_thru_aware_attributes(node_schema: NodeSchema, mapping: dict[str, ConversionFieldInput]) -> bool:
+    aware_attributes = [attr for attr in node_schema.attributes if attr.branch != BranchSupportType.AGNOSTIC]
+    aware_attributes_pass_thru = [
+        attr.name for attr in aware_attributes if attr.name in mapping and mapping[attr.name].source_field is not None
+    ]
+    return len(aware_attributes_pass_thru) > 0
+
+
+async def validate_conversion(
+    deleted_node: Node, branch: Branch, db: InfrahubDatabase, timestamp_before_conversion: Timestamp
+) -> None:
+    deleted_node_out_rels_peer_ids = await get_out_rels_peers_ids(
+        node=deleted_node, db=db, at=timestamp_before_conversion
+    )
+    deleted_node_unidir_rels_peer_ids = await get_unidirectional_rels_peers_ids(
+        node=deleted_node, db=db, branch=branch, at=timestamp_before_conversion
+    )
+
+    # Make sure relationships with constraints are not broken by retrieving them
+    peers_ids = deleted_node_out_rels_peer_ids + deleted_node_unidir_rels_peer_ids
+    peers = await NodeManager.get_many(ids=peers_ids, db=db, prefetch_relationships=True, branch=branch)
+    for peer in peers.values():
+        peer.validate_relationships()
+
+
+async def convert_and_validate_object_type(
+    node: Node,
+    target_schema: NodeSchema,
+    mapping: dict[str, ConversionFieldInput],
+    branch: Branch,
+    db: InfrahubDatabase,
+) -> Node:
+    async with db.start_transaction() as dbt:
+        timestamp_before_conversion = Timestamp()
+        new_node = await convert_object_type(
+            node=node, target_schema=target_schema, mapping=mapping, branch=branch, db=dbt
+        )
+        await validate_conversion(
+            deleted_node=node, branch=branch, db=dbt, timestamp_before_conversion=timestamp_before_conversion
+        )
+
+    # Refresh outside the transaction otherwise other workers would pull outdated branch objects.
+    message_bus = await get_message_bus()
+    await message_bus.send(RefreshRegistryBranches())
+
+    return new_node
+
+
+async def convert_object_type(
+    node: Node,
+    target_schema: NodeSchema,
+    mapping: dict[str, ConversionFieldInput],
+    branch: Branch,
+    db: InfrahubDatabase,
+) -> Node:
+    """Delete the node and return the new created one. If creation fails, the node is not deleted, and raise an error.
+    An extra check is performed on input node peers relationships to make sure they are still valid."""
+
+    node_schema = node.get_schema()
+    if not isinstance(node_schema, NodeSchema):
+        raise ValueError(f"Only a node with a NodeSchema can be converted, got {type(node_schema)}")
+
+    # Delete the node, so we delete relationships with peers as well, which might temporarily break cardinality constraints
+    # but they should be restored when creating the new node.
+    deleted_nodes = await NodeManager.delete(db=db, branch=branch, nodes=[node], cascade_delete=False)
+    if len(deleted_nodes) != 1:
+        raise ValueError(f"Deleted {len(deleted_nodes)} nodes instead of 1")
+
+    data_new_node = await build_data_new_node(db, mapping, node)
+
+    if node_schema.branch == BranchSupportType.AGNOSTIC and _has_pass_thru_aware_attributes(
+        node_schema=node_schema, mapping=mapping
+    ):
+        if not branch.is_default:
+            raise ValueError(
+                f"Conversion of {node_schema.kind} is not allowed on branch {branch.name} because it is agnostic and has aware attributes"
+            )
+
+        # When converting an agnostic node with aware attributes, we need to put other branches in NEED_REBASE state
+        # as aware attributes do not exist in other branches after conversion
+        other_branches = await _get_other_active_branches(db=db)
+        for br in other_branches:
+            br.status = BranchStatus.NEED_REBASE
+            await br.save(db=db)
+            # Registry of other API workers are updated outside the transaction
+            await update_branch_registry(db=db, branch=br)
+
+    node_created = await create_node(
+        data=data_new_node,
+        db=db,
+        branch=branch,
+        schema=target_schema,
+    )
+
+    # If the node had some value reserved in any Pools / Resource Manager, we need to change the identifier of the reservation(s)
+    query = await PoolChangeReserved.init(
+        db=db,
+        existing_identifier=node.get_id(),
+        new_identifier=node_created.get_id(),
+        branch=branch,
+    )
+    await query.execute(db=db)
+
+    return node_created

infrahub/core/convert_object_type/repository_conversion.py

@@ -0,0 +1,89 @@
+from infrahub import lock
+from infrahub.core.branch import Branch
+from infrahub.core.constants.infrahubkind import REPOSITORYVALIDATOR, USERVALIDATOR
+from infrahub.core.convert_object_type.object_conversion import (
+    ConversionFieldInput,
+    convert_object_type,
+    validate_conversion,
+)
+from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
+from infrahub.core.protocols import CoreReadOnlyRepository, CoreRepository
+from infrahub.core.schema import NodeSchema
+from infrahub.core.timestamp import Timestamp
+from infrahub.database import InfrahubDatabase
+from infrahub.message_bus.messages import RefreshRegistryBranches
+from infrahub.repositories.create_repository import RepositoryFinalizer
+from infrahub.workers.dependencies import get_message_bus
+
+
+async def convert_repository_type(
+    repository: CoreRepository | CoreReadOnlyRepository,
+    target_schema: NodeSchema,
+    mapping: dict[str, ConversionFieldInput],
+    branch: Branch,
+    db: InfrahubDatabase,
+    repository_post_creator: RepositoryFinalizer,
+) -> Node:
+    """Delete the node and return the new created one. If creation fails, the node is not deleted, and raise an error.
+    An extra check is performed on input node peers relationships to make sure they are still valid."""
+
+    repo_name = repository.name.value
+    async with lock.registry.get(name=repo_name, namespace="repository"):
+        async with db.start_transaction() as dbt:
+            timestamp_before_conversion = Timestamp()
+
+            # Fetch validators before deleting the repository otherwise validator-repository would no longer exist
+            user_validators = await NodeManager.query(
+                db=dbt, schema=USERVALIDATOR, prefetch_relationships=True, filters={"repository__id": repository.id}
+            )
+            repository_validators = await NodeManager.query(
+                db=dbt,
+                schema=REPOSITORYVALIDATOR,
+                prefetch_relationships=True,
+                filters={"repository__id": repository.id},
+            )
+            new_repository = await convert_object_type(
+                node=repository,  # type: ignore[arg-type]
+                target_schema=target_schema,
+                mapping=mapping,
+                branch=branch,
+                db=dbt,
+            )
+
+            for user_validator in user_validators:
+                await user_validator.repository.update(db=dbt, data=new_repository)
+                await user_validator.repository.save(db=dbt)
+
+            for repository_validator in repository_validators:
+                await repository_validator.repository.update(db=dbt, data=new_repository)
+                await repository_validator.repository.save(db=dbt)
+
+            await validate_conversion(
+                deleted_node=repository,  # type: ignore[arg-type]
+                branch=branch,
+                db=dbt,
+                timestamp_before_conversion=timestamp_before_conversion,
+            )
+
+        # Refresh outside the transaction otherwise other workers would pull outdated branch objects.
+        message_bus = await get_message_bus()
+        await message_bus.send(RefreshRegistryBranches())
+
+        # Following call involve a potential update of `commit` value of the newly created repository
+        # that would be done from another database connection so it can't be performed within above transaction.
+        # Also note since the conversion can only be performed on main branch here, it is fine that we do it
+        # after having updating other branches status to NEEDS_REBASE.
+        await repository_post_creator.post_create(
+            branch=branch,
+            obj=new_repository,  # type: ignore
+            db=db,
+            delete_on_connectivity_failure=False,
+        )
+
+        # Delete the RepositoryGroup associated with the old repository, as a new one was created for the new repository.
+        repository_groups = (await repository.groups_objects.get_peers(db=db)).values()
+        for repository_group in repository_groups:
+            await NodeManager.delete(db=db, branch=branch, nodes=[repository_group], cascade_delete=False)
+
+    return new_repository

infrahub/core/convert_object_type/schema_mapping.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel
 
-from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.constants import BranchSupportType, RelationshipCardinality
 from infrahub.core.schema import NodeSchema
 
 
@@ -13,6 +13,21 @@ class SchemaMappingValue(BaseModel):
 SchemaMapping = dict[str, SchemaMappingValue]
 
 
+def _are_branch_support_matching(
+    left_branch_support: BranchSupportType | None,
+    right_branch_support: BranchSupportType | None,
+) -> bool:
+    if left_branch_support == right_branch_support:
+        return True
+
+    local_aware = [BranchSupportType.AWARE, BranchSupportType.LOCAL]
+
+    if left_branch_support in local_aware and right_branch_support in local_aware:
+        return True
+
+    return False
+
+
 def get_schema_mapping(source_schema: NodeSchema, target_schema: NodeSchema) -> SchemaMapping:
     """
     Return fields mapping meant to be used for converting a node from `source_kind` to `target_kind`.
@@ -31,7 +46,11 @@ def get_schema_mapping(source_schema: NodeSchema, target_schema: NodeSchema) ->
     # Process attributes
     for target_attr in target_schema.attributes:
         source_attr = source_attrs.get(target_attr.name)
-        if source_attr and source_attr.kind == target_attr.kind:
+        if (
+            source_attr
+            and source_attr.kind == target_attr.kind
+            and _are_branch_support_matching(source_attr.branch, target_attr.branch)
+        ):
             target_field_to_source_field[target_attr.name] = SchemaMappingValue(
                 source_field_name=source_attr.name, is_mandatory=not target_attr.optional
             )
@@ -41,7 +60,12 @@ def get_schema_mapping(source_schema: NodeSchema, target_schema: NodeSchema) ->
     # Process relationships
     for target_rel in target_schema.relationships:
         source_rel = source_rels.get(target_rel.name)
-        if source_rel and source_rel.peer == target_rel.peer and source_rel.cardinality == target_rel.cardinality:
+        if (
+            source_rel
+            and source_rel.peer == target_rel.peer
+            and source_rel.cardinality == target_rel.cardinality
+            and _are_branch_support_matching(source_rel.branch, target_rel.branch)
+        ):
             target_field_to_source_field[target_rel.name] = SchemaMappingValue(
                 source_field_name=source_rel.name,
                 is_mandatory=not target_rel.optional,

infrahub/core/diff/model/path.py

@@ -335,6 +335,10 @@ class EnrichedDiffNode(BaseSummary):
     def kind(self) -> str:
         return self.identifier.kind
 
+    @property
+    def is_schema_node(self) -> bool:
+        return self.identifier.kind.startswith("Schema")
+
     @property
     def num_properties(self) -> int:
         return sum(a.num_properties for a in self.attributes) + sum(r.num_properties for r in self.relationships)

infrahub/core/diff/payload_builder.py

@@ -36,7 +36,7 @@ async def get_display_labels_per_kind(
             break
         node_map = await NodeManager.get_many(ids=limited_ids, fields=fields, db=db, branch=branch)
         for node_id, node in node_map.items():
-            display_label_map[node_id] = await node.render_display_label(db=db)
+            display_label_map[node_id] = await node.get_display_label(db=db)
         offset += limit
     return display_label_map
 

infrahub/core/diff/query/artifact.py

@@ -148,7 +148,7 @@ CALL (target_node, definition_node){
         )
         RETURN
             target_artifact,
-            (trel1.status = "active" AND trel2.status = "active" AND drel1.status = "active" AND drel1.status = "active") AS artifact_is_active
+            (trel1.status = "active" AND trel2.status = "active" AND drel1.status = "active" AND drel2.status = "active") AS artifact_is_active
         ORDER BY trel1.from DESC, trel2.from DESC, drel1.from DESC, drel2.from DESC,
             trel1.status ASC, trel2.status ASC, drel1.status ASC, drel2.status ASC
         LIMIT 1

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 39
+GRAPH_VERSION = 42

infrahub/core/initialization.py

@@ -34,7 +34,7 @@ from infrahub.database import InfrahubDatabase
 from infrahub.database.memgraph import IndexManagerMemgraph
 from infrahub.database.neo4j import IndexManagerNeo4j
 from infrahub.exceptions import DatabaseError
-from infrahub.graphql.manager import GraphQLSchemaManager
+from infrahub.graphql.manager import registry as graphql_registry
 from infrahub.log import get_logger
 from infrahub.menu.utils import create_default_menu
 from infrahub.permissions import PermissionBackend, get_or_create_global_permission
@@ -196,7 +196,7 @@ async def initialization(db: InfrahubDatabase, add_database_indexes: bool = Fals
 
     default_branch = registry.get_branch_from_registry(branch=registry.default_branch)
     schema_branch = registry.schema.get_schema_branch(name=default_branch.name)
-    gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=default_branch, schema_branch=schema_branch)
+    gqlm = graphql_registry.get_manager_for_branch(branch=default_branch, schema_branch=schema_branch)
     gqlm.get_graphql_schema(
         include_query=True,
         include_mutation=True,

infrahub/core/ipam/utilization.py

@@ -152,4 +152,4 @@ class PrefixUtilizationGetter:
             grand_total_space += prefix_total_space
         if grand_total_space == 0:
             return 0.0
-        return (grand_total_used / grand_total_space) * 100
+        return min((grand_total_used / grand_total_space) * 100, 100)