beeline 0.1.0

Async Rust helpers for Foursquare/Swarm OAuth and latest checkin polling.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::models::{ApiMeta, RateLimit};
use reqwest::StatusCode;
use thiserror::Error as ThisError;
use url::Url;

pub type Result<T> = std::result::Result<T, Error>;

#[derive(ThisError, Debug)]
pub enum Error {
    #[error("failed to build URL: {0}")]
    Url(#[from] url::ParseError),

    #[error("HTTP request failed: {source}")]
    Request {
        #[source]
        source: reqwest::Error,
    },

    #[error("failed to decode JSON response: {0}")]
    Decode(#[from] serde_json::Error),

    #[error("Foursquare callback returned error {error}: {description:?}")]
    CallbackDenied {
        error: String,
        description: Option<String>,
    },

    #[error("authorization callback did not include a code")]
    MissingCallbackCode,

    #[error("invalid OAuth state: {0}")]
    InvalidState(String),

    #[error("OAuth state has expired")]
    ExpiredState {
        issued_at: i64,
        max_age_seconds: u64,
    },

    #[error("bad request to Foursquare API")]
    BadRequest {
        meta: Option<Box<ApiMeta>>,
        body: Option<String>,
        rate_limit: RateLimit,
    },

    #[error("OAuth token is missing, invalid, or expired")]
    InvalidAuth {
        meta: Option<Box<ApiMeta>>,
        body: Option<String>,
        rate_limit: RateLimit,
    },

    #[error("Foursquare denied access for this token")]
    Forbidden {
        meta: Option<Box<ApiMeta>>,
        body: Option<String>,
        rate_limit: RateLimit,
    },

    #[error("Foursquare rate limit exceeded")]
    RateLimited {
        reset_at: Option<i64>,
        limit: Option<u64>,
        remaining: Option<u64>,
        meta: Option<Box<ApiMeta>>,
    },

    #[error("Foursquare daily quota exceeded")]
    QuotaExceeded {
        meta: Option<Box<ApiMeta>>,
        body: Option<String>,
        rate_limit: RateLimit,
    },

    #[error("Foursquare server error: {status}")]
    Server {
        status: StatusCode,
        meta: Option<Box<ApiMeta>>,
        body: Option<String>,
        rate_limit: RateLimit,
    },

    #[error("Foursquare API error: {status}")]
    Api {
        status: StatusCode,
        meta: Option<Box<ApiMeta>>,
        body: Option<String>,
        rate_limit: RateLimit,
    },

    #[error("malformed Foursquare response: {0}")]
    MalformedResponse(String),

    #[error("Foursquare response body exceeded {limit} bytes")]
    ResponseTooLarge { limit: usize },

    #[error("insecure {name} endpoint rejected: {url}")]
    InsecureEndpoint { name: &'static str, url: Url },
}

impl Error {
    pub(crate) fn request(source: reqwest::Error) -> Self {
        Self::Request {
            source: source.without_url(),
        }
    }

    pub fn is_invalid_auth(&self) -> bool {
        matches!(self, Error::InvalidAuth { .. })
    }

    pub fn is_rate_limited(&self) -> bool {
        matches!(
            self,
            Error::RateLimited { .. } | Error::QuotaExceeded { .. }
        )
    }

    pub fn is_retryable(&self) -> bool {
        matches!(self, Error::RateLimited { .. } | Error::Server { .. })
    }
}

impl From<reqwest::Error> for Error {
    fn from(source: reqwest::Error) -> Self {
        Self::request(source)
    }
}