infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/property.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 from uuid import UUID
 
 from pydantic import BaseModel
@@ -32,7 +32,7 @@ class FlagPropertyMixin:
     is_visible = True
     is_protected = False
 
-    def _init_flag_property_mixin(self, kwargs: Optional[dict] = None) -> None:
+    def _init_flag_property_mixin(self, kwargs: dict | None = None) -> None:
         if not kwargs:
             return
 
@@ -47,7 +47,7 @@ class NodePropertyMixin:
     branch: Branch
     at: Timestamp
 
-    def _init_node_property_mixin(self, kwargs: Optional[dict] = None) -> None:
+    def _init_node_property_mixin(self, kwargs: dict | None = None) -> None:
         for node in self._node_properties:
             setattr(self, f"_{node}", None)
             setattr(self, f"{node}_id", None)
@@ -66,7 +66,7 @@ class NodePropertyMixin:
         return self._get_node_property_from_cache(name="source")
 
     @source.setter
-    def source(self, value: Union[str, Node, UUID]) -> None:
+    def source(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="source", value=value)
 
     @property
@@ -74,25 +74,25 @@ class NodePropertyMixin:
         return self._get_node_property_from_cache(name="owner")
 
     @owner.setter
-    def owner(self, value: Optional[Union[str, Node, UUID]]) -> None:
+    def owner(self, value: str | Node | UUID | None) -> None:
         self._set_node_property(name="owner", value=value)
 
     def clear_owner(self) -> None:
         self._set_node_property(name="owner", value=None)
 
-    async def get_source(self, db: InfrahubDatabase) -> Optional[Node]:
+    async def get_source(self, db: InfrahubDatabase) -> Node | None:
         return await self._get_node_property(name="source", db=db)
 
     def clear_source(self) -> None:
         self._set_node_property(name="source", value=None)
 
-    def set_source(self, value: Union[str, Node, UUID]) -> None:
+    def set_source(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="source", value=value)
 
-    async def get_owner(self, db: InfrahubDatabase) -> Optional[Node]:
+    async def get_owner(self, db: InfrahubDatabase) -> Node | None:
         return await self._get_node_property(name="owner", db=db)
 
-    def set_owner(self, value: Union[str, Node, UUID]) -> None:
+    def set_owner(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="owner", value=value)
 
     def _get_node_property_from_cache(self, name: str) -> Node:
@@ -107,7 +107,7 @@ class NodePropertyMixin:
 
         return item
 
-    async def _get_node_property(self, db: InfrahubDatabase, name: str) -> Optional[Node]:
+    async def _get_node_property(self, db: InfrahubDatabase, name: str) -> Node | None:
         """Return the node attribute.
         If the node is already present in cache, serve from the cache
         If the node is not present, query it on the fly using the node_id
@@ -117,7 +117,7 @@ class NodePropertyMixin:
 
         return getattr(self, f"_{name}", None)
 
-    def _set_node_property(self, name: str, value: Optional[Union[str, Node, UUID]]) -> None:
+    def _set_node_property(self, name: str, value: str | Node | UUID | None) -> None:
         """Set the value of the node_property.
         If the value is a string, we assume it's an ID and we'll save it to query it later (if needed)
         If the value is a Node, we save the node and we extract the ID

infrahub/core/protocols.py

@@ -148,6 +148,10 @@ class CoreMenu(CoreNode):
     children: RelationshipManager
 
 
+class CoreObjectComponentTemplate(CoreNode):
+    template_name: String
+
+
 class CoreObjectTemplate(CoreNode):
     template_name: String
 
@@ -199,6 +203,7 @@ class CoreWebhook(CoreNode):
     name: String
     event_type: Enum
     branch_scope: Dropdown
+    node_kind: StringOptional
     description: StringOptional
     url: URL
     validate_certificates: BooleanOptional

infrahub/core/protocols_base.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Protocol, Union, runtime_checkable
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
 from typing_extensions import Self
 
@@ -38,23 +38,23 @@ class InfrahubDatabase(Protocol):
     @property
     def is_transaction(self) -> bool: ...
 
