feat(http): add cookie feature for client

Cargo.toml

@@ -50,6 +50,7 @@ chrono = { version = "0.4", default-features = false, features = [
 clap = "4"
 colored = "2"
 cookie = "0.18"
+cookie_store = "0.21"
 dashmap = "6"
 dirs = "5"
 faststr = { version = "0.2.21", features = ["serde"] }

volo-http/Cargo.toml

@@ -75,6 +75,8 @@ tokio-native-tls = { workspace = true, optional = true }
 
 # cookie support
 cookie = { workspace = true, optional = true, features = ["percent-encode"] }
+cookie_store = { workspace = true, optional = true }
+url = { workspace = true, optional = true }
 
 # serde and form, query, json
 serde = { workspace = true, optional = true }
@@ -109,7 +111,7 @@ rustls = ["__tls", "dep:tokio-rustls", "volo/rustls"]
 native-tls = ["__tls", "dep:tokio-native-tls", "volo/native-tls"]
 native-tls-vendored = ["native-tls", "volo/native-tls-vendored"]
 
-cookie = ["dep:cookie"]
+cookie = ["dep:cookie", "dep:cookie_store", "dep:url"]
 
 __serde = ["dep:serde"] # a private feature for enabling `serde` by `serde_xxx`
 query = ["__serde", "dep:serde_urlencoded"]

volo-http/src/client/cookie.rs

@@ -0,0 +1,88 @@
+use std::sync::RwLock;
+
+use motore::{layer::Layer, Service};
+
+use crate::{
+    context::ClientContext,
+    error::ClientError,
+    request::{ClientRequest, RequestPartsExt},
+    response::ClientResponse,
+    utils::cookie::CookieStore,
+};
+
+pub struct CookieService<S> {
+    inner: S,
+    cookie_store: RwLock<CookieStore>,
+}
+
+impl<S> CookieService<S> {
+    fn new(inner: S, cookie_store: RwLock<CookieStore>) -> Self {
+        Self {
+            inner,
+            cookie_store,
+        }
+    }
+}
+
+impl<S, B> Service<ClientContext, ClientRequest<B>> for CookieService<S>
+where
+    S: Service<ClientContext, ClientRequest<B>, Response = ClientResponse, Error = ClientError>
+        + Send
+        + Sync
+        + 'static,
+    B: Send + 'static,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+
+    async fn call(
+        &self,
+        cx: &mut ClientContext,
+        mut req: ClientRequest<B>,
+    ) -> Result<Self::Response, Self::Error> {
+        let url = req.url();
+
+        let (mut parts, body) = req.into_parts();
+        if let Some(url) = &url {
+            if parts.headers.get(http::header::COOKIE).is_none() {
+                self.cookie_store
+                    .read()
+                    .unwrap()
+                    .add_cookie_header(&mut parts.headers, url);
+            }
+        }
+
+        req = ClientRequest::from_parts(parts, body);
+
+        let resp = self.inner.call(cx, req).await?;
+
+        if let Some(url) = &url {
+            self.cookie_store
+                .write()
+                .unwrap()
+                .with_response_headers(resp.headers(), url);
+        }
+
+        Ok(resp)
+    }
+}
+
+pub struct CookieLayer {
+    cookie_store: RwLock<CookieStore>,
+}
+
+impl CookieLayer {
+    pub fn new(cookie_store: CookieStore) -> Self {
+        Self {
+            cookie_store: RwLock::new(cookie_store),
+        }
+    }
+}
+
+impl<S> Layer<S> for CookieLayer {
+    type Service = CookieService<S>;
+
+    fn layer(self, inner: S) -> Self::Service {
+        CookieService::new(inner, self.cookie_store)
+    }
+}