url rework

Cargo.lock

···
  "serde_html_form",
  "serde_json",
  "sha2",
- "signature",
  "smol_str",
  "thiserror 2.0.17",
  "tokio",

Cargo.toml

···
 ipld-core = { version = "0.4.2", features = ["serde"] }
 multihash = "0.19"
 dashmap = "6.1"
-moka = "0.12"
 mini-moka = "0.10"
 
 # Proc macros

crates/jacquard-common/Cargo.toml

···
 futures-lite = "2.6"
 
 [package.metadata.docs.rs]
-features = [ "crypto-k256", "crypto-k256", "crypto-p256",  "websocket", "zstd", "service-auth", "reqwest-client", "crypto"]
+features = [ "crypto-k256", "crypto-ed22519", "crypto-p256",  "websocket", "zstd", "service-auth", "reqwest-client", "crypto"]

crates/jacquard-oauth/Cargo.toml

···
 serde_html_form = { workspace = true }
 miette = { workspace = true }
 p256 = { workspace = true, features = ["ecdsa"] }
-signature = "2"
 jose-jwa = "0.1"
 jose-jwk = { workspace = true, features = ["p256"] }
 chrono.workspace = true

crates/jacquard-oauth/src/atproto.rs

···
         #[derive(serde::Serialize)]
         struct Parameters<'a> {
             #[serde(skip_serializing_if = "Option::is_none")]
-            redirect_uri: Option<Vec<Url>>,
+            redirect_uri: Option<Vec<CowStr<'a>>>,
             #[serde(skip_serializing_if = "Option::is_none")]
             scope: Option<CowStr<'a>>,
         }
         let query = serde_html_form::to_string(Parameters {
-            redirect_uri: redirect_uris.clone(),
+            redirect_uri: redirect_uris.as_ref().map(|u| {
+                u.iter()
+                    .map(|u| u.as_str().trim_end_matches("/").to_cowstr().into_static())
+                    .collect()
+            }),
             scope: scopes
                 .as_ref()
                 .map(|s| Scope::serialize_multiple(s.as_slice())),
         })
         .ok();
-        let mut client_id = String::from("http://localhost");
+        let mut client_id = String::from("http://localhost/");
         if let Some(query) = query
             && !query.is_empty()
         {
···
             client_id: Url::parse(&client_id).unwrap(),
             client_uri: None,
             redirect_uris: redirect_uris.unwrap_or(vec![
-                Url::from_str("http://127.0.0.1/").unwrap(),
-                Url::from_str("http://[::1]/").unwrap(),
+                Url::from_str("http://127.0.0.1").unwrap(),
+                Url::from_str("http://[::1]").unwrap(),
             ]),
             grant_types: vec![GrantType::AuthorizationCode, GrantType::RefreshToken],
             scopes: scopes.unwrap_or(vec![Scope::Atproto]),
···
     } else {
         (AuthMethod::None, None, None)
     };
