infrahub-server 1.7.1__py3-none-any.whl → 1.7.3__py3-none-any.whl

infrahub/core/query/node.py

@@ -2180,6 +2180,134 @@ WITH %(tracked_vars)s,
         return [str(result.get("n.uuid")) for result in self.get_results()]
 
 
+@dataclass(frozen=True)
+class NodeGetListByAttributeValueQueryResult:
+    """Result from NodeGetListByAttributeValueQuery."""
+
+    uuid: str
+    kind: str
+
+
+class NodeGetListByAttributeValueQuery(Query):
+    """Query to find nodes by searching attribute values.
+
+    This query is optimized for search operations by starting from the AttributeValueIndexed
+    nodes and using a TEXT index for efficient CONTAINS searches. This approach is more
+    efficient than the standard NodeGetListQuery when searching for values across all nodes.
+    """
+
+    name = "node_get_list_by_attribute_value"
+    type = QueryType.READ
+
+    def __init__(
+        self,
+        search_value: str,
+        kinds: list[str] | None = None,
+        partial_match: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        self.search_value = search_value
+        self.kinds = kinds
+        self.partial_match = partial_match
+
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.order_by = ["n.uuid"]
+        self.return_labels = ["DISTINCT n.uuid as uuid", "n.kind as kind"]
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(
+            at=self.at, branch_agnostic=self.branch_agnostic
+        )
+        self.params.update(branch_params)
+
+        # Build search values for case-insensitive matching without using toLower/toString
+        # which would disable index lookup. We search for four case variations:
+        # 1. Original (as provided), 2. lowercase, 3. UPPERCASE, 4. Title Case (first char upper, rest lower)
+        search_original = self.search_value
+        search_lower = self.search_value.lower()
+        search_upper = self.search_value.upper()
+        search_title = self.search_value.capitalize()
+
+        # Build the search predicate based on partial_match
+        # We avoid toLower/toString to allow TEXT index usage
+        if self.partial_match:
+            # Use CONTAINS with multiple case variations to leverage TEXT index
+            search_predicate = (
+                "(av.value CONTAINS $search_original OR av.value CONTAINS $search_lower "
+                "OR av.value CONTAINS $search_upper OR av.value CONTAINS $search_title)"
+            )
+        else:
+            # Exact match with case variations
+            search_predicate = (
+                "(av.value = $search_original OR av.value = $search_lower "
+                "OR av.value = $search_upper OR av.value = $search_title)"
+            )
+
+        self.params["search_original"] = search_original
+        self.params["search_lower"] = search_lower
+        self.params["search_upper"] = search_upper
+        self.params["search_title"] = search_title
+
+        # Build kind filter if specified
+        kind_filter = ""
+        if self.kinds:
+            kind_filter = "AND any(l IN labels(n) WHERE l in $kinds)"
+            self.params["kinds"] = self.kinds
+
+        # The query starts from AttributeValueIndexed nodes to leverage the TEXT index
+        # This approach is more efficient for search operations as it:
+        # 1. Starts from AttributeValueIndexed nodes (smaller set when filtered)
+        # 2. Traverses from matching values back to their owning nodes
+        # 3. Filters nodes by branch and status
+        query = """
+        // --------------------------
+        // start with all possible Node-Attribute-AttributeValue combinations
+        // --------------------------
+        MATCH (av:AttributeValueIndexed)<-[:HAS_VALUE]-(attr:Attribute)<-[:HAS_ATTRIBUTE]-(n)
+        WHERE %(search_predicate)s %(kind_filter)s
+        WITH DISTINCT n, attr, av
+        // --------------------------
+        // filter HAS_VALUE edges
+        // --------------------------
+        CALL (av, attr) {
+            MATCH (av)<-[r:HAS_VALUE]-(attr)
+            WHERE %(branch_filter)s
+            RETURN r
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        WITH n, attr
+        WHERE r.status = "active"
+        // --------------------------
+        // filter HAS_ATTRIBUTE edges
+        // --------------------------
+        CALL (n, attr) {
+            MATCH (attr)<-[r:HAS_ATTRIBUTE]-(n)
+            WHERE %(branch_filter)s
+            RETURN r
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        WITH n, attr, r
+        WHERE r.status = "active"
+        """ % {
+            "search_predicate": search_predicate,
+            "kind_filter": kind_filter,
+            "branch_filter": branch_filter,
+        }
+
+        self.add_to_query(query)
+
+    def get_data(self) -> Generator[NodeGetListByAttributeValueQueryResult, None, None]:
+        """Yield results as typed dataclass instances."""
+        for result in self.get_results():
+            yield NodeGetListByAttributeValueQueryResult(
+                uuid=result.get_as_str("uuid"),
+                kind=result.get_as_str("kind"),
+            )
+
+
 class NodeGetHierarchyQuery(Query):
     name = "node_get_hierarchy"
     type = QueryType.READ

infrahub/core/query/resource_manager.py

@@ -70,6 +70,21 @@ class NumberPoolAllocatedResult:
         )
 
 
