Expose corresponding node in measure in GQL

For debugging purposes, explicitly return the node that
the placeholder values are calculated from if requested
as measure.corresponding_node

frameworks/models.py

@@ -45,6 +45,7 @@
 
     from nodes.instance import Instance
     from nodes.models import InstanceConfig
+    from nodes.node import Node
     from users.models import User
 
     from .object_cache import (
@@ -809,6 +810,8 @@ class Measure(CacheablePathsModel['FrameworkConfigCacheData'], models.Model):
 
     framework_config_id: int
 
+    _node: tuple[Node | None, NodeDimensionSelection | None]
+
     class Meta:
         constraints = [
             models.UniqueConstraint(fields=['framework_config', 'measure_template'], name='unique_instance_measure'),

frameworks/schema.py

@@ -26,6 +26,7 @@
 from nodes.constants import YEAR_COLUMN
 from nodes.exceptions import NodeComputationError
 from nodes.models import InstanceConfig
+from nodes.schema import NodeInterface
 
 from .models import (
     Framework,
@@ -44,7 +45,9 @@
 
     from paths.types import PathsGQLInfo as GQLInfo
 
-    from nodes.instance import Instance
+    from frameworks.models import NodeDimensionSelection
+    from nodes.instance import Context, Instance
+    from nodes.node import Node
     from nodes.units import Unit
 
 
@@ -189,6 +192,7 @@ class PlaceHolderDataPoint(graphene.ObjectType):
 class MeasureType(DjangoNode):
     measure_template = graphene.Field(MeasureTemplateType, required=True)
     placeholder_data_points = graphene.List(PlaceHolderDataPoint)
+    corresponding_node = graphene.Field(NodeInterface, required=False)
 
     class Meta:
         model = Measure
@@ -205,20 +209,42 @@ def resolve_data_points(root: Measure, info: GQLInfo) -> list[MeasureDataPoint]:
         return root.cache.measure_datapoints.by_measure(root.pk)
 
     @staticmethod
-    def resolve_placeholder_data_points(root: Measure, info: GQLInfo) -> list[PlaceHolderDataPoint]:
-        measure_template_uuid = str(root.measure_template.uuid)
-        fwc = root.cache.framework_config
-        if hasattr(root.cache, 'instance'):
-            instance = root.cache.instance
+    def _get_fwc_and_context(measure: Measure) -> tuple[FrameworkConfig, Context]:
+        fwc = measure.cache.framework_config
+        if hasattr(measure.cache, 'instance'):
+            instance = measure.cache.instance
         else:
             instance = fwc.instance_config.get_instance()
-            root.cache.instance = instance
+            measure.cache.instance = instance
         context = instance.context
+        return fwc, context
+
+    @staticmethod
+    def _find_corresponding_node(measure: Measure) -> tuple[Node | None, NodeDimensionSelection | None]:
+        cached = getattr(measure, '_node', None)
+        if cached is not None:
+            return cached
+        measure_template_uuid = str(measure.measure_template.uuid)
+        fwc, context = MeasureType._get_fwc_and_context(measure)
         node_dimension_selection = fwc.measure_template_uuid_to_node_dimension_selection.get(measure_template_uuid)
         if node_dimension_selection is None:
-            return []
+            return None, None
         node_id = node_dimension_selection.node_id
         node = context.get_node(node_id)
+        measure._node = node, node_dimension_selection
+        return node, node_dimension_selection
+
+    @staticmethod
+    def resolve_corresponding_node(root: Measure, info: GQLInfo) -> Node | None:
+        node = MeasureType._find_corresponding_node(root)
+        return node[0]
+
+    @staticmethod
+    def resolve_placeholder_data_points(root: Measure, info: GQLInfo) -> list[PlaceHolderDataPoint]:
+        node, node_dimension_selection = MeasureType._find_corresponding_node(root)
+        if node is None or node_dimension_selection is None:
+            return []
+        fwc, context = MeasureType._get_fwc_and_context(root)
         with context.get_default_scenario().override():
             try:
                 df = node.get_output_pl()