-
+    let client_id = metadata.client_id.as_str().trim_end_matches("/");
+    let client_uri = metadata
+        .client_uri
+        .map(|u| u.as_str().trim_end_matches("/").to_cowstr().into_static());
+    let redirect_uris = metadata
+        .redirect_uris
+        .iter()
+        .map(|u| u.as_str().trim_end_matches("/").to_cowstr().into_static())
+        .collect();
+    let jwks_uri = jwks_uri.map(|u| u.as_str().trim_end_matches("/").to_cowstr().into_static());
     Ok(OAuthClientMetadata {
-        client_id: metadata.client_id.to_cowstr().into_static(),
-        client_uri: metadata.client_uri.map(|u| u.to_cowstr().into_static()),
-        redirect_uris: metadata
-            .redirect_uris
-            .iter()
-            .map(|u| u.to_cowstr().into_static())
-            .collect(),
+        client_id: client_id.to_cowstr().into_static(),
+        client_uri,
+        redirect_uris,
         token_endpoint_auth_method: Some(auth_method.into()),
         grant_types: if keyset.is_some() {
             Some(metadata.grant_types.into_iter().map(|v| v.into()).collect())
···
         },
         scope: Some(Scope::serialize_multiple(metadata.scopes.as_slice())),
         dpop_bound_access_tokens: Some(true),
-        jwks_uri: jwks_uri.map(|u| u.to_cowstr().into_static()),
+        jwks_uri,
         jwks,
         token_endpoint_auth_signing_alg: if keyset.is_some() {
             Some(CowStr::new_static("ES256"))
···
                 client_id: CowStr::new_static("http://localhost"),
                 client_uri: None,
                 redirect_uris: vec![
-                    CowStr::new_static("http://127.0.0.1/"),
-                    CowStr::new_static("http://[::1]/"),
+                    CowStr::new_static("http://127.0.0.1"),
+                    CowStr::new_static("http://[::1]"),
                 ],
                 scope: Some(CowStr::new_static("atproto")),
                 grant_types: None,
···
             .expect("failed to convert metadata"),
             OAuthClientMetadata {
                 client_id: CowStr::new_static(
-                    "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%2Fcallback&redirect_uri=http%3A%2F%2F127.0.0.1%2Fcallback&scope=account%3Aemail+atproto+transition%3Ageneric"
+                    "http://localhost/?redirect_uri=http%3A%2F%2F127.0.0.1%2Fcallback&redirect_uri=http%3A%2F%2F127.0.0.1%2Fcallback&scope=account%3Aemail+atproto+transition%3Ageneric"
                 ),
                 client_uri: None,
                 redirect_uris: vec![
···
                 out,
                 OAuthClientMetadata {
                     client_id: CowStr::new_static(
-                        "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%2F"
+                        "http://localhost/?redirect_uri=http%3A%2F%2F127.0.0.1"
                     ),
                     client_uri: None,
                     redirect_uris: vec![CowStr::new_static("http://127.0.0.1")],
···
                 out,
                 OAuthClientMetadata {
                     client_id: CowStr::new_static(
-                        "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%3A8000%2F"
+                        "http://localhost/?redirect_uri=http%3A%2F%2F127.0.0.1%3A8000"
                     ),
                     client_uri: None,
                     redirect_uris: vec![CowStr::new_static("http://127.0.0.1:8000")],
···
                 out,
                 OAuthClientMetadata {
                     client_id: CowStr::new_static(
-                        "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%2F"
+                        "http://localhost/?redirect_uri=http%3A%2F%2F127.0.0.1"
                     ),
                     client_uri: None,
-                    redirect_uris: vec![CowStr::new_static("http://127.0.0.1/")],
+                    redirect_uris: vec![CowStr::new_static("http://127.0.0.1")],
                     scope: Some(CowStr::new_static("atproto")),
                     grant_types: None,
                     token_endpoint_auth_method: Some(AuthMethod::None.into()),

crates/jacquard-oauth/src/client.rs

···
 
     async fn set_base_uri(&self, url: Url) {
         let mut guard = self.data.write().await;
-        guard.host_url = url.to_cowstr().into_static();
+        guard.host_url = url.as_str().trim_end_matches("/").to_cowstr().into_static();
     }
 
     async fn send<R>(&self, request: R) -> XrpcResult<XrpcResponse<R>>

crates/jacquard-oauth/src/resolver.rs

···
 use http::{Request, StatusCode};
 use jacquard_common::CowStr;
 use jacquard_common::IntoStatic;
+use jacquard_common::cowstr::ToCowStr;
 use jacquard_common::types::did_doc::DidDocument;
 use jacquard_common::types::ident::AtIdentifier;
 use jacquard_common::{http_client::HttpClient, types::did::Did};
···
     // resolve to a DID)
     Ok(if input.starts_with("https://") {
         let url = Url::parse(input).map_err(|_| ResolverError::not_found())?;
-        (resolver.resolve_from_service(&url).await?, None)
+        (resolver.resolve_from_service(&url.to_cowstr()).await?, None)
     } else {
         let (metadata, identity) = resolver.resolve_from_identity(input).await?;
         (metadata, Some(identity))
···
         .map_err(|e| ResolverError::at_identifier(smol_str::format_smolstr!("{:?}", e)))?;
     let identity = resolver.resolve_ident_owned(&actor).await?;
     if let Some(pds) = &identity.pds_endpoint() {
-        let metadata = resolver.get_resource_server_metadata(pds).await?;
+        let metadata = resolver
+            .get_resource_server_metadata(&pds.to_cowstr())
+            .await?;
         Ok((metadata, identity))
     } else {
         Err(ResolverError::did_document("Did doc lacking pds"))
···
     issuer: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
     let mut md = resolve_authorization_server(client, issuer).await?;
-    md.issuer = issuer.into_static();
+    md.issuer = issuer.clone().into_static();
     Ok(md)
 }
 

crates/jacquard/Cargo.toml

···
 bytes.workspace = true
 http.workspace = true
 miette = { workspace = true }
-reqwest = { workspace = true, features = ["charset", "json", "gzip"] }
+reqwest = { workspace = true, features = ["json", "gzip"] }
 serde.workspace = true
 serde_html_form.workspace = true
 serde_json.workspace = true

crates/jacquard/src/client.rs

···
             let base_uri = self.base_uri().await;
             let base_uri = Url::parse(&base_uri).expect("base_uri should be valid url");
             self.resolver
-                .xrpc(base_uri.clone())
+                .xrpc(base_uri)
                 .with_options(opts.clone())
                 .send(&request)
                 .await
···
     {
         async move {
             let base_uri = self.base_uri().await;
+            let base_uri = Url::parse(&base_uri).expect("base_uri should be valid url");
             self.resolver
-                .xrpc(base_uri.clone())
+                .xrpc(base_uri)
                 .with_options(opts.clone())
                 .send(&request)
                 .await

crates/jacquard/src/client/credential_session.rs

···
         }
         // Activate
         *self.key.write().await = Some(key);
-        *self.endpoint.write().await = Some(pds.to_cowstr().into_static());
+        *self.endpoint.write().await =
+            Some(pds.as_str().trim_end_matches("/").to_cowstr().into_static());
 
         Ok(session)
     }
···
 
     async fn set_base_uri(&self, url: Url) {
         let mut guard = self.endpoint.write().await;
-        *guard = Some(url.to_cowstr().into_static());
+        *guard = Some(url.as_str().trim_end_matches("/").to_cowstr().into_static());
     }
 
     async fn send<R>(&self, request: R) -> XrpcResult<XrpcResponse<R>>

crates/jacquard/tests/credential_session.rs

···
     let session = CredentialSession::new(store.clone(), client.clone());
 
     // Before login, default endpoint should be public appview
-    assert_eq!(
-        session.endpoint().await.as_str(),
-        "https://public.bsky.app/"
-    );
+    assert_eq!(session.endpoint().await.as_str(), "https://public.bsky.app");
 
     // Login using handle; resolves to PDS and persists session
     session
···
         .expect("login ok");
 
     // Endpoint switches to PDS
-    assert_eq!(session.endpoint().await.as_str(), "https://pds/");
+    assert_eq!(session.endpoint().await.as_str(), "https://pds");
 
     // Send a request that will first 401 (ExpiredToken), then refresh, then succeed
     let resp = session

rust-toolchain.toml

···
 [toolchain]
-channel = "stable"
+channel = "nightly"
 profile = "default"
 targets = [ "wasm32-unknown-unknown" ]