-    def add_schema(self, schema: SchemaBranch, name: Optional[str] = None) -> None: ...
-    def start_session(self, read_only: bool = False, schemas: Optional[list[SchemaBranch]] = None) -> Self: ...
-    def start_transaction(self, schemas: Optional[list[SchemaBranch]] = None) -> Self: ...
+    def add_schema(self, schema: SchemaBranch, name: str | None = None) -> None: ...
+    def start_session(self, read_only: bool = False, schemas: list[SchemaBranch] | None = None) -> Self: ...
+    def start_transaction(self, schemas: list[SchemaBranch] | None = None) -> Self: ...
     async def session(self) -> AsyncSession: ...
-    async def transaction(self, name: Optional[str]) -> AsyncTransaction: ...
+    async def transaction(self, name: str | None) -> AsyncTransaction: ...
     async def close(self) -> None: ...
 
     async def execute_query(
-        self, query: str, params: Optional[dict[str, Any]] = None, name: str = "undefined"
+        self, query: str, params: dict[str, Any] | None = None, name: str = "undefined"
     ) -> list[Record]: ...
 
     async def execute_query_with_metadata(
-        self, query: str, params: Optional[dict[str, Any]] = None, name: str = "undefined"
+        self, query: str, params: dict[str, Any] | None = None, name: str = "undefined"
     ) -> tuple[list[Record], dict[str, Any]]: ...
 
     async def run_query(
-        self, query: str, params: Optional[dict[str, Any]] = None, name: str = "undefined"
+        self, query: str, params: dict[str, Any] | None = None, name: str = "undefined"
     ) -> AsyncResult: ...
 
     def render_list_comprehension(self, items: str, item_name: str) -> str: ...
@@ -73,29 +73,29 @@ class CoreNode(Protocol):
     @classmethod
     async def init(
         cls,
-        schema: Union[NodeSchema, ProfileSchema, str],
+        schema: NodeSchema | ProfileSchema | str,
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = None,
-        at: Optional[Union[Timestamp, str]] = None,
+        branch: Branch | str | None = None,
+        at: Timestamp | str | None = None,
     ) -> Self: ...
-    async def new(self, db: InfrahubDatabase, id: Optional[str] = None, **kwargs: Any) -> Self: ...
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> Self: ...
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None: ...
+    async def new(self, db: InfrahubDatabase, id: str | None = None, **kwargs: Any) -> Self: ...
+    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None) -> Self: ...
+    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None: ...
     async def load(
         self,
         db: InfrahubDatabase,
-        id: Optional[str] = None,
-        db_id: Optional[str] = None,
-        updated_at: Optional[Union[Timestamp, str]] = None,
+        id: str | None = None,
+        db_id: str | None = None,
+        updated_at: Timestamp | str | None = None,
         **kwargs: Any,
     ) -> Self: ...
     async def to_graphql(
         self,
         db: InfrahubDatabase,
-        fields: Optional[dict] = None,
-        related_node_ids: Optional[set] = None,
+        fields: dict | None = None,
+        related_node_ids: set | None = None,
         filter_sensitive: bool = False,
-        permissions: Optional[dict] = None,
+        permissions: dict | None = None,
     ) -> dict: ...
-    async def render_display_label(self, db: Optional[InfrahubDatabase] = None) -> str: ...
+    async def render_display_label(self, db: InfrahubDatabase | None = None) -> str: ...
     async def from_graphql(self, data: dict, db: InfrahubDatabase) -> bool: ...

infrahub/core/query/__init__.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Generator, Iterator, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterator, TypeVar
 
 import ujson
 from neo4j.graph import Node as Neo4jNode
@@ -68,9 +68,9 @@ class QueryRelDirection(Enum):
 @dataclass
 class QueryElement:
     type: QueryElementType
-    name: Optional[str] = None
-    labels: Optional[list[str]] = None
-    params: Optional[dict] = None
+    name: str | None = None
+    labels: list[str] | None = None
+    params: dict | None = None
 
     def __str__(self) -> str:
         main_str = "%s%s%s" % (self.name or "", self.labels_as_str, self.params_as_str)
@@ -112,7 +112,7 @@ class QueryRel(QueryElement):
     type: QueryElementType = QueryElementType.RELATIONSHIP
     direction: QueryRelDirection = QueryRelDirection.BIDIR
     length_min: int = 1
-    length_max: Optional[int] = None
+    length_max: int | None = None
 
     def __str__(self) -> str:
         length_str = ""
