infrahub-server 1.3.0b1__py3-none-any.whl → 1.3.0b3__py3-none-any.whl

infrahub/core/migrations/graph/m030_illegal_edges.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class DeletePosthumousEdges(Query):
+    name = "delete_posthumous_edges_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+// ------------
+// find deleted nodes
+// ------------
+MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
+WHERE e.status = "deleted" OR e.to IS NOT NULL
+WITH DISTINCT n, e.branch AS delete_branch, e.branch_level AS delete_branch_level, CASE
+    WHEN e.status = "deleted" THEN e.from
+    ELSE e.to
+END AS delete_time
+// ------------
+// find the edges added to the deleted node after the delete time
+// ------------
+MATCH (n)-[added_e]-(peer)
+WHERE added_e.from > delete_time
+AND type(added_e) <> "IS_PART_OF"
+// if the node was deleted on a branch (delete_branch_level > 1), and then updated on main/global (added_e.branch_level = 1), we can ignore it
+AND added_e.branch_level >= delete_branch_level
+AND (added_e.branch = delete_branch OR delete_branch_level = 1)
+WITH DISTINCT n, delete_branch, delete_time, added_e, peer
+// ------------
+// get the branched_from for the branch on which the node was deleted
+// ------------
+CALL (added_e) {
+    MATCH (b:Branch {name: added_e.branch})
+    RETURN b.branched_from AS added_e_branched_from
+}
+// ------------
+// account for the following situations, given that the edge update time is after the node delete time
+//  - deleted on main/global, updated on branch
+//    - illegal if the delete is before branch.branched_from
+//  - deleted on branch, updated on branch
+//    - illegal
+// ------------
+WITH n, delete_branch, delete_time, added_e, peer
+WHERE delete_branch = added_e.branch
+OR delete_time < added_e_branched_from
+DELETE added_e
+// --------------
+// the peer _should_ only be an Attribute, but I want to make sure we don't
+// inadvertently delete Root or an AttributeValue or a Boolean
+// --------------
+WITH peer
+WHERE "Attribute" IN labels(peer)
+DETACH DELETE peer
+        """
+        self.add_to_query(query)
+
+
+class Migration030(GraphMigration):
+    """
+    Edges could have been added to Nodes after the Node was deleted, so we need to hard-delete those illegal edges
+    """
+
+    name: str = "030_delete_illegal_edges"
+    minimum_version: int = 29
+    queries: Sequence[type[Query]] = [DeletePosthumousEdges]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

infrahub/core/migrations/query/attribute_add.py

@@ -62,28 +62,32 @@ class AttributeAddQuery(Query):
         WITH av, is_protected_value, is_visible_value
         MATCH p = (n:%(node_kind)s)
         CALL (n) {
-            MATCH (root:Root)<-[r1:IS_PART_OF]-(n)
-            OPTIONAL MATCH (n)-[r2:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })
-            WHERE all(r in [r1, r2] WHERE (%(branch_filter)s))
-            RETURN n as n1, r1 as r11, r2 as r12
-            ORDER BY r2.branch_level DESC, r2.from ASC, r1.branch_level DESC, r1.from ASC
+            MATCH (:Root)<-[r:IS_PART_OF]-(n)
+            WHERE %(branch_filter)s
+            WITH n, r AS is_part_of_e
+            OPTIONAL MATCH (n)-[r:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })
+            WHERE %(branch_filter)s
+            WITH is_part_of_e, r AS has_attr_e
+            RETURN is_part_of_e, has_attr_e
+            ORDER BY has_attr_e.branch_level DESC, has_attr_e.from ASC, is_part_of_e.branch_level DESC, is_part_of_e.from ASC
             LIMIT 1
         }
-        WITH n1 as n, r11 as r1, r12 as r2, av, is_protected_value, is_visible_value
-        WHERE r1.status = "active" AND (r2 IS NULL OR r2.status = "deleted")
+        WITH n, is_part_of_e, has_attr_e, av, is_protected_value, is_visible_value
+        WHERE is_part_of_e.status = "active" AND (has_attr_e IS NULL OR has_attr_e.status = "deleted")
         CREATE (a:Attribute { name: $attr_name, branch_support: $branch_support })
         CREATE (n)-[:HAS_ATTRIBUTE $rel_props ]->(a)
         CREATE (a)-[:HAS_VALUE $rel_props ]->(av)
         CREATE (a)-[:IS_PROTECTED $rel_props]->(is_protected_value)
         CREATE (a)-[:IS_VISIBLE $rel_props]->(is_visible_value)
         %(uuid_generation)s
-        FOREACH (i in CASE WHEN r2.status = "deleted" THEN [1] ELSE [] END |
-            SET r2.to = $current_time
+        FOREACH (i in CASE WHEN has_attr_e.status = "deleted" THEN [1] ELSE [] END |
+            SET has_attr_e.to = $current_time
         )
         """ % {
             "branch_filter": branch_filter,
             "node_kind": self.node_kind,
             "uuid_generation": db.render_uuid_generation(node_label="a", node_attr="uuid"),
         }
+
         self.add_to_query(query)
         self.return_labels = ["n.uuid", "a.uuid"]

infrahub/core/migrations/query/relationship_duplicate.py

@@ -117,7 +117,6 @@ class RelationshipDuplicateQuery(Query):
 
         self.add_to_query(self.render_match())
 
-        # ruff: noqa: E501
         query = """
         CALL (source, rel, destination) {
             MATCH path = (source)-[r1:IS_RELATED]-(rel)-[r2:IS_RELATED]-(destination)

infrahub/core/migrations/schema/node_remove.py

@@ -58,7 +58,6 @@ class NodeRemoveMigrationBaseQuery(MigrationQuery):
 
         node_remove_query = self.render_node_remove_query(branch_filter=branch_filter)
 
-        # ruff: noqa: E501
         query = """
         // Find all the active nodes
         MATCH (node:%(node_kind)s)

infrahub/core/node/__init__.py

@@ -16,6 +16,7 @@ from infrahub.core.constants import (
     BranchSupportType,
     ComputedAttributeKind,
     InfrahubKind,
+    NumberPoolType,
     RelationshipCardinality,
     RelationshipKind,
 )
@@ -328,6 +329,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             node_attribute=attribute.schema.name,
             start_range=number_pool_parameters.start_range,
             end_range=number_pool_parameters.end_range,
+            pool_type=NumberPoolType.SCHEMA.value,
         )
         await number_pool.save(db=db)
         # Do a lookup of the number pool to get the correct mapped type from the registry

infrahub/core/node/base.py

@@ -52,7 +52,7 @@ class BaseNodeOptions(BaseOptions):
 
 
 class ObjectNodeMeta(BaseNodeMeta):
-    def __new__(mcs, name_, bases, namespace, **options):  # noqa: N804
+    def __new__(mcs, name_, bases, namespace, **options):
         # Note: it's safe to pass options as keyword arguments as they are still type-checked by NodeOptions.
 
         # We create this type, to then overload it with the dataclass attrs

infrahub/core/path.py

@@ -125,7 +125,7 @@ class SchemaPath(InfrahubPath):
         if self.field_name:
             identifier += f"/{self.field_name}"
 
-        if self.property_name and not self.path_type == SchemaPathType.NODE:
+        if self.property_name and self.path_type != SchemaPathType.NODE:
             identifier += f"/{self.property_name}"
 
         return identifier

infrahub/core/protocols.py

@@ -403,12 +403,12 @@ class CoreGraphQLQueryGroup(CoreGroup):
 
 
 class CoreGroupAction(CoreAction):
-    add_members: Boolean
+    member_action: Dropdown
     group: RelationshipManager
 
 
 class CoreGroupTriggerRule(CoreTriggerRule):
-    members_added: Boolean
+    member_update: Dropdown
     group: RelationshipManager
 
 
@@ -440,7 +440,7 @@ class CoreNodeTriggerAttributeMatch(CoreNodeTriggerMatch):
 
 class CoreNodeTriggerRelationshipMatch(CoreNodeTriggerMatch):
     relationship_name: String
-    added: Boolean
+    modification_type: Dropdown
     peer: StringOptional
 
 
@@ -455,6 +455,7 @@ class CoreNumberPool(CoreResourcePool, LineageSource):
     node_attribute: String
     start_range: Integer
     end_range: Integer
+    pool_type: Enum
 
 
 class CoreObjectPermission(CoreBasePermission):

infrahub/core/query/node.py

@@ -1469,7 +1469,7 @@ class NodeGetHierarchyQuery(Query):
 
         clean_filters = extract_field_filters(field_name=self.direction.value, filters=self.filters)
 
-        if clean_filters and "id" in clean_filters or "ids" in clean_filters:
+        if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:
             where_clause.append("peer.uuid IN $peer_ids")
             self.params["peer_ids"] = clean_filters.get("ids", [])
             if clean_filters.get("id", None):

infrahub/core/query/relationship.py

@@ -676,7 +676,7 @@ class RelationshipGetPeerQuery(Query):
         where_clause = ['all(r IN rels WHERE r.status = "active")']
         clean_filters = extract_field_filters(field_name=self.schema.name, filters=self.filters)
 
-        if clean_filters and "id" in clean_filters or "ids" in clean_filters:
+        if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:
             where_clause.append("peer.uuid IN $peer_ids")
             self.params["peer_ids"] = clean_filters.get("ids", [])
             if clean_filters.get("id", None):
@@ -1035,7 +1035,7 @@ class RelationshipDeleteAllQuery(Query):
         self.node_id = node_id
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
+    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:
         self.params["source_id"] = kwargs["node_id"]
         self.params["branch"] = self.branch.name
 

infrahub/core/query/standard_node.py

@@ -3,28 +3,42 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub.core.query import Query, QueryType
+from infrahub.exceptions import InitializationError
 
 if TYPE_CHECKING:
+    from uuid import UUID
+
     from infrahub.core.node.standard import StandardNode
     from infrahub.database import InfrahubDatabase
 
 
 class StandardNodeQuery(Query):
     def __init__(
-        self, node: StandardNode = None, node_id: str | None = None, node_db_id: int | None = None, **kwargs: Any
-    ):
-        self.node = node
+        self,
+        node: StandardNode | None = None,
+        node_id: UUID | None = None,
+        node_db_id: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self._node = node
         self.node_id = node_id
         self.node_db_id = node_db_id
 
-        if not self.node_id and self.node:
+        if not self.node_id and self._node:
             self.node_id = self.node.uuid
 
-        if not self.node_db_id and self.node:
+        if not self.node_db_id and self._node:
             self.node_db_id = self.node.id
 
         super().__init__(**kwargs)
 
+    @property
+    def node(self) -> StandardNode:
+        if self._node:
+            return self._node
+
+        raise InitializationError("The query is not initialized with a node")
+
 
 class RootNodeCreateQuery(StandardNodeQuery):
     name = "standard_node_create"

infrahub/core/relationship/constraints/peer_relatives.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Mapping
+
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.exceptions import ValidationError
+
+from .interface import RelationshipManagerConstraintInterface
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.schema import MainSchemaTypes, NonGenericSchemaTypes
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import RelationshipManager
+
+
+@dataclass
+class NodeToValidate:
+    uuid: str
+    relative_uuids: set[str]
+    schema: NonGenericSchemaTypes
+
+
+class RelationshipPeerRelativesConstraint(RelationshipManagerConstraintInterface):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    async def _check_relationship_peers_relatives(
+        self,
+        relm: RelationshipManager,
+        node_schema: MainSchemaTypes,
+        peers: Mapping[str, Node],
+        relationship_name: str,
+    ) -> None:
+        """Validate that all peers of a given `relm` have the same set of relatives (aka peers) for the given `relationship_name`."""
+        nodes_to_validate: list[NodeToValidate] = []
+
+        for peer in peers.values():
+            peer_schema = peer.get_schema()
+            peer_relm: RelationshipManager = getattr(peer, relationship_name)
+            peer_relm_peers = await peer_relm.get_peers(db=self.db)
+
+            nodes_to_validate.append(
+                NodeToValidate(
+                    uuid=peer.id, relative_uuids={n.id for n in peer_relm_peers.values()}, schema=peer_schema
+                )
+            )
+
+        relative_uuids = nodes_to_validate[0].relative_uuids
+        for node in nodes_to_validate[1:]:
+            if node.relative_uuids != relative_uuids:
+                raise ValidationError(
+                    f"All the elements of the '{relm.name}' relationship on node {node.uuid} ({node_schema.kind}) must have the same set of peers "
+                    f"for their '{node.schema.kind}.{relationship_name}' relationship"
+                )
+
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:
+        if relm.schema.cardinality != RelationshipCardinality.MANY or not relm.schema.common_relatives:
+            return
+
+        peers = await relm.get_peers(db=self.db)
+        if not peers:
+            return
+
+        for rel_name in relm.schema.common_relatives:
+            await self._check_relationship_peers_relatives(
+                relm=relm, node_schema=node_schema, peers=peers, relationship_name=rel_name
+            )

infrahub/core/relationship/model.py

@@ -494,7 +494,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             peer_fields = {
                 key: value
                 for key, value in fields.items()
-                if not key.startswith(PREFIX_PROPERTY) or not key == "__typename"
+                if not key.startswith(PREFIX_PROPERTY) or key != "__typename"
             }
             rel_fields = {
                 key.replace(PREFIX_PROPERTY, ""): value

infrahub/core/schema/attribute_schema.py

@@ -30,12 +30,6 @@ if TYPE_CHECKING:
 
 
 def get_attribute_schema_class_for_kind(kind: str) -> type[AttributeSchema]:
-    attribute_schema_class_by_kind: dict[str, type[AttributeSchema]] = {
-        "NumberPool": NumberPoolSchema,
-        "Text": TextAttributeSchema,
-        "TextArea": TextAttributeSchema,
-        "Number": NumberAttributeSchema,
-    }
     return attribute_schema_class_by_kind.get(kind, AttributeSchema)
 
 
@@ -43,6 +37,24 @@ class AttributeSchema(GeneratedAttributeSchema):
     _sort_by: list[str] = ["name"]
     _enum_class: type[enum.Enum] | None = None
 
+    @classmethod
+    def model_json_schema(cls, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        schema = super().model_json_schema(*args, **kwargs)
+
+        # Build conditional schema based on attribute_schema_class_by_kind mapping
+        # This override allows people using the Yaml language server to get the correct mappings
+        # for the parameters when selecting the appropriate kind
+        schema["allOf"] = []
+        for kind, schema_class in attribute_schema_class_by_kind.items():
+            schema["allOf"].append(
+                {
+                    "if": {"properties": {"kind": {"const": kind}}},
+                    "then": {"properties": {"parameters": {"$ref": f"#/definitions/{schema_class.__name__}"}}},
+                }
+            )
+
+        return schema
+
     @property
     def is_attribute(self) -> bool:
         return True
@@ -247,3 +259,11 @@ class NumberAttributeSchema(AttributeSchema):
         description="Extra parameters specific to number attributes",
         json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
     )
+
+
+attribute_schema_class_by_kind: dict[str, type[AttributeSchema]] = {
+    "NumberPool": NumberPoolSchema,
+    "Text": TextAttributeSchema,
+    "TextArea": TextAttributeSchema,
+    "Number": NumberAttributeSchema,
+}

infrahub/core/schema/basenode_schema.py

@@ -386,7 +386,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.display_labels:
             return None
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         for item in self.display_labels:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields
@@ -401,7 +401,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.human_friendly_id:
             return None
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         for item in self.human_friendly_id:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields

infrahub/core/schema/definitions/core/resource_pool.py

@@ -1,6 +1,7 @@
 from infrahub.core.constants import (
     BranchSupportType,
     InfrahubKind,
+    NumberPoolType,
 )
 from infrahub.core.constants import RelationshipCardinality as Cardinality
 from infrahub.core.constants import RelationshipKind as RelKind
@@ -186,5 +187,13 @@ core_number_pool = NodeSchema(
         Attr(
             name="end_range", kind="Number", optional=False, description="The end range for the pool", order_weight=6000
         ),
+        Attr(
+            name="pool_type",
+            kind="Text",
+            description="Defines how this number pool was created",
+            default_value=NumberPoolType.USER.value,
+            enum=NumberPoolType.available_types(),
+            read_only=True,
+        ),
     ],
 )

infrahub/core/schema/definitions/internal.py

@@ -82,7 +82,7 @@ class SchemaAttribute(BaseModel):
 
     @property
     def optional_in_model(self) -> bool:
-        if self.optional and self.default_value is None and self.default_factory is None or self.default_to_none:
+        if (self.optional and self.default_value is None and self.default_factory is None) or self.default_to_none:
             return True
 
         return False
@@ -754,6 +754,14 @@ relationship_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
+        SchemaAttribute(
+            name="common_relatives",
+            kind="List",
+            internal_kind=str,
+            optional=True,
+            description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
+            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+        ),
         SchemaAttribute(
             name="order_weight",
             kind="Number",

infrahub/core/schema/generated/attribute_schema.py

@@ -9,10 +9,10 @@ from pydantic import Field
 from infrahub.core.constants import AllowOverrideType, BranchSupportType, HashableModelState
 from infrahub.core.models import HashableModel
 from infrahub.core.schema.attribute_parameters import (
-    AttributeParameters,  # noqa: TC001
-    NumberAttributeParameters,  # noqa: TC001
-    NumberPoolParameters,  # noqa: TC001
-    TextAttributeParameters,  # noqa: TC001
+    AttributeParameters,
+    NumberAttributeParameters,
+    NumberPoolParameters,
+    TextAttributeParameters,
 )
 from infrahub.core.schema.computed_attribute import ComputedAttribute  # noqa: TC001
 from infrahub.core.schema.dropdown import DropdownChoice  # noqa: TC001

infrahub/core/schema/generated/relationship_schema.py

@@ -12,7 +12,7 @@ from infrahub.core.constants import (
     RelationshipDeleteBehavior,
     RelationshipDirection,
     RelationshipKind,
-)  # noqa: TC001
+)
 from infrahub.core.models import HashableModel
 
 
@@ -73,6 +73,11 @@ class GeneratedRelationshipSchema(HashableModel):
         description="Defines the maximum objects allowed on the other side of the relationship.",
         json_schema_extra={"update": "validate_constraint"},
     )
