boatramp 0.42.0

//! The `graphql` subcommand: manage a project's GraphQL admin surface — the
//! persisted-operation **safelist** (register/list/remove trusted operations) and the
//! federation **subgraphs** (publish an SDL / SQL / function subgraph, remove one, and
//! read the composed supergraph). Project-scoped over the control-plane API — the same
//! endpoints `graphql.md` previously documented with `curl`.

use std::path::PathBuf;

use clap::Subcommand;

use crate::client;
use crate::config::ProjectConfig;

/// A failure in the `graphql` subcommand.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// Resolving the target or talking to the control plane failed.
    #[error(transparent)]
    Client(#[from] crate::client::ClientError),
    /// A request to the GraphQL admin API failed.
    #[error(transparent)]
    Http(#[from] reqwest::Error),
    /// Reading a `--sdl`/`--file`/`--query-file` input failed.
    #[error("reading {0}: {1}")]
    Io(String, #[source] std::io::Error),
}

type Result<T> = std::result::Result<T, Error>;

/// Arguments for `boatramp graphql`.
#[derive(Debug, clap::Args)]
pub struct GraphqlArgs {
    /// boatramp server base URL (overrides [deploy].server).
    #[arg(long, env = "BOATRAMP_SERVER", global = true)]
    server: Option<String>,

    #[command(subcommand)]
    command: GraphqlCommand,
}

#[derive(Debug, Subcommand)]
enum GraphqlCommand {
    /// Manage the persisted-operation safelist (trusted-operation allowlist).
    Safelist {
        #[command(subcommand)]
        command: SafelistCommand,
    },
    /// Manage federation subgraphs.
    Subgraph {
        #[command(subcommand)]
        command: SubgraphCommand,
    },
    /// Print the composed supergraph SDL.
    Supergraph,
}

#[derive(Debug, Subcommand)]
enum SafelistCommand {
    /// Register a trusted operation. Give the query inline or with `--file`.
    Add {
        /// The GraphQL operation text (omit to read from `--file`).
        query: Option<String>,
        /// Read the operation from a file instead of an argument.
        #[arg(long)]
        file: Option<PathBuf>,
    },
    /// List the registered trusted operations.
    List,
    /// Remove a trusted operation by its hash.
    Rm {
        /// The operation hash (as returned by `add`/`list`).
        hash: String,
    },
}

#[derive(Debug, Subcommand)]
enum SubgraphCommand {
    /// Publish (or replace) a Wasm subgraph from its SDL file.
    Put {
        /// Subgraph name.
        name: String,
        /// Path to the subgraph's SDL.
        #[arg(long)]
        sdl: PathBuf,
    },
    /// Publish (or replace) a SQL subgraph from a request JSON file (`{site, config}`).
    Sql {
        /// Subgraph name.
        name: String,
        /// Path to the JSON request body.
        #[arg(long)]
        file: PathBuf,
    },
    /// Register (or refresh) a function subgraph by introspecting the deployed
    /// function of the same name — no SDL, no body.
    Function {
        /// Subgraph / function name.
        name: String,
    },
    /// Remove a subgraph.
    Rm {
        /// Subgraph name.
        name: String,
    },
}

/// The result of a `graphql` subcommand, rendered by [`crate::output`].
#[derive(Debug, serde::Serialize)]
#[serde(tag = "result", rename_all = "snake_case")]
pub enum GraphqlOutput {
    /// A trusted operation was registered (`safelist add`).
    Safelisted { hash: String },
    /// The registered trusted operations (`safelist list`) — the admin API's
    /// JSON body, verbatim.
    Safelist { operations: serde_json::Value },
    /// A trusted operation was removed (`safelist rm`).
    SafelistRemoved { hash: String },
    /// A subgraph was published. `kind` is `sdl`, `sql`, or `function`.
    SubgraphPublished { name: String, kind: String },
    /// A subgraph was removed.
    SubgraphRemoved { name: String },
    /// The composed supergraph SDL (`supergraph`).
    Supergraph { sdl: String },
}

impl crate::output::Rendered for GraphqlOutput {
    fn render_human(&self, w: &mut dyn std::io::Write) -> std::io::Result<()> {
        match self {
            Self::Safelisted { hash } => writeln!(w, "safelisted operation: {hash}"),
            Self::Safelist { operations } => writeln!(
                w,
                "{}",
                serde_json::to_string_pretty(operations).unwrap_or_default()
            ),
            Self::SafelistRemoved { hash } => {
                writeln!(w, "removed safelisted operation {hash}")
            }
            // The human wording matches the original per-kind phrasing; `kind` rides the JSON shape.
            Self::SubgraphPublished { name, kind } => match kind.as_str() {
                "function" => writeln!(w, "registered function subgraph {name}"),
                "sdl" => writeln!(w, "published subgraph {name}"),
                other => writeln!(w, "published {other} subgraph {name}"),
            },
            Self::SubgraphRemoved { name } => writeln!(w, "removed subgraph {name}"),
            Self::Supergraph { sdl } => writeln!(w, "{sdl}"),
        }
    }
}

/// Entry point for `boatramp graphql`.
pub async fn run(args: GraphqlArgs, config: &ProjectConfig) -> Result<GraphqlOutput> {
    let server = client::resolve_server(args.server, config)?;
    let project = client::resolve_project(config);
    let seg = client::project_seg(&project, "graphql");
    let http = client::http_client(client::token(config).as_deref());
    let base = format!("{server}/api/{seg}");

    let out = match args.command {
        GraphqlCommand::Safelist { command } => match command {
            SafelistCommand::Add { query, file } => {
                let query = read_input(query, file)?;
                let resp = http
                    .post(format!("{base}/safelist"))
                    .json(&serde_json::json!({ "query": query }))
                    .send()
                    .await?
                    .error_for_status()?;
                let body: serde_json::Value = resp.json().await.unwrap_or_default();
                let hash = body
                    .get("hash")
                    .and_then(|h| h.as_str())
                    .unwrap_or("(registered)")
                    .to_string();
                GraphqlOutput::Safelisted { hash }
            }
            SafelistCommand::List => {
                let body: serde_json::Value = http
                    .get(format!("{base}/safelist"))
                    .send()
                    .await?
                    .error_for_status()?
                    .json()
                    .await
                    .unwrap_or_default();
                GraphqlOutput::Safelist { operations: body }
            }
            SafelistCommand::Rm { hash } => {
                http.delete(format!("{base}/safelist/{hash}"))
                    .send()
                    .await?
                    .error_for_status()?;
                GraphqlOutput::SafelistRemoved { hash }
            }
        },
        GraphqlCommand::Subgraph { command } => match command {
            SubgraphCommand::Put { name, sdl } => {
                let body = read_file(&sdl)?;
                http.put(format!("{base}/subgraphs/{name}"))
                    .header("content-type", "text/plain")
                    .body(body)
                    .send()
                    .await?
                    .error_for_status()?;
                GraphqlOutput::SubgraphPublished {
                    name,
                    kind: "sdl".to_string(),
                }
            }
            SubgraphCommand::Sql { name, file } => {
                put_json_subgraph(&http, &base, &name, "sql", &file).await?;
                GraphqlOutput::SubgraphPublished {
                    name,
                    kind: "sql".to_string(),
                }
            }
            SubgraphCommand::Function { name } => {
                http.put(format!("{base}/subgraphs/{name}/function"))
                    .send()
                    .await?
                    .error_for_status()?;
                GraphqlOutput::SubgraphPublished {
                    name,
                    kind: "function".to_string(),
                }
            }
            SubgraphCommand::Rm { name } => {
                http.delete(format!("{base}/subgraphs/{name}"))
                    .send()
                    .await?
                    .error_for_status()?;
                GraphqlOutput::SubgraphRemoved { name }
            }
        },
        GraphqlCommand::Supergraph => {
            let text = http
                .get(format!("{base}/supergraph"))
                .send()
                .await?
                .error_for_status()?
                .text()
                .await?;
            GraphqlOutput::Supergraph { sdl: text }
        }
    };
    Ok(out)
}

/// PUT a JSON-bodied subgraph (`sql` / `function`) from a request file. The
/// caller reports the outcome; this only performs the request.
async fn put_json_subgraph(
    http: &client::ApiClient,
    base: &str,
    name: &str,
    kind: &str,
    file: &std::path::Path,
) -> Result<()> {
    let raw = read_file(file)?;
    let value: serde_json::Value = serde_json::from_str(&raw).map_err(|e| {
        Error::Io(
            file.display().to_string(),
            std::io::Error::new(std::io::ErrorKind::InvalidData, e),
        )
    })?;
    http.put(format!("{base}/subgraphs/{name}/{kind}"))
        .json(&value)
        .send()
        .await?
        .error_for_status()?;
    Ok(())
}

/// Resolve a query given inline text or a `--file`.
fn read_input(inline: Option<String>, file: Option<PathBuf>) -> Result<String> {
    match (inline, file) {
        (Some(q), _) => Ok(q),
        (None, Some(path)) => read_file(&path),
        (None, None) => Ok(String::new()),
    }
}

/// Read a file, tagging the path into the error.
fn read_file(path: &std::path::Path) -> Result<String> {
    std::fs::read_to_string(path).map_err(|e| Error::Io(path.display().to_string(), e))
}