feat(http): persist cookies on disk

.changes/persist-cookies.md

@@ -0,0 +1,7 @@
+---
+"http": "patch"
+"http-js": "patch"
+---
+
+Persist cookies to disk and load it on next app start.
+

plugins/http/Cargo.toml

@@ -41,6 +41,8 @@ http = "1"
 reqwest = { version = "0.12", default-features = false }
 url = { workspace = true }
 data-url = "0.3"
+cookie_store = { version = "0.21.1", optional = true, features = ["serde"] }
+bytes = { version = "1.9", optional = true }
 tracing = { workspace = true, optional = true }
 
 [features]
@@ -62,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"]
+cookies = ["reqwest/cookies", "dep:cookie_store", "dep:bytes"]
 gzip = ["reqwest/gzip"]
 brotli = ["reqwest/brotli"]
 deflate = ["reqwest/deflate"]

plugins/http/src/lib.rs

@@ -14,25 +14,68 @@ 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: std::sync::Arc<reqwest::cookie::Jar>,
+    cookies_jar_path: std::path::PathBuf,
+    #[cfg(feature = "cookies")]
+    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 crate::reqwest_cookie_store::*;
+                use std::fs::File;
+                use std::io::BufReader;
+                use std::sync::Arc;
+
+                let cache_dir = app.path().app_cache_dir()?;
+                std::fs::create_dir_all(&cache_dir)?;
+
+                let path = cache_dir.join("Cookies");
+                let file = File::options()
+                    .create(true)
+                    .append(true)
+                    .read(true)
+                    .open(&path)?;
+
+                let reader = BufReader::new(file);
+                let store = CookieStoreMutex::load(reader).map_err(|e| e.to_string())?;
+
+                (path, Arc::new(store))
+            };
+
             let state = Http {
                 #[cfg(feature = "cookies")]
-                cookies_jar: std::sync::Arc::new(reqwest::cookie::Jar::default()),
+                cookies_jar_path,
+                #[cfg(feature = "cookies")]
+                cookies_jar,
             };
 
             app.manage(state);
 
             Ok(())
         })
+        .on_event(|app, event| {
+            #[cfg(feature = "cookies")]
+            if let tauri::RunEvent::Exit = event {
+                use std::fs::File;
+                use std::io::BufWriter;
+
+                let state = app.state::<Http>();
+
+                if let Ok(file) = File::create(&state.cookies_jar_path) {
+                    let mut writer = BufWriter::new(file);
+                    let _ = state.cookies_jar.save(&mut writer);
+                }
+            }
+        })
         .invoke_handler(tauri::generate_handler![
             commands::fetch,
             commands::fetch_cancel,

plugins/http/src/reqwest_cookie_store.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, serde_json::to_string)
+    }
+}
+
+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)
+    }
+}