taler-rust

api.rs (6420B)

---

 /*
   This file is part of TALER
   Copyright (C) 2025 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::borrow::Cow;
 
 use reqwest::{Client, Method, RequestBuilder, Response, StatusCode, Url, header};
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use taler_common::error::FmtSource;
 use thiserror::Error;
 use tracing::Level;
 
 use crate::magnet_api::oauth::{Token, oauth};
 
 #[derive(Deserialize, Debug)]
 struct Header {
     #[serde(rename = "errorCode")]
     pub error_code: Option<u16>,
 }
 
 #[derive(Deserialize, Debug)]
 struct Empty {}
 
 #[derive(Deserialize, Error, Debug)]
 #[error("{error_code} {short_message} '{long_message}'")]
 pub struct MagnetError {
     #[serde(rename = "errorCode")]
     pub error_code: u16,
     #[serde(rename = "shortMessage")]
     pub short_message: String,
     #[serde(rename = "longMessage")]
     pub long_message: String,
 }
 
 #[derive(Error, Debug)]
 #[error("{method} {path} {kind}")]
 pub struct ApiErr {
     pub path: Cow<'static, str>,
     pub method: Method,
     pub kind: ErrKind,
 }
 
 #[derive(Error, Debug)]
 pub enum ErrKind {
     #[error("transport: {0}")]
     Transport(FmtSource<reqwest::Error>),
     #[error("magnet {0}")]
     Magnet(#[from] MagnetError),
     #[error("JSON body: {0}")]
     Json(#[from] serde_path_to_error::Error<serde_json::Error>),
     #[error("form body: {0}")]
     Form(#[from] serde_urlencoded::de::Error),
     #[error("status {0}")]
     Status(StatusCode),
     #[error("status {0} '{1}'")]
     StatusCause(StatusCode, String),
 }
 
 impl From<reqwest::Error> for ErrKind {
     fn from(value: reqwest::Error) -> Self {
         Self::Transport(value.into())
     }
 }
 
 pub type ApiResult<R> = std::result::Result<R, ApiErr>;
 
 /** Handle error from magnet API calls */
 async fn error_handling(res: reqwest::Result<Response>) -> Result<String, ErrKind> {
     let res = res?;
     let status = res.status();
     match status {
         StatusCode::OK => Ok(res.text().await?),
         StatusCode::BAD_REQUEST => Err(ErrKind::Status(status)),
         StatusCode::FORBIDDEN => {
             let cause = res
                 .headers()
                 .get(header::WWW_AUTHENTICATE)
                 .map(|s| s.to_str().unwrap_or_default())
                 .unwrap_or_default();
             Err(ErrKind::StatusCause(status, cause.to_string()))
         }
         _ => {
             if tracing::enabled!(Level::DEBUG) {
                 tracing::debug!("unexpected error: {:?}", &res);
                 let body = res.text().await;
                 tracing::debug!("unexpected error body: {:?}", body);
             }
             Err(ErrKind::Status(status))
         }
     }
 }
 
 /** Parse JSON and track error path */
 fn parse<'de, T: Deserialize<'de>>(str: &'de str) -> Result<T, ErrKind> {
     let deserializer = &mut serde_json::Deserializer::from_str(str);
     serde_path_to_error::deserialize(deserializer).map_err(ErrKind::Json)
 }
 
 /** Parse magnet JSON response */
 async fn magnet_json<T: DeserializeOwned>(res: reqwest::Result<Response>) -> Result<T, ErrKind> {
     let body = error_handling(res).await?;
     let header: Header = parse(&body)?;
     if header.error_code.unwrap_or(200) == 200 {
         parse(&body)
     } else {
         Err(ErrKind::Magnet(parse(&body)?))
     }
 }
 
 /** Parse magnet URL encoded response into our own type */
 async fn magnet_url<T: DeserializeOwned>(
     response: reqwest::Result<Response>,
 ) -> Result<T, ErrKind> {
     let body = error_handling(response).await?;
     serde_urlencoded::from_str(&body).map_err(ErrKind::Form)
 }
 
 pub struct MagnetRequest<'a> {
     path: Cow<'static, str>,
     method: Method,
     builder: RequestBuilder,
     consumer: &'a Token,
     access: Option<&'a Token>,
     verifier: Option<&'a str>,
 }
 
 impl<'a> MagnetRequest<'a> {
     pub fn new(
         client: &Client,
         method: Method,
         base_url: &Url,
         path: impl Into<Cow<'static, str>>,
         consumer: &'a Token,
         access: Option<&'a Token>,
         verifier: Option<&'a str>,
     ) -> Self {
         let path = path.into();
         let url = base_url.join(&path).unwrap();
         let builder = client.request(method.clone(), url);
         Self {
             path,
             method,
             builder,
             consumer,
             access,
             verifier,
         }
     }
 
     pub fn query<T: Serialize + ?Sized>(mut self, query: &T) -> Self {
         self.builder = self.builder.query(query);
         self
     }
 
     pub fn json<T: Serialize + ?Sized>(mut self, json: &T) -> Self {
         self.builder = self.builder.json(json);
         self
     }
 
     pub async fn parse_url<T: DeserializeOwned>(self) -> ApiResult<T> {
         let Self {
             path,
             builder,
             method,
             consumer,
             access,
             verifier,
         } = self;
         let (client, req) = builder.build_split();
         async {
             let mut req = req?;
             oauth(&mut req, consumer, access, verifier);
             let res = client.execute(req).await;
             magnet_url(res).await
         }
         .await
         .map_err(|kind| ApiErr { path, method, kind })
     }
 
     pub async fn parse_json<T: DeserializeOwned>(self) -> ApiResult<T> {
         let Self {
             path,
             builder,
             method,
             consumer,
             access,
             verifier,
         } = self;
         let (client, req) = builder.build_split();
         async {
             let mut req = req?;
             oauth(&mut req, consumer, access, verifier);
             let res = client.execute(req).await;
             magnet_json(res).await
         }
         .await
         .map_err(|kind| ApiErr { path, method, kind })
     }
 
     pub async fn parse_empty(self) -> ApiResult<()> {
         self.parse_json::<Empty>().await?;
         Ok(())
     }
 }