+208

crates/common/src/config.rs

··· 10 10 pub data_dir: PathBuf, 11 11 pub database_url: String, 12 12 pub public_url: String, 13 13 + pub server_did: Option<String>, 14 14 + pub available_user_domains: Vec<String>, 15 15 + pub invite_code_required: bool, 16 16 + pub links: ServerLinksConfig, 17 17 + pub contact: ContactConfig, 13 18 pub blobs: BlobsConfig, 14 19 pub oauth: OAuthConfig, 15 20 pub iroh: IrohConfig, 16 21 } 17 22 23 23 + /// Optional privacy/ToS links surfaced by `com.atproto.server.describeServer`. 24 24 + #[derive(Debug, Clone, Deserialize, Default)] 25 25 + pub struct ServerLinksConfig { 26 26 + pub privacy_policy: Option<String>, 27 27 + pub terms_of_service: Option<String>, 28 28 + } 29 29 + 30 30 + /// Optional admin contact surfaced by `com.atproto.server.describeServer`. 31 31 + #[derive(Debug, Clone, Deserialize, Default)] 32 32 + pub struct ContactConfig { 33 33 + pub email: Option<String>, 34 34 + } 35 35 + 18 36 /// Stub for future blob storage configuration. 19 37 #[derive(Debug, Clone, Deserialize, Default)] 20 38 pub struct BlobsConfig {} ··· 35 53 pub(crate) data_dir: Option<String>, 36 54 pub(crate) database_url: Option<String>, 37 55 pub(crate) public_url: Option<String>, 56 56 + pub(crate) server_did: Option<String>, 57 57 + pub(crate) available_user_domains: Option<Vec<String>>, 58 58 + pub(crate) invite_code_required: Option<bool>, 59 59 + #[serde(default)] 60 60 + pub(crate) links: ServerLinksConfig, 61 61 + #[serde(default)] 62 62 + pub(crate) contact: ContactConfig, 38 63 #[serde(default)] 39 64 pub(crate) blobs: BlobsConfig, 40 65 #[serde(default)] ··· 84 109 if let Some(v) = env.get("EZPDS_PUBLIC_URL") { 85 110 raw.public_url = Some(v.clone()); 86 111 } 112 112 + if let Some(v) = env.get("EZPDS_SERVER_DID") { 113 113 + raw.server_did = Some(v.clone()); 114 114 + } 115 115 + if let Some(v) = env.get("EZPDS_INVITE_CODE_REQUIRED") { 116 116 + raw.invite_code_required = Some(v.parse::<bool>().map_err(|e| { 117 117 + ConfigError::Invalid(format!( 118 118 + "EZPDS_INVITE_CODE_REQUIRED is not a valid boolean: '{v}': {e}" 119 119 + )) 120 120 + })?); 121 121 + } 122 122 + if let Some(v) = env.get("EZPDS_AVAILABLE_USER_DOMAINS") { 123 123 + raw.available_user_domains = Some( 124 124 + v.split(',') 125 125 + .map(str::trim) 126 126 + .filter(|s| !s.is_empty()) 127 127 + .map(str::to_string) 128 128 + .collect(), 129 129 + ); 130 130 + } 87 131 Ok(raw) 88 132 } 89 133 ··· 115 159 let public_url = raw.public_url.ok_or(ConfigError::MissingField { 116 160 field: "public_url", 117 161 })?; 162 162 + let available_user_domains = raw.available_user_domains.unwrap_or_default(); 163 163 + if available_user_domains.is_empty() { 164 164 + return Err(ConfigError::MissingField { 165 165 + field: "available_user_domains", 166 166 + }); 167 167 + } 168 168 + let invite_code_required = raw.invite_code_required.unwrap_or(true); 118 169 119 170 Ok(Config { 120 171 bind_address, ··· 122 173 data_dir, 123 174 database_url, 124 175 public_url, 176 176 + server_did: raw.server_did, 177 177 + available_user_domains, 178 178 + invite_code_required, 179 179 + links: raw.links, 180 180 + contact: raw.contact, 125 181 blobs: raw.blobs, 126 182 oauth: raw.oauth, 127 183 iroh: raw.iroh, ··· 136 192 RawConfig { 137 193 data_dir: Some("/var/pds".to_string()), 138 194 public_url: Some("https://pds.example.com".to_string()), 195 195 + available_user_domains: Some(vec!["example.com".to_string()]), 139 196 ..Default::default() 140 197 } 141 198 } ··· 145 202 let toml = r#" 146 203 data_dir = "/var/pds" 147 204 public_url = "https://pds.example.com" 205 205 + available_user_domains = ["example.com"] 148 206 "#; 149 207 let raw: RawConfig = toml::from_str(toml).unwrap(); 150 208 let config = validate_and_build(raw).unwrap(); ··· 164 222 data_dir = "/data" 165 223 database_url = "sqlite:///data/custom.db" 166 224 public_url = "https://pds.example.com" 225 225 + available_user_domains = ["example.com"] 167 226 "#; 168 227 let raw: RawConfig = toml::from_str(toml).unwrap(); 169 228 let config = validate_and_build(raw).unwrap(); ··· 179 238 let toml = r#" 180 239 data_dir = "/var/pds" 181 240 public_url = "https://pds.example.com" 241 241 + available_user_domains = ["example.com"] 182 242 183 243 [blobs] 184 244 ··· 214 274 data_dir = "/var/pds" 215 275 port = 3000 216 276 public_url = "https://pds.example.com" 277 277 + available_user_domains = ["example.com"] 217 278 "#; 218 279 let raw: RawConfig = toml::from_str(toml).unwrap(); 219 280 let env = HashMap::from([("EZPDS_PORT".to_string(), "9999".to_string())]); ··· 236 297 ( 237 298 "EZPDS_PUBLIC_URL".to_string(), 238 299 "https://pds.test".to_string(), 300 300 + ), 301 301 + ( 302 302 + "EZPDS_AVAILABLE_USER_DOMAINS".to_string(), 303 303 + "pds.test".to_string(), 239 304 ), 240 305 ]); 241 306 let raw = apply_env_overrides(RawConfig::default(), &env).unwrap(); ··· 286 351 field: "public_url" 287 352 } 288 353 )); 354 354 + } 355 355 + 356 356 + // --- describeServer config fields --- 357 357 + 358 358 + #[test] 359 359 + fn parses_describe_server_fields_from_toml() { 360 360 + let toml = r#" 361 361 + data_dir = "/var/pds" 362 362 + public_url = "https://pds.example.com" 363 363 + server_did = "did:plc:abc123" 364 364 + available_user_domains = ["pds.example.com", "alt.example.com"] 365 365 + invite_code_required = false 366 366 + 367 367 + [links] 368 368 + privacy_policy = "https://example.com/privacy" 369 369 + terms_of_service = "https://example.com/tos" 370 370 + 371 371 + [contact] 372 372 + email = "admin@example.com" 373 373 + "#; 374 374 + let raw: RawConfig = toml::from_str(toml).unwrap(); 375 375 + let config = validate_and_build(raw).unwrap(); 376 376 + 377 377 + assert_eq!(config.server_did.as_deref(), Some("did:plc:abc123")); 378 378 + assert_eq!( 379 379 + config.available_user_domains, 380 380 + vec!["pds.example.com", "alt.example.com"] 381 381 + ); 382 382 + assert!(!config.invite_code_required); 383 383 + assert_eq!( 384 384 + config.links.privacy_policy.as_deref(), 385 385 + Some("https://example.com/privacy") 386 386 + ); 387 387 + assert_eq!( 388 388 + config.links.terms_of_service.as_deref(), 389 389 + Some("https://example.com/tos") 390 390 + ); 391 391 + assert_eq!(config.contact.email.as_deref(), Some("admin@example.com")); 392 392 + } 393 393 + 394 394 + #[test] 395 395 + fn available_user_domains_missing_returns_error() { 396 396 + let raw = RawConfig { 397 397 + data_dir: Some("/var/pds".to_string()), 398 398 + public_url: Some("https://pds.example.com".to_string()), 399 399 + ..Default::default() 400 400 + }; 401 401 + let err = validate_and_build(raw).unwrap_err(); 402 402 + 403 403 + assert!(matches!( 404 404 + err, 405 405 + ConfigError::MissingField { 406 406 + field: "available_user_domains" 407 407 + } 408 408 + )); 409 409 + } 410 410 + 411 411 + #[test] 412 412 + fn available_user_domains_empty_returns_error() { 413 413 + let raw = RawConfig { 414 414 + data_dir: Some("/var/pds".to_string()), 415 415 + public_url: Some("https://pds.example.com".to_string()), 416 416 + available_user_domains: Some(vec![]), 417 417 + ..Default::default() 418 418 + }; 419 419 + let err = validate_and_build(raw).unwrap_err(); 420 420 + 421 421 + assert!(matches!( 422 422 + err, 423 423 + ConfigError::MissingField { 424 424 + field: "available_user_domains" 425 425 + } 426 426 + )); 427 427 + } 428 428 + 429 429 + #[test] 430 430 + fn invite_code_required_defaults_to_true() { 431 431 + let config = validate_and_build(minimal_raw()).unwrap(); 432 432 + assert!(config.invite_code_required); 433 433 + } 434 434 + 435 435 + #[test] 436 436 + fn server_did_is_optional() { 437 437 + let config = validate_and_build(minimal_raw()).unwrap(); 438 438 + assert!(config.server_did.is_none()); 439 439 + } 440 440 + 441 441 + #[test] 442 442 + fn links_section_optional() { 443 443 + let config = validate_and_build(minimal_raw()).unwrap(); 444 444 + assert!(config.links.privacy_policy.is_none()); 445 445 + assert!(config.links.terms_of_service.is_none()); 446 446 + } 447 447 + 448 448 + #[test] 449 449 + fn contact_section_optional() { 450 450 + let config = validate_and_build(minimal_raw()).unwrap(); 451 451 + assert!(config.contact.email.is_none()); 452 452 + } 453 453 + 454 454 + #[test] 455 455 + fn env_override_server_did() { 456 456 + let env = HashMap::from([("EZPDS_SERVER_DID".to_string(), "did:plc:xyz".to_string())]); 457 457 + let raw = apply_env_overrides(minimal_raw(), &env).unwrap(); 458 458 + let config = validate_and_build(raw).unwrap(); 459 459 + 460 460 + assert_eq!(config.server_did.as_deref(), Some("did:plc:xyz")); 461 461 + } 462 462 + 463 463 + #[test] 464 464 + fn env_override_invite_code_required_false() { 465 465 + let env = HashMap::from([( 466 466 + "EZPDS_INVITE_CODE_REQUIRED".to_string(), 467 467 + "false".to_string(), 468 468 + )]); 469 469 + let raw = apply_env_overrides(minimal_raw(), &env).unwrap(); 470 470 + let config = validate_and_build(raw).unwrap(); 471 471 + 472 472 + assert!(!config.invite_code_required); 473 473 + } 474 474 + 475 475 + #[test] 476 476 + fn env_override_invite_code_required_invalid_returns_error() { 477 477 + let env = HashMap::from([( 478 478 + "EZPDS_INVITE_CODE_REQUIRED".to_string(), 479 479 + "maybe".to_string(), 480 480 + )]); 481 481 + let err = apply_env_overrides(minimal_raw(), &env).unwrap_err(); 482 482 + 483 483 + assert!(matches!(err, ConfigError::Invalid(_))); 484 484 + assert!(err.to_string().contains("EZPDS_INVITE_CODE_REQUIRED")); 485 485 + } 486 486 + 487 487 + #[test] 488 488 + fn env_override_available_user_domains_comma_separated() { 489 489 + let env = HashMap::from([( 490 490 + "EZPDS_AVAILABLE_USER_DOMAINS".to_string(), 491 491 + "foo.com, bar.com".to_string(), 492 492 + )]); 493 493 + let raw = apply_env_overrides(minimal_raw(), &env).unwrap(); 494 494 + let config = validate_and_build(raw).unwrap(); 495 495 + 496 496 + assert_eq!(config.available_user_domains, vec!["foo.com", "bar.com"]); 289 497 } 290 498 }

