Beginner Questions - Handling API response Errors & structs

[miketwenty1]

Question 1:

If I get back an unexpected response from an API call, and I can't serialize it into a struct, I'll get a reqwest error like

Err(reqwest::Error { kind: Decode, source: Error("missing field `success`

(From the ChargesRes struct not being satisfied).

But instead I want to see the bad response of a potentially changed API, or a response like "Permission denied" or "API limit reached" or whatever the unexpected message would be.. How can I return this as the error instead of the generic reqwest errors?

Example Code:

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::json;

#[derive(Debug, Serialize, Deserialize)]
struct InvoiceData {
    request: String,
    uri: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct ChargesData {
    #[serde(rename = "confirmedAt")]
    confirmed_at: Option<DateTime<Utc>>,
    status: String,
    invoice: InvoiceData,
}

#[derive(Debug, Serialize, Deserialize)]
struct ChargesRes {
    success: bool,
    data: ChargesData,
    message: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct Charge {
    #[serde(rename = "expiresIn")]
    expires_in: u32,
    amount: String,
}

impl Default for Charge {
    fn default() -> Charge {
        Charge {
            expires_in: 300,
            amount: String::from("0"),
        }
    }
}

#[tokio::main]
async fn charges(charge: Charge, apikey: &str) -> Result<ChargesRes, reqwest::Error> {

    let client = reqwest::Client::new();
    let resp = client
        .post("https://api.someapi.io/v0/charges")
        .header("Content-Type", "application/json")
        .header("apikey", apikey)
        //.json(&charge)
        .json(&charge)
        .send()
        .await?
        .json()
        .await?;
        
    Ok(resp)
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::env;

    #[test]
    fn test_charge() {
        let apikey: String = env::var("API_KEY").unwrap();

        let charge = Charge {
            ..Default::default() 
        };

        let r = charges(charge, &apikey).unwrap();
        println!("{:?}", &r);

        assert_eq!(r.success, true);
    }
}

Question 2:

Given a sufficiently deep/complicated json response, is it normal to want to perfectly define the response body? Should I just be using a HashMap or something instead?

Question 3:

Is there anything glaring wrong with the way I'm using reqwest and perhaps could benefit from some tips/tricks given this code example?

[seanmonstar]

I want to see the bad response of a potentially changed API

If it could change often, you could use Response::text() instead of JSON, use serde_json yourself, and then you still have the string to fall back on.

a response like "Permission denied" or "API limit reached" or whatever the unexpected message would be

This might be noticeable by checking the Response::status() before trying to decode the body. If the API has a standard way of reporting errors, you could define that as structs and then define some local enum ApiResponse<T> { Success(T), Error { ... } }.

Given a sufficiently deep/complicated json response, is it normal to want to perfectly define the response body?

That's normal. The guides and examples at https://serde.rs/ may be useful.

Is there anything glaring wrong with the way I'm using reqwest

Looks fine to me. If you're making many requests, it'd be more performant to share the Client (it's cheap to Clone).

[miketwenty1]

@seanmonstar Thank you for the response.
Because of the mix of reqwest errors and serde potential errors.. I'm now using "anyhow" which seems to work pretty well.

It seems there's no way to clone/copy a Reqwest Response so, I'm doing as you suggested, (bringing it first to text). I can then clone that text as needed.

I wanted to show you what I did incase you have more suggestions or feedback on what I can do to improve the code (As I'm learning, anything is appreciated).
Also, the idea you proposed of using some sort of enum ApiResponse<T> { Success(T), Error { ... } } sounds neat, but I not sure how I would exactly implement that ApiResponse enum. I did pass the Client in as a function arg which I believe you were suggesting.

// use anyhow::Result; (this is being used now)
#[tokio::main]
async fn charges(
    client: Client,
    charge: Charge,
    apikey: &str,
) -> Result<ChargesRes, anyhow::Error> {
    let client = reqwest::Client::new();
    let resp = client
        .post("https://api.someapi.io/v0/charges")
        .header("Content-Type", "application/json")
        .header("apikey", apikey)
        .json(&charge)
        .send()
        .await?;

    let status_code = resp.status();

    let resp_text = resp.text().await?;

    match status_code {
        reqwest::StatusCode::OK => dbg!("OK status:"),
        s => {
            return Err(anyhow::anyhow!(
                "Error: status {}, message: {}",
                s,
                resp_text.clone()
            ));
        }
    };

    let resp_serialized = serde_json::from_str(&resp_text); // purposely not using the "?" here so I can give a custom error message.

    let resp_seralized_2: ChargesRes = match resp_serialized {
        Ok(c) => c,
        Err(e) => {
            return Err(anyhow::anyhow!(
                "Was given a good status, but something failed when parsing to json\nserde parse error: {}, \ntext from API: {}\n status code: {}",
                e,
                resp_text.clone(),
                status_code
            ))
        }
    };

    Ok(resp_seralized_2)
}