refactor: create synd_authn crate

Author: ymgyt

Cargo.lock

@@ -20,9 +20,11 @@ clap               = { version = "4.4" }
 feed-rs            = { version = "1.4" }
 futures-util       = { version = "0.3.30" }
 graphql_client     = { version = "0.13.0", default-features = false }
+http               = { version = "0.2" }                                                                                                   # request use 0.2
 moka               = { version = "0.12.4", features = ["future"] }
 reqwest            = { version = "0.11.23", default-features = false, features = ["rustls-tls", "json"] }
 serde              = { version = "1", features = ["derive"] }
+serde_json         = { version = "1.0.111" }
 tokio              = { version = "1.35" }
 tracing            = { version = "0.1.40" }
 tracing-subscriber = { version = "0.3.18", features = ["smallvec", "fmt", "ansi", "std", "env-filter", "time"], default-features = false }

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+authors.workspace     = true
+categories.workspace  = true
+description.workspace = true
+edition.workspace     = true
+license.workspace     = true
+name                  = "synd_authn"
+readme.workspace      = true
+repository.workspace  = true
+version               = "0.1.0"
+
+[dependencies]
+anyhow         = { workspace = true }
+http           = { workspace = true }
+http-serde-ext = "0.1"
+reqwest        = { workspace = true }
+serde          = { workspace = true, features = ["derive"] }
+serde_json     = { workspace = true }
+tokio          = { workspace = true, features = ["time"] }
+tracing        = { workspace = true }

crates/synd_authn/Cargo.toml

@@ -1,39 +1,38 @@
-use std::{io::Write, time::Duration};
+use std::{borrow::Cow, future::Future, time::Duration};
 
-use http::StatusCode;
+use http::{StatusCode, Uri};
 use reqwest::Client;
 use tracing::debug;
 
