pickpoint 2.0.6

Official Rust SDK for Pickpoint — geocoding, routing, devices, and realtime tracking
Documentation
use std::time::Duration;

use rand::Rng;
use reqwest::header::{HeaderMap, CONTENT_TYPE};
use reqwest::Client as HttpClient;
use serde_json::Value;

use crate::auth::AuthKind;
use crate::config::{DEFAULT_RETRY_BASE, MIN_RETRY_BASE};
use crate::error::{ApiError, Error, Result};

#[derive(Clone, Copy)]
pub(crate) enum OnClientError {
    Throw,
    Empty,
}

pub(crate) struct RequestOpts<'a> {
    pub method: reqwest::Method,
    pub path: &'a str,
    pub query: Vec<(String, String)>,
    pub body: Option<Value>,
    pub on_client_error: OnClientError,
    pub empty: Option<&'static [u8]>,
}

pub(crate) struct Transport {
    pub base_url: String,
    pub http: HttpClient,
    pub auth: AuthKind,
    pub max_retries: u32,
    pub retry_base: Duration,
}

impl Transport {
    pub async fn do_request(&self, opts: RequestOpts<'_>) -> Result<Vec<u8>> {
        let mut attempt = 0u32;
        let mut auth_retried = false;

        loop {
            let mut url = format!("{}{}", self.base_url, opts.path);
            if !opts.query.is_empty() {
                let mut ser = url::form_urlencoded::Serializer::new(String::new());
                for (k, v) in &opts.query {
                    if !v.is_empty() {
                        ser.append_pair(k, v);
                    }
                }
                let q = ser.finish();
                if !q.is_empty() {
                    url.push('?');
                    url.push_str(&q);
                }
            }

            let mut headers = HeaderMap::new();
            self.auth.apply(&mut headers).await?;
            if opts.body.is_some() {
                headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
            }

            let mut builder = self
                .http
                .request(opts.method.clone(), &url)
                .headers(headers);
            if let Some(body) = &opts.body {
                builder = builder.json(body);
            }

            let send_result = builder.send().await;
            let res = match send_result {
                Ok(r) => r,
                Err(e) => {
                    if attempt >= self.max_retries {
                        return Err(Error::Api(ApiError::new(
                            0,
                            "NETWORK",
                            format!("network error: {e}"),
                            Vec::new(),
                        )));
                    }
                    sleep_backoff(self.retry_base, attempt).await;
                    attempt += 1;
                    continue;
                }
            };

            let status = res.status().as_u16();
            let raw = res.bytes().await.unwrap_or_default().to_vec();

            match status {
                401 => {
                    if !auth_retried
                        && self.auth.is_bearer()
                        && self.auth.refresh_after_unauthorized().await
                    {
                        auth_retried = true;
                        continue;
                    }
                    return Err(Error::Api(ApiError::new(
                        status,
                        "API_AUTH",
                        "auth failed (401)",
                        raw,
                    )));
                }
                402 | 403 => {
                    return Err(Error::Api(ApiError::new(
                        status,
                        "API_AUTH",
                        "auth failed",
                        raw,
                    )));
                }
                204 => return Ok(Vec::new()),
                409 => {
                    return Err(Error::Api(ApiError::new(
                        409,
                        "CONFLICT",
                        message_from_body(&raw, 409),
                        raw,
                    )));
                }
                400 | 404..=499 => {
                    if matches!(opts.on_client_error, OnClientError::Empty) {
                        return Ok(opts.empty.unwrap_or_default().to_vec());
                    }
                    let code = if status == 404 {
                        "NOT_FOUND"
                    } else {
                        "CLIENT_ERROR"
                    };
                    return Err(Error::Api(ApiError::new(
                        status,
                        code,
                        message_from_body(&raw, status),
                        raw,
                    )));
                }
                500..=599 => {
                    if attempt >= self.max_retries {
                        return Err(Error::Api(ApiError::new(
                            status,
                            "SERVER_ERROR",
                            "server error after retries",
                            raw,
                        )));
                    }
                    sleep_backoff(self.retry_base, attempt).await;
                    attempt += 1;
                    continue;
                }
                200..=299 => return Ok(raw),
                _ => {
                    if (400..500).contains(&status)
                        && matches!(opts.on_client_error, OnClientError::Empty)
                    {
                        return Ok(opts.empty.unwrap_or_default().to_vec());
                    }
                    return Err(Error::Api(ApiError::new(
                        status,
                        "CLIENT_ERROR",
                        message_from_body(&raw, status),
                        raw,
                    )));
                }
            }
        }
    }
}

fn message_from_body(raw: &[u8], status: u16) -> String {
    #[derive(serde::Deserialize)]
    struct Msg {
        message: Option<String>,
        error: Option<String>,
    }
    if let Ok(m) = serde_json::from_slice::<Msg>(raw) {
        if let Some(message) = m.message.filter(|s| !s.is_empty()) {
            return message;
        }
        if let Some(error) = m.error.filter(|s| !s.is_empty()) {
            return error;
        }
    }
    http_status_text(status)
}

fn http_status_text(status: u16) -> String {
    http::StatusCode::from_u16(status)
        .ok()
        .and_then(|s| s.canonical_reason())
        .unwrap_or("unknown")
        .to_string()
}

async fn sleep_backoff(base: Duration, attempt: u32) {
    let base = if base.is_zero() {
        DEFAULT_RETRY_BASE
    } else {
        base.max(MIN_RETRY_BASE)
    };
    let max = base
        .checked_mul(1u32 << attempt.min(16))
        .unwrap_or(Duration::from_secs(60));
    let jitter = rand::thread_rng().gen_range(0..=max.as_millis() as u64);
    tokio::time::sleep(Duration::from_millis(jitter)).await;
}

pub(crate) fn trim_slash(s: &str) -> String {
    s.trim_end_matches('/').to_string()
}