inline reqwest_cookie_store to fix clippy

Author: amrbashir

Cargo.lock

@@ -41,7 +41,8 @@ http = "1"
 reqwest = { version = "0.12", default-features = false }
 url = { workspace = true }
 data-url = "0.3"
-reqwest_cookie_store = { version = "0.8", optional = true }
+cookie_store = { version = "0.21.1", optional = true, features = ["serde"] }
+bytes = { version = "1.9", optional = true }
 tracing = { workspace = true, optional = true }
 
 [features]
@@ -63,7 +64,7 @@ rustls-tls-manual-roots = ["reqwest/rustls-tls-manual-roots"]
 rustls-tls-webpki-roots = ["reqwest/rustls-tls-webpki-roots"]
 rustls-tls-native-roots = ["reqwest/rustls-tls-native-roots"]
 blocking = ["reqwest/blocking"]
-cookies = ["reqwest/cookies", "dep:reqwest_cookie_store"]
+cookies = ["reqwest/cookies", "dep:cookie_store", "dep:bytes"]
 gzip = ["reqwest/gzip"]
 brotli = ["reqwest/brotli"]
 deflate = ["reqwest/deflate"]

plugins/http/Cargo.toml

@@ -14,21 +14,23 @@ pub use error::{Error, Result};
 
 mod commands;
 mod error;
+#[cfg(feature = "cookies")]
+mod reqwest_cookie_store;
 mod scope;
 
 pub(crate) struct Http {
     #[cfg(feature = "cookies")]
     cookies_jar_path: std::path::PathBuf,
     #[cfg(feature = "cookies")]
-    cookies_jar: std::sync::Arc<reqwest_cookie_store::CookieStoreMutex>,
+    cookies_jar: std::sync::Arc<crate::reqwest_cookie_store::CookieStoreMutex>,
 }
 
 pub fn init<R: Runtime>() -> TauriPlugin<R> {
     Builder::<R>::new("http")
         .setup(|app, _| {
             #[cfg(feature = "cookies")]
             let (cookies_jar_path, cookies_jar) = {
-                use reqwest_cookie_store::*;
+                use crate::reqwest_cookie_store::*;
                 use std::fs::File;
                 use std::io::BufReader;
                 use std::sync::Arc;
@@ -44,9 +46,9 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
                     .open(&path)?;
 
                 let reader = BufReader::new(file);
-                let store = CookieStore::load_json(reader).map_err(|e| e.to_string())?;
+                let store = CookieStoreMutex::load(reader).map_err(|e| e.to_string())?;
 
-                (path, Arc::new(CookieStoreMutex::new(store)))
+                (path, Arc::new(store))
             };
 
             let state = Http {
@@ -69,9 +71,8 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
                 let state = app.state::<Http>();
 
                 if let Ok(file) = File::create(&state.cookies_jar_path) {
-                    let store = state.cookies_jar.lock().expect("poisoned cookie jar mutex");
                     let mut writer = BufWriter::new(file);
-                    let _ = store.save_json(&mut writer);
+                    let _ = state.cookies_jar.save(&mut writer);
                 }
             }
         })

plugins/http/src/lib.rs

@@ -0,0 +1,83 @@
+// taken from https://github.com/pfernie/reqwest_cookie_store/blob/2ec4afabcd55e24d3afe3f0626ee6dc97bed938d/src/lib.rs
+
+use std::sync::{Mutex, MutexGuard, PoisonError};
+
+use cookie_store::{CookieStore, RawCookie, RawCookieParseError};
+use reqwest::header::HeaderValue;
+use serde::{Deserialize, Serialize};
+
+fn set_cookies(
+    cookie_store: &mut CookieStore,
+    cookie_headers: &mut dyn Iterator<Item = &HeaderValue>,
+    url: &url::Url,
+) {
+    let cookies = cookie_headers.filter_map(|val| {
+        std::str::from_utf8(val.as_bytes())
+            .map_err(RawCookieParseError::from)
+            .and_then(RawCookie::parse)
+            .map(|c| c.into_owned())
+            .ok()
+    });
+    cookie_store.store_response_cookies(cookies, url);
+}
+
+fn cookies(cookie_store: &CookieStore, url: &url::Url) -> Option<HeaderValue> {
+    let s = cookie_store
+        .get_request_values(url)
+        .map(|(name, value)| format!("{}={}", name, value))
+        .collect::<Vec<_>>()
+        .join("; ");
+
+    if s.is_empty() {
+        return None;
+    }
+
+    HeaderValue::from_maybe_shared(bytes::Bytes::from(s)).ok()
+}
+
+/// A [`cookie_store::CookieStore`] wrapped internally by a [`std::sync::Mutex`], suitable for use in
+/// async/concurrent contexts.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CookieStoreMutex(Mutex<CookieStore>);
+
+impl Default for CookieStoreMutex {
+    /// Create a new, empty [`CookieStoreMutex`]
+    fn default() -> Self {
+        CookieStoreMutex::new(CookieStore::default())
+    }
+}
+
+impl CookieStoreMutex {
+    /// Create a new [`CookieStoreMutex`] from an existing [`cookie_store::CookieStore`].
+    pub const fn new(cookie_store: CookieStore) -> CookieStoreMutex {
+        CookieStoreMutex(Mutex::new(cookie_store))
+    }
+
+    /// Lock and get a handle to the contained [`cookie_store::CookieStore`].
+    pub fn lock(
+        &self,
+    ) -> Result<MutexGuard<'_, CookieStore>, PoisonError<MutexGuard<'_, CookieStore>>> {
+        self.0.lock()
+    }
+
+    pub fn load<R: std::io::BufRead>(reader: R) -> cookie_store::Result<CookieStoreMutex> {
+        cookie_store::serde::load(reader, |c| serde_json::from_str(c)).map(CookieStoreMutex::new)
+    }
+
+    pub fn save<W: std::io::Write>(&self, writer: &mut W) -> cookie_store::Result<()> {
+        let store = self.lock().expect("poisoned cookie jar mutex");
+        cookie_store::serde::save(&store, writer, |c| serde_json::to_string(c))
+    }
+}
+
+impl reqwest::cookie::CookieStore for CookieStoreMutex {
+    fn set_cookies(&self, cookie_headers: &mut dyn Iterator<Item = &HeaderValue>, url: &url::Url) {
+        let mut store = self.0.lock().unwrap();
+        set_cookies(&mut store, cookie_headers, url);
+    }
+
+    fn cookies(&self, url: &url::Url) -> Option<HeaderValue> {
+        let store = self.0.lock().unwrap();
+        cookies(&store, url)
+    }
+}