API Errors swallowed

[gus4rs]

Twitter accepts video in 3 shapes: 1280x720 (landscape), 720x1280 (portrait), 720x720 (square)

https://developer.twitter.com/en/docs/twitter-api/v1/media/upload-media/uploading-media/media-best-practices

When trying to Tweet a video which does not comply with those dimensions, Twitter may return error status 324 meaning "The validation of media ids failed", or it may not return any code and a detail messages saying "Your media IDs are invalid"

critter hides this error and simply returns the string unknown when posting the tweet. It should return all error field according to Twitter API, so the user can decide how to handle them on a case by case basis.

See https://developer.twitter.com/en/support/twitter-api/error-troubleshooting

Use this video to test:

disform.mp4

[gus4rs]

Twitter error format is a mess. In the case above, the most accurate error is not present in the detail, but inside the vector:

res = {critter::TwitterApiResponse} 
 detail = {core::option::Option<alloc::string::String>::Some} 
  0 = {alloc::string::String} "One or more parameters to your request was invalid."
 errors = {core::option::Option<alloc::vec::Vec>::Some} 
  0 = {alloc::vec::Vec<critter::TwitterApiResponseError, alloc::alloc::Global>} size=1
   [0] = {critter::TwitterApiResponseError} 
    code = {core::option::Option<u32>::None} 
    message = {alloc::string::String} "Your media IDs are invalid."
 data = {core::option::Option<serde_json::value::Value>::None} 

One idea is to abandon neat little enums like this:

pub enum Error {
    Reqwest(reqwest::Error),
    BadMedia,
    NoUserData,
    TooManyRequests,
    Unknown
}

and mimic the twitter response format, returning every single field present in the json response. To give you a taste of how bad was the work of Twitter devs on error reporting, take a look at https://twittercommunity.com/t/inconsistent-error-format-v2-api/148334

[gus4rs]

This is how some popular libraries handle errors:

Tweepy: navigate the mess and grab all text available, gluing it together. Does a best effort to capture the code too

        errors = response_json.get("errors", [])

        # Use := when support for Python 3.7 is dropped
        if "error" in response_json:
            errors.append(response_json["error"])

        error_text = ""

        for error in errors:
            self.api_errors.append(error)

            if isinstance(error, str):
                self.api_messages.append(error)
                error_text += '\n' + error
                continue

            if "code" in error:
                self.api_codes.append(error["code"])
            if "message" in error:
                self.api_messages.append(error["message"])

            if "code" in error and "message" in error:
                error_text += f"\n{error['code']} - {error['message']}"
            elif "message" in error:
                error_text += '\n' + error["message"]

   # Use := when support for Python 3.7 is dropped
        if not error_text and "detail" in response_json:
            self.api_messages.append(response_json["detail"])
            error_text = '\n' + response_json["detail"]

twitter-v2 has a catch-all HashMap plus some fixed fields, modelled like this:

pub errors: Option<Vec<ApiError>>,

pub struct ApiError {
    pub title: String,
    #[serde(rename = "type")]
    pub kind: String,
    #[serde(default, with = "crate::utils::serde::status_code")]
    pub status: StatusCode,
    #[serde(default)]
    pub detail: String,
    #[serde(default)]
    pub errors: Vec<ApiErrorItem>,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct ApiErrorItem {
    parameters: HashMap<String, Vec<serde_json::Value>>,
    message: String,
}