infrahub-server 1.2.11__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

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

@@ -146,6 +146,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/convert_object_type/conversion.py

@@ -0,0 +1,122 @@
+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:  # noqa: PLR1702
+        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)
+
+        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/query/all_conflicts.py

@@ -37,22 +37,18 @@ AND (
     ($diff_id IS NOT NULL AND root.uuid = $diff_id)
     OR ($tracking_id IS NOT NULL AND root.tracking_id = $tracking_id AND root.diff_branch = $diff_branch_name)
 )
-CALL {
-    WITH root
+CALL (root) {
     MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_CONFLICT]->(node_conflict:DiffConflict)
     RETURN node.path_identifier AS path_identifier, node_conflict AS conflict
     UNION
-    WITH root
     MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_ATTRIBUTE]->(:DiffAttribute)
         -[:DIFF_HAS_PROPERTY]->(property:DiffProperty)-[:DIFF_HAS_CONFLICT]->(attr_property_conflict:DiffConflict)
     RETURN property.path_identifier AS path_identifier, attr_property_conflict AS conflict
     UNION
-    WITH root
     MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_RELATIONSHIP]->(:DiffRelationship)
         -[:DIFF_HAS_ELEMENT]->(element:DiffRelationshipElement)-[:DIFF_HAS_CONFLICT]->(rel_element_conflict:DiffConflict)
     RETURN element.path_identifier AS path_identifier, rel_element_conflict AS conflict
     UNION
-    WITH root
     MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_RELATIONSHIP]->(:DiffRelationship)
         -[:DIFF_HAS_ELEMENT]->(:DiffRelationshipElement)-[:DIFF_HAS_PROPERTY]->(property:DiffProperty)
         -[:DIFF_HAS_CONFLICT]->(rel_property_conflict:DiffConflict)

infrahub/core/diff/query/artifact.py

@@ -40,8 +40,7 @@ class ArtifactDiffQuery(Query):
 // -----------------------
 MATCH (source_artifact:%(artifact_kind)s)-[r:IS_PART_OF]->(:Root)
 WHERE r.branch IN [$source_branch_name, $target_branch_name]
-CALL {
-    WITH source_artifact
+CALL (source_artifact) {
     MATCH (source_artifact)-[r:IS_PART_OF]->(:Root)
     WHERE %(source_branch_filter)s
     RETURN r AS root_rel
@@ -50,13 +49,11 @@ CALL {
 }
 WITH source_artifact, root_rel
 WHERE root_rel.status = "active"
-CALL {
-    WITH source_artifact
+CALL (source_artifact) {
     // -----------------------
     // get the artifact's target node
     // -----------------------
-    CALL {
-        WITH source_artifact
+    CALL (source_artifact) {
         OPTIONAL MATCH (source_artifact)-[rrel1:IS_RELATED]-(rel_node:Relationship)-[rrel2:IS_RELATED]-(target_node:Node)
         WHERE rel_node.name = $target_rel_identifier
         AND all(r IN [rrel1, rrel2] WHERE ( %(source_branch_filter)s ))
@@ -70,8 +67,7 @@ CALL {
     // -----------------------
     // get the artifact's definition node
     // -----------------------
-    CALL {
-        WITH source_artifact
+    CALL (source_artifact) {
         OPTIONAL MATCH (source_artifact)-[rrel1:IS_RELATED]-(rel_node:Relationship)-[rrel2:IS_RELATED]-(definition_node:Node)
         WHERE rel_node.name = $definition_rel_identifier
         AND all(r IN [rrel1, rrel2] WHERE ( %(source_branch_filter)s ))
@@ -85,8 +81,7 @@ CALL {
     // -----------------------
     // get the artifact's checksum
     // -----------------------
-    CALL {
-        WITH source_artifact
+    CALL (source_artifact) {
         OPTIONAL MATCH (source_artifact)-[attr_rel:HAS_ATTRIBUTE]->(attr:Attribute)-[value_rel:HAS_VALUE]->(attr_val:AttributeValue)
         WHERE attr.name = "checksum"
         AND all(r IN [attr_rel, value_rel] WHERE ( %(source_branch_filter)s ))
@@ -100,8 +95,7 @@ CALL {
     // -----------------------
     // get the artifact's storage_id
     // -----------------------
-    CALL {
-        WITH source_artifact
+    CALL (source_artifact) {
         OPTIONAL MATCH (source_artifact)-[attr_rel:HAS_ATTRIBUTE]->(attr:Attribute)-[value_rel:HAS_VALUE]->(attr_val:AttributeValue)
         WHERE attr.name = "storage_id"
         AND all(r IN [attr_rel, value_rel] WHERE ( %(source_branch_filter)s ))
@@ -137,13 +131,11 @@ CALL {
         ELSE NULL
     END AS source_storage_id
 }
-CALL {
+CALL (target_node, definition_node){
     // -----------------------
     // get the corresponding artifact on the target branch, if it exists
     // -----------------------
-    WITH target_node, definition_node
-    CALL {
-        WITH target_node, definition_node
+    CALL (target_node, definition_node) {
         OPTIONAL MATCH path = (target_node)-[trel1:IS_RELATED]-(trel_node:Relationship)-[trel2:IS_RELATED]-
         (target_artifact:%(artifact_kind)s)-[drel1:IS_RELATED]-(drel_node:Relationship)-[drel2:IS_RELATED]-(definition_node)
         WHERE trel_node.name = $target_rel_identifier
@@ -165,8 +157,7 @@ CALL {
     // -----------------------
     // get the artifact's checksum on target branch
     // -----------------------
-    CALL {
-        WITH target_artifact
+    CALL (target_artifact) {
         OPTIONAL MATCH (target_artifact)-[attr_rel:HAS_ATTRIBUTE]->(attr:Attribute)-[value_rel:HAS_VALUE]->(attr_val:AttributeValue)
         WHERE attr.name = "checksum"
         AND attr_rel.branch = $target_branch_name
@@ -178,8 +169,7 @@ CALL {
     // -----------------------
     // get the artifact's storage_id on target branch
     // -----------------------
-    CALL {
-        WITH target_artifact
+    CALL (target_artifact) {
         OPTIONAL MATCH (target_artifact)-[attr_rel:HAS_ATTRIBUTE]->(attr:Attribute)-[value_rel:HAS_VALUE]->(attr_val:AttributeValue)
         WHERE attr.name = "storage_id"
         AND attr_rel.branch = $target_branch_name