some atrium oauth stuff

Cargo.lock

···
  "atrium-xrpc",
  "atrium-xrpc-client",
  "esquema-codegen",
+ "hickory-resolver",
  "http",
  "libsqlite3-sys",
  "markdown-weaver",

crates/weaver-common/Cargo.toml

···
 markdown-weaver = { workspace = true }
 libsqlite3-sys = { version = "0.33.0", features = ["bundled"] }
 
-atrium-api = "0.25.2"
+http = "1.3.1"
+
+atrium-xrpc = "0.12.3"
+atrium-api =  "0.25.3"
 atrium-common = "0.1.1"
 atrium-identity = "0.1.3"
 atrium-oauth = "0.1.1"
···
 serde_json = { version = "1.0.140", features = ["preserve_order", "raw_value"] }
 serde_ipld_dagcbor = { version = "0.6.1", features = ["codec"] }
 serde_cbor = "0.11.2"
+serde_html_form = "0.2.7"
+serde_bytes = "0.11.17"
 
 minijinja = { workspace = true, features = [
   "builtins",
···
 owo-colors = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
+hickory-resolver = "0.24.1"
 
-http = "1.3.1"
-serde_html_form = "0.2.7"
-serde_bytes = "0.11.17"
-atrium-xrpc = "0.12.3"
+
 
 
 [dev-dependencies]

crates/weaver-common/src/lib.rs

···
-pub use merde::CowStr;
-
 pub mod error;
 pub mod lexicons;
+pub mod oauth;
 pub use lexicons::*;
+
+use atrium_identity::handle::DnsTxtResolver;
 
 pub use crate::error::{Error, IoError, ParseError, SerDeError};
+
+/// Canonical Cow for us, thanks Amos
+pub use merde::CowStr;
+
+use hickory_resolver::TokioAsyncResolver;
 
 /// too many cows, so we have conversions
 pub fn mcow_to_cow(cow: CowStr<'_>) -> std::borrow::Cow<'_, str> {
···
         markdown_weaver::CowStr::Inlined(s) => std::borrow::Cow::Owned(s.as_ref().to_owned()),
     }
 }
+
+pub struct HickoryDnsTxtResolver {
+    resolver: TokioAsyncResolver,
+}
+
+impl Default for HickoryDnsTxtResolver {
+    fn default() -> Self {
+        Self {
+            resolver: TokioAsyncResolver::tokio_from_system_conf()
+                .expect("failed to create resolver"),
+        }
+    }
+}
+
+impl DnsTxtResolver for HickoryDnsTxtResolver {
+    async fn resolve(
+        &self,
+        query: &str,
+    ) -> core::result::Result<Vec<String>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+        Ok(self
+            .resolver
+            .txt_lookup(query)
+            .await?
+            .iter()
+            .map(|txt| txt.to_string())
+            .collect())
+    }
+}

crates/weaver-common/src/oauth.rs

···
+use atrium_api::types::string::Did;
+use atrium_common::store::memory::MemoryStore;
+use atrium_identity::{
+    did::{CommonDidResolver, CommonDidResolverConfig, DEFAULT_PLC_DIRECTORY_URL},
+    handle::{AtprotoHandleResolver, AtprotoHandleResolverConfig},
+};
+use atrium_oauth::{
+    AtprotoLocalhostClientMetadata, DefaultHttpClient, KnownScope, OAuthClient, OAuthClientConfig,
+    OAuthResolverConfig, Scope,
+    store::{
+        session::{MemorySessionStore, Session},
+        state::{InternalStateData, MemoryStateStore},
+    },
+};
+
+use std::sync::Arc;
+
+use crate::HickoryDnsTxtResolver;
+
+pub fn default_oauth_client(
+    url: impl AsRef<str>,
+) -> Result<
+    atrium_oauth::OAuthClient<
+        MemoryStore<String, InternalStateData>,
+        MemoryStore<Did, Session>,
+        CommonDidResolver<DefaultHttpClient>,
+        AtprotoHandleResolver<HickoryDnsTxtResolver, DefaultHttpClient>,
+        DefaultHttpClient,
+    >,
+    atrium_oauth::Error,
+> {
+    let http_client = Arc::new(atrium_oauth::DefaultHttpClient::default());
+    let config = OAuthClientConfig {
+        client_metadata: AtprotoLocalhostClientMetadata {
+            redirect_uris: Some(vec![url.as_ref().to_string()]),
+            scopes: Some(vec![
+                Scope::Known(KnownScope::Atproto),
+                Scope::Known(KnownScope::TransitionGeneric),
+            ]),
+        },
+        keys: None,
+        resolver: OAuthResolverConfig {
+            did_resolver: CommonDidResolver::new(CommonDidResolverConfig {
+                plc_directory_url: DEFAULT_PLC_DIRECTORY_URL.to_string(),
+                http_client: Arc::clone(&http_client),
+            }),
+            handle_resolver: AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+                dns_txt_resolver: HickoryDnsTxtResolver::default(),
+                http_client: Arc::clone(&http_client),
+            }),
+            authorization_server_metadata: Default::default(),
+            protected_resource_metadata: Default::default(),
+        },
+        state_store: MemoryStateStore::default(),
+        session_store: MemorySessionStore::default(),
+    };
+    let client = OAuthClient::new(config)?;
+    Ok(client)
+}