-use crate::{
-    auth::device_flow::{
-        DeviceAccessTokenErrorResponse, DeviceAccessTokenRequest, DeviceAccessTokenResponse,
-        DeviceAuthorizationRequest, DeviceAuthorizationResponse,
-    },
-    config,
+use crate::device_flow::{
+    DeviceAccessTokenErrorResponse, DeviceAccessTokenRequest, DeviceAccessTokenResponse,
+    DeviceAuthorizationRequest, DeviceAuthorizationResponse,
 };
 
+const USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));
+
 /// https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/authorizing-oauth-apps#device-flow
 #[derive(Clone)]
 pub struct DeviceFlow {
     client: Client,
-    client_id: &'static str,
+    client_id: Cow<'static, str>,
     endpoint: Option<&'static str>,
 }
 
 impl DeviceFlow {
     const DEVICE_AUTHORIZATION_ENDPOINT: &'static str = "https://github.com/login/device/code";
     const TOKEN_ENDPOINT: &'static str = "https://github.com/login/oauth/access_token";
 
-    pub fn new() -> Self {
+    pub fn new(client_id: impl Into<Cow<'static, str>>) -> Self {
         let client = reqwest::ClientBuilder::new()
-            .user_agent(config::USER_AGENT)
+            .user_agent(USER_AGENT)
             .timeout(Duration::from_secs(5))
             .build()
             .unwrap();
 
         Self {
             client,
-            client_id: config::github::CLIENT_ID,
+            client_id: client_id.into(),
             endpoint: None,
         }
     }
@@ -57,7 +56,7 @@ impl DeviceFlow {
             .post(self.endpoint.unwrap_or(Self::DEVICE_AUTHORIZATION_ENDPOINT))
             .header(http::header::ACCEPT, "application/json")
             .form(&DeviceAuthorizationRequest {
-                client_id: self.client_id.into(),
+                client_id: self.client_id.clone(),
                 scope: scope.into(),
             })
             .send()
@@ -99,7 +98,10 @@ impl DeviceFlow {
                 .client
                 .post(Self::TOKEN_ENDPOINT)
                 .header(http::header::ACCEPT, "application/json")
-                .form(&DeviceAccessTokenRequest::new(&device_code, self.client_id))
+                .form(&DeviceAccessTokenRequest::new(
+                    &device_code,
+                    self.client_id.as_ref(),
+                ))
                 .send()
                 .await?;
 
@@ -128,10 +130,11 @@ impl DeviceFlow {
     }
 
     #[tracing::instrument(skip_all)]
-    pub async fn device_flow<W: Write>(
-        self,
-        writer: W,
-    ) -> anyhow::Result<DeviceAccessTokenResponse> {
+    pub async fn device_flow<F, Fut>(self, callback: F) -> anyhow::Result<DeviceAccessTokenResponse>
+    where
+        F: FnOnce(Uri, String) -> Fut,
+        Fut: Future<Output = ()>,
+    {
         let DeviceAuthorizationResponse {
             device_code,
             user_code,
@@ -140,12 +143,7 @@ impl DeviceFlow {
             ..
         } = self.device_authorize_request().await?;
 
-        let mut writer = writer;
-        writeln!(&mut writer, "Open `{verification_uri}` on your browser")?;
-        writeln!(&mut writer, "Enter CODE: `{user_code}`")?;
-
-        // attempt to open input screen in the browser
-        open::that(verification_uri.to_string()).ok();
+        callback(verification_uri, user_code).await;
 
         self.pool_device_access_token(device_code, interval).await
     }

crates/synd_term/src/auth/github.rs crates/synd_authn/src/device_flow/github.rs

@@ -3,6 +3,8 @@ use std::borrow::Cow;
 use http::Uri;
 use serde::{Deserialize, Serialize};
 
+pub mod github;
+
 /// https://datatracker.ietf.org/doc/html/rfc8628#section-3.1
 #[derive(Serialize, Deserialize, Debug)]
 pub struct DeviceAuthorizationRequest<'s> {
@@ -39,13 +41,13 @@ pub struct DeviceAccessTokenRequest<'s> {
     grant_type: &'static str,
     /// The device verification code, "device_code" from the device authorization response
     device_code: &'s str,
-    client_id: &'static str,
+    client_id: &'s str,
 }
 
 impl<'s> DeviceAccessTokenRequest<'s> {
     const GRANT_TYPE: &'static str = "urn:ietf:params:oauth:grant-type:device_code";
 
-    pub fn new(device_code: &'s str, client_id: &'static str) -> Self {
+    pub fn new(device_code: &'s str, client_id: &'s str) -> Self {
         Self {
             grant_type: Self::GRANT_TYPE,
             device_code,

crates/synd_term/src/auth/device_flow.rs crates/synd_authn/src/device_flow/mod.rs

@@ -0,0 +1 @@
+pub mod device_flow;

crates/synd_authn/src/lib.rs

@@ -12,25 +12,23 @@ name = "synd"
 path = "src/main.rs"
 
 [dependencies]
-anyhow         = { workspace = true }
-chrono         = { workspace = true }
-clap           = { workspace = true, features = ["derive", "string"] }
-crossterm      = { version = "0.27.0", features = ["event-stream"] }
-directories    = "5.0.1"
-edit           = "0.1.5"
-futures-util   = "0.3.30"
-graphql_client = { workspace = true }
-# reqwest use 0.2
-html2text      = { version = "0.12" }
-http           = "0.2"
-http-serde-ext = "0.1"
-open           = "5.0.1"
-# Use latest api
+synd_authn = { path = "../synd_authn", version = "0.1.0" }
+synd_feed  = { path = "../synd_feed", version = "0.1.0" }
+
+anyhow               = { workspace = true }
+chrono               = { workspace = true }
+clap                 = { workspace = true, features = ["derive", "string"] }
+crossterm            = { version = "0.27.0", features = ["event-stream"] }
+directories          = "5.0.1"
+edit                 = "0.1.5"
+futures-util         = "0.3.30"
+graphql_client       = { workspace = true }
+html2text            = { version = "0.12" }
+open                 = "5.0.1"
 ratatui              = { git = "https://github.com/ratatui-org/ratatui.git", branch = "main" }
 reqwest              = { workspace = true }
 serde                = { workspace = true, features = ["derive"] }
 serde_json           = "1.0.111"
-synd_feed            = { path = "../synd_feed", version = "0.1.0" }
 tokio                = { workspace = true, features = ["macros", "rt-multi-thread", "sync", "time"] }
 tracing              = { workspace = true }
 tracing-appender     = "0.2.3"

crates/synd_term/Cargo.toml

@@ -3,17 +3,16 @@ use std::{pin::Pin, time::Duration};
 use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEvent, KeyEventKind};
 use futures_util::{FutureExt, Stream, StreamExt};
 use ratatui::widgets::Widget;
+use synd_authn::device_flow::{
+    github::DeviceFlow, DeviceAccessTokenResponse, DeviceAuthorizationResponse,
+};
 use tokio::time::{Instant, Sleep};
 
 use crate::{
-    auth::{
-        self,
-        device_flow::{DeviceAccessTokenResponse, DeviceAuthorizationResponse},
-        github::DeviceFlow,
-        AuthenticationProvider, Credential,
-    },
+    auth::{self, AuthenticationProvider, Credential},
     client::Client,
     command::Command,
+    config,
     job::Jobs,
     terminal::Terminal,
     ui::{
@@ -45,7 +44,7 @@ impl Default for Config {
     fn default() -> Self {
         Self {
             idle_timer_interval: Duration::from_secs(250),
-            github_device_flow: DeviceFlow::new(),
+            github_device_flow: DeviceFlow::new(config::github::CLIENT_ID),
         }
     }
 }
@@ -460,9 +459,10 @@ impl Application {
         // attempt to open input screen in the browser
         open::that(device_authorization.verification_uri.to_string()).ok();
 
+        let device_flow = self.config.github_device_flow.clone();
         let fut = async move {
             // TODO: error handling
-            let res = auth::github::DeviceFlow::new()
+            let res = device_flow
                 .pool_device_access_token(
                     device_authorization.device_code,
                     device_authorization.interval,

crates/synd_term/src/application/mod.rs

@@ -5,9 +5,6 @@ use tracing::debug;
 
 use crate::config;
 
-pub mod device_flow;
-pub mod github;
-
 #[derive(Debug, Clone, Copy)]
 pub enum AuthenticationProvider {
     Github,

crates/synd_term/src/auth/mod.rs

@@ -1,11 +1,9 @@
 use std::fmt::Display;
+use synd_authn::device_flow::{DeviceAccessTokenResponse, DeviceAuthorizationResponse};
 
 use crate::{
     application::Direction,
-    auth::{
-        device_flow::{DeviceAccessTokenResponse, DeviceAuthorizationResponse},
-        AuthenticationProvider,
-    },
+    auth::AuthenticationProvider,
     client::{payload, query::subscription::SubscriptionOutput},
     types::Feed,
 };

crates/synd_term/src/command.rs

@@ -7,9 +7,10 @@ use ratatui::{
         Widget,
     },
 };
+use synd_authn::device_flow::DeviceAuthorizationResponse;
 
 use crate::{
-    auth::{device_flow::DeviceAuthorizationResponse, AuthenticationProvider},
+    auth::AuthenticationProvider,
     ui::{self, extension::RectExt, Context},
 };
 

crates/synd_term/src/ui/components/authentication.rs

@@ -10,9 +10,9 @@ mod test {
         style::{Modifier, Style},
     };
     use serial_test::file_serial;
+    use synd_authn::device_flow::github::DeviceFlow;
     use synd_term::{
         application::{Application, Config},
-        auth::github::DeviceFlow,
         client::Client,
         ui::theme::Theme,
     };
@@ -42,7 +42,7 @@ mod test {
         let client = Client::new(endpoint).unwrap();
         let config = Config {
             idle_timer_interval: Duration::from_millis(2000),
-            github_device_flow: DeviceFlow::new()
+            github_device_flow: DeviceFlow::new("dummy")
                 .with_endpoint("http://localhost:6000/github/login/device/code"),
         };
         // or mpsc and tokio_stream ReceiverStream

crates/synd_term/tests/integration.rs

@@ -10,7 +10,9 @@ repository.workspace  = true
 version               = "0.1.0"
 
 [dependencies]
-anyhow    = { workspace = true }
-axum      = { workspace = true }
-synd_term = { path = "../synd_term" }
-tokio     = { workspace = true, features = ["rt-multi-thread", "net"] }
+synd_authn = { path = "../synd_authn" }
+synd_term  = { path = "../synd_term" }
+
+anyhow = { workspace = true }
+axum   = { workspace = true }
+tokio  = { workspace = true, features = ["rt-multi-thread", "net"] }

crates/synd_test/Cargo.toml

@@ -1,5 +1,5 @@
 use axum::{http::StatusCode, routing::post, Form, Json, Router};
-use synd_term::auth::device_flow::{DeviceAuthorizationRequest, DeviceAuthorizationResponse};
+use synd_authn::device_flow::{DeviceAuthorizationRequest, DeviceAuthorizationResponse};
 use tokio::net::TcpListener;
 
 async fn device_authorization(