infrahub-server 1.4.9__py3-none-any.whl → 1.4.11__py3-none-any.whl

infrahub/core/ipam/utilization.py

@@ -152,4 +152,4 @@ class PrefixUtilizationGetter:
             grand_total_space += prefix_total_space
         if grand_total_space == 0:
             return 0.0
-        return (grand_total_used / grand_total_space) * 100
+        return min((grand_total_used / grand_total_space) * 100, 100)

infrahub/core/manager.py

@@ -63,12 +63,15 @@ def identify_node_class(node: NodeToProcess) -> type[Node]:
 
 
 def get_schema(
-    db: InfrahubDatabase, branch: Branch, node_schema: type[SchemaProtocol] | MainSchemaTypes | str
+    db: InfrahubDatabase,
+    branch: Branch,
+    node_schema: type[SchemaProtocol] | MainSchemaTypes | str,
+    duplicate: bool = False,
 ) -> MainSchemaTypes:
     if isinstance(node_schema, str):
-        return db.schema.get(name=node_schema, branch=branch.name)
+        return db.schema.get(name=node_schema, branch=branch.name, duplicate=duplicate)
     if hasattr(node_schema, "_is_runtime_protocol") and node_schema._is_runtime_protocol:
-        return db.schema.get(name=node_schema.__name__, branch=branch.name)
+        return db.schema.get(name=node_schema.__name__, branch=branch.name, duplicate=duplicate)
     if not isinstance(node_schema, (MainSchemaTypes)):
         raise ValueError(f"Invalid schema provided {node_schema}")
 

infrahub/core/node/__init__.py

@@ -408,7 +408,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         for attribute_name in template._attributes:
             if attribute_name in list(fields) + [OBJECT_TEMPLATE_NAME_ATTR]:
                 continue
-            fields[attribute_name] = {"value": getattr(template, attribute_name).value, "source": template.id}
+            attr_value = getattr(template, attribute_name).value
+            if attr_value is not None:
+                fields[attribute_name] = {"value": attr_value, "source": template.id}
 
         for relationship_name in template._relationships:
             relationship_schema = template._schema.get_relationship(name=relationship_name)

infrahub/core/node/constraints/attribute_uniqueness.py

@@ -29,7 +29,9 @@ class NodeAttributeUniquenessConstraint(NodeConstraintInterface):
             attr = getattr(node, unique_attr.name)
             if unique_attr.inherited:
                 for generic_parent_schema_name in node_schema.inherit_from:
-                    generic_parent_schema = self.db.schema.get(generic_parent_schema_name, branch=self.branch)
+                    generic_parent_schema = self.db.schema.get(
+                        generic_parent_schema_name, branch=self.branch, duplicate=False
+                    )
                     parent_attr = generic_parent_schema.get_attribute_or_none(unique_attr.name)
                     if parent_attr is None:
                         continue

infrahub/core/node/create.py

@@ -41,10 +41,19 @@ async def extract_peer_data(
 ) -> Mapping[str, Any]:
     obj_peer_data: dict[str, Any] = {}
 
-    for attr in template_peer.get_schema().attribute_names:
-        if attr not in obj_peer_schema.attribute_names:
+    for attr_name in template_peer.get_schema().attribute_names:
+        template_attr = getattr(template_peer, attr_name)
+        if template_attr.value is None:
             continue
-        obj_peer_data[attr] = {"value": getattr(template_peer, attr).value, "source": template_peer.id}
+        if template_attr.is_default:
+            # if template attr is_default and the value matches the object schema, then do not set the source
+            try:
+                if obj_peer_schema.get_attribute(name=attr_name).default_value == template_attr.value:
+                    continue
+            except ValueError:
+                pass
+
+        obj_peer_data[attr_name] = {"value": template_attr.value, "source": template_peer.id}
 
     for rel in template_peer.get_schema().relationship_names:
         rel_manager: RelationshipManager = getattr(template_peer, rel)

infrahub/core/registry.py

@@ -113,8 +113,8 @@ class Registry:
             return True
         return False
 
-    def get_node_schema(self, name: str, branch: Branch | str | None = None) -> NodeSchema:
-        return self.schema.get_node_schema(name=name, branch=branch)
+    def get_node_schema(self, name: str, branch: Branch | str | None = None, duplicate: bool = False) -> NodeSchema:
+        return self.schema.get_node_schema(name=name, branch=branch, duplicate=duplicate)
 
     def get_data_type(self, name: str) -> type[InfrahubDataType]:
         if name not in self.data_type:

infrahub/core/relationship/constraints/count.py

@@ -40,7 +40,7 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
         # peer_ids_present_database_only:
         #    relationship to be deleted, need to check if the schema on the other side has a min_count defined
         # TODO see how to manage Generic node
-        peer_schema = registry.schema.get(name=relm.schema.peer, branch=branch)
+        peer_schema = registry.schema.get(name=relm.schema.peer, branch=branch, duplicate=False)
         peer_rels = peer_schema.get_relationships_by_identifier(id=relm.schema.get_identifier())
         if not peer_rels:
             return

infrahub/core/relationship/model.py

@@ -440,7 +440,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
                 self.set_peer(value=peer)
 
         if not self.peer_id and self.peer_hfid:
-            peer_schema = db.schema.get(name=self.schema.peer, branch=self.branch)
+            peer_schema = db.schema.get(name=self.schema.peer, branch=self.branch, duplicate=False)
             kind = (
                 self.data["kind"]
                 if isinstance(self.data, dict) and "kind" in self.data and peer_schema.is_generic_schema

infrahub/core/schema/definitions/internal.py

@@ -180,6 +180,7 @@ class SchemaNode(BaseModel):
     attributes: list[SchemaAttribute]
     relationships: list[SchemaRelationship]
     display_labels: list[str]
+    uniqueness_constraints: list[list[str]] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -195,6 +196,7 @@ class SchemaNode(BaseModel):
             ],
             "relationships": [relationship.to_dict() for relationship in self.relationships],
             "display_labels": self.display_labels,
+            "uniqueness_constraints": self.uniqueness_constraints,
         }
 
     def without_duplicates(self, other: SchemaNode) -> SchemaNode:
@@ -465,6 +467,7 @@ attribute_schema = SchemaNode(
     include_in_menu=False,
     default_filter=None,
     display_labels=["name__value"],
+    uniqueness_constraints=[["name__value", "node"]],
     attributes=[
         SchemaAttribute(
             name="id",
@@ -669,6 +672,7 @@ relationship_schema = SchemaNode(
     include_in_menu=False,
     default_filter=None,
     display_labels=["name__value"],
+    uniqueness_constraints=[["name__value", "node"]],
     attributes=[
         SchemaAttribute(
             name="id",

infrahub/core/schema/manager.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from cachetools import LRUCache
+from infrahub_sdk.schema import BranchSchema as SDKBranchSchema
+
 from infrahub import lock
 from infrahub.core.manager import NodeManager
 from infrahub.core.models import (
@@ -40,6 +43,8 @@ class SchemaManager(NodeManager):
     def __init__(self) -> None:
         self._cache: dict[int, Any] = {}
         self._branches: dict[str, SchemaBranch] = {}
+        self._branch_hash_by_name: dict[str, str] = {}
+        self._sdk_branches: LRUCache[str, SDKBranchSchema] = LRUCache(maxsize=10)
 
     def _get_from_cache(self, key: int) -> Any:
         return self._cache[key]
@@ -140,12 +145,23 @@ class SchemaManager(NodeManager):
         if name in self._branches:
             return self._branches[name]
 
-        self._branches[name] = SchemaBranch(cache=self._cache, name=name)
+        self.set_schema_branch(name, schema=SchemaBranch(cache=self._cache, name=name))
         return self._branches[name]
 
+    def get_sdk_schema_branch(self, name: str) -> SDKBranchSchema:
+        schema_hash = self._branch_hash_by_name[name]
+        branch_schema = self._sdk_branches.get(schema_hash)
+        if not branch_schema:
+            self._sdk_branches[schema_hash] = SDKBranchSchema.from_api_response(
+                data=self._branches[name].to_dict_api_schema_object()
+            )
+
+        return self._sdk_branches[schema_hash]
+
     def set_schema_branch(self, name: str, schema: SchemaBranch) -> None:
         schema.name = name
         self._branches[name] = schema
+        self._branch_hash_by_name[name] = schema.get_hash()
 
     def process_schema_branch(self, name: str) -> None:
         schema_branch = self.get_schema_branch(name=name)
@@ -764,6 +780,8 @@ class SchemaManager(NodeManager):
         for branch_name in list(self._branches.keys()):
             if branch_name not in active_branches:
                 del self._branches[branch_name]
+                if branch_name in self._branch_hash_by_name:
+                    del self._branch_hash_by_name[branch_name]
                 removed_branches.append(branch_name)
 
         for hash_key in list(self._cache.keys()):

infrahub/core/schema/node_schema.py

@@ -129,10 +129,12 @@ class NodeSchema(GeneratedNodeSchema):
                 item_idx = existing_inherited_relationships[relationship.name]
                 self.relationships[item_idx].update_from_generic(other=new_relationship)
 
-    def get_hierarchy_schema(self, db: InfrahubDatabase, branch: Branch | str | None = None) -> GenericSchema:
+    def get_hierarchy_schema(
+        self, db: InfrahubDatabase, branch: Branch | str | None = None, duplicate: bool = False
+    ) -> GenericSchema:
         if not self.hierarchy:
             raise ValueError("The node is not part of a hierarchy")
-        schema = db.schema.get(name=self.hierarchy, branch=branch)
+        schema = db.schema.get(name=self.hierarchy, branch=branch, duplicate=duplicate)
         if not isinstance(schema, GenericSchema):
             raise TypeError
         return schema

infrahub/core/schema/schema_branch.py

@@ -162,6 +162,14 @@ class SchemaBranch:
             "templates": {name: self.get(name, duplicate=duplicate) for name in self.templates},
         }
 
+    def to_dict_api_schema_object(self) -> dict[str, list[dict]]:
+        return {
+            "nodes": [self.get(name, duplicate=False).model_dump() for name in self.nodes],
+            "profiles": [self.get(name, duplicate=False).model_dump() for name in self.profiles],
+            "generics": [self.get(name, duplicate=False).model_dump() for name in self.generics],
+            "templates": [self.get(name, duplicate=False).model_dump() for name in self.templates],
+        }
+
     @classmethod
     def from_dict_schema_object(cls, data: dict) -> Self:
         type_mapping = {

infrahub/core/validators/determiner.py

@@ -10,6 +10,7 @@ from infrahub.core.schema.attribute_parameters import AttributeParameters
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.schema.schema_branch import SchemaBranch
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
+from infrahub.exceptions import SchemaNotFoundError
 from infrahub.log import get_logger
 
 if TYPE_CHECKING:
@@ -81,7 +82,17 @@ class ConstraintValidatorDeterminer:
 
     async def _get_all_property_constraints(self) -> list[SchemaUpdateConstraintInfo]:
         constraints: list[SchemaUpdateConstraintInfo] = []
-        for schema in self.schema_branch.get_all().values():
+        schemas = list(self.schema_branch.get_all(duplicate=False).values())
+        # added here to check their uniqueness constraints
+        try:
+            schemas.append(self.schema_branch.get_node(name="SchemaAttribute", duplicate=False))
+        except SchemaNotFoundError:
+            pass
+        try:
+            schemas.append(self.schema_branch.get_node(name="SchemaRelationship", duplicate=False))
+        except SchemaNotFoundError:
+            pass
+        for schema in schemas:
             constraints.extend(await self._get_property_constraints_for_one_schema(schema=schema))
         return constraints
 

infrahub/core/validators/relationship/peer.py

@@ -22,7 +22,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
     name = "relationship_constraints_peer_validator"
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
-        peer_schema = db.schema.get(name=self.relationship_schema.peer, branch=self.branch)
+        peer_schema = db.schema.get(name=self.relationship_schema.peer, branch=self.branch, duplicate=False)
         allowed_peer_kinds = [peer_schema.kind]
         if isinstance(peer_schema, GenericSchema):
             allowed_peer_kinds += peer_schema.used_by

infrahub/core/validators/tasks.py

@@ -36,7 +36,7 @@ async def schema_validate_migrations(message: SchemaValidateMigrationData) -> li
     log.info(f"{len(message.constraints)} constraint(s) to validate")
     # NOTE this task is a good candidate to add a progress bar
     for constraint in message.constraints:
-        schema = message.schema_branch.get(name=constraint.path.schema_kind)
+        schema = message.schema_branch.get(name=constraint.path.schema_kind, duplicate=False)
         if not isinstance(schema, GenericSchema | NodeSchema):
             continue
         batch.add(

infrahub/generators/tasks.py

@@ -21,6 +21,7 @@ from infrahub.generators.models import (
 )
 from infrahub.git.base import extract_repo_file_information
 from infrahub.git.repository import get_initialized_repo
+from infrahub.git.utils import fetch_proposed_change_generator_definition_targets
 from infrahub.workers.dependencies import get_client, get_workflow
 from infrahub.workflows.catalogue import REQUEST_GENERATOR_DEFINITION_RUN, REQUEST_GENERATOR_RUN
 from infrahub.workflows.utils import add_tags
@@ -177,14 +178,9 @@ async def request_generator_definition_run(
         branch=model.branch,
     )
 
-    group = await client.get(
-        kind=InfrahubKind.GENERICGROUP,
-        prefetch_relationships=True,
-        populate_store=True,
-        id=model.generator_definition.group_id,
-        branch=model.branch,
+    group = await fetch_proposed_change_generator_definition_targets(
+        client=client, branch=model.branch, definition=model.generator_definition
     )
-    await group.members.fetch()
 
     instance_by_member = {}
     for instance in existing_instances:

infrahub/git/integrator.py

@@ -1363,7 +1363,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         message: CheckArtifactCreate | RequestArtifactGenerate,
     ) -> ArtifactGenerateResult:
         response = await self.sdk.query_gql_query(
-            name=message.query,
+            name=message.query_id,
             variables=message.variables,
             update_group=True,
             subscribers=[artifact.id],

infrahub/git/models.py

@@ -38,7 +38,8 @@ class RequestArtifactGenerate(BaseModel):
     target_kind: str = Field(..., description="The kind of the target object for this artifact")
     target_name: str = Field(..., description="Name of the artifact target")
     artifact_id: str | None = Field(default=None, description="The id of the artifact if it previously existed")
-    query: str = Field(..., description="The name of the query to use when collecting data")
+    query: str = Field(..., description="The name of the query to use when collecting data")  # Deprecated
+    query_id: str = Field(..., description="The id of the query to use when collecting data")
     timeout: int = Field(..., description="Timeout for requests used to generate this artifact")
     variables: dict = Field(..., description="Input variables when generating the artifact")
     context: InfrahubContext = Field(..., description="The context of the task")

infrahub/git/repository.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from cachetools import TTLCache
+from cachetools.keys import hashkey
+from cachetools_async import cached
 from git.exc import BadName, GitCommandError
 from infrahub_sdk.exceptions import GraphQLError
 from prefect import task
@@ -248,12 +251,13 @@ class InfrahubReadOnlyRepository(InfrahubRepositoryIntegrator):
         await self.update_commit_value(branch_name=self.infrahub_branch_name, commit=commit)
 
 
-@task(
-    name="Fetch repository commit",
-    description="Retrieve a git repository at a given commit, if it does not already exist locally",
-    cache_policy=NONE,
+@cached(
+    TTLCache(maxsize=100, ttl=30),
+    key=lambda *_, **kwargs: hashkey(
+        kwargs.get("repository_id"), kwargs.get("name"), kwargs.get("repository_kind"), kwargs.get("commit")
+    ),
 )
-async def get_initialized_repo(
+async def _get_initialized_repo(
     client: InfrahubClient, repository_id: str, name: str, repository_kind: str, commit: str | None = None
 ) -> InfrahubReadOnlyRepository | InfrahubRepository:
     if repository_kind == InfrahubKind.REPOSITORY:
@@ -263,3 +267,16 @@ async def get_initialized_repo(
         return await InfrahubReadOnlyRepository.init(id=repository_id, name=name, commit=commit, client=client)
 
     raise NotImplementedError(f"The repository kind {repository_kind} has not been implemented")
+
+
+@task(
+    name="Fetch repository commit",
+    description="Retrieve a git repository at a given commit, if it does not already exist locally",
+    cache_policy=NONE,
+)
+async def get_initialized_repo(
+    client: InfrahubClient, repository_id: str, name: str, repository_kind: str, commit: str | None = None
+) -> InfrahubReadOnlyRepository | InfrahubRepository:
+    return await _get_initialized_repo(
+        client=client, repository_id=repository_id, name=name, repository_kind=repository_kind, commit=commit
+    )

infrahub/git/tasks.py

@@ -53,6 +53,7 @@ from .models import (
     UserCheckDefinitionData,
 )
 from .repository import InfrahubReadOnlyRepository, InfrahubRepository, get_initialized_repo
+from .utils import fetch_artifact_definition_targets, fetch_check_definition_targets
 
 
 @flow(
@@ -323,9 +324,8 @@ async def generate_request_artifact_definition(
         kind=CoreArtifactDefinition, id=model.artifact_definition_id, branch=model.branch
     )
 
-    await artifact_definition.targets.fetch()
-    group = artifact_definition.targets.peer
-    await group.members.fetch()
+    group = await fetch_artifact_definition_targets(client=client, branch=model.branch, definition=artifact_definition)
+
     current_members = [member.id for member in group.members.peers]
 
     artifacts_by_member = {}
@@ -356,6 +356,7 @@ async def generate_request_artifact_definition(
         transform_location = f"{transform.file_path.value}::{transform.class_name.value}"
         convert_query_response = transform.convert_query_response.value
 
+    batch = await client.create_batch()
     for relationship in group.members.peers:
         member = relationship.peer
         artifact_id = artifacts_by_member.get(member.id)
@@ -376,6 +377,7 @@ async def generate_request_artifact_definition(
             repository_kind=repository.get_kind(),
             branch_name=model.branch,
             query=query.name.value,
+            query_id=query.id,
             variables=await member.extract(params=artifact_definition.parameters.value),
             target_id=member.id,
             target_name=member.display_label,
@@ -385,10 +387,16 @@ async def generate_request_artifact_definition(
             context=context,
         )
 
-        await get_workflow().submit_workflow(
-            workflow=REQUEST_ARTIFACT_GENERATE, context=context, parameters={"model": request_artifact_generate_model}
+        batch.add(
+            task=get_workflow().submit_workflow,
+            workflow=REQUEST_ARTIFACT_GENERATE,
+            context=context,
+            parameters={"model": request_artifact_generate_model},
         )
 
+    async for _, _ in batch.execute():
+        pass
+
 
 @flow(name="git-repository-pull-read-only", flow_run_name="Pull latest commit on {model.repository_name}")
 async def pull_read_only(model: GitRepositoryPullReadOnly) -> None:
@@ -569,9 +577,7 @@ async def trigger_repository_user_checks_definitions(model: UserCheckDefinitionD
 
     if definition.targets.id:
         # Check against a group of targets
-        await definition.targets.fetch()
-        group = definition.targets.peer
-        await group.members.fetch()
+        group = await fetch_check_definition_targets(client=client, branch=model.branch_name, definition=definition)
         check_models = []
         for relationship in group.members.peers:
             member = relationship.peer

infrahub/git/utils.py

@@ -1,9 +1,16 @@
-from typing import TYPE_CHECKING
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any
+
+from infrahub_sdk import InfrahubClient
+from infrahub_sdk.node import RelationshipManager
+from infrahub_sdk.protocols import CoreArtifactDefinition, CoreCheckDefinition, CoreGroup
+from infrahub_sdk.types import Order
 
 from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.database import InfrahubDatabase
+from infrahub.generators.models import ProposedChangeGeneratorDefinition
 
 from .models import RepositoryBranchInfo, RepositoryData
 
@@ -46,3 +53,118 @@ async def get_repositories_commit_per_branch(
             )
 
     return repositories
+
+
+def _collect_parameter_first_segments(params: Any) -> set[str]:
+    segments: set[str] = set()
+
+    def _walk(value: Any) -> None:
+        if isinstance(value, str):
+            segment = value.split("__", 1)[0]
+            if segment:
+                segments.add(segment)
+        elif isinstance(value, dict):
+            for nested in value.values():
+                _walk(nested)
+        elif isinstance(value, (list, tuple, set)):
+            for nested in value:
+                _walk(nested)
+
+    _walk(params)
+    return segments
+
+
+async def _prefetch_group_member_nodes(
+    client: InfrahubClient,
+    members: RelationshipManager,
+    branch: str,
+    required_fields: set[str],
+) -> None:
+    ids_per_kind: dict[str, set[str]] = defaultdict(set)
+    for peer in members.peers:
+        if peer.id and peer.typename:
+            ids_per_kind[peer.typename].add(peer.id)
+
+    if not ids_per_kind:
+        return
+
+    batch = await client.create_batch()
+
+    for kind, ids in ids_per_kind.items():
+        schema = await client.schema.get(kind=kind, branch=branch)
+
+        # FIXME: https://github.com/opsmill/infrahub-sdk-python/pull/205
+        valid_fields = set(schema.attribute_names) | set(schema.relationship_names)
+        keep_relationships = set(schema.relationship_names) & required_fields
+        cleaned_fields = valid_fields - required_fields
+
+        kwargs: dict[str, Any] = {
+            "kind": kind,
+            "ids": list(ids),
+            "branch": branch,
+            "exclude": list(cleaned_fields),
+            "populate_store": True,
+            "order": Order(disable=True),
+        }
+
+        if keep_relationships:
+            kwargs["include"] = list(keep_relationships)
+
+        batch.add(task=client.filters, **kwargs)
+
+    async for _ in batch.execute():
+        pass
+
+
+async def _fetch_definition_targets(
+    client: InfrahubClient,
+    branch: str,
+    group_id: str,
+    parameters: Any,
+) -> CoreGroup:
+    group = await client.get(
+        kind=CoreGroup,
+        id=group_id,
+        branch=branch,
+        include=["members"],
+    )
+
+    parameter_fields = _collect_parameter_first_segments(parameters)
+    await _prefetch_group_member_nodes(
+        client=client,
+        members=group.members,
+        branch=branch,
+        required_fields=parameter_fields,
+    )
+
+    return group
+
+
+async def fetch_artifact_definition_targets(
+    client: InfrahubClient,
+    branch: str,
+    definition: CoreArtifactDefinition,
+) -> CoreGroup:
+    return await _fetch_definition_targets(
+        client=client, branch=branch, group_id=definition.targets.id, parameters=definition.parameters.value
+    )
+
+
+async def fetch_check_definition_targets(
+    client: InfrahubClient,
+    branch: str,
+    definition: CoreCheckDefinition,
+) -> CoreGroup:
+    return await _fetch_definition_targets(
+        client=client, branch=branch, group_id=definition.targets.id, parameters=definition.parameters.value
+    )
+
+
+async def fetch_proposed_change_generator_definition_targets(
+    client: InfrahubClient,
+    branch: str,
+    definition: ProposedChangeGeneratorDefinition,
+) -> CoreGroup:
+    return await _fetch_definition_targets(
+        client=client, branch=branch, group_id=definition.group_id, parameters=definition.parameters
+    )

infrahub/graphql/analyzer.py

@@ -639,7 +639,7 @@ class InfrahubGraphQLQueryAnalyzer(GraphQLQueryAnalyzer):
         self, node: InlineFragmentNode, query_node: GraphQLQueryNode
     ) -> GraphQLQueryNode:
         context_type = query_node.context_type
-        infrahub_model = self.schema_branch.get(name=node.type_condition.name.value)
+        infrahub_model = self.schema_branch.get(name=node.type_condition.name.value, duplicate=False)
         context_type = ContextType.DIRECT
         current_node = GraphQLQueryNode(
             parent=query_node,

infrahub/graphql/mutations/main.py

@@ -479,7 +479,7 @@ def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch
     it means node schema overrided this constraint, in which case we only need to lock on the generic.
     """
 
-    node_schema = schema_branch.get(name=kind)
+    node_schema = schema_branch.get(name=kind, duplicate=False)
 
     schema_uc = None
     kinds = []
@@ -494,7 +494,7 @@ def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch
 
     node_schema_kind_removed = False
     for generic_kind in generics_kinds:
-        generic_uc = schema_branch.get(name=generic_kind).uniqueness_constraints
+        generic_uc = schema_branch.get(name=generic_kind, duplicate=False).uniqueness_constraints
         if generic_uc:
             kinds.append(generic_kind)
             if not node_schema_kind_removed and generic_uc == schema_uc:
@@ -513,7 +513,7 @@ def _should_kind_be_locked_on_any_branch(kind: str, schema_branch: SchemaBranch)
     if kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
         return True
 
-    node_schema = schema_branch.get(name=kind)
+    node_schema = schema_branch.get(name=kind, duplicate=False)
     if node_schema.is_generic_schema:
         return False
 

infrahub/graphql/mutations/schema.py

@@ -81,7 +81,7 @@ class SchemaDropdownAdd(Mutation):
         _validate_schema_permission(graphql_context=graphql_context)
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
-        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name, duplicate=False)
         attribute = str(data.attribute)
         validate_kind_dropdown(kind=kind, attribute=attribute)
         dropdown = str(data.dropdown)
@@ -104,7 +104,7 @@ class SchemaDropdownAdd(Mutation):
             context=graphql_context.get_context(),
         )
 
-        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name, duplicate=False)
         attrib = kind.get_attribute(attribute)
         dropdown_entry = {}
         success = False
@@ -141,7 +141,7 @@ class SchemaDropdownRemove(Mutation):
         graphql_context: GraphqlContext = info.context
 
         _validate_schema_permission(graphql_context=graphql_context)
-        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name, duplicate=False)
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         attribute = str(data.attribute)
@@ -197,7 +197,7 @@ class SchemaEnumAdd(Mutation):
         graphql_context: GraphqlContext = info.context
 
         _validate_schema_permission(graphql_context=graphql_context)
-        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name, duplicate=False)
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         attribute = str(data.attribute)
@@ -243,7 +243,7 @@ class SchemaEnumRemove(Mutation):
         graphql_context: GraphqlContext = info.context
 
         _validate_schema_permission(graphql_context=graphql_context)
-        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name, duplicate=False)
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         attribute = str(data.attribute)

infrahub/message_bus/types.py

@@ -89,7 +89,8 @@ class ProposedChangeArtifactDefinition(BaseModel):
     definition_id: str
     definition_name: str
     artifact_name: str
-    query_name: str
+    query_name: str  # Deprecated
+    query_id: str
     query_models: list[str]
     repository_id: str
     transform_kind: str