infrahub-server 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/computed_attribute/tasks.py

@@ -15,7 +15,7 @@ from infrahub.events import BranchDeletedEvent
 from infrahub.git.repository import get_initialized_repo
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.trigger.models import TriggerSetupReport, TriggerType
-from infrahub.trigger.setup import setup_triggers
+from infrahub.trigger.setup import setup_triggers, setup_triggers_specific
 from infrahub.workflows.catalogue import (
     COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
     COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
@@ -304,36 +304,30 @@ async def computed_attribute_setup_jinja2(
             await add_tags(branches=[branch_name])
             await wait_for_schema_to_converge(branch_name=branch_name, component=service.component, db=db, log=log)
 
-        triggers = await gather_trigger_computed_attribute_jinja2()
-
+        report: TriggerSetupReport = await setup_triggers_specific(
+            gatherer=gather_trigger_computed_attribute_jinja2, trigger_type=TriggerType.COMPUTED_ATTR_JINJA2
+        )  # type: ignore[misc]
         # Configure all ComputedAttrJinja2Trigger in Prefect
-        async with get_client(sync_client=False) as prefect_client:
-            report: TriggerSetupReport = await setup_triggers(
-                client=prefect_client,
-                triggers=triggers,
-                trigger_type=TriggerType.COMPUTED_ATTR_JINJA2,
-                force_update=False,
-            )  # type: ignore[misc]
 
-            # Since we can have multiple trigger per NodeKind
-            # we need to extract the list of unique node that should be processed
-            unique_nodes: set[tuple[str, str, str]] = {
-                (trigger.branch, trigger.computed_attribute.kind, trigger.computed_attribute.attribute.name)  # type: ignore[attr-defined]
-                for trigger in report.updated + report.created
-            }
-            for branch, kind, attribute_name in unique_nodes:
-                if event_name != BranchDeletedEvent.event_name and branch == branch_name:
-                    await service.workflow.submit_workflow(
-                        workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
-                        context=context,
-                        parameters={
-                            "branch_name": branch,
-                            "computed_attribute_name": attribute_name,
-                            "computed_attribute_kind": kind,
-                        },
-                    )
-
-        log.info(f"{len(triggers)} Computed Attribute for Jinja2 automation configuration completed")
+        # Since we can have multiple trigger per NodeKind
+        # we need to extract the list of unique node that should be processed
+        unique_nodes: set[tuple[str, str, str]] = {
+            (trigger.branch, trigger.computed_attribute.kind, trigger.computed_attribute.attribute.name)  # type: ignore[attr-defined]
+            for trigger in report.updated + report.created
+        }
+        for branch, kind, attribute_name in unique_nodes:
+            if event_name != BranchDeletedEvent.event_name and branch == branch_name:
+                await service.workflow.submit_workflow(
+                    workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+                    context=context,
+                    parameters={
+                        "branch_name": branch,
+                        "computed_attribute_name": attribute_name,
+                        "computed_attribute_kind": kind,
+                    },
+                )
+
+        log.info(f"{report.in_use_count} Computed Attribute for Jinja2 automation configuration completed")
 
 
 @flow(

infrahub/core/account.py

@@ -69,8 +69,7 @@ class AccountGlobalPermissionQuery(Query):
         query = """
         MATCH (account:%(generic_account_node)s)
         WHERE account.uuid = $account_id
-        CALL {
-            WITH account
+        CALL (account) {
             MATCH (account)-[r:IS_PART_OF]-(root:Root)
             WHERE %(branch_filter)s
             RETURN account as account1, r as r1
@@ -80,8 +79,7 @@ class AccountGlobalPermissionQuery(Query):
         WITH account, r1 as r
         WHERE r.status = "active"
         WITH account
-        CALL {
-            WITH account
+        CALL (account) {
             MATCH (account)-[r1:IS_RELATED]->(:Relationship {name: "group_member"})<-[r2:IS_RELATED]-(account_group:%(account_group_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH account_group, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -92,8 +90,7 @@ class AccountGlobalPermissionQuery(Query):
         }
         WITH account_group
 
-        CALL {
-            WITH account_group
+        CALL (account_group) {
             MATCH (account_group)-[r1:IS_RELATED]->(:Relationship {name: "role__accountgroups"})<-[r2:IS_RELATED]-(account_role:%(account_role_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH account_role, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -104,8 +101,7 @@ class AccountGlobalPermissionQuery(Query):
         }
         WITH account_role
 
-        CALL {
-            WITH account_role
+        CALL (account_role) {
             MATCH (account_role)-[r1:IS_RELATED]->(:Relationship {name: "role__permissions"})<-[r2:IS_RELATED]-(global_permission:%(global_permission_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH global_permission, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -116,7 +112,7 @@ class AccountGlobalPermissionQuery(Query):
         }
         WITH global_permission
 
-        CALL {
+        CALL (global_permission) {
             WITH global_permission
             MATCH (global_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "action"})-[r2:HAS_VALUE]->(global_permission_action:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
@@ -127,8 +123,7 @@ class AccountGlobalPermissionQuery(Query):
         WITH global_permission, global_permission_action, is_active AS gpa_is_active
         WHERE gpa_is_active = TRUE
 
-        CALL {
-            WITH global_permission
+        CALL (global_permission) {
             MATCH (global_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "decision"})-[r2:HAS_VALUE]->(global_permission_decision:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN global_permission_decision, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -183,8 +178,7 @@ class AccountObjectPermissionQuery(Query):
         query = """
         MATCH (account:%(generic_account_node)s)
         WHERE account.uuid = $account_id
-        CALL {
-            WITH account
+        CALL (account) {
             MATCH (account)-[r:IS_PART_OF]-(root:Root)
             WHERE %(branch_filter)s
             RETURN account as account1, r as r1
@@ -194,8 +188,7 @@ class AccountObjectPermissionQuery(Query):
         WITH account, r1 as r
         WHERE r.status = "active"
         WITH account
-        CALL {
-            WITH account
+        CALL (account) {
             MATCH (account)-[r1:IS_RELATED]->(:Relationship {name: "group_member"})<-[r2:IS_RELATED]-(account_group:%(account_group_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH account_group, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -206,8 +199,7 @@ class AccountObjectPermissionQuery(Query):
         }
         WITH account_group
 
-        CALL {
-            WITH account_group
+        CALL (account_group) {
             MATCH (account_group)-[r1:IS_RELATED]->(:Relationship {name: "role__accountgroups"})<-[r2:IS_RELATED]-(account_role:%(account_role_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH account_role, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -218,8 +210,7 @@ class AccountObjectPermissionQuery(Query):
         }
         WITH account_role
 
-        CALL {
-            WITH account_role
+        CALL (account_role) {
             MATCH (account_role)-[r1:IS_RELATED]->(:Relationship {name: "role__permissions"})<-[r2:IS_RELATED]-(object_permission:%(object_permission_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH object_permission, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -230,8 +221,7 @@ class AccountObjectPermissionQuery(Query):
         }
         WITH object_permission
 
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "namespace"})-[r2:HAS_VALUE]->(object_permission_namespace:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_namespace, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -240,8 +230,7 @@ class AccountObjectPermissionQuery(Query):
         }
         WITH object_permission, object_permission_namespace, is_active AS opn_is_active
         WHERE opn_is_active = TRUE
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "name"})-[r2:HAS_VALUE]->(object_permission_name:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_name, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -250,8 +239,7 @@ class AccountObjectPermissionQuery(Query):
         }
         WITH object_permission, object_permission_namespace, object_permission_name, is_active AS opn_is_active
         WHERE opn_is_active = TRUE
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "action"})-[r2:HAS_VALUE]->(object_permission_action:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_action, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -260,8 +248,7 @@ class AccountObjectPermissionQuery(Query):
         }
         WITH object_permission, object_permission_namespace, object_permission_name, object_permission_action, is_active AS opa_is_active
         WHERE opa_is_active = TRUE
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "decision"})-[r2:HAS_VALUE]->(object_permission_decision:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_decision, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -336,8 +323,7 @@ class AccountRoleGlobalPermissionQuery(Query):
         query = """
         MATCH (account_role:%(account_role_node)s)
         WHERE account_role.uuid = $role_id
-        CALL {
-            WITH account_role
+        CALL (account_role) {
             MATCH (account_role)-[r:IS_PART_OF]-(root:Root)
             WHERE %(branch_filter)s
             RETURN account_role as account_role1, r as r1
@@ -348,8 +334,7 @@ class AccountRoleGlobalPermissionQuery(Query):
         WHERE r.status = "active"
         WITH account_role
 
-        CALL {
-            WITH account_role
+        CALL (account_role) {
             MATCH (account_role)-[r1:IS_RELATED]->(:Relationship {name: "role__permissions"})<-[r2:IS_RELATED]-(global_permission:%(global_permission_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH global_permission, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -360,8 +345,7 @@ class AccountRoleGlobalPermissionQuery(Query):
         }
         WITH global_permission
 
-        CALL {
-            WITH global_permission
+        CALL (global_permission) {
             MATCH (global_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "action"})-[r2:HAS_VALUE]->(global_permission_action:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN global_permission_action, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -371,8 +355,7 @@ class AccountRoleGlobalPermissionQuery(Query):
         WITH global_permission, global_permission_action, is_active AS gpa_is_active
         WHERE gpa_is_active = TRUE
 
-        CALL {
-            WITH global_permission
+        CALL (global_permission) {
             MATCH (global_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "decision"})-[r2:HAS_VALUE]->(global_permission_decision:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN global_permission_decision, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -425,8 +408,7 @@ class AccountRoleObjectPermissionQuery(Query):
         query = """
         MATCH (account_role:%(account_role_node)s)
         WHERE account_role.uuid = $role_id
-        CALL {
-            WITH account_role
+        CALL (account_role) {
             MATCH (account_role)-[r:IS_PART_OF]-(root:Root)
             WHERE %(branch_filter)s
             RETURN account_role as account_role1, r as r1
@@ -437,8 +419,7 @@ class AccountRoleObjectPermissionQuery(Query):
         WHERE r.status = "active"
         WITH account_role
 
-        CALL {
-            WITH account_role
+        CALL (account_role) {
             MATCH (account_role)-[r1:IS_RELATED]->(:Relationship {name: "role__permissions"})<-[r2:IS_RELATED]-(object_permission:%(object_permission_node)s)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             WITH object_permission, r1, r2, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -449,8 +430,7 @@ class AccountRoleObjectPermissionQuery(Query):
         }
         WITH object_permission
 
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "namespace"})-[r2:HAS_VALUE]->(object_permission_namespace:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_namespace, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -459,8 +439,7 @@ class AccountRoleObjectPermissionQuery(Query):
         }
         WITH object_permission, object_permission_namespace, is_active AS opn_is_active
         WHERE opn_is_active = TRUE
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "name"})-[r2:HAS_VALUE]->(object_permission_name:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_name, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -469,8 +448,7 @@ class AccountRoleObjectPermissionQuery(Query):
         }
         WITH object_permission, object_permission_namespace, object_permission_name, is_active AS opn_is_active
         WHERE opn_is_active = TRUE
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "action"})-[r2:HAS_VALUE]->(object_permission_action:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_action, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -479,8 +457,7 @@ class AccountRoleObjectPermissionQuery(Query):
         }
         WITH object_permission, object_permission_namespace, object_permission_name, object_permission_action, is_active AS opa_is_active
         WHERE opa_is_active = TRUE
-        CALL {
-            WITH object_permission
+        CALL (object_permission) {
             MATCH (object_permission)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "decision"})-[r2:HAS_VALUE]->(object_permission_decision:AttributeValue)
             WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
             RETURN object_permission_decision, (r1.status = "active" AND r2.status = "active") AS is_active

infrahub/core/attribute.py

@@ -93,8 +93,8 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         updated_at: Timestamp | str | None = None,
         is_default: bool = False,
         is_from_profile: bool = False,
-        **kwargs,
-    ):
+        **kwargs: dict[str, Any],
+    ) -> None:
         self.id = id
         self.db_id = db_id
 
@@ -169,7 +169,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         return self.branch
 
     @classmethod
-    def __init_subclass__(cls, **kwargs) -> None:
+    def __init_subclass__(cls, **kwargs: dict[str, Any]) -> None:
         super().__init_subclass__(**kwargs)
         registry.attribute[cls.__name__] = cls
 
@@ -232,7 +232,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         Raises:
             ValidationError: Content of the attribute value is not valid
         """
-        if schema.regex:
+        if regex := schema.get_regex():
             if schema.kind == "List":
                 validation_values = [str(entry) for entry in value]
             else:
@@ -240,22 +240,20 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
             for validation_value in validation_values:
                 try:
-                    is_valid = re.match(pattern=schema.regex, string=str(validation_value))
+                    is_valid = re.match(pattern=regex, string=str(validation_value))
                 except re.error as exc:
-                    raise ValidationError(
-                        {name: f"The regex defined in the schema is not valid ({schema.regex!r})"}
-                    ) from exc
+                    raise ValidationError({name: f"The regex defined in the schema is not valid ({regex!r})"}) from exc
 
                 if not is_valid:
-                    raise ValidationError({name: f"{validation_value} must conform with the regex: {schema.regex!r}"})
+                    raise ValidationError({name: f"{validation_value} must conform with the regex: {regex!r}"})
 
-        if schema.min_length:
-            if len(value) < schema.min_length:
-                raise ValidationError({name: f"{value} must have a minimum length of {schema.min_length!r}"})
+        if min_length := schema.get_min_length():
+            if len(value) < min_length:
+                raise ValidationError({name: f"{value} must have a minimum length of {min_length!r}"})
 
-        if schema.max_length:
-            if len(value) > schema.max_length:
-                raise ValidationError({name: f"{value} must have a maximum length of {schema.max_length!r}"})
+        if max_length := schema.get_max_length():
+            if len(value) > max_length:
+                raise ValidationError({name: f"{value} must have a maximum length of {max_length!r}"})
 
         if schema.enum:
             try:

infrahub/core/constants/__init__.py

@@ -112,6 +112,11 @@ class AccountType(InfrahubStringEnum):
     Git = "Git"
 
 
+class NumberPoolType(InfrahubStringEnum):
+    USER = "User"
+    SCHEMA = "Schema"
+
+
 class AccountStatus(InfrahubStringEnum):
     ACTIVE = "active"
     INACTIVE = "inactive"
@@ -146,6 +151,11 @@ class AllowOverrideType(InfrahubStringEnum):
     ANY = "any"
 
 
+class RepositoryObjects(InfrahubStringEnum):
+    OBJECT = "object"
+    MENU = "menu"
+
+
 class ContentType(InfrahubStringEnum):
     APPLICATION_JSON = "application/json"
     APPLICATION_YAML = "application/yaml"

infrahub/core/constants/infrahubkind.py

@@ -2,6 +2,7 @@ ACCOUNT = "CoreAccount"
 ACCOUNTGROUP = "CoreAccountGroup"
 ACCOUNTROLE = "CoreAccountRole"
 ACCOUNTTOKEN = "InternalAccountToken"
+ACTION = "CoreAction"
 ARTIFACT = "CoreArtifact"
 ARTIFACTCHECK = "CoreArtifactCheck"
 ARTIFACTDEFINITION = "CoreArtifactDefinition"
@@ -21,6 +22,7 @@ DATAVALIDATOR = "CoreDataValidator"
 FILECHECK = "CoreFileCheck"
 FILETHREAD = "CoreFileThread"
 GENERICACCOUNT = "CoreGenericAccount"
+GENERATORACTION = "CoreGeneratorAction"
 GENERATORCHECK = "CoreGeneratorCheck"
 GENERATORDEFINITION = "CoreGeneratorDefinition"
 GENERATORINSTANCE = "CoreGeneratorInstance"
@@ -30,6 +32,8 @@ GENERICGROUP = "CoreGroup"
 GLOBALPERMISSION = "CoreGlobalPermission"
 GRAPHQLQUERY = "CoreGraphQLQuery"
 GRAPHQLQUERYGROUP = "CoreGraphQLQueryGroup"
+GROUPACTION = "CoreGroupAction"
+GROUPTRIGGERRULE = "CoreGroupTriggerRule"
 IPNAMESPACE = "BuiltinIPNamespace"
 IPADDRESS = "BuiltinIPAddress"
 IPADDRESSPOOL = "CoreIPAddressPool"
@@ -39,6 +43,9 @@ MENU = "CoreMenu"
 MENUITEM = "CoreMenuItem"
 NAMESPACE = "IpamNamespace"
 NODE = "CoreNode"
+NODETRIGGERRULE = "CoreNodeTriggerRule"
+NODETRIGGERATTRIBUTEMATCH = "CoreNodeTriggerAttributeMatch"
+NODETRIGGERRELATIONSHIPMATCH = "CoreNodeTriggerRelationshipMatch"
 NUMBERPOOL = "CoreNumberPool"
 LINEAGEOWNER = "LineageOwner"
 LINEAGESOURCE = "LineageSource"
@@ -51,6 +58,7 @@ PROFILE = "CoreProfile"
 PROPOSEDCHANGE = "CoreProposedChange"
 REFRESHTOKEN = "InternalRefreshToken"
 REPOSITORY = "CoreRepository"
+REPOSITORYGROUP = "CoreRepositoryGroup"
 RESOURCEPOOL = "CoreResourcePool"
 GENERICREPOSITORY = "CoreGenericRepository"
 READONLYREPOSITORY = "CoreReadOnlyRepository"
@@ -67,6 +75,7 @@ THREADCOMMENT = "CoreThreadComment"
 TRANSFORM = "CoreTransformation"
 TRANSFORMJINJA2 = "CoreTransformJinja2"
 TRANSFORMPYTHON = "CoreTransformPython"
+TRIGGERRULE = "CoreTriggerRule"
 USERVALIDATOR = "CoreUserValidator"
 VALIDATOR = "CoreValidator"
 WEBHOOK = "CoreWebhook"

infrahub/core/constraint/node/runner.py

@@ -38,4 +38,6 @@ class NodeConstraintRunner:
                 relationship_manager: RelationshipManager = getattr(node, relationship_name)
                 await relationship_manager.fetch_relationship_ids(db=db, force_refresh=True)
                 for relationship_constraint in self.relationship_manager_constraints:
-                    await relationship_constraint.check(relm=relationship_manager, node_schema=node.get_schema())
+                    await relationship_constraint.check(
+                        relm=relationship_manager, node_schema=node.get_schema(), node=node
+                    )

infrahub/core/convert_object_type/conversion.py

@@ -0,0 +1,124 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from infrahub.core.attribute import BaseAttribute
+from infrahub.core.branch import Branch
+from infrahub.core.constants import 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.relationship import RelationshipManager
+from infrahub.core.schema import NodeSchema
+from infrahub.database import InfrahubDatabase
+
+
+class InputDataForDestField(BaseModel):  # Only one of these fields can be not None
+    attribute_value: Any | None = None
+    peer_id: str | None = None
+    peers_ids: list[str] | None = None
+
+    @property
+    def value(self) -> Any:
+        fields = [self.attribute_value, self.peer_id, self.peers_ids]
+        set_fields = [f for f in fields if f is not None]
+        if len(set_fields) != 1:
+            raise ValueError("Exactly one of attribute_value, peer_id, or peers_ids must be set")
+        return set_fields[0]
+
+
+class InputForDestField(BaseModel):  # Only one of these fields can be not None
+    source_field: str | None = None
+    data: InputDataForDestField | None = None
+
+    @property
+    def value(self) -> Any:
+        if self.source_field is not None and self.data is not None:
+            raise ValueError("Only one of source_field or data can be set")
+        if self.source_field is None and self.data is None:
+            raise ValueError("Either source_field or data must be set")
+        return self.source_field if self.source_field is not None else self.data
+
+
+async def get_out_rels_peers_ids(node: Node, db: InfrahubDatabase) -> list[str]:
+    all_peers: list[Node] = []
+    for name in node._relationships:
+        relm: RelationshipManager = getattr(node, name)
+        peers = await relm.get_peers(db=db)
+        all_peers.extend(peers.values())
+    return [peer.id for peer in all_peers]
+
+
+async def build_data_new_node(db: InfrahubDatabase, mapping: dict[str, InputForDestField], 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, input_for_dest_field in mapping.items():
+        value = input_for_dest_field.value
+        if isinstance(value, str):  # source_field
+            item = getattr(node, value)
+            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:
+                    raise ValueError(f"Unknown cardinality {item.schema.cardinality=}")
+        else:  # user input data
+            data[dest_field_name] = value.value
+    return data
+
+
+async def get_unidirectional_rels_peers_ids(node: Node, branch: Branch, db: InfrahubDatabase) -> 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]
+    query = await GetAllPeersIds.init(db=db, node_id=node.id, branch=branch, exclude_identifiers=out_rels_identifier)
+    await query.execute(db=db)
+    return query.get_peers_uuids()
+
+
+async def convert_object_type(
+    node: Node, target_schema: NodeSchema, mapping: dict[str, InputForDestField], 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)}")
+
+    async with db.start_transaction() as dbt:
+        deleted_node_out_rels_peer_ids = await get_out_rels_peers_ids(node=node, db=dbt)
+        deleted_node_unidir_rels_peer_ids = await get_unidirectional_rels_peers_ids(node=node, db=dbt, branch=branch)
+
+        # 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=dbt, 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(dbt, mapping, node)
+        node_created = await create_node(
+            data=data_new_node,
+            db=dbt,
+            branch=branch,
+            schema=target_schema,
+        )
+
+        # 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=dbt, prefetch_relationships=True, branch=branch)
+        for peer in peers.values():
+            peer.validate_relationships()
+
+        return node_created

infrahub/core/convert_object_type/schema_mapping.py

@@ -0,0 +1,56 @@
+from pydantic import BaseModel
+
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.schema import NodeSchema
+
+
+class SchemaMappingValue(BaseModel):
+    is_mandatory: bool
+    source_field_name: str | None = None  # None means there is no corresponding source field name
+    relationship_cardinality: RelationshipCardinality | None = None
+
+
+SchemaMapping = dict[str, SchemaMappingValue]
+
+
+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`.
+    For any field of the target kind, field of the source kind will be matched if:
+    - It's an attribute with identical name and type.
+    - It's a relationship with identical peer kind and cardinality.
+    If there is no match, the mapping will only indicate whether the field is mandatory or not.
+    """
+
+    target_field_to_source_field = {}
+
+    # Create lookup dictionaries for source attributes and relationships
+    source_attrs = {attr.name: attr for attr in source_schema.attributes}
+    source_rels = {rel.name: rel for rel in source_schema.relationships}
+
+    # 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:
+            target_field_to_source_field[target_attr.name] = SchemaMappingValue(
+                source_field_name=source_attr.name, is_mandatory=not target_attr.optional
+            )
+        else:
+            target_field_to_source_field[target_attr.name] = SchemaMappingValue(is_mandatory=not target_attr.optional)
+
+    # 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:
+            target_field_to_source_field[target_rel.name] = SchemaMappingValue(
+                source_field_name=source_rel.name,
+                is_mandatory=not target_rel.optional,
+                relationship_cardinality=target_rel.cardinality,
+            )
+        else:
+            target_field_to_source_field[target_rel.name] = SchemaMappingValue(
+                is_mandatory=not target_rel.optional,
+                relationship_cardinality=target_rel.cardinality,
+            )
+
+    return target_field_to_source_field

infrahub/core/diff/coordinator.py

@@ -4,7 +4,10 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Iterable, Literal, Sequence, overload
 from uuid import uuid4
 
+from prefect import flow
+
 from infrahub import lock
+from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import ValidationError
 from infrahub.log import get_logger
@@ -22,7 +25,6 @@ from .model.path import (
 )
 
 if TYPE_CHECKING:
-    from infrahub.core.branch import Branch
     from infrahub.core.node import Node
 
     from .calculator import DiffCalculator
@@ -301,6 +303,11 @@ class DiffCoordinator:
         force_branch_refresh: Literal[False] = ...,
     ) -> tuple[EnrichedDiffs | EnrichedDiffsMetadata, set[NodeIdentifier]]: ...
 
+    @flow(  # type: ignore[misc]
+        name="update-diff",
+        flow_run_name="Update diff for {base_branch.name} - {diff_branch.name}: ({from_time}-{to_time}),tracking_id={tracking_id}",
+        validate_parameters=False,
+    )
     async def _update_diffs(
         self,
         base_branch: Branch,