+4 -2

crates/common/src/config_loader.rs

··· 60 60 writeln!( 61 61 tmp, 62 62 r#"data_dir = "/var/pds" 63 63 - public_url = "https://pds.example.com""# 63 63 + public_url = "https://pds.example.com" 64 64 + available_user_domains = ["example.com"]"# 64 65 ) 65 66 .unwrap(); 66 67 ··· 90 91 writeln!( 91 92 tmp, 92 93 r#"data_dir = "/var/pds" 93 93 - public_url = "https://pds.example.com""# 94 94 + public_url = "https://pds.example.com" 95 95 + available_user_domains = ["example.com"]"# 94 96 ) 95 97 .unwrap(); 96 98 let env = HashMap::from([("EZPDS_PORT".to_string(), "9999".to_string())]);

+3 -1

crates/common/src/lib.rs

··· 2 2 mod config_loader; 3 3 mod error; 4 4 5 5 - pub use config::{BlobsConfig, Config, ConfigError, IrohConfig, OAuthConfig}; 5 5 + pub use config::{ 6 6 + BlobsConfig, Config, ConfigError, ContactConfig, IrohConfig, OAuthConfig, ServerLinksConfig, 7 7 + }; 6 8 pub use config_loader::load_config; 7 9 pub use error::{ApiError, ErrorCode};

+10

crates/relay/src/app.rs

··· 4 4 use common::{ApiError, Config, ErrorCode}; 5 5 use tower_http::{cors::CorsLayer, trace::TraceLayer}; 6 6 7 7 + use crate::routes::describe_server::describe_server; 7 8 use crate::routes::health::health; 8 9 9 10 /// Shared application state cloned into every request handler via Axum's `State` extractor. ··· 21 22 pub fn app(state: AppState) -> Router { 22 23 Router::new() 23 24 .route("/xrpc/_health", get(health)) 25 25 + .route( 26 26 + "/xrpc/com.atproto.server.describeServer", 27 27 + get(describe_server), 28 28 + ) 24 29 .route("/xrpc/:method", get(xrpc_handler).post(xrpc_handler)) 25 30 .layer(CorsLayer::permissive()) 26 31 .layer(TraceLayer::new_for_http()) ··· 58 63 data_dir: PathBuf::from("/tmp"), 59 64 database_url: "sqlite::memory:".to_string(), 60 65 public_url: "https://test.example.com".to_string(), 66 66 + server_did: None, 67 67 + available_user_domains: vec!["test.example.com".to_string()], 68 68 + invite_code_required: true, 69 69 + links: common::ServerLinksConfig::default(), 70 70 + contact: common::ContactConfig::default(), 61 71 blobs: BlobsConfig::default(), 62 72 oauth: OAuthConfig::default(), 63 73 iroh: IrohConfig::default(),

+260

crates/relay/src/routes/describe_server.rs

··· 1 1 + // pattern: Imperative Shell 2 2 + // 3 3 + // Gathers: server metadata from config 4 4 + // Processes: none (response shape maps 1:1 from config fields) 5 5 + // Returns: JSON matching com.atproto.server.describeServer Lexicon 6 6 + 7 7 + use axum::{ 8 8 + extract::State, 9 9 + response::{IntoResponse, Json}, 10 10 + }; 11 11 + use serde::Serialize; 12 12 + 13 13 + use crate::app::AppState; 14 14 + 15 15 + #[derive(Serialize)] 16 16 + #[serde(rename_all = "camelCase")] 17 17 + struct DescribeServerResponse { 18 18 + did: String, 19 19 + available_user_domains: Vec<String>, 20 20 + invite_code_required: bool, 21 21 + phone_verification_required: bool, 22 22 + #[serde(skip_serializing_if = "Option::is_none")] 23 23 + links: Option<ServerLinks>, 24 24 + #[serde(skip_serializing_if = "Option::is_none")] 25 25 + contact: Option<Contact>, 26 26 + } 27 27 + 28 28 + #[derive(Serialize)] 29 29 + #[serde(rename_all = "camelCase")] 30 30 + struct ServerLinks { 31 31 + #[serde(skip_serializing_if = "Option::is_none")] 32 32 + privacy_policy: Option<String>, 33 33 + #[serde(skip_serializing_if = "Option::is_none")] 34 34 + terms_of_service: Option<String>, 35 35 + } 36 36 + 37 37 + #[derive(Serialize)] 38 38 + struct Contact { 39 39 + #[serde(skip_serializing_if = "Option::is_none")] 40 40 + email: Option<String>, 41 41 + } 42 42 + 43 43 + /// Resolve the DID to return in the `did` field. 44 44 + /// 45 45 + /// The ATProto Lexicon marks `did` as required, but in Wave 1 the server DID may not be 46 46 + /// configured — DID generation is deferred to Wave 3. This function decides what to surface 47 47 + /// in the meantime. 48 48 + /// 49 49 + /// TODO: implement this function (5-10 lines). 50 50 + /// 51 51 + /// Parameters: 52 52 + /// - `server_did`: the configured `server_did` value, if any 53 53 + /// - `public_url`: the server's configured public URL (e.g. "https://pds.example.com") 54 54 + /// 55 55 + /// Consider the trade-offs: 56 56 + /// - Returning `""` is the simplest option; the Bluesky app tolerates it during initial setup 57 57 + /// - Deriving `did:web:<hostname>` from `public_url` is a valid DID and more semantically correct 58 58 + /// - Whatever you choose becomes the pattern for how Wave 3 replaces the placeholder 59 59 + fn resolve_did(server_did: &Option<String>, public_url: &str) -> String { 60 60 + if let Some(did) = server_did { 61 61 + return did.clone(); 62 62 + } 63 63 + let host = public_url 64 64 + .strip_prefix("https://") 65 65 + .or_else(|| public_url.strip_prefix("http://")) 66 66 + .unwrap_or(public_url) 67 67 + .split('/') 68 68 + .next() 69 69 + .unwrap_or(""); 70 70 + format!("did:web:{host}") 71 71 + } 72 72 + 73 73 + pub async fn describe_server(State(state): State<AppState>) -> impl IntoResponse { 74 74 + let config = &state.config; 75 75 + 76 76 + let links = if config.links.privacy_policy.is_some() || config.links.terms_of_service.is_some() 77 77 + { 78 78 + Some(ServerLinks { 79 79 + privacy_policy: config.links.privacy_policy.clone(), 80 80 + terms_of_service: config.links.terms_of_service.clone(), 81 81 + }) 82 82 + } else { 83 83 + None 84 84 + }; 85 85 + 86 86 + let contact = config.contact.email.as_ref().map(|email| Contact { 87 87 + email: Some(email.clone()), 88 88 + }); 89 89 + 90 90 + Json(DescribeServerResponse { 91 91 + did: resolve_did(&config.server_did, &config.public_url), 92 92 + available_user_domains: config.available_user_domains.clone(), 93 93 + invite_code_required: config.invite_code_required, 94 94 + phone_verification_required: false, 95 95 + links, 96 96 + contact, 97 97 + }) 98 98 + } 99 99 + 100 100 + #[cfg(test)] 101 101 + mod tests { 102 102 + use axum::{ 103 103 + body::Body, 104 104 + http::{Request, StatusCode}, 105 105 + }; 106 106 + use tower::ServiceExt; 107 107 + 108 108 + use crate::app::{app, test_state}; 109 109 + 110 110 + #[test] 111 111 + fn resolve_did_returns_configured_did() { 112 112 + let did = super::resolve_did(&Some("did:plc:abc123".to_string()), "https://pds.example.com"); 113 113 + assert_eq!(did, "did:plc:abc123"); 114 114 + } 115 115 + 116 116 + #[test] 117 117 + fn resolve_did_derives_did_web_from_public_url() { 118 118 + let did = super::resolve_did(&None, "https://pds.example.com"); 119 119 + assert_eq!(did, "did:web:pds.example.com"); 120 120 + } 121 121 + 122 122 + #[test] 123 123 + fn resolve_did_did_web_strips_path() { 124 124 + let did = super::resolve_did(&None, "https://pds.example.com/some/path"); 125 125 + assert_eq!(did, "did:web:pds.example.com"); 126 126 + } 127 127 + 128 128 + #[tokio::test] 129 129 + async fn describe_server_returns_200() { 130 130 + let response = app(test_state().await) 131 131 + .oneshot( 132 132 + Request::builder() 133 133 + .uri("/xrpc/com.atproto.server.describeServer") 134 134 + .body(Body::empty()) 135 135 + .unwrap(), 136 136 + ) 137 137 + .await 138 138 + .unwrap(); 139 139 + 140 140 + assert_eq!(response.status(), StatusCode::OK); 141 141 + } 142 142 + 143 143 + #[tokio::test] 144 144 + async fn describe_server_has_json_content_type() { 145 145 + let response = app(test_state().await) 146 146 + .oneshot( 147 147 + Request::builder() 148 148 + .uri("/xrpc/com.atproto.server.describeServer") 149 149 + .body(Body::empty()) 150 150 + .unwrap(), 151 151 + ) 152 152 + .await 153 153 + .unwrap(); 154 154 + 155 155 + assert_eq!( 156 156 + response.headers().get("content-type").unwrap(), 157 157 + "application/json" 158 158 + ); 159 159 + } 160 160 + 161 161 + #[tokio::test] 162 162 + async fn describe_server_available_user_domains_from_config() { 163 163 + let response = app(test_state().await) 164 164 + .oneshot( 165 165 + Request::builder() 166 166 + .uri("/xrpc/com.atproto.server.describeServer") 167 167 + .body(Body::empty()) 168 168 + .unwrap(), 169 169 + ) 170 170 + .await 171 171 + .unwrap(); 172 172 + 173 173 + let body = axum::body::to_bytes(response.into_body(), 4096) 174 174 + .await 175 175 + .unwrap(); 176 176 + let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 177 177 + 178 178 + assert_eq!(json["availableUserDomains"][0], "test.example.com"); 179 179 + } 180 180 + 181 181 + #[tokio::test] 182 182 + async fn describe_server_invite_code_required_from_config() { 183 183 + let response = app(test_state().await) 184 184 + .oneshot( 185 185 + Request::builder() 186 186 + .uri("/xrpc/com.atproto.server.describeServer") 187 187 + .body(Body::empty()) 188 188 + .unwrap(), 189 189 + ) 190 190 + .await 191 191 + .unwrap(); 192 192 + 193 193 + let body = axum::body::to_bytes(response.into_body(), 4096) 194 194 + .await 195 195 + .unwrap(); 196 196 + let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 197 197 + 198 198 + assert!(json["inviteCodeRequired"].as_bool().unwrap()); 199 199 + } 200 200 + 201 201 + #[tokio::test] 202 202 + async fn describe_server_phone_verification_required_is_false() { 203 203 + let response = app(test_state().await) 204 204 + .oneshot( 205 205 + Request::builder() 206 206 + .uri("/xrpc/com.atproto.server.describeServer") 207 207 + .body(Body::empty()) 208 208 + .unwrap(), 209 209 + ) 210 210 + .await 211 211 + .unwrap(); 212 212 + 213 213 + let body = axum::body::to_bytes(response.into_body(), 4096) 214 214 + .await 215 215 + .unwrap(); 216 216 + let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 217 217 + 218 218 + assert!(!json["phoneVerificationRequired"].as_bool().unwrap()); 219 219 + } 220 220 + 221 221 + #[tokio::test] 222 222 + async fn describe_server_omits_links_when_not_configured() { 223 223 + let response = app(test_state().await) 224 224 + .oneshot( 225 225 + Request::builder() 226 226 + .uri("/xrpc/com.atproto.server.describeServer") 227 227 + .body(Body::empty()) 228 228 + .unwrap(), 229 229 + ) 230 230 + .await 231 231 + .unwrap(); 232 232 + 233 233 + let body = axum::body::to_bytes(response.into_body(), 4096) 234 234 + .await 235 235 + .unwrap(); 236 236 + let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 237 237 + 238 238 + assert!(json.get("links").is_none()); 239 239 + } 240 240 + 241 241 + #[tokio::test] 242 242 + async fn describe_server_omits_contact_when_not_configured() { 243 243 + let response = app(test_state().await) 244 244 + .oneshot( 245 245 + Request::builder() 246 246 + .uri("/xrpc/com.atproto.server.describeServer") 247 247 + .body(Body::empty()) 248 248 + .unwrap(), 249 249 + ) 250 250 + .await 251 251 + .unwrap(); 252 252 + 253 253 + let body = axum::body::to_bytes(response.into_body(), 4096) 254 254 + .await 255 255 + .unwrap(); 256 256 + let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 257 257 + 258 258 + assert!(json.get("contact").is_none()); 259 259 + } 260 260 + }

+1

crates/relay/src/routes/mod.rs

··· 1 1 + pub mod describe_server; 1 2 pub mod health;

+16

relay.dev.toml

··· 11 11 bind_address = "127.0.0.1" 12 12 port = 8080 13 13 database_url = ":memory:" 14 14 + 15 15 + # Required: at least one handle domain your PDS serves (e.g. ["your.domain"]) 16 16 + available_user_domains = [] 17 17 + invite_code_required = true 18 18 + 19 19 + # Optional: set to your server's DID once generated in Wave 3 20 20 + # server_did = "did:plc:..." 21 21 + 22 22 + # Optional: legal links 23 23 + # [links] 24 24 + # privacy_policy = "https://example.com/privacy" 25 25 + # terms_of_service = "https://example.com/tos" 26 26 + 27 27 + # Optional: admin contact 28 28 + # [contact] 29 29 + # email = "admin@example.com"