@@ -160,7 +160,7 @@ def cleanup_return_labels(labels: list[str]) -> list[str]:
 
 
 class QueryResult:
-    def __init__(self, data: list[Union[Neo4jNode, Neo4jRelationship, list[Neo4jNode]]], labels: list[str]):
+    def __init__(self, data: list[Neo4jNode | Neo4jRelationship | list[Neo4jNode]], labels: list[str]):
         self.data = data
         self.labels = labels
         self.branch_score: int = 0
@@ -212,23 +212,23 @@ class QueryResult:
                 self.has_deleted_rels = True
                 return
 
-    def _get(self, label: str) -> Union[Neo4jNode, Neo4jRelationship, list[Neo4jNode]]:
+    def _get(self, label: str) -> Neo4jNode | Neo4jRelationship | list[Neo4jNode]:
         if label not in self.labels:
             raise ValueError(f"{label} is not a valid value for this query, must be one of {self.labels}")
 
         return_id = self.labels.index(label)
         return self.data[return_id]
 
-    def get(self, label: str) -> Union[Neo4jNode, Neo4jRelationship]:
+    def get(self, label: str) -> Neo4jNode | Neo4jRelationship:
         return self._get(label=label)
 
-    def get_as_str(self, label: str) -> Optional[str]:
+    def get_as_str(self, label: str) -> str | None:
         item = self._get(label=label)
         if item:
             return str(item)
         return None
 
-    def get_as_optional_type(self, label: str, return_type: Callable[..., RETURN_TYPE]) -> Optional[RETURN_TYPE]:
+    def get_as_optional_type(self, label: str, return_type: Callable[..., RETURN_TYPE]) -> RETURN_TYPE | None:
         """Return a label as a given type.
 
         For example if an integer is needed the caller would use:
@@ -305,7 +305,7 @@ class QueryResult:
 class QueryStats:
     stats: list[QueryStat] = field(default_factory=list)
 
-    def add(self, data: Optional[dict[str, Any]]) -> None:
+    def add(self, data: dict[str, Any] | None) -> None:
         if data:
             self.stats.append(QueryStat.from_metadata(data))
 
@@ -322,13 +322,13 @@ class QueryStats:
 @dataclass
 class QueryStat:
     contains_updates: bool = False
-    labels_added: Optional[int] = None
-    labels_removed: Optional[int] = None
-    nodes_created: Optional[int] = None
-    nodes_deleted: Optional[int] = None
-    properties_set: Optional[int] = None
-    relationships_created: Optional[int] = None
-    relationships_deleted: Optional[int] = None
+    labels_added: int | None = None
+    labels_removed: int | None = None
+    nodes_created: int | None = None
+    nodes_deleted: int | None = None
+    properties_set: int | None = None
+    relationships_created: int | None = None
+    relationships_deleted: int | None = None
 
     @classmethod
     def from_metadata(cls, data: dict[str, Any]) -> Self:
@@ -346,11 +346,11 @@ class Query(ABC):
 
     def __init__(
         self,
-        branch: Optional[Branch] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-        limit: Optional[int] = None,
-        offset: Optional[int] = None,
-        order_by: Optional[list[str]] = None,
+        branch: Branch | None = None,
+        at: Timestamp | str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        order_by: list[str] | None = None,
         branch_agnostic: bool = False,
     ):
         if branch:
@@ -379,7 +379,7 @@ class Query(ABC):
 
         self.stats: QueryStats = QueryStats()
 
-    def update_return_labels(self, value: Union[str, list[str]]) -> None:
+    def update_return_labels(self, value: str | list[str]) -> None:
         if isinstance(value, str) and value not in self.return_labels:
             self.return_labels.append(value)
             return
@@ -391,10 +391,10 @@ class Query(ABC):
     async def init(
         cls,
         db: InfrahubDatabase,
-        branch: Optional[Branch] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-        limit: Optional[int] = None,
-        offset: Optional[int] = None,
+        branch: Branch | None = None,
+        at: Timestamp | str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
         **kwargs: Any,
     ) -> Self:
         query = cls(branch=branch, at=at, limit=limit, offset=offset, **kwargs)
@@ -412,7 +412,7 @@ class Query(ABC):
         Right now it's mainly used to add more labels to the metrics."""
         return {}
 
