feat(graph-proxy): implement Node on Workflow for refetchable fragments

Author: VictoriaBeilsten-Edmands

backend/graph-proxy/src/graphql/mod.rs

@@ -17,12 +17,13 @@ pub mod subscription_integration;
 use crate::RouterState;
 
 use self::{
-    subscription::WorkflowsSubscription, workflow_templates::WorkflowTemplatesQuery,
-    workflows::WorkflowsQuery,
+    subscription::WorkflowsSubscription,
+    workflow_templates::WorkflowTemplatesQuery,
+    workflows::{Workflow, WorkflowsQuery},
 };
 use async_graphql::{
-    parser::parse_query, InputObject, MergedObject, MergedSubscription, Schema, SchemaBuilder,
-    SimpleObject,
+    parser::parse_query, Context, InputObject, MergedObject, MergedSubscription, Object, Schema,
+    SchemaBuilder, SimpleObject, Union, ID,
 };
 use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
 use axum::extract::State;
@@ -50,12 +51,61 @@ pub fn root_schema_builder() -> SchemaBuilder<Query, Mutation, Subscription> {
 
 /// The root query of the service
 #[derive(Debug, Clone, Default, MergedObject)]
-pub struct Query(WorkflowsQuery, WorkflowTemplatesQuery);
+pub struct Query(NodeQuery, WorkflowsQuery, WorkflowTemplatesQuery);
+
+/// Provides Relay node resolver for fetching any Node by ID.
+#[derive(Debug, Clone, Default)]
+pub struct NodeQuery;
+
+#[Object]
+impl NodeQuery {
+    async fn node(&self, ctx: &Context<'_>, id: ID) -> Option<NodeValue> {
+        let id_str = id.to_string();
+        let parts: Vec<&str> = id_str.split(':').collect();
+        if parts.len() != 2 {
+            return None;
+        }
+        let visit_display = parts[0];
+        let workflow_name = parts[1];
+
+        let visit_input = match parse_visit_display(visit_display) {
+            Some(v) => v,
+            None => return None,
+        };
+
+        let workflows_query = WorkflowsQuery;
+        match workflows_query
+            .workflow(ctx, visit_input, workflow_name.to_string())
+            .await
+        {
+            Ok(workflow) => Some(NodeValue::Workflow(workflow)),
+            Err(_) => None,
+        }
+    }
+}
+
+/// Helper to parse VisitInput Display back into VisitInput
+fn parse_visit_display(display: &str) -> Option<VisitInput> {
+    let re = regex::Regex::new(r"^([A-Za-z]+)(\d+)-(\d+)$").ok()?;
+    let caps = re.captures(display)?;
+    Some(VisitInput {
+        proposal_code: caps[1].to_string(),
+        proposal_number: caps[2].parse().ok()?,
+        number: caps[3].parse().ok()?,
+    })
+}
 
 /// The root mutation of the service
 #[derive(Debug, Clone, Default, MergedObject)]
 pub struct Mutation(WorkflowTemplatesMutation);
 
+/// Represents Relay Node types
+#[derive(Union)]
+enum NodeValue {
+    /// A workflow node.
+    Workflow(Workflow),
+}
+
 /// The root mutation of the service
 #[derive(Debug, Clone, Default, MergedSubscription)]
 pub struct Subscription(WorkflowsSubscription);
@@ -131,13 +181,13 @@ impl Display for Visit {
 
 /// A visit to an instrument as part of a session
 #[derive(Debug, Clone, InputObject)]
-struct VisitInput {
+pub struct VisitInput {
     /// Project Proposal Code
-    proposal_code: String,
+    pub proposal_code: String,
     /// Project Proposal Number
-    proposal_number: u32,
+    pub proposal_number: u32,
     /// Session visit Number
-    number: u32,
+    pub number: u32,
 }
 
 impl From<VisitInput> for Visit {

backend/graph-proxy/src/graphql/workflows.rs

@@ -6,7 +6,7 @@ use argo_workflows_openapi::{
 };
 use async_graphql::{
     connection::{Connection, CursorType, Edge, EmptyFields, OpaqueCursor},
-    Context, Enum, Object, SimpleObject, Union,
+    Context, Enum, Object, SimpleObject, Union, ID,
 };
 use aws_sdk_s3::presigning::PresigningConfig;
 use axum_extra::headers::{authorization::Bearer, Authorization};
@@ -69,6 +69,13 @@ impl Workflow {
 
 #[Object]
 impl Workflow {
+    /// The unique ID derived from the visit and name
+    async fn id(&self) -> ID {
+        let visit_display = self.metadata.visit.to_string();
+        let unique_id = format!("{}:{}", visit_display, self.metadata.name);
+        ID::from(unique_id)
+    }
+
     /// The name given to the workflow, unique within a given visit
     async fn name(&self) -> &str {
         &self.metadata.name
@@ -540,7 +547,7 @@ pub struct WorkflowsQuery;
 impl WorkflowsQuery {
     /// Get a single [`Workflow`] by proposal, visit, and name
     #[instrument(name = "graph_proxy_workflow", skip(self, ctx))]
-    async fn workflow(
+    pub async fn workflow(
         &self,
         ctx: &Context<'_>,
         visit: VisitInput,