graphql_client + salesforce graphql + ok/error handling thinking

Cargo.toml

[package]
name = "demo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
graphql_client = { version = "0.13", features = ["reqwest"] }
serde = "1.0"
reqwest = "0.11"
serde_json = "1.0"

tokio = { version = "1.32", features = ["full"] }

main.rs

use std::env;

use graphql_client::{GraphQLQuery, Response};
use graphql_client::reqwest::post_graphql;
use reqwest::{self, Client, Error};
use serde::Deserialize;
use serde_json;

#[tokio::main]
async fn main() {
    println!("Hello, world!");

    let variables = demo_query::Variables;

    let endpoint = env::var("graphql_endpoint").unwrap();
    let access_token = env::var("access_token").unwrap();
    let client = Client::builder()
        .default_headers(
            std::iter::once((
                reqwest::header::AUTHORIZATION,
                reqwest::header::HeaderValue::from_str(&format!("Bearer {}", access_token)).unwrap()
            ))
            .collect()
        )
        .build().unwrap();

    /*
    let result = post_graphql::<DemoQuery, _>(&client, endpoint, variables)
        .await
        .map_err(|err| {
            println!("map_error >>");
            println!("{:?}", err);
        });
    println!("{:?}", result);

    match result {
        Ok(response) => {
            println!("response >>");
            println!("{:?}", response);
        },
        Err(error) => {
            println!("error >>");
            println!("{:?}", error);
        }
    }
    */

    let result = client.post(endpoint).json(&DemoQuery::build_query(demo_query::Variables)).send().await;
    println!("result >>>");
    println!("{:?}", result);

    match result {
        Ok(response) => {
            println!("response.json >>");
            println!("  response.status: {:?}", response.status());
            let text = response.bytes().await.unwrap();
            let data = serde_json::from_slice::<Response<demo_query::ResponseData>>(&text);
            //let data = response.json::<Response<demo_query::ResponseData>>().await;
            println!("{:?}", data);
            if data.is_err() {
                let errors = serde_json::from_slice::<DemoErrors>(&text);
                //let errors = response.json::<DemoErrors>().await;
                match errors {
                    Ok(errors_data) => {
                        println!("graphql errors data >>");
                        println!("{:?}", errors_data);
                    },
                    Err(error) => {
                        println!("graphql errors error >>");
                        println!("{:?}", error);
                    }
                }
            }
        },
        Err(error) => {
            println!("error >>");
            println!("{:?}", error);
        }
    }
}

async fn convert_to_data(response: reqwest::Response) -> Result<Response<demo_query::ResponseData>, Error> {
    response.json::<Response<demo_query::ResponseData>>().await
}
async fn convert_to_errors(response: reqwest::Response) -> Result<DemoErrors, Error> {
    response.json::<DemoErrors>().await
}

#[derive(GraphQLQuery)]
#[graphql(
    schema_path = "graphql/schema.json",
    query_path = "graphql/demo_query.graphql",
    response_derives = "Debug"
)]
struct DemoQuery;

#[derive(Debug, Deserialize)]
struct DemoErrors {
    errors: Vec<DemoError>
}

#[derive(Debug, Deserialize)]
struct DemoError {
    extensions: DemoExtension,
    locations: Vec<DemoLocation>,
    message: String

}
#[derive(Debug, Deserialize)]
struct DemoExtension {
    #[serde(rename="ErrorType")]
    error_type: String
}
#[derive(Debug, Deserialize)]
struct DemoLocation {
    column: i32,
    line: i32
}