-    def add_to_query(self, query: Union[str, list[str]]) -> None:
+    def add_to_query(self, query: str | list[str]) -> None:
         """Add a new section at the end of the query.
 
         A string with multiple lines will be broken down into multiple entries in self.query_lines
@@ -424,7 +424,7 @@ class Query(ABC):
         else:
             self.query_lines.extend([line.strip() for line in query.split("\n") if line.strip()])
 
-    def add_subquery(self, subquery: str, with_clause: Optional[str] = None) -> None:
+    def add_subquery(self, subquery: str, with_clause: str | None = None) -> None:
         self.add_to_query("CALL {")
         self.add_to_query(subquery)
         self.add_to_query("}")
@@ -435,8 +435,8 @@ class Query(ABC):
         self,
         var: bool = False,
         inline: bool = False,
-        limit: Optional[int] = None,
-        offset: Optional[int] = None,
+        limit: int | None = None,
+        offset: int | None = None,
     ) -> str:
         # Make a local copy of the _query_lines
         limit = limit or self.limit
@@ -602,7 +602,7 @@ class Query(ABC):
 
         return results[0][0]
 
-    def get_result(self) -> Optional[QueryResult]:
+    def get_result(self) -> QueryResult | None:
         """Return a single Result."""
 
         if not self.has_been_executed:

infrahub/core/query/attribute.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import AttributeDBNodeType
 from infrahub.core.constants.relationship_label import RELATIONSHIP_TO_NODE_LABEL, RELATIONSHIP_TO_VALUE_LABEL
@@ -20,9 +20,9 @@ class AttributeQuery(Query):
     def __init__(
         self,
         attr: BaseAttribute,
-        attr_id: Optional[str] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-        branch: Optional[Branch] = None,
+        attr_id: str | None = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | None = None,
         **kwargs: Any,
     ):
         self.attr = attr
@@ -66,6 +66,8 @@ class AttributeUpdateValueQuery(AttributeQuery):
         query = """
         MATCH (a:Attribute { uuid: $attr_uuid })
         MERGE (av:%(labels)s { %(props)s } )
