bird 0.1.2

X API CLI with entity caching, search, threads, and watchlists
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Central command requirements: which auth types each command accepts.
//! Used by execution, doctor (availability), and auth_flag mapping for xurl.

/// Auth types that a command can accept (OAuth2UserToken, OAuth1 UserToken, BearerToken).
/// The None variant indicates no authentication is available.
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
pub enum AuthType {
    #[serde(rename = "oauth2_user")]
    OAuth2User,
    #[serde(rename = "oauth1")]
    OAuth1,
    #[serde(rename = "bearer")]
    Bearer,
    #[serde(rename = "none")]
    None,
}

impl std::fmt::Display for AuthType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AuthType::OAuth2User => write!(f, "oauth2_user"),
            AuthType::OAuth1 => write!(f, "oauth1"),
            AuthType::Bearer => write!(f, "bearer"),
            AuthType::None => write!(f, "none"),
        }
    }
}

/// Per-command auth requirements: which auth types are accepted.
#[derive(Clone, Debug)]
pub struct CommandReqs {
    /// Auth types this command accepts (any one is sufficient).
    pub accepted: &'static [AuthType],
}

/// Map AuthType to xurl `--auth` flag value.
/// Returns None when xurl's default (OAuth2 user) is correct.
pub fn auth_flag(auth_type: &AuthType) -> Option<&'static str> {
    match auth_type {
        AuthType::OAuth2User => None, // xurl defaults to OAuth2
        AuthType::OAuth1 => Some("oauth1"),
        AuthType::Bearer => Some("app"),
        AuthType::None => None,
    }
}

const ME_ACCEPTED: &[AuthType] = &[AuthType::OAuth2User, AuthType::OAuth1];
const OAUTH2_ONLY: &[AuthType] = &[AuthType::OAuth2User];
// Profile: all three auth types per X API spec for GET /2/users/by/username/{username}
const PROFILE_ACCEPTED: &[AuthType] = &[AuthType::OAuth2User, AuthType::OAuth1, AuthType::Bearer];
// Search: OAuth 2.0 User, OAuth 1.0a, Bearer per X API spec for GET /2/tweets/search/recent
const SEARCH_ACCEPTED: &[AuthType] = &[AuthType::OAuth2User, AuthType::OAuth1, AuthType::Bearer];
// Thread: same auth as search (uses /2/tweets/{id} + /2/tweets/search/recent)
const THREAD_ACCEPTED: &[AuthType] = &[AuthType::OAuth2User, AuthType::OAuth1, AuthType::Bearer];
const RAW_ACCEPTED: &[AuthType] = &[AuthType::OAuth2User, AuthType::OAuth1, AuthType::Bearer];

/// Returns requirements for a command by name. Used by execution and doctor.
pub fn requirements_for_command(name: &str) -> Option<CommandReqs> {
    Some(match name {
        "me" => CommandReqs {
            accepted: ME_ACCEPTED,
        },
        "bookmarks" => CommandReqs {
            accepted: OAUTH2_ONLY,
        },
        "get" | "post" | "put" | "delete" => CommandReqs {
            accepted: RAW_ACCEPTED,
        },
        "profile" => CommandReqs {
            accepted: PROFILE_ACCEPTED,
        },
        "search" => CommandReqs {
            accepted: SEARCH_ACCEPTED,
        },
        "thread" => CommandReqs {
            accepted: THREAD_ACCEPTED,
        },
        // Write commands (all require OAuth2User)
        "tweet" | "reply" | "like" | "unlike" | "repost" | "unrepost" | "follow" | "unfollow"
        | "dm" | "block" | "unblock" | "mute" | "unmute" => CommandReqs {
            accepted: OAUTH2_ONLY,
        },
        "watchlist_check" => CommandReqs {
            accepted: SEARCH_ACCEPTED,
        },
        "watchlist_add" | "watchlist_remove" | "watchlist_list" => CommandReqs {
            accepted: &[AuthType::None],
        },
        "usage" => CommandReqs {
            accepted: &[AuthType::None],
        },
        "usage_sync" => CommandReqs {
            accepted: &[AuthType::Bearer],
        },
        "login" => return None,
        _ => return None,
    })
}

/// All command names that have auth requirements (for doctor full report).
pub fn command_names_with_auth() -> &'static [&'static str] {
    &[
        "login",
        "me",
        "bookmarks",
        "profile",
        "search",
        "thread",
        "tweet",
        "reply",
        "like",
        "unlike",
        "repost",
        "unrepost",
        "follow",
        "unfollow",
        "dm",
        "block",
        "unblock",
        "mute",
        "unmute",
        "watchlist_check",
        "watchlist_add",
        "watchlist_remove",
        "watchlist_list",
        "usage",
        "usage_sync",
        "get",
        "post",
        "put",
        "delete",
    ]
}

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

    #[test]
    fn command_names_and_requirements_in_sync() {
        for &name in command_names_with_auth() {
            // login is in the list for doctor reporting but has no auth requirements
            if name == "login" {
                continue;
            }
            assert!(
                requirements_for_command(name).is_some(),
                "command '{}' in command_names_with_auth() but missing from requirements_for_command()",
                name
            );
        }
    }
}