···

       
46
       
 
       
}

     

       
47
       
 
       


     

       
48
       
 
       
#[derive(Debug, Error)]

     

       
49
       
-
       
#[error(transparent)]

     

       
50
       
-
       
pub struct AuthSetupError(#[from] atrium_oauth::Error);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
51
       
 
       


     

       
52
       
 
       
#[derive(Debug, Error)]

     

       
53
       
 
       
#[error(transparent)]

     
···

       
93
       
 
       
                http_client: http_client.clone(),

     

       
94
       
 
       
            })

     

       
95
       
 
       
        };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
96
       
 
       
        let client_config = OAuthClientConfig {

     

       
97
       
 
       
            client_metadata: AtprotoLocalhostClientMetadata {

     

       
98
       
 
       
                redirect_uris: Some(vec![String::from("http://127.0.0.1:9997/authorized")]),

     
···

       
102
       
 
       
            resolver: OAuthResolverConfig {

     

       
103
       
 
       
                did_resolver: did_resolver(),

     

       
104
       
 
       
                handle_resolver: AtprotoHandleResolver::new(AtprotoHandleResolverConfig {

     

       
105
       
-
       
                    dns_txt_resolver: HickoryDnsTxtResolver::default(),

     

       
106
       
 
       
                    http_client: Arc::clone(&http_client),

     

       
107
       
 
       
                }),

     

       
108
       
 
       
                authorization_server_metadata: Default::default(),

     
···

       
112
       
 
       
            session_store: MemorySessionStore::default(),

     

       
113
       
 
       
        };

     

       
114
       
 
       


     

       
115
       
-
       
        let client = OAuthClient::new(client_config)?;

     

       
116
       
 
       


     

       
117
       
 
       
        Ok(Self {

     

       
118
       
 
       
            client: Arc::new(client),

     
···

       
185
       
 
       
    }

     

       
186
       
 
       
}

     

       
187
       
 
       


     

       
188
       
-
       
pub struct HickoryDnsTxtResolver {

     

       
189
       
-
       
    resolver: TokioResolver,

     

       
190
       
-
       
}

     

       
191
       
 
       


     

       
192
       
-
       
impl Default for HickoryDnsTxtResolver {

     

       
193
       
-
       
    fn default() -> Self {

     

       
194
       
-
       
        Self {

     

       
195
       
-
       
            resolver: TokioResolver::builder_tokio()

     

       
196
       
-
       
                .expect("failed to create resolver")

     

       
197
       
-
       
                .build(),

     

       
198
       
-
       
        }

     

       
199
       
 
       
    }

     

       
200
       
 
       
}

     

       
201
       
 
       


     
···

       
205
       
 
       
        query: &str,

     

       
206
       
 
       
    ) -> core::result::Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {

     

       
207
       
 
       
        Ok(self

     

       
208
       
-
       
            .resolver

     

       
209
       
 
       
            .txt_lookup(query)

     

       
210
       
 
       
            .await?

     

       
211
       
 
       
            .iter()

     

···

       
46
       
 
       
}

     

       
47
       
 
       


     

       
48
       
 
       
#[derive(Debug, Error)]

     

       
49
       
+
       
pub enum AuthSetupError {

     

       
50
       
+
       
    #[error("failed to intiialize atrium client: {0}")]

     

       
51
       
+
       
    AtriumClientError(atrium_oauth::Error),

     

       
52
       
+
       
    #[error("failed to initialize hickory dns resolver: {0}")]

     

       
53
       
+
       
    HickoryResolverError(hickory_resolver::ResolveError),

     

       
54
       
+
       
}

     

       
55
       
 
       


     

       
56
       
 
       
#[derive(Debug, Error)]

     

       
57
       
 
       
#[error(transparent)]

     
···

       
97
       
 
       
                http_client: http_client.clone(),

     

       
98
       
 
       
            })

     

       
99
       
 
       
        };

     

       
100
       
+
       
        let dns_txt_resolver =

     

       
101
       
+
       
            HickoryDnsTxtResolver::new().map_err(AuthSetupError::HickoryResolverError)?;

     

       
102
       
 
       
        let client_config = OAuthClientConfig {

     

       
103
       
 
       
            client_metadata: AtprotoLocalhostClientMetadata {

     

       
104
       
 
       
                redirect_uris: Some(vec![String::from("http://127.0.0.1:9997/authorized")]),

     
···

       
108
       
 
       
            resolver: OAuthResolverConfig {

     

       
109
       
 
       
                did_resolver: did_resolver(),

     

       
110
       
 
       
                handle_resolver: AtprotoHandleResolver::new(AtprotoHandleResolverConfig {

     

       
111
       
+
       
                    dns_txt_resolver,

     

       
112
       
 
       
                    http_client: Arc::clone(&http_client),

     

       
113
       
 
       
                }),

     

       
114
       
 
       
                authorization_server_metadata: Default::default(),

     
···

       
118
       
 
       
            session_store: MemorySessionStore::default(),

     

       
119
       
 
       
        };

     

       
120
       
 
       


     

       
121
       
+
       
        let client = OAuthClient::new(client_config).map_err(AuthSetupError::AtriumClientError)?;

     

       
122
       
 
       


     

       
123
       
 
       
        Ok(Self {

     

       
124
       
 
       
            client: Arc::new(client),

     
···

       
191
       
 
       
    }

     

       
192
       
 
       
}

     

       
193
       
 
       


     

       
194
       
+
       
pub struct HickoryDnsTxtResolver(TokioResolver);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
195
       
 
       


     

       
196
       
+
       
impl HickoryDnsTxtResolver {

     

       
197
       
+
       
    fn new() -> Result<Self, hickory_resolver::ResolveError> {

     

       
198
       
+
       
        let resolver = TokioResolver::builder_tokio()?.build();

     

       
199
       
+
       
        Ok(Self(resolver))

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
200
       
 
       
    }

     

       
201
       
 
       
}

     

       
202
       
 
       


     
···

       
206
       
 
       
        query: &str,

     

       
207
       
 
       
    ) -> core::result::Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {

     

       
208
       
 
       
        Ok(self

     

       
209
       
+
       
            .0

     

       
210
       
 
       
            .txt_lookup(query)

     

       
211
       
 
       
            .await?

     

       
212
       
 
       
            .iter()