+        WITH av, a
+        LIMIT 1
         CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(av)
         """ % {"rel_label": self.attr._rel_to_value_label, "labels": ":".join(labels), "props": ", ".join(prop_list)}
 

infrahub/core/query/diff.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any
 
 from infrahub import config
 from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType
@@ -21,8 +21,8 @@ class DiffQuery(Query):
     def __init__(
         self,
         branch: Branch,
-        diff_from: Union[Timestamp, str] = None,
-        diff_to: Union[Timestamp, str] = None,
+        diff_from: Timestamp | str = None,
+        diff_to: Timestamp | str = None,
         **kwargs,
     ):
         """A diff is always in the context of a branch"""

infrahub/core/query/node.py

@@ -5,7 +5,7 @@ from copy import copy
 from dataclasses import dataclass
 from dataclasses import field as dataclass_field
 from enum import Enum
-from typing import TYPE_CHECKING, Any, AsyncIterator, Generator, Optional, Union
+from typing import TYPE_CHECKING, Any, AsyncIterator, Generator
 
 from infrahub import config
 from infrahub.core.constants import (
@@ -37,7 +37,7 @@ if TYPE_CHECKING:
 
 @dataclass
 class NodeToProcess:
-    schema: Optional[Union[NodeSchema, ProfileSchema, TemplateSchema]]
+    schema: NodeSchema | ProfileSchema | TemplateSchema | None
 
     node_id: str
     node_uuid: str
@@ -65,7 +65,7 @@ class AttributeFromDB:
     attr_uuid: str
 
     attr_value_id: str
-    attr_value_uuid: Optional[str]
+    attr_value_uuid: str | None
 
     value: Any
     content: Any
@@ -96,11 +96,11 @@ class PeerInfo:
 class NodeQuery(Query):
     def __init__(
         self,
-        node: Optional[Node] = None,
-        node_id: Optional[str] = None,
-        node_db_id: Optional[int] = None,
-        id: Optional[str] = None,
-        branch: Optional[Branch] = None,
+        node: Node | None = None,
+        node_id: str | None = None,
+        node_db_id: int | None = None,
+        id: str | None = None,
+        branch: Branch | None = None,
         **kwargs,
     ) -> None:
         # TODO Validate that Node is a valid node
@@ -202,15 +202,16 @@ class NodeCreateAllQuery(NodeQuery):
         }
         ipnetwork_prop_list = [f"{key}: {value}" for key, value in ipnetwork_prop.items()]
 
-        query = """
-        MATCH (root:Root)
-        CREATE (n:Node:%(labels)s $node_prop )
-        CREATE (n)-[r:IS_PART_OF $node_branch_prop ]->(root)
+        attrs_query = """
         WITH distinct n
-        FOREACH ( attr IN $attrs |
+        UNWIND $attrs AS attr
+        CALL {
+            WITH n, attr
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
             MERGE (av:AttributeValue { value: attr.content.value, is_default: attr.content.is_default })
+            WITH n, attr, av, a
+            LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
             MERGE (iv:Boolean { value: attr.is_visible })
@@ -224,11 +225,19 @@ class NodeCreateAllQuery(NodeQuery):
                 MERGE (peer:Node { uuid: prop.peer_id })
                 CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
             )
-        )
-        FOREACH ( attr IN $attrs_iphost |
+        }"""
+
+        attrs_iphost_query = """
+        WITH distinct n
+        UNWIND $attrs_iphost AS attr_iphost
+        CALL {
+            WITH n, attr_iphost
+            WITH n, attr_iphost AS attr
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
             MERGE (av:AttributeValue:AttributeIPHost { %(iphost_prop)s })
+            WITH n, attr, av, a
+            LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
             MERGE (iv:Boolean { value: attr.is_visible })
@@ -242,11 +251,20 @@ class NodeCreateAllQuery(NodeQuery):
                 MERGE (peer:Node { uuid: prop.peer_id })
                 CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
             )
-        )
-        FOREACH ( attr IN $attrs_ipnetwork |
+        }
+        """ % {"iphost_prop": ", ".join(iphost_prop_list)}
+
+        attrs_ipnetwork_query = """
+        WITH distinct n
+        UNWIND $attrs_ipnetwork AS attr_ipnetwork
+        CALL {
+            WITH n, attr_ipnetwork
+            WITH n, attr_ipnetwork AS attr
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
             MERGE (av:AttributeValue:AttributeIPNetwork { %(ipnetwork_prop)s })
+            WITH n, attr, av, a
+            LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
             MERGE (iv:Boolean { value: attr.is_visible })
@@ -260,8 +278,14 @@ class NodeCreateAllQuery(NodeQuery):
                 MERGE (peer:Node { uuid: prop.peer_id })
                 CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
             )
-        )
-        FOREACH ( rel IN $rels_bidir |
+        }
+        """ % {"ipnetwork_prop": ", ".join(ipnetwork_prop_list)}
+
+        rels_bidir_query = """
+        WITH distinct n
+        UNWIND $rels_bidir AS rel
+        CALL {
+            WITH n, rel
             MERGE (d:Node { uuid: rel.destination_id })
             CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
             CREATE (n)-[:IS_RELATED %(rel_prop)s ]->(rl)
@@ -278,8 +302,15 @@ class NodeCreateAllQuery(NodeQuery):
                 MERGE (peer:Node { uuid: prop.peer_id })
                 CREATE (rl)-[:HAS_OWNER { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
             )
-        )
-        FOREACH ( rel IN $rels_out |
+        }
+        """ % {"rel_prop": rel_prop_str}
+
+        rels_out_query = """
+        WITH distinct n
+        UNWIND $rels_out AS rel_out
+        CALL {
+            WITH n, rel_out
+            WITH n, rel_out as rel
             MERGE (d:Node { uuid: rel.destination_id })
             CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
             CREATE (n)-[:IS_RELATED %(rel_prop)s ]->(rl)
@@ -296,8 +327,15 @@ class NodeCreateAllQuery(NodeQuery):
                 MERGE (peer:Node { uuid: prop.peer_id })
                 CREATE (rl)-[:HAS_OWNER { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
             )
-        )
-        FOREACH ( rel IN $rels_in |
+        }
+        """ % {"rel_prop": rel_prop_str}
+
+        rels_in_query = """
+        WITH distinct n
+        UNWIND $rels_in AS rel_in
+        CALL {
+            WITH n, rel_in
+            WITH n, rel_in AS rel
             MERGE (d:Node { uuid: rel.destination_id })
             CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
             CREATE (n)<-[:IS_RELATED %(rel_prop)s ]-(rl)
@@ -314,14 +352,23 @@ class NodeCreateAllQuery(NodeQuery):
                 MERGE (peer:Node { uuid: prop.peer_id })
                 CREATE (rl)-[:HAS_OWNER { branch: rel.branch, branch_level: rel.branch_level, status: rel.status, from: $at }]->(peer)
             )
-        )
+        }
+        """ % {"rel_prop": rel_prop_str}
+
+        query = f"""
+        MATCH (root:Root)
+        CREATE (n:Node:%(labels)s $node_prop )
+        CREATE (n)-[r:IS_PART_OF $node_branch_prop ]->(root)
+        {attrs_query if self.params["attrs"] else ""}
+        {attrs_iphost_query if self.params["attrs_iphost"] else ""}
+        {attrs_ipnetwork_query if self.params["attrs_ipnetwork"] else ""}
+        {rels_bidir_query if self.params["rels_bidir"] else ""}
+        {rels_out_query if self.params["rels_out"] else ""}
+        {rels_in_query if self.params["rels_in"] else ""}
         WITH distinct n
         MATCH (n)-[:HAS_ATTRIBUTE|IS_RELATED]-(rn)-[:HAS_VALUE|IS_RELATED]-(rv)
         """ % {
             "labels": ":".join(self.node.get_labels()),
-            "rel_prop": rel_prop_str,
-            "iphost_prop": ", ".join(iphost_prop_list),
-            "ipnetwork_prop": ", ".join(ipnetwork_prop_list),
         }
 
         self.params["at"] = at.to_string()
