infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

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/graphql/mutations/webhook.py

@@ -127,7 +127,7 @@ class InfrahubWebhookMutation(InfrahubMutationMixin, Mutation):
 
 
 def _validate_input(graphql_context: GraphqlContext, branch: Branch, input_data: WebhookCreate) -> None:
-    if input_data.node_kind:
+    if input_data.node_kind and input_data.node_kind.value:
         # Validate that the requested node_kind exists, will raise an error if not
         graphql_context.db.schema.get(name=input_data.node_kind.value, branch=branch, duplicate=False)
 

infrahub/graphql/queries/resource_manager.py

@@ -242,7 +242,7 @@ class PoolUtilization(ObjectType):
                     if "kind" in node_fields:
                         node_response["kind"] = resource_node.get_kind()
                     if "display_label" in node_fields:
-                        node_response["display_label"] = await resource_node.render_display_label(db=db)
+                        node_response["display_label"] = await resource_node.get_display_label(db=db)
                     if "weight" in node_fields:
                         node_response["weight"] = await resource_node.get_resource_weight(db=db)  # type: ignore[attr-defined]
                     if "utilization" in node_fields:

infrahub/graphql/registry.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from infrahub.core.timestamp import Timestamp
+from infrahub.exceptions import InitializationError
+
+if TYPE_CHECKING:
+    import graphene
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.schema.schema_branch import SchemaBranch
+    from infrahub.graphql.manager import GraphQLSchemaManager, InterfaceReference
+
+    from .mutations.main import InfrahubMutation
+    from .types import InfrahubObject
+
+
+@dataclass
+class BranchDetails:
+    schema_changed_at: Timestamp
+    schema_hash: str
+    gql_manager: GraphQLSchemaManager
+
+
+@dataclass
+class GraphQLSchemaRegistry:
+    _branch_details_by_hash: dict[str, BranchDetails] = field(default_factory=dict)
+    _branch_name_by_hash: dict[str, set[str]] = field(default_factory=dict)
+    _branch_hash_activation_by_branch_name: dict[str, dict[str, str]] = field(default_factory=dict)
+    _registered_interface_types: dict[str, type[graphene.Interface]] = field(default_factory=dict)
+    _reference_hash_schema_map: dict[str, set[str]] = field(default_factory=dict)
+    _registered_edge_types: dict[str, type[InfrahubObject]] = field(default_factory=dict)
+    _registered_paginated_types: dict[str, type[InfrahubObject]] = field(default_factory=dict)
+    _registered_input_types: dict[str, type[graphene.InputObjectType]] = field(default_factory=dict)
+    _registered_object_types: dict[str, type[InfrahubObject]] = field(default_factory=dict)
+    _registered_mutation_types: dict[str, type[InfrahubMutation]] = field(default_factory=dict)
+
+    _manager_class: type[GraphQLSchemaManager] | None = None
+
+    def _add_branch_hash(self, branch_name: str, schema_hash: str) -> None:
+        if schema_hash not in self._branch_name_by_hash:
+            self._branch_name_by_hash[schema_hash] = set()
+
+        self._branch_name_by_hash[schema_hash].add(branch_name)
+
+    def _register_manager(self, manager: type[GraphQLSchemaManager]) -> None:
+        self._manager_class = manager
+
+    @property
+    def manager(self) -> type[GraphQLSchemaManager]:
+        if self._manager_class:
+            return self._manager_class
+        raise InitializationError
+
+    def clear_cache(self) -> None:
+        """Clear internal cache stored within this registry."""
+        self._branch_details_by_hash = {}
+        self._branch_name_by_hash = {}
+        self._branch_hash_activation_by_branch_name = {}
+        self._registered_interface_types = {}
+        self._reference_hash_schema_map = {}
+        self._registered_edge_types = {}
+        self._registered_paginated_types = {}
+        self._registered_input_types = {}
+        self._registered_object_types = {}
+        self._registered_mutation_types = {}
+
+    def _add_schema_to_reference_hash(self, reference_hash: str, schema_hash: str) -> None:
+        """Add the schema hash to a map containing the referenced object.
+
+        The goal of this is to be able to see all schemas that use a given reference type,
+        once no schemas use a specific type it's safe to remove the type from the registry.
+        """
+        if reference_hash not in self._reference_hash_schema_map:
+            self._reference_hash_schema_map[reference_hash] = set()
+        self._reference_hash_schema_map[reference_hash].add(schema_hash)
+
+    def get_edge_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubObject] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_edge_types.get(reference_hash)
+
+    def set_edge_type(self, reference: type[InfrahubObject], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_edge_types[reference_hash] = reference
+
+    def get_input_type(self, reference_hash: str, schema_hash: str) -> type[graphene.InputObjectType] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_input_types.get(reference_hash)
+
+    def set_input_type(self, reference: type[graphene.InputObjectType], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_input_types[reference_hash] = reference
+
+    def get_interface_type(self, reference_hash: str, schema_hash: str) -> type[graphene.Interface] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_interface_types.get(reference_hash)
+
+    def set_interface_type(self, reference: InterfaceReference, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference.reference_hash, schema_hash=schema_hash)
+        self._registered_interface_types[reference.reference_hash] = reference.reference
+
+    def get_mutation_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubMutation] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_mutation_types.get(reference_hash)
+
+    def set_mutation_type(self, reference: type[InfrahubMutation], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_mutation_types[reference_hash] = reference
+
+    def get_object_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubObject] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_object_types.get(reference_hash)
+
+    def set_object_type(self, reference: type[InfrahubObject], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_object_types[reference_hash] = reference
+
+    def get_paginated_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubObject] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_paginated_types.get(reference_hash)
+
+    def set_paginated_type(self, reference: type[InfrahubObject], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_paginated_types[reference_hash] = reference
+
+    def purge_inactive(self, active_branches: list[str]) -> set[str]:
+        """Return inactive branches that were purged"""
+        inactive_branches: set[str] = set()
+        for schema_hash in list(self._branch_name_by_hash.keys()):
+            branches = list(self._branch_name_by_hash[schema_hash])
+            for branch in branches:
+                if branch not in active_branches and branch in self._branch_name_by_hash[schema_hash]:
+                    inactive_branches.add(branch)
+                    self._branch_name_by_hash[schema_hash].discard(branch)
+
+        for schema_hash in list(self._branch_name_by_hash.keys()):
+            if not self._branch_name_by_hash[schema_hash]:
+                # If no remaining branch is using the schema remove it completely
+                del self._branch_name_by_hash[schema_hash]
+                del self._branch_details_by_hash[schema_hash]
+
+        return inactive_branches
+
+    def cache_branch(self, branch: Branch, schema_branch: SchemaBranch, schema_hash: str) -> BranchDetails:
+        branch_details = BranchDetails(
+            schema_changed_at=Timestamp(branch.schema_changed_at) if branch.schema_changed_at else Timestamp(),
+            schema_hash=schema_hash,
+            gql_manager=self.manager(schema=schema_branch),
+        )
+
+        self._branch_details_by_hash[schema_hash] = branch_details
+
+        return branch_details
+
+    def get_manager_for_branch(self, branch: Branch, schema_branch: SchemaBranch) -> GraphQLSchemaManager:
+        if branch.schema_hash:
+            schema_hash = branch.schema_hash.main
+        else:
+            schema_hash = schema_branch.get_hash()
+
+        if schema_hash in self._branch_details_by_hash:
+            branch_details = self._branch_details_by_hash[schema_hash]
+        else:
+            branch_details = self.cache_branch(branch=branch, schema_branch=schema_branch, schema_hash=schema_hash)
+
+        self._add_branch_hash(branch_name=branch.name, schema_hash=schema_hash)
+
+        return branch_details.gql_manager
+
+
+registry = GraphQLSchemaRegistry()

infrahub/graphql/resolvers/resolver.py

@@ -166,6 +166,8 @@ async def default_paginated_list_resolver(
 
         edges = fields.get("edges", {})
         node_fields = edges.get("node", {})
+        if "hfid" in node_fields:
+            node_fields["human_friendly_id"] = None
 
         permission_set: dict[str, Any] | None = None
         permissions = (

infrahub/graphql/schema.py

@@ -15,11 +15,14 @@ from .mutations.branch import (
     BranchUpdate,
     BranchValidate,
 )
-from .mutations.computed_attribute import UpdateComputedAttribute
+from .mutations.computed_attribute import RecomputeComputedAttribute, UpdateComputedAttribute
 from .mutations.convert_object_type import ConvertObjectType
 from .mutations.diff import DiffUpdateMutation
 from .mutations.diff_conflict import ResolveDiffConflict
+from .mutations.display_label import UpdateDisplayLabel
 from .mutations.generator import GeneratorDefinitionRequestRun
+from .mutations.hfid import UpdateHFID
+from .mutations.profile import InfrahubProfilesRefresh
 from .mutations.proposed_change import (
     ProposedChangeCheckForApprovalRevoke,
     ProposedChangeMerge,
@@ -113,6 +116,9 @@ class InfrahubBaseMutation(ObjectType):
     InfrahubRepositoryProcess = ProcessRepository.Field()
     InfrahubRepositoryConnectivity = ValidateRepositoryConnectivity.Field()
     InfrahubUpdateComputedAttribute = UpdateComputedAttribute.Field()
+    InfrahubUpdateDisplayLabel = UpdateDisplayLabel.Field()
+    InfrahubUpdateHFID = UpdateHFID.Field()
+    InfrahubRecomputeComputedAttribute = RecomputeComputedAttribute.Field()
 
     RelationshipAdd = RelationshipAdd.Field()
     RelationshipRemove = RelationshipRemove.Field()
@@ -124,3 +130,4 @@ class InfrahubBaseMutation(ObjectType):
 
     ConvertObjectType = ConvertObjectType.Field()
     CoreProposedChangeCheckForApprovalRevoke = ProposedChangeCheckForApprovalRevoke.Field()
+    InfrahubProfilesRefresh = InfrahubProfilesRefresh.Field()

infrahub/groups/tasks.py

@@ -20,7 +20,7 @@ async def update_graphql_query_group(model: RequestGraphQLQueryGroupUpdate) -> N
     if len(model.subscribers) == 1:
         related_nodes.append(model.subscribers[0])
 
-    await add_tags(branches=[model.branch], nodes=related_nodes)
+    await add_tags(branches=[model.branch], nodes=related_nodes, namespace=False)
 
     params_hash = dict_hash(model.params)
     group_name = f"{model.query_name}__{params_hash}"

infrahub/hfid/gather.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from prefect import task
+from prefect.cache_policies import NONE
+from prefect.logging import get_run_logger
+
+from infrahub.core.registry import registry
+from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+
+from .models import HFIDTriggerDefinition
+
+
+@dataclass
+class BranchScope:
+    name: str
+    out_of_scope: list[str] = field(default_factory=list)
+
+
+@task(
+    name="gather-trigger-hfid",
+    cache_policy=NONE,
+)
+async def gather_trigger_hfid(
+    db: InfrahubDatabase | None = None,  # noqa: ARG001 Needed to have a common function signature for gathering functions
+) -> list[HFIDTriggerDefinition]:
+    log = get_run_logger()
+
+    # Build a list of all branches to process based on which branch is different from main
+    branches_with_diff_from_main = registry.get_altered_schema_branches()
+    branches_to_process: list[BranchScope] = [BranchScope(name=branch) for branch in branches_with_diff_from_main]
+    branches_to_process.append(BranchScope(name=registry.default_branch, out_of_scope=branches_with_diff_from_main))
+
+    triggers: list[HFIDTriggerDefinition] = []
+
+    for branch in branches_to_process:
+        schema_branch = registry.schema.get_schema_branch(name=branch.name)
+        branch_triggers = HFIDTriggerDefinition.from_schema_hfids(
+            branch=branch.name,
+            hfids=schema_branch.hfids,
+            branches_out_of_scope=branch.out_of_scope,
+        )
+        log.info(f"Generating {len(branch_triggers)} HFID trigger for {branch.name} (except {branch.out_of_scope})")
+
+        triggers.extend(branch_triggers)
+
+    return triggers

infrahub/hfid/models.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Self
+
+from infrahub_sdk.graphql import Query
+from pydantic import BaseModel, Field
+
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.registry import registry
+from infrahub.core.schema import NodeSchema  # noqa: TC001
+from infrahub.events import NodeUpdatedEvent
+from infrahub.trigger.constants import NAME_SEPARATOR
+from infrahub.trigger.models import (
+    EventTrigger,
+    ExecuteWorkflow,
+    TriggerBranchDefinition,
+    TriggerType,
+)
+from infrahub.workflows.catalogue import HFID_PROCESS
+
+if TYPE_CHECKING:
+    from infrahub.core.schema.schema_branch_hfid import HFIDs, RelationshipTriggers
+
+
+@dataclass
+class AttributeTarget:
+    hash: str
+    fields: set[str]
+
+
+class HFIDTriggerDefinition(TriggerBranchDefinition):
+    type: TriggerType = TriggerType.HUMAN_FRIENDLY_ID
+    hfid_hash: str
+    target_kind: str | None = Field(default=None)
+
+    def get_description(self) -> str:
+        return f"{super().get_description()} | hash:{self.hfid_hash}"
+
+    @classmethod
+    def from_schema_hfids(
+        cls,
+        branch: str,
+        hfids: HFIDs,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> list[HFIDTriggerDefinition]:
+        """
+        This function is used to create a trigger definition for a display labels of type Jinja2.
+        """
+
+        definitions: list[HFIDTriggerDefinition] = []
+
+        for node_kind, hfid_definition in hfids.get_template_nodes().items():
+            definitions.append(
+                cls.new(
+                    branch=branch,
+                    node_kind=node_kind,
+                    target_kind=node_kind,
+                    fields=[
+                        "_trigger_placeholder"
+                    ],  # Triggers for the nodes themselves are only used to determine if all nodes should be regenerated
+                    hfid_hash=hfid_definition.get_hash(),
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        for related_kind, relationship_trigger in hfids.get_related_trigger_nodes().items():
+            definitions.extend(
+                cls.from_related_node(
+                    branch=branch,
+                    related_kind=related_kind,
+                    relationship_trigger=relationship_trigger,
+                    hfids=hfids,
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        return definitions
+
+    @classmethod
+    def from_related_node(
+        cls,
+        branch: str,
+        related_kind: str,
+        relationship_trigger: RelationshipTriggers,
+        hfids: HFIDs,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> list[HFIDTriggerDefinition]:
+        targets_by_attribute: dict[str, AttributeTarget] = {}
+        definitions: list[HFIDTriggerDefinition] = []
+        for attribute, relationship_identifiers in relationship_trigger.attributes.items():
+            for relationship_identifier in relationship_identifiers:
+                actual_node = hfids.get_node_definition(kind=relationship_identifier.kind)
+                if relationship_identifier.kind not in targets_by_attribute:
+                    targets_by_attribute[relationship_identifier.kind] = AttributeTarget(
+                        actual_node.get_hash(), fields=set()
+                    )
+                targets_by_attribute[relationship_identifier.kind].fields.add(attribute)
+
+        for target_kind, attribute_target in targets_by_attribute.items():
+            definitions.append(
+                cls.new(
+                    branch=branch,
+                    node_kind=related_kind,
+                    target_kind=target_kind,
+                    fields=sorted(attribute_target.fields),
+                    hfid_hash=attribute_target.hash,
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        return definitions
+
+    @classmethod
+    def new(
+        cls,
+        branch: str,
+        node_kind: str,
+        target_kind: str,
+        hfid_hash: str,
+        fields: list[str],
+        branches_out_of_scope: list[str] | None = None,
+    ) -> Self:
+        event_trigger = EventTrigger()
+        event_trigger.events.add(NodeUpdatedEvent.event_name)
+        event_trigger.match = {"infrahub.node.kind": node_kind}
+        if branches_out_of_scope:
+            event_trigger.match["infrahub.branch.name"] = [f"!{branch}" for branch in branches_out_of_scope]
+        elif not branches_out_of_scope and branch != registry.default_branch:
+            event_trigger.match["infrahub.branch.name"] = branch
+
+        event_trigger.match_related = {
+            "prefect.resource.role": ["infrahub.node.attribute_update", "infrahub.node.relationship_update"],
+            "infrahub.field.name": fields,
+        }
+
+        workflow = ExecuteWorkflow(
+            workflow=HFID_PROCESS,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "node_kind": node_kind,
+                "object_id": "{{ event.resource['infrahub.node.id'] }}",
+                "target_kind": target_kind,
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {
+                        "__prefect_kind": "jinja",
+                        "template": "{{ event.payload['context'] | tojson }}",
+                    },
+                },
+            },
+        )
+
+        trigger_definition_target_kind = target_kind if target_kind == node_kind else None
+
+        return cls(
+            name=f"{target_kind}{NAME_SEPARATOR}by{NAME_SEPARATOR}{node_kind}",
+            hfid_hash=hfid_hash,
+            branch=branch,
+            trigger=event_trigger,
+            actions=[workflow],
+            target_kind=trigger_definition_target_kind,
+        )
+
+
+class HFIDGraphQLResponse(BaseModel):
+    node_id: str
+    hfid_value: list[str] | None = Field(default=None)
+    variables: dict[str, str] = Field(default_factory=dict)
+
+
+class HFIDGraphQL(BaseModel):
+    filter_key: str
+    node_schema: NodeSchema = Field(..., description="The node kind where the computed attribute is defined")
+    variables: list[str] = Field(..., description="The list of variable names used within the computed attribute")
+
+    def render_graphql_query(self, filter_id: str) -> str:
+        query_fields = self.query_fields
+        query_fields["id"] = None
+        query_fields["hfid"] = None
+        query = Query(
+            name="HFIDFilter",
+            query={
+                self.node_schema.kind: {
+                    "@filters": {self.filter_key: filter_id},
+                    "edges": {"node": query_fields},
+                }
+            },
+        )
+
+        return query.render()
+
+    @property
+    def query_fields(self) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            if field_name in self.node_schema.attribute_names:
+                output[field_name] = {remainder: None}
+            elif field_name in self.node_schema.relationship_names:
+                related_attribute, related_value = remainder.split("__", maxsplit=1)
+                relationship = self.node_schema.get_relationship(name=field_name)
+                if relationship.cardinality == RelationshipCardinality.ONE:
+                    if field_name not in output:
+                        output[field_name] = {"node": {}}
+                    output[field_name]["node"][related_attribute] = {related_value: None}
+        return output
+
+    def parse_response(self, response: dict[str, Any]) -> list[HFIDGraphQLResponse]:
+        rendered_response: list[HFIDGraphQLResponse] = []
+        if kind_payload := response.get(self.node_schema.kind):
+            edges = kind_payload.get("edges", [])
+            for node in edges:
+                if node_response := self.to_node_response(node_dict=node):
+                    rendered_response.append(node_response)
+        return rendered_response
+
+    def to_node_response(self, node_dict: dict[str, Any]) -> HFIDGraphQLResponse | None:
+        if node := node_dict.get("node"):
+            node_id = node.get("id")
+        else:
+            return None
+
+        hfid = node.get("hfid")
+        response = HFIDGraphQLResponse(node_id=node_id, hfid_value=hfid)
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            # response.variables[variable] = None
+            if field_content := node.get(field_name):
+                if field_name in self.node_schema.attribute_names:
+                    response.variables[variable] = str(field_content.get(remainder, ""))
+                elif field_name in self.node_schema.relationship_names:
+                    relationship = self.node_schema.get_relationship(name=field_name)
+                    if relationship.cardinality == RelationshipCardinality.ONE:
+                        related_attribute, related_value = remainder.split("__", maxsplit=1)
+                        node_content = field_content.get("node") or {}
+                        related_attribute_content = node_content.get(related_attribute) or {}
+                        response.variables[variable] = str(related_attribute_content.get(related_value, ""))
+
+        return response