infrahub-server 1.2.3__py3-none-any.whl → 1.2.4__py3-none-any.whl

infrahub/cli/git_agent.py

@@ -19,10 +19,8 @@ from infrahub.git import initialize_repositories_directory
 from infrahub.lock import initialize_lock
 from infrahub.log import get_logger
 from infrahub.services import InfrahubServices
-from infrahub.services.adapters.cache.nats import NATSCache
-from infrahub.services.adapters.cache.redis import RedisCache
-from infrahub.services.adapters.message_bus.nats import NATSMessageBus
-from infrahub.services.adapters.message_bus.rabbitmq import RabbitMQMessageBus
+from infrahub.services.adapters.cache import InfrahubCache
+from infrahub.services.adapters.message_bus import InfrahubMessageBus
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
 from infrahub.trace import configure_trace
@@ -121,13 +119,9 @@ async def start(
 
     component_type = ComponentType.GIT_AGENT
     message_bus = config.OVERRIDE.message_bus or (
-        await NATSMessageBus.new(component_type=component_type)
-        if config.SETTINGS.broker.driver == config.BrokerDriver.NATS
-        else await RabbitMQMessageBus.new(component_type=component_type)
-    )
-    cache = config.OVERRIDE.cache or (
-        await NATSCache.new() if config.SETTINGS.cache.driver == config.CacheDriver.NATS else RedisCache()
+        await InfrahubMessageBus.new_from_driver(component_type=component_type, driver=config.SETTINGS.broker.driver)
     )
+    cache = config.OVERRIDE.cache or (await InfrahubCache.new_from_driver(driver=config.SETTINGS.cache.driver))
 
     service = await InfrahubServices.new(
         cache=cache,

infrahub/config.py

@@ -115,11 +115,43 @@ class BrokerDriver(str, Enum):
     RabbitMQ = "rabbitmq"
     NATS = "nats"
 
+    @property
+    def driver_module_path(self) -> str:
+        match self:
+            case BrokerDriver.NATS:
+                return "infrahub.services.adapters.message_bus.nats"
+            case BrokerDriver.RabbitMQ:
+                return "infrahub.services.adapters.message_bus.rabbitmq"
+
+    @property
+    def driver_class_name(self) -> str:
+        match self:
+            case BrokerDriver.NATS:
+                return "NATSMessageBus"
+            case BrokerDriver.RabbitMQ:
+                return "RabbitMQMessageBus"
+
 
 class CacheDriver(str, Enum):
     Redis = "redis"
     NATS = "nats"
 
+    @property
+    def driver_module_path(self) -> str:
+        match self:
+            case CacheDriver.NATS:
+                return "infrahub.services.adapters.cache.nats"
+            case CacheDriver.Redis:
+                return "infrahub.services.adapters.cache.redis"
+
+    @property
+    def driver_class_name(self) -> str:
+        match self:
+            case CacheDriver.NATS:
+                return "NATSCache"
+            case CacheDriver.Redis:
+                return "RedisCache"
+
 
 class WorkflowDriver(str, Enum):
     LOCAL = "local"

infrahub/core/constants/__init__.py

@@ -348,6 +348,7 @@ RESTRICTED_NAMESPACES: list[str] = [
 NODE_NAME_REGEX = r"^[A-Z][a-zA-Z0-9]+$"
 DEFAULT_NAME_MIN_LENGTH = 2
 NAME_REGEX = r"^[a-z0-9\_]+$"
+NAME_REGEX_OR_EMPTY = r"^[a-z0-9\_]*$"
 DEFAULT_DESCRIPTION_LENGTH = 128
 
 DEFAULT_NAME_MAX_LENGTH = 32

infrahub/core/constraint/node/runner.py

@@ -23,10 +23,15 @@ class NodeConstraintRunner:
         self.uniqueness_constraint = uniqueness_constraint
         self.relationship_manager_constraints = relationship_manager_constraints
 
-    async def check(self, node: Node, field_filters: list[str] | None = None) -> None:
+    async def check(
+        self, node: Node, field_filters: list[str] | None = None, skip_uniqueness_check: bool = False
+    ) -> None:
         async with self.db.start_session() as db:
             await node.resolve_relationships(db=db)
 
+            if not skip_uniqueness_check:
+                await self.uniqueness_constraint.check(node, filters=field_filters)
+
             for relationship_name in node.get_schema().relationship_names:
                 if field_filters and relationship_name not in field_filters:
                     continue
@@ -34,7 +39,3 @@ class NodeConstraintRunner:
                 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())
-
-            # If HFID constraint is the only constraint violated, all other constraints need to have ran before,
-            # as it means there is an existing node that we might want to update in the case of an upsert
-            await self.uniqueness_constraint.check(node, filters=field_filters)

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 24
+GRAPH_VERSION = 25

infrahub/core/migrations/graph/__init__.py

@@ -26,6 +26,7 @@ from .m021_missing_hierarchy_merge import Migration021
 from .m022_add_generate_template_attr import Migration022
 from .m023_deduplicate_cardinality_one_relationships import Migration023
 from .m024_missing_hierarchy_backfill import Migration024
+from .m025_uniqueness_nulls import Migration025
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -57,6 +58,7 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration022,
     Migration023,
     Migration024,
+    Migration025,
 ]
 
 

infrahub/core/migrations/graph/m018_uniqueness_nulls.py

@@ -21,81 +21,79 @@ if TYPE_CHECKING:
 log = get_logger()
 
 
+async def validate_nulls_in_uniqueness_constraints(db: InfrahubDatabase) -> MigrationResult:
+    """
+    Validate any schema that include optional attributes in the uniqueness constraints
+
+    An update to uniqueness constraint validation now handles NULL values as unique instead of ignoring them
+    """
+
+    default_branch = registry.get_branch_from_registry()
+    build_component_registry()
+    component_registry = get_component_registry()
+    uniqueness_checker = await component_registry.get_component(UniquenessChecker, db=db, branch=default_branch)
+    non_unique_nodes_by_kind: dict[str, list[NonUniqueNode]] = defaultdict(list)
+
+    manager = SchemaManager()
+    registry.schema = manager
+    internal_schema_root = SchemaRoot(**internal_schema)
+    manager.register_schema(schema=internal_schema_root)
+    schema_branch = await manager.load_schema_from_db(db=db, branch=default_branch)
+    manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
+
+    for schema_kind in schema_branch.node_names + schema_branch.generic_names_without_templates:
+        schema = schema_branch.get(name=schema_kind, duplicate=False)
+        if not isinstance(schema, NodeSchema | GenericSchema):
+            continue
+
+        uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(schema_branch=schema_branch)
+        includes_optional_attr: bool = False
+
+        for uniqueness_constraint_path in uniqueness_constraint_paths:
+            for schema_attribute_path in uniqueness_constraint_path.attributes_paths:
+                if schema_attribute_path.attribute_schema and schema_attribute_path.attribute_schema.optional is True:
+                    includes_optional_attr = True
+                    break
+
+        if not includes_optional_attr:
+            continue
+
+        non_unique_nodes = await uniqueness_checker.check_one_schema(schema=schema)
+        if non_unique_nodes:
+            non_unique_nodes_by_kind[schema_kind] = non_unique_nodes
+
+    if not non_unique_nodes_by_kind:
+        return MigrationResult()
+
+    error_strings = []
+    for schema_kind, non_unique_nodes in non_unique_nodes_by_kind.items():
+        display_label_map = await get_display_labels_per_kind(
+            db=db, kind=schema_kind, branch_name=default_branch.name, ids=[nun.node_id for nun in non_unique_nodes]
+        )
+        for non_unique_node in non_unique_nodes:
+            display_label = display_label_map.get(non_unique_node.node_id)
+            error_str = f"{display_label or ''}({non_unique_node.node_schema.kind} / {non_unique_node.node_id})"
+            error_str += " violates uniqueness constraints for the following attributes: "
+            attr_values = [
+                f"{attr.attribute_name}={attr.attribute_value}" for attr in non_unique_node.non_unique_attributes
+            ]
+            error_str += ", ".join(attr_values)
+            error_strings.append(error_str)
+    if error_strings:
+        error_str = "For the following nodes, you must update the uniqueness_constraints on the schema of the node"
+        error_str += " to remove the attribute(s) with NULL values or update the data on the nodes to be unique"
+        error_str += " now that NULL values are considered during uniqueness validation"
+        return MigrationResult(errors=[error_str] + error_strings)
+    return MigrationResult()
+
+
 class Migration018(InternalSchemaMigration):
     name: str = "018_validate_nulls_in_uniqueness_constraints"
     minimum_version: int = 17
     migrations: Sequence[SchemaMigration] = []
 
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
-        result = MigrationResult()
-
-        return result
+        return MigrationResult()
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
-        """
-        Validate any schema that include optional attributes in the uniqueness constraints
-
-        An update to uniqueness constraint validation now handles NULL values as unique instead of ignoring them
-        """
-        default_branch = registry.get_branch_from_registry()
-        build_component_registry()
-        component_registry = get_component_registry()
-        uniqueness_checker = await component_registry.get_component(UniquenessChecker, db=db, branch=default_branch)
-        non_unique_nodes_by_kind: dict[str, list[NonUniqueNode]] = defaultdict(list)
-
-        manager = SchemaManager()
-        registry.schema = manager
-        internal_schema_root = SchemaRoot(**internal_schema)
-        manager.register_schema(schema=internal_schema_root)
-        schema_branch = await manager.load_schema_from_db(db=db, branch=default_branch)
-        manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
-
-        for schema_kind in schema_branch.node_names + schema_branch.generic_names_without_templates:
-            schema = schema_branch.get(name=schema_kind, duplicate=False)
-            if not isinstance(schema, NodeSchema | GenericSchema):
-                continue
-
-            uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(
-                schema_branch=schema_branch
-            )
-            includes_optional_attr: bool = False
-
-            for uniqueness_constraint_path in uniqueness_constraint_paths:
-                for schema_attribute_path in uniqueness_constraint_path.attributes_paths:
-                    if (
-                        schema_attribute_path.attribute_schema
-                        and schema_attribute_path.attribute_schema.optional is True
-                    ):
-                        includes_optional_attr = True
-                        break
-
-            if not includes_optional_attr:
-                continue
-
-            non_unique_nodes = await uniqueness_checker.check_one_schema(schema=schema)
-            if non_unique_nodes:
-                non_unique_nodes_by_kind[schema_kind] = non_unique_nodes
-
-        if not non_unique_nodes_by_kind:
-            return MigrationResult()
-
-        error_strings = []
-        for schema_kind, non_unique_nodes in non_unique_nodes_by_kind.items():
-            display_label_map = await get_display_labels_per_kind(
-                db=db, kind=schema_kind, branch_name=default_branch.name, ids=[nun.node_id for nun in non_unique_nodes]
-            )
-            for non_unique_node in non_unique_nodes:
-                display_label = display_label_map.get(non_unique_node.node_id)
-                error_str = f"{display_label or ''}({non_unique_node.node_schema.kind} / {non_unique_node.node_id})"
-                error_str += " violates uniqueness constraints for the following attributes: "
-                attr_values = [
-                    f"{attr.attribute_name}={attr.attribute_value}" for attr in non_unique_node.non_unique_attributes
-                ]
-                error_str += ", ".join(attr_values)
-                error_strings.append(error_str)
-        if error_strings:
-            error_str = "For the following nodes, you must update the uniqueness_constraints on the schema of the node"
-            error_str += " to remove the attribute(s) with NULL values or update the data on the nodes to be unique"
-            error_str += " now that NULL values are considered during uniqueness validation"
-            return MigrationResult(errors=[error_str] + error_strings)
-        return MigrationResult()
+        return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/graph/m025_uniqueness_nulls.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.log import get_logger
+
+from ..shared import InternalSchemaMigration, SchemaMigration
+from .m018_uniqueness_nulls import validate_nulls_in_uniqueness_constraints
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class Migration025(InternalSchemaMigration):
+    name: str = "025_validate_nulls_in_uniqueness_constraints"
+    minimum_version: int = 24
+    migrations: Sequence[SchemaMigration] = []
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/schema/node_attribute_remove.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, Sequence
 
 from infrahub.core.constants import RelationshipStatus
 from infrahub.core.graph.schema import GraphAttributeRelationships
+from infrahub.core.schema.generic_schema import GenericSchema
 
 from ..query import AttributeMigrationQuery
 from ..shared import AttributeSchemaMigration
@@ -22,8 +23,20 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(branch_params)
 
+        attr_name = self.migration.schema_path.field_name
+        kinds_to_ignore = []
+        if isinstance(self.migration.new_node_schema, GenericSchema) and attr_name is not None:
+            for inheriting_schema_kind in self.migration.new_node_schema.used_by:
+                node_schema = db.schema.get_node_schema(
+                    name=inheriting_schema_kind, branch=self.branch, duplicate=False
+                )
+                attr_schema = node_schema.get_attribute_or_none(name=attr_name)
+                if attr_schema and not attr_schema.inherited:
+                    kinds_to_ignore.append(inheriting_schema_kind)
+
         self.params["node_kind"] = self.migration.new_schema.kind
-        self.params["attr_name"] = self.migration.schema_path.field_name
+        self.params["kinds_to_ignore"] = kinds_to_ignore
+        self.params["attr_name"] = attr_name
         self.params["current_time"] = self.at.to_string()
         self.params["branch_name"] = self.branch.name
         self.params["branch_support"] = self.migration.previous_attribute_schema.get_branch().value
@@ -60,7 +73,8 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         query = """
         // Find all the active nodes
         MATCH (node:%(node_kind)s)
-        WHERE exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
+        WHERE (size($kinds_to_ignore) = 0 OR NOT any(l IN labels(node) WHERE l IN $kinds_to_ignore))
+        AND exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
         CALL {
             WITH node
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)

infrahub/core/models.py

@@ -529,7 +529,7 @@ class HashableModel(BaseModel):
 
         return new_list
 
-    def update(self, other: Self) -> Self:
+    def update(self, other: HashableModel) -> Self:
         """Update the current object with the new value from the new one if they are defined.
 
         Currently this method works for the following type of fields

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -220,8 +220,13 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
 
         violations = []
         for schema in schemas_to_check:
+            schema_filters = list(filters) if filters is not None else []
+            for attr_schema in schema.attributes:
+                if attr_schema.optional and attr_schema.unique and attr_schema.name not in schema_filters:
+                    schema_filters.append(attr_schema.name)
+
             schema_violations = await self._get_single_schema_violations(
-                node=node, node_schema=schema, at=at, filters=filters
+                node=node, node_schema=schema, at=at, filters=schema_filters
             )
             violations.extend(schema_violations)
 

infrahub/core/registry.py

@@ -220,5 +220,23 @@ class Registry:
             and branch.active_schema_hash.main != default_branch.active_schema_hash.main
         ]
 
+    async def purge_inactive_branches(
+        self, db: InfrahubDatabase, active_branches: list[Branch] | None = None
+    ) -> list[str]:
+        """Return a list of branches that were purged from the registry."""
+        active_branches = active_branches or await self.branch_object.get_list(db=db)
+        active_branch_names = [branch.name for branch in active_branches]
+        purged_branches: set[str] = set()
+
+        for branch_name in list(registry.branch.keys()):
+            if branch_name not in active_branch_names:
+                del registry.branch[branch_name]
+                purged_branches.add(branch_name)
+
+        purged_branches.update(self.schema.purge_inactive_branches(active_branches=active_branch_names))
+        purged_branches.update(db.purge_inactive_schemas(active_branches=active_branch_names))
+
+        return sorted(purged_branches)
+
 
 registry = Registry()

infrahub/core/schema/basenode_schema.py

@@ -11,7 +11,7 @@ from infrahub_sdk.utils import compare_lists, intersection
 from pydantic import field_validator
 
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
-from infrahub.core.models import HashableModelDiff
+from infrahub.core.models import HashableModel, HashableModelDiff
 
 from .attribute_schema import AttributeSchema
 from .generated.base_node_schema import GeneratedBaseNodeSchema
@@ -27,6 +27,16 @@ if TYPE_CHECKING:
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
 INHERITED = "INHERITED"
 
+OPTIONAL_TEXT_FIELDS = [
+    "default_filter",
+    "description",
+    "label",
+    "menu_placement",
+    "documentation",
+    "parent",
+    "children",
+]
+
 
 class BaseNodeSchema(GeneratedBaseNodeSchema):
     _exclude_from_hash: list[str] = ["attributes", "relationships"]
@@ -480,6 +490,16 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
             return UniquenessConstraintType.SUBSET_OF_HFID
         return UniquenessConstraintType.STANDARD
 
+    def update(self, other: HashableModel) -> Self:
+        super().update(other=other)
+
+        # Allow to specify empty string to remove existing fields values
+        for field_name in OPTIONAL_TEXT_FIELDS:
+            if getattr(other, field_name, None) == "":  # noqa: PLC1901
+                setattr(self, field_name, None)
+
+        return self
+
 
 @dataclass
 class SchemaUniquenessConstraintPath:

infrahub/core/schema/definitions/internal.py

@@ -18,6 +18,7 @@ from infrahub.core.constants import (
     DEFAULT_NAME_MIN_LENGTH,
     DEFAULT_REL_IDENTIFIER_LENGTH,
     NAME_REGEX,
+    NAME_REGEX_OR_EMPTY,
     NAMESPACE_REGEX,
     NODE_KIND_REGEX,
     NODE_NAME_REGEX,
@@ -269,7 +270,7 @@ base_node_schema = SchemaNode(
         SchemaAttribute(
             name="default_filter",
             kind="Text",
-            regex=str(NAME_REGEX),
+            regex=str(NAME_REGEX_OR_EMPTY),
             description="Default filter used to search for a node in addition to its ID. (deprecated: please use human_friendly_id instead)",
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},

infrahub/core/schema/generated/base_node_schema.py

@@ -50,7 +50,7 @@ class GeneratedBaseNodeSchema(HashableModel):
     default_filter: str | None = Field(
         default=None,
         description="Default filter used to search for a node in addition to its ID. (deprecated: please use human_friendly_id instead)",
-        pattern=r"^[a-z0-9\_]+$",
+        pattern=r"^[a-z0-9\_]*$",
         json_schema_extra={"update": "allowed"},
     )
     human_friendly_id: list[str] | None = Field(

infrahub/core/schema/manager.py

@@ -744,3 +744,24 @@ class SchemaManager(NodeManager):
         """Convert a schema_node object loaded from the database into GenericSchema object."""
         node_data = await cls._prepare_node_data(schema_node=schema_node, db=db)
         return GenericSchema(**node_data)
+
+    def purge_inactive_branches(self, active_branches: list[str]) -> list[str]:
+        """Return non active branches that were purged."""
+
+        hashes_to_keep: set[str] = set()
+        for active_branch in active_branches:
+            if branch := self._branches.get(active_branch):
+                nodes = branch.get_all(include_internal=True, duplicate=False)
+                hashes_to_keep.update([node.get_hash() for node in nodes.values()])
+
+        removed_branches: list[str] = []
+        for branch_name in list(self._branches.keys()):
+            if branch_name not in active_branches:
+                del self._branches[branch_name]
+                removed_branches.append(branch_name)
+
+        for hash_key in list(self._cache.keys()):
+            if hash_key not in hashes_to_keep:
+                del self._cache[hash_key]
+
+        return removed_branches

infrahub/core/schema/schema_branch.py

@@ -1955,10 +1955,9 @@ class SchemaBranch:
                 )
             )
 
-            if relationship.kind == RelationshipKind.PARENT:
-                template_schema.human_friendly_id = [
-                    f"{relationship.name}__template_name__value"
-                ] + template_schema.human_friendly_id
+            parent_hfid = f"{relationship.name}__template_name__value"
+            if 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)
 
     def generate_object_template_from_node(

infrahub/database/__init__.py

@@ -205,6 +205,16 @@ class InfrahubDatabase:
     def add_schema(self, schema: SchemaBranch, name: str | None = None) -> None:
         self._schemas[name or schema.name] = schema
 
+    def purge_inactive_schemas(self, active_branches: list[str]) -> list[str]:
+        """Return non active schema branches that were purged."""
+        removed_branches: list[str] = []
+        for branch_name in list(self._schemas.keys()):
+            if branch_name not in active_branches:
+                del self._schemas[branch_name]
+                removed_branches.append(branch_name)
+
+        return removed_branches
+
     def start_session(self, read_only: bool = False, schemas: list[SchemaBranch] | None = None) -> InfrahubDatabase:
         """Create a new InfrahubDatabase object in Session mode."""
         session_mode = InfrahubDatabaseSessionMode.WRITE

infrahub/events/group_action.py

@@ -2,7 +2,7 @@ from typing import ClassVar
 
 from pydantic import Field
 
-from infrahub.core.constants import MutationAction
+from infrahub.core.constants import InfrahubKind, MutationAction
 
 from .constants import EVENT_NAMESPACE
 from .models import EventNode, InfrahubEvent
@@ -21,6 +21,11 @@ class GroupMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
+
+        if self.kind == InfrahubKind.GRAPHQLQUERYGROUP:
+            # Temporary workaround to avoid too large payloads for the related field
+            return related
+
         related.append(
             {
                 "prefect.resource.id": self.node_id,

infrahub/events/node_action.py

@@ -7,7 +7,7 @@ from infrahub.core.changelog.models import (
     RelationshipCardinalityManyChangelog,
     RelationshipCardinalityOneChangelog,
 )
-from infrahub.core.constants import DiffAction, MutationAction
+from infrahub.core.constants import DiffAction, InfrahubKind, MutationAction
 
 from .constants import EVENT_NAMESPACE
 from .models import InfrahubEvent
@@ -24,6 +24,10 @@ class NodeMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
+        if self.kind == InfrahubKind.GRAPHQLQUERYGROUP:
+            # Temporary workaround to avoid too large payloads for the related field
+            return related
+
         for attribute in self.changelog.attributes.values():
             related.append(
                 {

infrahub/graphql/mutations/main.py

@@ -363,7 +363,7 @@ class InfrahubMutationMixin:
         branch: Branch,
         db: InfrahubDatabase,
         obj: Node,
-        run_constraint_checks: bool = True,
+        skip_uniqueness_check: bool = False,
     ) -> tuple[Node, Self]:
         """
         Wrapper around mutate_update to potentially activate locking and call it within a database transaction.
@@ -378,11 +378,11 @@ class InfrahubMutationMixin:
             if lock_names:
                 async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
                     obj = await cls.mutate_update_object(
-                        db=db, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                        db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                     )
             else:
                 obj = await cls.mutate_update_object(
-                    db=db, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                    db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                 )
             result = await cls.mutate_update_to_graphql(db=db, info=info, obj=obj)
             return obj, result
@@ -396,11 +396,11 @@ class InfrahubMutationMixin:
                         data=data,
                         branch=branch,
                         obj=obj,
-                        run_constraint_checks=run_constraint_checks,
+                        skip_uniqueness_check=skip_uniqueness_check,
                     )
             else:
                 obj = await cls.mutate_update_object(
-                    db=dbt, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                    db=dbt, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                 )
             result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=obj)
             return obj, result
@@ -434,7 +434,7 @@ class InfrahubMutationMixin:
         data: InputObjectType,
         branch: Branch,
         obj: Node,
-        run_constraint_checks: bool = True,
+        skip_uniqueness_check: bool = False,
     ) -> Node:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
@@ -442,8 +442,9 @@ class InfrahubMutationMixin:
         before_mutate_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
         await obj.from_graphql(db=db, data=data)
         fields_to_validate = list(data)
-        if run_constraint_checks:
-            await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
+        await node_constraint_runner.check(
+            node=obj, field_filters=fields_to_validate, skip_uniqueness_check=skip_uniqueness_check
+        )
 
         fields = list(data.keys())
         for field_to_remove in ("id", "hfid"):
@@ -494,7 +495,6 @@ class InfrahubMutationMixin:
         db = database or graphql_context.db
         dict_data = dict(data)
         node = None
-        run_constraint_checks = True
 
         if "id" in dict_data:
             node = await NodeManager.get_one(
@@ -506,7 +506,6 @@ class InfrahubMutationMixin:
                 db=db,
                 branch=branch,
                 obj=node,
-                run_constraint_checks=run_constraint_checks,
             )
             return updated_obj, mutation, False
 
@@ -525,7 +524,6 @@ class InfrahubMutationMixin:
                 db=db,
                 branch=branch,
                 obj=node,
-                run_constraint_checks=run_constraint_checks,
             )
             return updated_obj, mutation, False
 
@@ -545,7 +543,7 @@ class InfrahubMutationMixin:
                 db=db,
                 branch=branch,
                 obj=node,
-                run_constraint_checks=run_constraint_checks,
+                skip_uniqueness_check=True,
             )
             return updated_obj, mutation, False