+    common_relatives: list[str] | None = Field(
+        default=None,
+        description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
+        json_schema_extra={"update": "validate_constraint"},
+    )
     order_weight: int | None = Field(
         default=None,
         description="Number used to order the relationship in the frontend (table and view). Lowest value will be ordered first.",

infrahub/core/schema/manager.py

@@ -471,7 +471,7 @@ class SchemaManager(NodeManager):
         if diff_attributes:
             for item in node.local_attributes:
                 # if item is in changed and has no ID, then it is being overridden from a generic and must be added
-                if item.name in diff_attributes.added or item.name in diff_attributes.changed and item.id is None:
+                if item.name in diff_attributes.added or (item.name in diff_attributes.changed and item.id is None):
                     created_item = await self.create_attribute_in_db(
                         schema=attribute_schema, item=item, branch=branch, db=db, parent=obj
                     )
@@ -491,7 +491,9 @@ class SchemaManager(NodeManager):
         if diff_relationships:
             for item in node.local_relationships:
                 # if item is in changed and has no ID, then it is being overridden from a generic and must be added
-                if item.name in diff_relationships.added or item.name in diff_relationships.changed and item.id is None:
+                if item.name in diff_relationships.added or (
+                    item.name in diff_relationships.changed and item.id is None
+                ):
                     created_rel = await self.create_relationship_in_db(
                         schema=relationship_schema, item=item, branch=branch, db=db, parent=obj
                     )

infrahub/core/schema/schema_branch.py

@@ -91,7 +91,7 @@ class SchemaBranch:
             self.templates = data.get("templates", {})
 
     @classmethod
-    def validate(cls, data: Any) -> Self:  # noqa: ARG003
+    def validate(cls, data: Any) -> Self:
         if isinstance(data, cls):
             return data
         if isinstance(data, dict):
@@ -453,7 +453,7 @@ class SchemaBranch:
         if isinstance(node, NodeSchema | ProfileSchema | TemplateSchema):
             return node.generate_fields_for_display_label()
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         if isinstance(node, GenericSchema):
             for child_node_name in node.used_by:
                 child_node = self.get(name=child_node_name, duplicate=False)
@@ -997,6 +997,13 @@ class SchemaBranch:
                     raise ValueError(
                         f"{node.kind}: Relationship {rel.name!r} is referring an invalid peer {rel.peer!r}"
                     ) from None
+                if rel.common_relatives:
+                    peer_schema = self.get(name=rel.peer, duplicate=False)
+                    for common_relatives_rel_name in rel.common_relatives:
+                        if common_relatives_rel_name not in peer_schema.relationship_names:
+                            raise ValueError(
+                                f"{node.kind}: Relationship {rel.name!r} set 'common_relatives' with invalid relationship from '{rel.peer}'"
+                            ) from None
 
     def validate_attribute_parameters(self) -> None:
         for name in self.generics.keys():
@@ -2015,7 +2022,11 @@ class SchemaBranch:
             )
 
             parent_hfid = f"{relationship.name}__template_name__value"
-            if relationship.kind == RelationshipKind.PARENT and parent_hfid not in template_schema.human_friendly_id:
+            if (
+                not isinstance(template_schema, GenericSchema)
+                and relationship.kind == RelationshipKind.PARENT
+                and parent_hfid not in template_schema.human_friendly_id
+            ):
                 template_schema.human_friendly_id = [parent_hfid] + template_schema.human_friendly_id
                 template_schema.uniqueness_constraints[0].append(relationship.name)
 
@@ -2051,7 +2062,6 @@ class SchemaBranch:
                 include_in_menu=False,
                 display_labels=["template_name__value"],
                 human_friendly_id=["template_name__value"],
-                uniqueness_constraints=[["template_name__value"]],
                 attributes=[template_name_attr],
             )
 
@@ -2070,7 +2080,6 @@ class SchemaBranch:
                 human_friendly_id=["template_name__value"],
                 uniqueness_constraints=[["template_name__value"]],
                 inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
-                default_filter="template_name__value",
                 attributes=[template_name_attr],
                 relationships=[
                     RelationshipSchema(

infrahub/core/validators/tasks.py

@@ -9,7 +9,7 @@ from prefect.logging import get_run_logger
 
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.path import SchemaPath  # noqa: TC001
-from infrahub.core.schema import GenericSchema, NodeSchema  # noqa: TC001
+from infrahub.core.schema import GenericSchema, NodeSchema
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
 from infrahub.core.validators.model import (
     SchemaConstraintValidatorRequest,

infrahub/database/__init__.py

@@ -339,7 +339,7 @@ class InfrahubDatabase:
         CONNECTION_POOL_USAGE.labels(self._driver._pool.address).set(float(connpool_usage))
 
         if config.SETTINGS.database.max_concurrent_queries:
-            while connpool_usage > config.SETTINGS.database.max_concurrent_queries:  # noqa: ASYNC110
+            while connpool_usage > config.SETTINGS.database.max_concurrent_queries:
                 await asyncio.sleep(config.SETTINGS.database.max_concurrent_queries_delay)
                 connpool_usage = self._driver._pool.in_use_connection_count(self._driver._pool.address)