@@ -415,7 +462,7 @@ class NodeListGetAttributeQuery(Query):
     def __init__(
         self,
         ids: list[str],
-        fields: Optional[dict] = None,
+        fields: dict | None = None,
         include_source: bool = False,
         include_owner: bool = False,
         account=None,
@@ -618,18 +665,21 @@ class NodeListGetRelationshipsQuery(Query):
         MATCH paths_in = ((n)<-[r1:IS_RELATED]-(rel:Relationship)<-[r2:IS_RELATED]-(peer))
         WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
         AND all(r IN relationships(paths_in) WHERE (%(filters)s))
+        AND n.uuid <> peer.uuid
         RETURN n, rel, peer, r1, r2, "inbound" as direction
         UNION
         MATCH (n:Node) WHERE n.uuid IN $ids
         MATCH paths_out = ((n)-[r1:IS_RELATED]->(rel:Relationship)-[r2:IS_RELATED]->(peer))
         WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
         AND all(r IN relationships(paths_out) WHERE (%(filters)s))
+        AND n.uuid <> peer.uuid
         RETURN n, rel, peer, r1, r2, "outbound" as direction
         UNION
         MATCH (n:Node) WHERE n.uuid IN $ids
         MATCH paths_bidir = ((n)-[r1:IS_RELATED]->(rel:Relationship)<-[r2:IS_RELATED]-(peer))
         WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
         AND all(r IN relationships(paths_bidir) WHERE (%(filters)s))
+        AND n.uuid <> peer.uuid
         RETURN n, rel, peer, r1, r2, "bidirectional" as direction
         """ % {"filters": rels_filter}
 
@@ -757,7 +807,7 @@ class FieldAttributeRequirementType(Enum):
 @dataclass
 class FieldAttributeRequirement:
     field_name: str
-    field: Optional[Union[AttributeSchema, RelationshipSchema]]
+    field: AttributeSchema | RelationshipSchema | None
     field_attr_name: str
     field_attr_value: Any
     index: int
@@ -817,7 +867,7 @@ class NodeGetListQuery(Query):
     def __init__(
         self,
         schema: NodeSchema,
-        filters: Optional[dict] = None,
+        filters: dict | None = None,
         partial_match: bool = False,
         order: OrderModel | None = None,
         **kwargs: Any,
@@ -1264,8 +1314,8 @@ class NodeGetHierarchyQuery(Query):
         self,
         node_id: str,
         direction: RelationshipHierarchyDirection,
-        node_schema: Union[NodeSchema, GenericSchema],
-        filters: Optional[dict] = None,
+        node_schema: NodeSchema | GenericSchema,
+        filters: dict | None = None,
         hierarchical_ordering: bool = False,
         **kwargs: Any,
     ) -> None: