feat(query): add currentRun field to turbo query

crates/turborepo-lib/src/commands/query.rs

@@ -100,7 +100,7 @@ pub async fn run(
             }
         }
     } else {
-        query::run_server(run, handler).await?;
+        query::run_query_server(run, handler).await?;
     }
 
     Ok(0)

crates/turborepo-lib/src/query/mod.rs

@@ -1,16 +1,17 @@
 mod file;
 mod package;
+mod server;
 
 use std::{io, sync::Arc};
 
 use async_graphql::{http::GraphiQLSource, *};
-use async_graphql_axum::GraphQL;
-use axum::{response, response::IntoResponse, routing::get, Router};
+use axum::{response, response::IntoResponse};
 use itertools::Itertools;
 use miette::Diagnostic;
 use package::Package;
+pub use server::run_server;
 use thiserror::Error;
-use tokio::{net::TcpListener, select};
+use tokio::select;
 use turbo_trace::TraceError;
 use turbopath::AbsoluteSystemPathBuf;
 use turborepo_repository::package_graph::PackageName;
@@ -39,6 +40,8 @@ pub enum Error {
     Run(#[from] crate::run::Error),
     #[error(transparent)]
     Path(#[from] turbopath::PathError),
+    #[error(transparent)]
+    UI(#[from] turborepo_ui::Error),
 }
 
 pub struct RepositoryQuery {
@@ -358,14 +361,7 @@ pub async fn graphiql() -> impl IntoResponse {
     response::Html(GraphiQLSource::build().endpoint("/").finish())
 }
 
-pub async fn run_server(run: Run, signal: SignalHandler) -> Result<(), Error> {
-    let schema = Schema::new(
-        RepositoryQuery::new(Arc::new(run)),
-        EmptyMutation,
-        EmptySubscription,
-    );
-    let app = Router::new().route("/", get(graphiql).post_service(GraphQL::new(schema)));
-
+pub async fn run_query_server(run: Run, signal: SignalHandler) -> Result<(), Error> {
     let subscriber = signal.subscribe().ok_or(Error::NoSignalHandler)?;
     println!("GraphiQL IDE: http://localhost:8000");
     webbrowser::open("http://localhost:8000")?;
@@ -375,7 +371,7 @@ pub async fn run_server(run: Run, signal: SignalHandler) -> Result<(), Error> {
             println!("Shutting down GraphQL server");
             return Ok(());
         }
-        result = axum::serve(TcpListener::bind("127.0.0.1:8000").await?, app) => {
+        result = server::run_server(None, Arc::new(run)) => {
             result?;
         }
     }

crates/turborepo-lib/src/query/server.rs

@@ -0,0 +1,45 @@
+use std::sync::Arc;
+
+use async_graphql::{EmptyMutation, EmptySubscription, MergedObject, Schema};
+use async_graphql_axum::GraphQL;
+use axum::{http::Method, routing::get, Router};
+use tokio::net::TcpListener;
+use tower_http::cors::{Any, CorsLayer};
+use turborepo_ui::wui::query::SharedState;
+
+use crate::{query, query::graphiql, run::Run};
+
+#[derive(MergedObject)]
+struct Query(turborepo_ui::wui::RunQuery, query::RepositoryQuery);
+
+pub async fn run_server(
+    state: Option<SharedState>,
+    run: Arc<Run>,
+) -> Result<(), turborepo_ui::Error> {
+    let cors = CorsLayer::new()
+        // allow `GET` and `POST` when accessing the resource
+        .allow_methods([Method::GET, Method::POST])
+        .allow_headers(Any)
+        // allow requests from any origin
+        .allow_origin(Any);
+
+    let web_ui_query = turborepo_ui::wui::RunQuery::new(state.clone());
+    let turbo_query = query::RepositoryQuery::new(run);
+    let combined_query = Query(web_ui_query, turbo_query);
+
+    let schema = Schema::new(combined_query, EmptyMutation, EmptySubscription);
+    let app = Router::new()
+        .route("/", get(graphiql).post_service(GraphQL::new(schema)))
+        .layer(cors);
+
+    axum::serve(
+        TcpListener::bind("127.0.0.1:8000")
+            .await
+            .map_err(turborepo_ui::wui::Error::Server)?,
+        app,
+    )
+    .await
+    .map_err(turborepo_ui::wui::Error::Server)?;
+
+    Ok(())
+}

crates/turborepo-lib/src/run/ui.rs

@@ -1,13 +1,8 @@
 use std::sync::Arc;
 
-use async_graphql::{EmptyMutation, EmptySubscription, MergedObject, Schema};
-use async_graphql_axum::GraphQL;
-use axum::{http::Method, routing::get, Router};
-use tokio::net::TcpListener;
-use tower_http::cors::{Any, CorsLayer};
-use turborepo_ui::wui::{event::WebUIEvent, server::SharedState};
+use turborepo_ui::wui::{event::WebUIEvent, query::SharedState};
 
-use crate::{query, query::graphiql, run::Run};
+use crate::{query, run::Run};
 
 pub async fn start_web_ui_server(
     rx: tokio::sync::mpsc::UnboundedReceiver<WebUIEvent>,
@@ -17,39 +12,7 @@ pub async fn start_web_ui_server(
     let subscriber = turborepo_ui::wui::subscriber::Subscriber::new(rx);
     tokio::spawn(subscriber.watch(state.clone()));
 
-    run_server(state.clone(), run).await?;
-
-    Ok(())
-}
-
-#[derive(MergedObject)]
-struct Query(turborepo_ui::wui::RunQuery, query::RepositoryQuery);
-
-async fn run_server(state: SharedState, run: Arc<Run>) -> Result<(), turborepo_ui::Error> {
-    let cors = CorsLayer::new()
-        // allow `GET` and `POST` when accessing the resource
-        .allow_methods([Method::GET, Method::POST])
-        .allow_headers(Any)
-        // allow requests from any origin
-        .allow_origin(Any);
-
-    let web_ui_query = turborepo_ui::wui::RunQuery::new(state.clone());
-    let turbo_query = query::RepositoryQuery::new(run);
-    let combined_query = Query(web_ui_query, turbo_query);
-
-    let schema = Schema::new(combined_query, EmptyMutation, EmptySubscription);
-    let app = Router::new()
-        .route("/", get(graphiql).post_service(GraphQL::new(schema)))
-        .layer(cors);
-
-    axum::serve(
-        TcpListener::bind("127.0.0.1:8000")
-            .await
-            .map_err(turborepo_ui::wui::Error::Server)?,
-        app,
-    )
-    .await
-    .map_err(turborepo_ui::wui::Error::Server)?;
+    query::run_server(Some(state.clone()), run).await?;
 
     Ok(())
 }

crates/turborepo-ui/src/wui/mod.rs

@@ -2,12 +2,12 @@
 //! by a web client to display the status of tasks.
 
 pub mod event;
+pub mod query;
 pub mod sender;
-pub mod server;
 pub mod subscriber;
 
 use event::WebUIEvent;
-pub use server::RunQuery;
+pub use query::RunQuery;
 use thiserror::Error;
 
 #[derive(Debug, Error)]

crates/turborepo-ui/src/wui/server.rs → crates/turborepo-ui/src/wui/query.rs

@@ -39,19 +39,22 @@ pub type SharedState = Arc<Mutex<WebUIState>>;
 
 /// The query for actively running tasks (as opposed to the query for general
 /// repository state `RepositoryQuery` in `turborepo_lib::query`)
+/// This is `None` when we're not actually running a task (e.g. `turbo query`)
 pub struct RunQuery {
-    state: SharedState,
+    state: Option<SharedState>,
 }
 
 impl RunQuery {
-    pub fn new(state: SharedState) -> Self {
+    pub fn new(state: Option<SharedState>) -> Self {
         Self { state }
     }
 }
 
 #[Object]
 impl RunQuery {
-    async fn current_run(&self) -> CurrentRun {
-        CurrentRun { state: &self.state }
+    async fn current_run(&self) -> Option<CurrentRun> {
+        Some(CurrentRun {
+            state: self.state.as_ref()?,
+        })
     }
 }

crates/turborepo-ui/src/wui/subscriber.rs

@@ -6,7 +6,7 @@ use tokio::sync::Mutex;
 
 use crate::{
     tui::event::{CacheResult, TaskResult},
-    wui::{event::WebUIEvent, server::SharedState},
+    wui::{event::WebUIEvent, query::SharedState},
 };
 
 /// Subscribes to the Web UI events and updates the state
@@ -150,7 +150,7 @@ mod test {
     use super::*;
     use crate::{
         tui::event::OutputLogs,
-        wui::{sender::WebUISender, server::RunQuery},
+        wui::{query::RunQuery, sender::WebUISender},
     };
 
     #[tokio::test]
@@ -200,7 +200,7 @@ mod test {
         );
 
         // Now let's check with the GraphQL API
-        let schema = Schema::new(RunQuery::new(state), EmptyMutation, EmptySubscription);
+        let schema = Schema::new(RunQuery::new(Some(state)), EmptyMutation, EmptySubscription);
         let result = schema
             .execute("query { currentRun { tasks { name state { status } } } }")
             .await;