+@dataclass(frozen=True)
+class NumberPoolFreeData:
+    value: int
+    is_free: bool
+    is_last: bool
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> NumberPoolFreeData:
+        return cls(
+            value=result.get_as_type("value", return_type=int),
+            is_free=result.get_as_type("is_free", return_type=bool),
+            is_last=result.get_as_type("is_last", return_type=bool),
+        )
+
+
 class IPAddressPoolGetIdentifiers(Query):
     name = "ipaddresspool_get_identifiers"
     type = QueryType.READ
@@ -393,7 +408,9 @@ class NumberPoolGetUsed(Query):
                 n.uuid = res.identifier AND
                 attr.name = $attribute_name AND
                 all(r in [res, hv, ha] WHERE (%(branch_filter)s))
-            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC, res.from DESC, hv.from DESC, ha.from DESC
+            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC,
+                res.from DESC, hv.from DESC, ha.from DESC,
+                res.status ASC, hv.status ASC, ha.status ASC
             RETURN (res.status = "active" AND hv.status = "active" AND ha.status = "active") AS is_active
             LIMIT 1
         }
@@ -419,6 +436,102 @@ class NumberPoolGetUsed(Query):
             yield NumberPoolIdentifierData.from_db(result)
 
 
+class NumberPoolGetFree(Query):
+    name = "number_pool_get_free"
+    type = QueryType.READ
+
+    def __init__(
+        self,
+        pool: CoreNumberPool,
+        min_value: int | None = None,
+        max_value: int | None = None,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        self.pool = pool
+        self.min_value = min_value
+        self.max_value = max_value
+
+        super().__init__(**kwargs)  # type: ignore[arg-type]
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["pool_id"] = self.pool.get_id()
+        # Use min_value/max_value if provided, otherwise use pool's start_range/end_range
+        self.params["start_range"] = self.min_value if self.min_value is not None else self.pool.start_range.value
+        self.params["end_range"] = self.max_value if self.max_value is not None else self.pool.end_range.value
+        self.limit = 1  # Query only works at returning a single, free entry
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(
+            at=self.at.to_string(), branch_agnostic=self.branch_agnostic
+        )
+
+        self.params.update(branch_params)
+        self.params["attribute_name"] = self.pool.node_attribute.value
+
+        query = """
+        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValueIndexed)
+        WHERE toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
+        CALL (pool, res, av) {
+            MATCH (pool)-[res]->(av)<-[hv:HAS_VALUE]-(attr:Attribute)<-[ha:HAS_ATTRIBUTE]-(n:%(node)s)
+            WHERE
+                n.uuid = res.identifier AND
+                attr.name = $attribute_name AND
+                all(r in [res, hv, ha] WHERE (%(branch_filter)s))
+            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC,
+                res.from DESC, hv.from DESC, ha.from DESC,
+                res.status ASC, hv.status ASC, ha.status ASC
+            RETURN (res.status = "active" AND hv.status = "active" AND ha.status = "active") AS is_active
+            LIMIT 1
+        }
+        WITH av, res, is_active
+        WHERE is_active = True
+        WITH DISTINCT toInteger(av.value) AS used_value
+        ORDER BY used_value ASC
+        WITH [$start_range - 1] + collect(used_value) AS nums
+        UNWIND range(0, size(nums) - 1) AS idx
+        CALL (nums, idx) {
+            WITH nums[idx] AS curr, idx - 1 + $start_range AS expected
+            RETURN expected AS number, expected <> curr AS is_free, idx = size(nums) - 1 AS is_last
+        }
+        WITH number, is_free, is_last
+        WHERE is_free = true OR is_last = true
+        WITH number AS free_number, is_free, is_last
+        """ % {
+            "branch_filter": branch_filter,
+            "number_pool": InfrahubKind.NUMBERPOOL,
+            "node": self.pool.node.value,
+        }
+
+        self.add_to_query(query)
+        self.return_labels = ["free_number as value", "is_free", "is_last"]
+        self.order_by = ["value"]
+
+    def get_free_data(self) -> NumberPoolFreeData | None:
+        if not self.results:
+            return None
+
+        return NumberPoolFreeData.from_db(result=self.results[0])
+
+    def get_result_value(self) -> int | None:
+        """Get the free number from query results, handling edge cases.
+
+        Returns:
+            The free number if found, None if pool is exhausted in queried range.
+        """
+        result_data = self.get_free_data()
+        if result_data is None:
+            # No reservations in range - return start_range
+            if self.params["start_range"] <= self.params["end_range"]:
+                return self.params["start_range"]
+            return None
+
+        if result_data.is_free:
+            return result_data.value
+        # is_last=True and is_free=False means all numbers up to value are used
+        if result_data.is_last and result_data.value < self.params["end_range"]:
+            return result_data.value + 1
+        return None
+
+
 class NumberPoolSetReserved(Query):
     name = "numberpool_set_reserved"
     type = QueryType.WRITE

infrahub/core/relationship/model.py

@@ -652,7 +652,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin, MetadataInterface):
             destination_id=peer.id,
             status="active",
             direction=self.schema.direction.value,
-            branch_level=self.branch.hierarchy_level,
+            branch_level=branch.hierarchy_level,
             branch_support=self.schema.branch.value if self.schema.branch else None,
             hierarchical=self.schema.hierarchical,
             is_protected=self.is_protected,

infrahub/core/schema/definitions/core/webhook.py

@@ -87,7 +87,6 @@ core_webhook = GenericSchema(
             name="validate_certificates",
             kind="Boolean",
             description="Whether to validate SSL/TLS certificates",
-            default_value=True,
             optional=True,
             order_weight=5000,
         ),

infrahub/core/schema/definitions/internal.py

@@ -182,6 +182,7 @@ class SchemaNode(BaseModel):
     display_label: str | None = None
     display_labels: list[str]
     uniqueness_constraints: list[list[str]] | None = None
+    human_friendly_id: list[str] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -199,6 +200,7 @@ class SchemaNode(BaseModel):
             "display_label": self.display_label,
             "display_labels": self.display_labels,
             "uniqueness_constraints": self.uniqueness_constraints,
+            "human_friendly_id": self.human_friendly_id,
         }
 
     def without_duplicates(self, other: SchemaNode) -> SchemaNode:
@@ -225,7 +227,6 @@ base_node_schema = SchemaNode(
     namespace="Schema",
     branch=BranchSupportType.AWARE.value,
     include_in_menu=False,
-    default_filter="name__value",
     display_labels=["label__value"],
     attributes=[
         SchemaAttribute(
@@ -239,7 +240,7 @@ base_node_schema = SchemaNode(
             name="name",
             kind="Text",
             description="Node name, must be unique within a namespace and must start with an uppercase letter.",
-            unique=True,
+            unique=False,
             regex=str(NODE_NAME_REGEX),
             min_length=DEFAULT_NAME_MIN_LENGTH,
             max_length=DEFAULT_NAME_MAX_LENGTH,
@@ -394,8 +395,9 @@ node_schema = SchemaNode(
     namespace="Schema",
     branch=BranchSupportType.AWARE.value,
     include_in_menu=False,
-    default_filter="name__value",
     display_labels=["label__value"],
+    human_friendly_id=["namespace__value", "name__value"],
+    uniqueness_constraints=[["namespace__value", "name__value"]],
     attributes=base_node_schema.attributes
     + [
         SchemaAttribute(
@@ -802,7 +804,7 @@ relationship_schema = SchemaNode(
             name="branch",
             kind="Text",
             internal_kind=BranchSupportType,
-            description="Type of branch support for the relatioinship, if not defined it will be determine based both peers.",
+            description="Type of branch support for the relationship. If not defined, it will be determined based on both peers.",
             enum=BranchSupportType.available_types(),
             optional=True,
             extra={"update": UpdateSupport.NOT_SUPPORTED},  # https://github.com/opsmill/infrahub/issues/2476
@@ -898,8 +900,9 @@ generic_schema = SchemaNode(
     namespace="Schema",
     branch=BranchSupportType.AWARE.value,
     include_in_menu=False,
-    default_filter="name__value",
     display_labels=["label__value"],
+    human_friendly_id=["namespace__value", "name__value"],
+    uniqueness_constraints=[["namespace__value", "name__value"]],
     attributes=base_node_schema.attributes
     + [
         SchemaAttribute(

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/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)