infrahub-server 1.7.0rc0__py3-none-any.whl → 1.7.2__py3-none-any.whl

infrahub/core/schema/manager.py

@@ -25,6 +25,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.utils import parse_node_kind
 from infrahub.exceptions import SchemaNotFoundError
 from infrahub.log import get_logger
@@ -36,7 +37,6 @@ log = get_logger()
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
-    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -179,18 +179,20 @@ class SchemaManager(NodeManager):
         diff: SchemaDiff | None = None,
         limit: list[str] | None = None,
         update_db: bool = True,
+        at: Timestamp | None = None,
         user_id: str = SYSTEM_USER_ID,
     ) -> None:
         branch = await registry.get_branch(branch=branch, db=db)
+        at = Timestamp(at)
 
         updated_schema = None
         if update_db:
             if diff:
                 schema_diff = await self.update_schema_to_db(
-                    schema=schema, db=db, branch=branch, diff=diff, user_id=user_id
+                    schema=schema, db=db, branch=branch, diff=diff, at=at, user_id=user_id
                 )
             else:
-                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, user_id=user_id)
+                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, at=at, user_id=user_id)
                 # After updating the schema into the db
                 # we need to pull a fresh version because some default value are managed/generated within the node object
                 schema_diff = None
@@ -201,7 +203,7 @@ class SchemaManager(NodeManager):
                     )
 
             updated_schema = await self.load_schema_from_db(
-                db=db, branch=branch, schema=schema, schema_diff=schema_diff
+                db=db, branch=branch, schema=schema, schema_diff=schema_diff, at=at
             )
 
         self.set_schema_branch(name=branch.name, schema=updated_schema or schema)
@@ -221,6 +223,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         diff: SchemaDiff,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> SchemaBranchDiff:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
@@ -231,7 +234,7 @@ class SchemaManager(NodeManager):
         added_generics = []
         for item_kind in diff.added.keys():
             item = schema.get(name=item_kind, duplicate=False)
-            node = await self.load_node_to_db(node=item, branch=branch, db=db, user_id=user_id)
+            node = await self.load_node_to_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 added_nodes.append(item_kind)
@@ -244,10 +247,10 @@ class SchemaManager(NodeManager):
             item = schema.get(name=item_kind, duplicate=False)
             if item_diff:
                 node = await self.update_node_in_db_based_on_diff(
-                    node=item, branch=branch, db=db, diff=item_diff, user_id=user_id
+                    node=item, branch=branch, db=db, diff=item_diff, at=at, user_id=user_id
                 )
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 changed_nodes.append(item_kind)
@@ -258,7 +261,7 @@ class SchemaManager(NodeManager):
         removed_generics = []
         for item_kind in diff.removed.keys():
             item = schema.get(name=item_kind, duplicate=False)
-            node = await self.delete_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
+            node = await self.delete_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.delete(name=item_kind)
             if item.is_node_schema:
                 removed_nodes.append(item_kind)
@@ -281,9 +284,10 @@ class SchemaManager(NodeManager):
         branch: Branch | str | None = None,
         limit: list[str] | None = None,
         user_id: str = SYSTEM_USER_ID,
+        at: Timestamp | None = None,
     ) -> None:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
-
+        at = Timestamp(at)
         branch = await registry.get_branch(branch=branch, db=db)
 
         for item_kind in schema.node_names + schema.generic_names_without_templates:
@@ -291,10 +295,10 @@ class SchemaManager(NodeManager):
                 continue
             item = schema.get(name=item_kind, duplicate=False)
             if not item.id:
-                node = await self.load_node_to_db(node=item, branch=branch, db=db, user_id=user_id)
+                node = await self.load_node_to_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
 
     async def load_node_to_db(
@@ -302,6 +306,7 @@ class SchemaManager(NodeManager):
         node: NodeSchema | GenericSchema,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Load a Node with its attributes and its relationships to the database."""
@@ -322,7 +327,7 @@ class SchemaManager(NodeManager):
         schema_dict = node.model_dump(exclude={"id", "state", "filters", "relationships", "attributes"})
         obj = await Node.init(schema=node_schema, branch=branch, db=db)
         await obj.new(**schema_dict, db=db)
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
         new_node.id = obj.id
 
         # Then create the Attributes and the relationships
@@ -333,7 +338,7 @@ class SchemaManager(NodeManager):
             for item in node.attributes:
                 if item.inherited is False:
                     new_attr = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
+                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db, at=at, user_id=user_id
                     )
                 else:
                     new_attr = item.duplicate()
@@ -342,7 +347,7 @@ class SchemaManager(NodeManager):
             for item in node.relationships:
                 if item.inherited is False:
                     new_rel = await self.create_relationship_in_db(
-                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
+                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db, at=at, user_id=user_id
                     )
                 else:
                     new_rel = item.duplicate()
@@ -357,6 +362,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database."""
@@ -380,11 +386,11 @@ class SchemaManager(NodeManager):
         new_node = node.duplicate()
 
         # Update the attributes and the relationships nodes as well
-        await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id])
+        await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id], at=at)
         await obj.relationships.update(
-            db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"]
+            db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"], at=at
         )
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
 
         # Then Update the Attributes and the relationships
 
@@ -397,19 +403,19 @@ class SchemaManager(NodeManager):
 
         for item in node.local_attributes:
             if item.id and item.id in items:
-                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
+                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, at=at, user_id=user_id)
             elif not item.id:
                 new_attr = await self.create_attribute_in_db(
-                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
+                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                 )
                 new_node.attributes.append(new_attr)
 
         for item in node.local_relationships:
             if item.id and item.id in items:
-                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
+                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, at=at, user_id=user_id)
             elif not item.id:
                 new_rel = await self.create_relationship_in_db(
-                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
+                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                 )
                 new_node.relationships.append(new_rel)
 
@@ -423,6 +429,7 @@ class SchemaManager(NodeManager):
         diff: HashableModelDiff,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database based on a HashableModelDiff."""
@@ -496,24 +503,24 @@ class SchemaManager(NodeManager):
             items.update({field.id: field for field in missing_attrs + missing_rels})
 
         if diff_attributes:
-            await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id])
+            await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id], at=at)
 
         if diff_relationships:
-            await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id])
+            await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id], at=at)
 
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
 
         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):
                     created_item = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
+                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                     )
                     new_attr = new_node.get_attribute(name=item.name)
                     new_attr.id = created_item.id
                 elif item.name in diff_attributes.changed and item.id and item.id in items:
-                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
+                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, at=at, user_id=user_id)
                 elif item.name in diff_attributes.removed and item.id and item.id in items:
                     await items[item.id].delete(db=db, user_id=user_id)
                 elif (
@@ -530,12 +537,12 @@ class SchemaManager(NodeManager):
                     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, user_id=user_id
+                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                     )
                     new_rel = new_node.get_relationship(name=item.name)
                     new_rel.id = created_rel.id
                 elif item.name in diff_relationships.changed and item.id and item.id in items:
-                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
+                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, at=at, user_id=user_id)
                 elif item.name in diff_relationships.removed and item.id and item.id in items:
                     await items[item.id].delete(db=db, user_id=user_id)
                 elif (
@@ -555,7 +562,7 @@ class SchemaManager(NodeManager):
         if field_names_to_remove:
             for field_schema in items.values():
                 if field_schema.name.value in field_names_to_remove:
-                    await field_schema.delete(db=db, user_id=user_id)
+                    await field_schema.delete(db=db, at=at, user_id=user_id)
 
         # Save back the node with the (potentially) newly created IDs in the SchemaManager
         self.set(name=new_node.kind, schema=new_node, branch=branch.name)
@@ -566,6 +573,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> None:
         """Delete the node with its attributes and relationships."""
@@ -581,11 +589,11 @@ class SchemaManager(NodeManager):
 
         # First delete the attributes and the relationships
         for attr_schema_node in (await obj.attributes.get_peers(db=db)).values():
-            await attr_schema_node.delete(db=db, user_id=user_id)
+            await attr_schema_node.delete(db=db, at=at, user_id=user_id)
         for rel_schema_node in (await obj.relationships.get_peers(db=db)).values():
-            await rel_schema_node.delete(db=db, user_id=user_id)
+            await rel_schema_node.delete(db=db, at=at, user_id=user_id)
 
-        await obj.delete(db=db, user_id=user_id)
+        await obj.delete(db=db, at=at, user_id=user_id)
 
     @staticmethod
     async def create_attribute_in_db(
@@ -595,20 +603,23 @@ class SchemaManager(NodeManager):
         parent: Node,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
     ) -> AttributeSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.to_node(), node=parent, db=db)
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
-    async def update_attribute_in_db(item: AttributeSchema, attr: Node, db: InfrahubDatabase, user_id: str) -> None:
+    async def update_attribute_in_db(
+        item: AttributeSchema, attr: Node, db: InfrahubDatabase, at: Timestamp, user_id: str
+    ) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(attr, key).value = value
-        await attr.save(db=db, user_id=user_id)
+        await attr.save(db=db, at=at, user_id=user_id)
 
     @staticmethod
     async def create_relationship_in_db(
@@ -618,22 +629,23 @@ class SchemaManager(NodeManager):
         parent: Node,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
     ) -> RelationshipSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.model_dump(exclude={"id", "state", "filters"}), node=parent, db=db)
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
     async def update_relationship_in_db(
-        item: RelationshipSchema, rel: Node, db: InfrahubDatabase, user_id: str
+        item: RelationshipSchema, rel: Node, db: InfrahubDatabase, at: Timestamp, user_id: str
     ) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(rel, key).value = value
-        await rel.save(db=db, user_id=user_id)
+        await rel.save(db=db, at=at, user_id=user_id)
 
     async def load_schema(
         self,

infrahub/core/validators/attribute/kind.py

@@ -36,7 +36,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params["null_value"] = NULL_VALUE
 
         query = """
-        MATCH p = (n:%(node_kind)s)
+        MATCH (n:%(node_kinds)s)
         CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
@@ -51,7 +51,10 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value
-        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+        """ % {
+            "branch_filter": branch_filter,
+            "node_kinds": f"{self.node_schema.kind}|Profile{self.node_schema.kind}|Template{self.node_schema.kind}",
+        }
 
         self.add_to_query(query)
         self.return_labels = ["node.uuid", "attribute_value", "value_relationship.branch as value_branch"]

infrahub/core/validators/determiner.py

@@ -85,6 +85,10 @@ class ConstraintValidatorDeterminer:
         constraints: list[SchemaUpdateConstraintInfo] = []
         schemas = list(self.schema_branch.get_all(duplicate=False).values())
         # added here to check their uniqueness constraints
+        with contextlib.suppress(SchemaNotFoundError):
+            schemas.append(self.schema_branch.get_node(name="SchemaNode", duplicate=False))
+        with contextlib.suppress(SchemaNotFoundError):
+            schemas.append(self.schema_branch.get_node(name="SchemaGeneric", duplicate=False))
         with contextlib.suppress(SchemaNotFoundError):
             schemas.append(self.schema_branch.get_node(name="SchemaAttribute", duplicate=False))
         with contextlib.suppress(SchemaNotFoundError):

infrahub/graphql/analyzer.py

@@ -8,6 +8,7 @@ from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
 from graphql import (
+    DocumentNode,
     FieldNode,
     FragmentDefinitionNode,
     FragmentSpreadNode,
@@ -389,6 +390,7 @@ class InfrahubGraphQLQueryAnalyzer(GraphQLQueryAnalyzer):
         schema: GraphQLSchema | None = None,
         query_variables: dict[str, Any] | None = None,
         operation_name: str | None = None,
+        document: DocumentNode | None = None,
     ) -> None:
         self.branch = branch
         self.schema_branch = schema_branch
@@ -396,7 +398,7 @@ class InfrahubGraphQLQueryAnalyzer(GraphQLQueryAnalyzer):
         self.query_variables: dict[str, Any] = query_variables or {}
         self._named_fragments: dict[str, GraphQLQueryNode] = {}
         self._fragment_dependencies: dict[str, set[str]] = {}
-        super().__init__(query=query, schema=schema)
+        super().__init__(query=query, schema=schema, document=document)
 
     @property
     def operation_names(self) -> list[str]:

infrahub/graphql/app.py

@@ -22,10 +22,7 @@ from graphql import (
     ExecutionContext,
     ExecutionResult,
     GraphQLError,
-    GraphQLFormattedError,
     OperationType,
-    graphql,
-    parse,
     subscribe,
     validate,
 )
@@ -45,6 +42,7 @@ from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import BranchNotFoundError, Error
 from infrahub.graphql.analyzer import InfrahubGraphQLQueryAnalyzer
+from infrahub.graphql.execution import cached_parse, execute_graphql_query
 from infrahub.graphql.initialization import GraphqlParams, prepare_graphql_params
 from infrahub.log import get_logger
 
@@ -62,7 +60,7 @@ from .middleware import raise_on_mutation_on_branch_needing_rebase
 
 if TYPE_CHECKING:
     import graphene
-    from graphql import GraphQLSchema
+    from graphql import GraphQLFormattedError, GraphQLSchema
     from graphql.language.ast import (
         DocumentNode,
         OperationDefinitionNode,
@@ -213,6 +211,7 @@ class InfrahubGraphQLApp:
             schema=graphql_params.schema,
             operation_name=operation_name,
             branch=branch,
+            document=cached_parse(query),
         )
 
         # if the query contains some mutation, it's not currently supported to set AT manually
@@ -228,6 +227,7 @@ class InfrahubGraphQLApp:
                 schema=graphql_params.schema,
                 operation_name=operation_name,
                 branch=branch,
+                document=cached_parse(query),
             )
         impacted_models = analyzed_query.query_report.impacted_models
 
@@ -252,7 +252,7 @@ class InfrahubGraphQLApp:
             span.set_attributes(labels)
 
             with GRAPHQL_DURATION_METRICS.labels(**labels).time():
-                result = await graphql(
+                result = await execute_graphql_query(
                     schema=graphql_params.schema,
                     source=query,
                     context_value=graphql_params.context,
@@ -265,6 +265,7 @@ class InfrahubGraphQLApp:
 
         response: dict[str, Any] = {"data": result.data}
         if result.errors:
+            GRAPHQL_QUERY_ERRORS_METRICS.labels(**labels).observe(len(result.errors))
             for error in result.errors:
                 if error.original_error:
                     self._log_error(error=error.original_error)
@@ -283,10 +284,6 @@ class InfrahubGraphQLApp:
         GRAPHQL_TOP_LEVEL_QUERIES_METRICS.labels(**labels).observe(analyzed_query.nbr_queries)
         GRAPHQL_QUERY_OBJECTS_METRICS.labels(**labels).observe(len(impacted_models))
 
-        _, errors = analyzed_query.is_valid
-        if errors:
-            GRAPHQL_QUERY_ERRORS_METRICS.labels(**labels).observe(len(errors))
-
         return json_response
 
     def _set_labels(self, request: Request, branch: Branch, query: InfrahubGraphQLQueryAnalyzer) -> dict[str, Any]:  # noqa: ARG002
@@ -391,7 +388,7 @@ class InfrahubGraphQLApp:
         document: DocumentNode | None = None
 
         try:
-            document = parse(query)
+            document = cached_parse(query)
             operation = get_operation_ast(document, operation_name)
             errors = validate(graphql_params.schema, document)
         except GraphQLError as e:

infrahub/graphql/execution.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from inspect import isawaitable
+from typing import TYPE_CHECKING, Any, Callable
+
+from graphql import GraphQLSchema, execute, parse, validate
+from graphql.error import GraphQLError
+from graphql.execution import ExecutionResult
+from graphql.type import validate_schema
+
+if TYPE_CHECKING:
+    from graphql import ExecutionContext, GraphQLFieldResolver, GraphQLTypeResolver
+    from graphql.execution import Middleware
+    from graphql.language import Source
+    from graphql.language.ast import DocumentNode
+
+
+@lru_cache(maxsize=1024)
+def _cached_parse(query: str) -> DocumentNode:
+    """Internal cached parse function for queries without @expand directive."""
+    return parse(query)
+
+
+def cached_parse(query: str | Source) -> DocumentNode:
+    """Parse a GraphQL query string into a DocumentNode.
+
+    Queries containing the @expand directive are not cached because the parser
+    mutates the AST to add expanded fields, which would corrupt the cache.
+    """
+    query_str = query if isinstance(query, str) else query.body
+    if "@expand" in query_str:
+        return parse(query)
+    return _cached_parse(query_str)
+
+
+@lru_cache(maxsize=1024)
+def cached_validate(schema: GraphQLSchema, document_ast: DocumentNode) -> list[GraphQLError]:
+    return validate(schema, document_ast)
+
+
+@lru_cache(maxsize=1024)
+def cached_validate_schema(schema: GraphQLSchema) -> list[GraphQLError]:
+    return validate_schema(schema)
+
+
+async def execute_graphql_query(
+    schema: GraphQLSchema,
+    source: str | Source,
+    root_value: Any = None,
+    context_value: Any = None,
+    variable_values: dict[str, Any] | None = None,
+    operation_name: str | None = None,
+    field_resolver: GraphQLFieldResolver | None = None,
+    type_resolver: GraphQLTypeResolver | None = None,
+    middleware: Middleware | None = None,
+    execution_context_class: type[ExecutionContext] | None = None,
+    is_awaitable: Callable[[Any], bool] | None = None,
+) -> ExecutionResult:
+    """Execute a query, return asynchronously only if necessary."""
+    # Validate Schema
+    schema_validation_errors = cached_validate_schema(schema)
+    if schema_validation_errors:
+        return ExecutionResult(data=None, errors=schema_validation_errors)
+
+    # Parse
+    try:
+        document = cached_parse(source)
+    except GraphQLError as error:
+        return ExecutionResult(data=None, errors=[error])
+
+    validation_errors = cached_validate(schema, document)
+    if validation_errors:
+        return ExecutionResult(data=None, errors=validation_errors)
+
+    # Execute
+    result = execute(
+        schema,
+        document,
+        root_value,
+        context_value,
+        variable_values,
+        operation_name,
+        field_resolver,
+        type_resolver,
+        None,
+        middleware,
+        execution_context_class,
+        is_awaitable,
+    )
+
+    if isawaitable(result):
+        return await result
+
+    return result

infrahub/graphql/manager.py

@@ -598,7 +598,10 @@ class GraphQLSchemaManager:
                 required=False,
                 description="Human friendly identifier",
             ),
-            "_updated_at": graphene.DateTime(required=False),
+            "_updated_at": graphene.DateTime(
+                required=False,
+                deprecation_reason="Query the node_metadata field instead. Will be removed in Infrahub 1.9",
+            ),
             "display_label": graphene.String(required=False),
             "Meta": type("Meta", (object,), meta_attrs),
         }
@@ -1209,7 +1212,10 @@ class GraphQLSchemaManager:
 
         main_attrs: dict[str, Any] = {
             "node": graphene.Field(base_interface, required=False),
-            "_updated_at": graphene.DateTime(required=False),
+            "_updated_at": graphene.DateTime(
+                required=False,
+                deprecation_reason="Query the node_metadata field instead. Will be removed in Infrahub 1.9",
+            ),
             "node_metadata": graphene.Field(node_metadata, required=True),
             "Meta": type("Meta", (object,), meta_attrs),
         }

infrahub/graphql/mutations/proposed_change.py

@@ -84,7 +84,22 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
         if state and state != ProposedChangeState.OPEN.value:
             raise ValidationError(input_value="A proposed change has to be in the open state during creation")
 
+        source_branch_name = data.get("source_branch", {}).get("value")
+
         async with graphql_context.db.start_transaction() as dbt:
+            existing_open_pcs = await NodeManager.query(
+                db=dbt,
+                schema=InfrahubKind.PROPOSEDCHANGE,
+                filters={
+                    "source_branch__value": source_branch_name,
+                    "state__value": ProposedChangeState.OPEN.value,
+                },
+            )
+            if existing_open_pcs:
+                raise ValidationError(
+                    input_value=f"An open proposed change already exists for branch '{source_branch_name}'"
+                )
+
             proposed_change, result = await super().mutate_create(
                 info=info, data=data, branch=branch, database=dbt, override_data=override_data
             )

infrahub/graphql/parser.py

@@ -99,12 +99,9 @@ class GraphQLExtractor:
                         key=attribute.name,
                         node=FieldNode(
                             kind="field",
-                            name=NameNode(
-                                kind="name",
-                                value=key,
-                                directives=[],
-                                arguments=[],
-                            ),
+                            name=NameNode(kind="name", value=key),
+                            directives=[],
+                            arguments=[],
                         ),
                         path=attribute_path,
                         fields={key: None},
@@ -117,7 +114,9 @@ class GraphQLExtractor:
                     FieldNode(
                         kind="field",
                         name=NameNode(kind="name", value=attribute.name),
-                        selection_set=SelectionSetNode(selections=tuple(enrichers)),
+                        selection_set=SelectionSetNode(selections=tuple(e.node for e in enrichers)),
+                        directives=[],
+                        arguments=[],
                     )
                 )
 
@@ -130,6 +129,8 @@ class GraphQLExtractor:
                         kind="field",
                         name=NameNode(kind="name", value="node"),
                         selection_set=SelectionSetNode(selections=tuple(attribute_enrichers)),
+                        directives=[],
+                        arguments=[],
                     ),
                     fields={attribute.name: field_attributes for attribute in self.schema.attributes},
                 )
@@ -166,6 +167,8 @@ class GraphQLExtractor:
                             kind="field",
                             name=NameNode(kind="name", value=sub_node.key),
                             selection_set=SelectionSetNode(selections=(sub_node.node,)),
+                            directives=[],
+                            arguments=[],
                         )
                     )
                     selection_set.selections = tuple(selections)