+10

api/.spectral.yaml

··· 1 1 + # Spectral linting for OpenAPI specs 2 2 + # 3 3 + # Usage: 4 4 + # spectral lint <path-to-openapi-spec> 5 5 + # spectral lint openapi.json --ruleset .spectral.yaml 6 6 + # 7 7 + # To lint the generated OpenAPI spec from the API: 8 8 + # curl "http://localhost:3000/xrpc/social.slices.slice.openapi?slice=at://did:plc:example/social.slices.slice/example" | spectral lint - 9 9 + # 10 10 + extends: ["spectral:oas"]

+985

api/src/handler_openapi_spec.rs

··· 1 1 + use axum::{ 2 2 + extract::{Query, State}, 3 3 + http::StatusCode, 4 4 + response::Json, 5 5 + }; 6 6 + use serde::{Deserialize, Serialize}; 7 7 + use std::collections::HashMap; 8 8 + 9 9 + use crate::AppState; 10 10 + 11 11 + #[derive(Deserialize)] 12 12 + pub struct OpenApiParams { 13 13 + pub slice: String, 14 14 + } 15 15 + 16 16 + #[derive(Serialize, Clone)] 17 17 + pub struct OpenApiSpec { 18 18 + openapi: String, 19 19 + info: OpenApiInfo, 20 20 + servers: Vec<OpenApiServer>, 21 21 + paths: HashMap<String, HashMap<String, OpenApiOperation>>, 22 22 + components: OpenApiComponents, 23 23 + } 24 24 + 25 25 + #[derive(Serialize, Clone)] 26 26 + pub struct OpenApiInfo { 27 27 + title: String, 28 28 + version: String, 29 29 + description: String, 30 30 + contact: OpenApiContact, 31 31 + } 32 32 + 33 33 + #[derive(Serialize, Clone)] 34 34 + pub struct OpenApiContact { 35 35 + name: String, 36 36 + url: String, 37 37 + } 38 38 + 39 39 + #[derive(Serialize, Clone)] 40 40 + pub struct OpenApiServer { 41 41 + url: String, 42 42 + description: String, 43 43 + } 44 44 + 45 45 + #[derive(Serialize, Clone)] 46 46 + pub struct OpenApiOperation { 47 47 + #[serde(rename = "operationId")] 48 48 + operation_id: String, 49 49 + summary: String, 50 50 + description: String, 51 51 + #[serde(skip_serializing_if = "Option::is_none")] 52 52 + parameters: Option<Vec<OpenApiParameter>>, 53 53 + #[serde(rename = "requestBody", skip_serializing_if = "Option::is_none")] 54 54 + request_body: Option<OpenApiRequestBody>, 55 55 + responses: HashMap<String, OpenApiResponse>, 56 56 + tags: Vec<String>, 57 57 + #[serde(skip_serializing_if = "Option::is_none")] 58 58 + security: Option<Vec<HashMap<String, Vec<String>>>>, 59 59 + } 60 60 + 61 61 + #[derive(Serialize, Clone)] 62 62 + pub struct OpenApiParameter { 63 63 + name: String, 64 64 + #[serde(rename = "in")] 65 65 + location: String, 66 66 + description: String, 67 67 + required: bool, 68 68 + schema: OpenApiSchema, 69 69 + #[serde(skip_serializing_if = "Option::is_none")] 70 70 + example: Option<String>, 71 71 + } 72 72 + 73 73 + #[derive(Serialize, Clone)] 74 74 + pub struct OpenApiRequestBody { 75 75 + description: String, 76 76 + content: HashMap<String, OpenApiMediaType>, 77 77 + required: bool, 78 78 + } 79 79 + 80 80 + #[derive(Serialize, Clone)] 81 81 + pub struct OpenApiMediaType { 82 82 + schema: OpenApiSchema, 83 83 + } 84 84 + 85 85 + #[derive(Serialize, Clone)] 86 86 + pub struct OpenApiResponse { 87 87 + description: String, 88 88 + #[serde(skip_serializing_if = "Option::is_none")] 89 89 + content: Option<HashMap<String, OpenApiMediaType>>, 90 90 + } 91 91 + 92 92 + #[derive(Serialize, Clone)] 93 93 + pub struct OpenApiSchema { 94 94 + #[serde(rename = "type")] 95 95 + schema_type: String, 96 96 + #[serde(skip_serializing_if = "Option::is_none")] 97 97 + format: Option<String>, 98 98 + #[serde(skip_serializing_if = "Option::is_none")] 99 99 + items: Option<Box<OpenApiSchema>>, 100 100 + #[serde(skip_serializing_if = "Option::is_none")] 101 101 + properties: Option<HashMap<String, OpenApiSchema>>, 102 102 + #[serde(skip_serializing_if = "Option::is_none")] 103 103 + required: Option<Vec<String>>, 104 104 + #[serde(skip_serializing_if = "Option::is_none")] 105 105 + default: Option<serde_json::Value>, 106 106 + } 107 107 + 108 108 + #[derive(Serialize, Clone)] 109 109 + pub struct OpenApiSecurityScheme { 110 110 + #[serde(rename = "type")] 111 111 + scheme_type: String, 112 112 + scheme: String, 113 113 + #[serde(rename = "bearerFormat", skip_serializing_if = "Option::is_none")] 114 114 + bearer_format: Option<String>, 115 115 + description: String, 116 116 + #[serde(skip_serializing_if = "Option::is_none")] 117 117 + example: Option<String>, 118 118 + } 119 119 + 120 120 + #[derive(Serialize, Clone)] 121 121 + pub struct OpenApiComponents { 122 122 + schemas: HashMap<String, OpenApiSchema>, 123 123 + #[serde(rename = "securitySchemes", skip_serializing_if = "Option::is_none")] 124 124 + security_schemes: Option<HashMap<String, OpenApiSecurityScheme>>, 125 125 + } 126 126 + 127 127 + pub async fn get_openapi_spec( 128 128 + State(state): State<AppState>, 129 129 + Query(params): Query<OpenApiParams>, 130 130 + ) -> Result<Json<OpenApiSpec>, StatusCode> { 131 131 + // Get collections for this slice 132 132 + let slice_collections = state 133 133 + .database 134 134 + .get_slice_collections_list(&params.slice) 135 135 + .await 136 136 + .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; 137 137 + 138 138 + if slice_collections.is_empty() { 139 139 + return Err(StatusCode::NOT_FOUND); 140 140 + } 141 141 + 142 142 + // Get lexicon definitions for this slice 143 143 + let mut collection_lexicons = HashMap::new(); 144 144 + if let Ok(lexicons) = state.database.get_lexicons_by_slice(&params.slice).await { 145 145 + for lexicon in lexicons { 146 146 + if let Some(nsid) = lexicon.get("nsid").and_then(|v| v.as_str()) { 147 147 + collection_lexicons.insert(nsid.to_string(), lexicon); 148 148 + } 149 149 + } 150 150 + } 151 151 + 152 152 + let mut paths = HashMap::new(); 153 153 + let mut schemas = HashMap::new(); 154 154 + 155 155 + // Create OpenAPI paths for each collection 156 156 + for collection in slice_collections { 157 157 + let lexicon_data = collection_lexicons.get(&collection); 158 158 + create_collection_paths(&collection, &params.slice, lexicon_data, &mut paths); 159 159 + create_collection_schemas(&collection, lexicon_data, &mut schemas); 160 160 + } 161 161 + 162 162 + let spec = OpenApiSpec { 163 163 + openapi: "3.0.3".to_string(), 164 164 + info: OpenApiInfo { 165 165 + title: format!("Slice API: {}", params.slice), 166 166 + version: "1.0.0".to_string(), 167 167 + description: format!("Dynamically generated OpenAPI specification for slice: {}", params.slice), 168 168 + contact: OpenApiContact { 169 169 + name: "Slice API".to_string(), 170 170 + url: "https://github.com/anthropics/slice".to_string(), 171 171 + }, 172 172 + }, 173 173 + servers: vec![OpenApiServer { 174 174 + url: "/xrpc".to_string(), 175 175 + description: "XRPC endpoint base".to_string(), 176 176 + }], 177 177 + paths, 178 178 + components: OpenApiComponents { 179 179 + schemas, 180 180 + security_schemes: Some(create_security_schemes()), 181 181 + }, 182 182 + }; 183 183 + 184 184 + Ok(Json(spec)) 185 185 + } 186 186 + 187 187 + fn create_collection_paths(collection: &str, slice_uri: &str, lexicon_data: Option<&serde_json::Value>, paths: &mut HashMap<String, HashMap<String, OpenApiOperation>>) { 188 188 + // List operation (GET) 189 189 + let list_path = format!("/{}.list", collection); 190 190 + let mut list_operations = HashMap::new(); 191 191 + list_operations.insert("get".to_string(), OpenApiOperation { 192 192 + operation_id: format!("list{}", collection.replace(".", "_")), 193 193 + summary: format!("List {} records", collection), 194 194 + description: format!("List records from the {} collection", collection), 195 195 + parameters: Some(vec![ 196 196 + OpenApiParameter { 197 197 + name: "slice".to_string(), 198 198 + location: "query".to_string(), 199 199 + description: "Slice URI to filter records by".to_string(), 200 200 + required: true, 201 201 + schema: string_schema_with_default(slice_uri), 202 202 + example: Some(slice_uri.to_string()), 203 203 + }, 204 204 + OpenApiParameter { 205 205 + name: "author".to_string(), 206 206 + location: "query".to_string(), 207 207 + description: "Filter by author DID".to_string(), 208 208 + required: false, 209 209 + schema: OpenApiSchema { 210 210 + schema_type: "string".to_string(), 211 211 + format: None, 212 212 + items: None, 213 213 + properties: None, 214 214 + required: None, 215 215 + default: None, 216 216 + }, 217 217 + example: None, 218 218 + }, 219 219 + OpenApiParameter { 220 220 + name: "limit".to_string(), 221 221 + location: "query".to_string(), 222 222 + description: "Maximum number of records to return".to_string(), 223 223 + required: false, 224 224 + schema: OpenApiSchema { 225 225 + schema_type: "integer".to_string(), 226 226 + format: Some("int32".to_string()), 227 227 + items: None, 228 228 + properties: None, 229 229 + required: None, 230 230 + default: None, 231 231 + }, 232 232 + example: None, 233 233 + }, 234 234 + OpenApiParameter { 235 235 + name: "cursor".to_string(), 236 236 + location: "query".to_string(), 237 237 + description: "Pagination cursor".to_string(), 238 238 + required: false, 239 239 + schema: OpenApiSchema { 240 240 + schema_type: "string".to_string(), 241 241 + format: None, 242 242 + items: None, 243 243 + properties: None, 244 244 + required: None, 245 245 + default: None, 246 246 + }, 247 247 + example: None, 248 248 + }, 249 249 + ]), 250 250 + request_body: None, 251 251 + responses: create_list_responses(), 252 252 + tags: vec![collection.to_string()], 253 253 + security: None, // No auth required for read operations 254 254 + }); 255 255 + paths.insert(list_path, list_operations); 256 256 + 257 257 + // Get operation (GET) 258 258 + let get_path = format!("/{}.get", collection); 259 259 + let mut get_operations = HashMap::new(); 260 260 + get_operations.insert("get".to_string(), OpenApiOperation { 261 261 + operation_id: format!("get{}", collection.replace(".", "_")), 262 262 + summary: format!("Get {} record", collection), 263 263 + description: format!("Get a specific record from the {} collection", collection), 264 264 + parameters: Some(vec![ 265 265 + OpenApiParameter { 266 266 + name: "slice".to_string(), 267 267 + location: "query".to_string(), 268 268 + description: "Slice URI to filter records by".to_string(), 269 269 + required: true, 270 270 + schema: string_schema_with_default(slice_uri), 271 271 + example: Some(slice_uri.to_string()), 272 272 + }, 273 273 + OpenApiParameter { 274 274 + name: "uri".to_string(), 275 275 + location: "query".to_string(), 276 276 + description: "AT Protocol URI of the record".to_string(), 277 277 + required: true, 278 278 + schema: OpenApiSchema { 279 279 + schema_type: "string".to_string(), 280 280 + format: None, 281 281 + items: None, 282 282 + properties: None, 283 283 + required: None, 284 284 + default: None, 285 285 + }, 286 286 + example: None, 287 287 + }, 288 288 + ]), 289 289 + request_body: None, 290 290 + responses: create_get_responses(), 291 291 + tags: vec![collection.to_string()], 292 292 + security: None, // No auth required for read operations 293 293 + }); 294 294 + paths.insert(get_path, get_operations); 295 295 + 296 296 + // Search operation (GET) 297 297 + let search_path = format!("/{}.searchRecords", collection); 298 298 + let mut search_operations = HashMap::new(); 299 299 + search_operations.insert("get".to_string(), OpenApiOperation { 300 300 + operation_id: format!("search{}", collection.replace(".", "_")), 301 301 + summary: format!("Search {} records", collection), 302 302 + description: format!("Search records in the {} collection", collection), 303 303 + parameters: Some(vec![ 304 304 + OpenApiParameter { 305 305 + name: "slice".to_string(), 306 306 + location: "query".to_string(), 307 307 + description: "Slice URI to filter records by".to_string(), 308 308 + required: true, 309 309 + schema: string_schema_with_default(slice_uri), 310 310 + example: Some(slice_uri.to_string()), 311 311 + }, 312 312 + OpenApiParameter { 313 313 + name: "query".to_string(), 314 314 + location: "query".to_string(), 315 315 + description: "Search query string".to_string(), 316 316 + required: true, 317 317 + schema: OpenApiSchema { 318 318 + schema_type: "string".to_string(), 319 319 + format: None, 320 320 + items: None, 321 321 + properties: None, 322 322 + required: None, 323 323 + default: None, 324 324 + }, 325 325 + example: None, 326 326 + }, 327 327 + OpenApiParameter { 328 328 + name: "field".to_string(), 329 329 + location: "query".to_string(), 330 330 + description: "Specific field to search in".to_string(), 331 331 + required: false, 332 332 + schema: OpenApiSchema { 333 333 + schema_type: "string".to_string(), 334 334 + format: None, 335 335 + items: None, 336 336 + properties: None, 337 337 + required: None, 338 338 + default: None, 339 339 + }, 340 340 + example: None, 341 341 + }, 342 342 + OpenApiParameter { 343 343 + name: "limit".to_string(), 344 344 + location: "query".to_string(), 345 345 + description: "Maximum number of records to return".to_string(), 346 346 + required: false, 347 347 + schema: OpenApiSchema { 348 348 + schema_type: "integer".to_string(), 349 349 + format: Some("int32".to_string()), 350 350 + items: None, 351 351 + properties: None, 352 352 + required: None, 353 353 + default: None, 354 354 + }, 355 355 + example: None, 356 356 + }, 357 357 + OpenApiParameter { 358 358 + name: "cursor".to_string(), 359 359 + location: "query".to_string(), 360 360 + description: "Pagination cursor".to_string(), 361 361 + required: false, 362 362 + schema: OpenApiSchema { 363 363 + schema_type: "string".to_string(), 364 364 + format: None, 365 365 + items: None, 366 366 + properties: None, 367 367 + required: None, 368 368 + default: None, 369 369 + }, 370 370 + example: None, 371 371 + }, 372 372 + ]), 373 373 + request_body: None, 374 374 + responses: create_list_responses(), 375 375 + tags: vec![collection.to_string()], 376 376 + security: None, // No auth required for read operations 377 377 + }); 378 378 + paths.insert(search_path, search_operations); 379 379 + 380 380 + // Create operation (POST) 381 381 + let create_path = format!("/{}.create", collection); 382 382 + let mut create_operations = HashMap::new(); 383 383 + 384 384 + // Generate schema from lexicon if available 385 385 + let record_schema = if let Some(lexicon) = lexicon_data { 386 386 + create_record_schema_from_lexicon(Some(lexicon)) 387 387 + } else { 388 388 + OpenApiSchema { 389 389 + schema_type: "object".to_string(), 390 390 + format: None, 391 391 + items: None, 392 392 + properties: None, 393 393 + required: None, 394 394 + default: None, 395 395 + } 396 396 + }; 397 397 + 398 398 + create_operations.insert("post".to_string(), OpenApiOperation { 399 399 + operation_id: format!("create{}", collection.replace(".", "_")), 400 400 + summary: format!("Create {} record", collection), 401 401 + description: format!("Create a new record in the {} collection", collection), 402 402 + parameters: None, 403 403 + request_body: Some(OpenApiRequestBody { 404 404 + description: "Record data to create".to_string(), 405 405 + content: { 406 406 + let mut content = HashMap::new(); 407 407 + content.insert("application/json".to_string(), OpenApiMediaType { 408 408 + schema: record_schema.clone(), 409 409 + }); 410 410 + content 411 411 + }, 412 412 + required: true, 413 413 + }), 414 414 + responses: create_mutation_responses(), 415 415 + tags: vec![collection.to_string()], 416 416 + security: Some(create_bearer_auth_security()), // Auth required for mutations 417 417 + }); 418 418 + paths.insert(create_path, create_operations); 419 419 + 420 420 + // Update operation (POST) 421 421 + let update_path = format!("/{}.update", collection); 422 422 + let mut update_operations = HashMap::new(); 423 423 + update_operations.insert("post".to_string(), OpenApiOperation { 424 424 + operation_id: format!("update{}", collection.replace(".", "_")), 425 425 + summary: format!("Update {} record", collection), 426 426 + description: format!("Update an existing record in the {} collection", collection), 427 427 + parameters: None, 428 428 + request_body: Some(OpenApiRequestBody { 429 429 + description: "Record data and rkey to update".to_string(), 430 430 + content: { 431 431 + let mut content = HashMap::new(); 432 432 + content.insert("application/json".to_string(), OpenApiMediaType { 433 433 + schema: OpenApiSchema { 434 434 + schema_type: "object".to_string(), 435 435 + format: None, 436 436 + items: None, 437 437 + properties: Some({ 438 438 + let mut props = HashMap::new(); 439 439 + props.insert("rkey".to_string(), OpenApiSchema { 440 440 + schema_type: "string".to_string(), 441 441 + format: None, 442 442 + items: None, 443 443 + properties: None, 444 444 + required: None, 445 445 + default: None, 446 446 + }); 447 447 + props.insert("record".to_string(), record_schema.clone()); 448 448 + props 449 449 + }), 450 450 + required: Some(vec!["rkey".to_string(), "record".to_string()]), 451 451 + default: None, 452 452 + }, 453 453 + }); 454 454 + content 455 455 + }, 456 456 + required: true, 457 457 + }), 458 458 + responses: create_mutation_responses(), 459 459 + tags: vec![collection.to_string()], 460 460 + security: Some(create_bearer_auth_security()), // Auth required for mutations 461 461 + }); 462 462 + paths.insert(update_path, update_operations); 463 463 + 464 464 + // Delete operation (POST) 465 465 + let delete_path = format!("/{}.delete", collection); 466 466 + let mut delete_operations = HashMap::new(); 467 467 + delete_operations.insert("post".to_string(), OpenApiOperation { 468 468 + operation_id: format!("delete{}", collection.replace(".", "_")), 469 469 + summary: format!("Delete {} record", collection), 470 470 + description: format!("Delete a record from the {} collection", collection), 471 471 + parameters: None, 472 472 + request_body: Some(OpenApiRequestBody { 473 473 + description: "Record key to delete".to_string(), 474 474 + content: { 475 475 + let mut content = HashMap::new(); 476 476 + content.insert("application/json".to_string(), OpenApiMediaType { 477 477 + schema: OpenApiSchema { 478 478 + schema_type: "object".to_string(), 479 479 + format: None, 480 480 + items: None, 481 481 + properties: Some({ 482 482 + let mut props = HashMap::new(); 483 483 + props.insert("rkey".to_string(), OpenApiSchema { 484 484 + schema_type: "string".to_string(), 485 485 + format: None, 486 486 + items: None, 487 487 + properties: None, 488 488 + required: None, 489 489 + default: None, 490 490 + }); 491 491 + props 492 492 + }), 493 493 + required: Some(vec!["rkey".to_string()]), 494 494 + default: None, 495 495 + }, 496 496 + }); 497 497 + content 498 498 + }, 499 499 + required: true, 500 500 + }), 501 501 + responses: create_delete_responses(), 502 502 + tags: vec![collection.to_string()], 503 503 + security: Some(create_bearer_auth_security()), // Auth required for mutations 504 504 + }); 505 505 + paths.insert(delete_path, delete_operations); 506 506 + } 507 507 + 508 508 + fn create_collection_schemas(_collection: &str, _lexicon_data: Option<&serde_json::Value>, schemas: &mut HashMap<String, OpenApiSchema>) { 509 509 + // IndexedRecord schema 510 510 + let mut record_props = HashMap::new(); 511 511 + record_props.insert("uri".to_string(), OpenApiSchema { 512 512 + schema_type: "string".to_string(), 513 513 + format: None, 514 514 + items: None, 515 515 + properties: None, 516 516 + required: None, 517 517 + default: None, 518 518 + }); 519 519 + record_props.insert("cid".to_string(), OpenApiSchema { 520 520 + schema_type: "string".to_string(), 521 521 + format: None, 522 522 + items: None, 523 523 + properties: None, 524 524 + required: None, 525 525 + default: None, 526 526 + }); 527 527 + record_props.insert("did".to_string(), OpenApiSchema { 528 528 + schema_type: "string".to_string(), 529 529 + format: None, 530 530 + items: None, 531 531 + properties: None, 532 532 + required: None, 533 533 + default: None, 534 534 + }); 535 535 + record_props.insert("collection".to_string(), OpenApiSchema { 536 536 + schema_type: "string".to_string(), 537 537 + format: None, 538 538 + items: None, 539 539 + properties: None, 540 540 + required: None, 541 541 + default: None, 542 542 + }); 543 543 + record_props.insert("value".to_string(), OpenApiSchema { 544 544 + schema_type: "object".to_string(), 545 545 + format: None, 546 546 + items: None, 547 547 + properties: None, 548 548 + required: None, 549 549 + default: None, 550 550 + }); 551 551 + record_props.insert("indexed_at".to_string(), OpenApiSchema { 552 552 + schema_type: "string".to_string(), 553 553 + format: Some("date-time".to_string()), 554 554 + items: None, 555 555 + properties: None, 556 556 + required: None, 557 557 + default: None, 558 558 + }); 559 559 + 560 560 + schemas.insert("IndexedRecord".to_string(), OpenApiSchema { 561 561 + schema_type: "object".to_string(), 562 562 + format: None, 563 563 + items: None, 564 564 + properties: Some(record_props), 565 565 + required: Some(vec!["uri".to_string(), "cid".to_string(), "did".to_string(), "collection".to_string(), "value".to_string(), "indexed_at".to_string()]), 566 566 + default: None, 567 567 + }); 568 568 + 569 569 + // ListRecordsOutput schema 570 570 + let mut list_props = HashMap::new(); 571 571 + list_props.insert("records".to_string(), OpenApiSchema { 572 572 + schema_type: "array".to_string(), 573 573 + format: None, 574 574 + items: Some(Box::new(OpenApiSchema { 575 575 + schema_type: "object".to_string(), 576 576 + format: None, 577 577 + items: None, 578 578 + properties: None, 579 579 + required: None, 580 580 + default: None, 581 581 + })), 582 582 + properties: None, 583 583 + required: None, 584 584 + default: None, 585 585 + }); 586 586 + list_props.insert("cursor".to_string(), OpenApiSchema { 587 587 + schema_type: "string".to_string(), 588 588 + format: None, 589 589 + items: None, 590 590 + properties: None, 591 591 + required: None, 592 592 + default: None, 593 593 + }); 594 594 + 595 595 + schemas.insert("ListRecordsOutput".to_string(), OpenApiSchema { 596 596 + schema_type: "object".to_string(), 597 597 + format: None, 598 598 + items: None, 599 599 + properties: Some(list_props), 600 600 + required: Some(vec!["records".to_string()]), 601 601 + default: None, 602 602 + }); 603 603 + } 604 604 + 605 605 + fn create_list_responses() -> HashMap<String, OpenApiResponse> { 606 606 + let mut responses = HashMap::new(); 607 607 + 608 608 + responses.insert("200".to_string(), OpenApiResponse { 609 609 + description: "Successfully retrieved records".to_string(), 610 610 + content: Some({ 611 611 + let mut content = HashMap::new(); 612 612 + content.insert("application/json".to_string(), OpenApiMediaType { 613 613 + schema: OpenApiSchema { 614 614 + schema_type: "object".to_string(), 615 615 + format: None, 616 616 + items: None, 617 617 + properties: None, 618 618 + required: None, 619 619 + default: None, 620 620 + }, 621 621 + }); 622 622 + content 623 623 + }), 624 624 + }); 625 625 + 626 626 + responses.insert("400".to_string(), OpenApiResponse { 627 627 + description: "Bad request".to_string(), 628 628 + content: None, 629 629 + }); 630 630 + 631 631 + responses.insert("500".to_string(), OpenApiResponse { 632 632 + description: "Internal server error".to_string(), 633 633 + content: None, 634 634 + }); 635 635 + 636 636 + responses 637 637 + } 638 638 + 639 639 + fn create_get_responses() -> HashMap<String, OpenApiResponse> { 640 640 + let mut responses = HashMap::new(); 641 641 + 642 642 + responses.insert("200".to_string(), OpenApiResponse { 643 643 + description: "Successfully retrieved record".to_string(), 644 644 + content: Some({ 645 645 + let mut content = HashMap::new(); 646 646 + content.insert("application/json".to_string(), OpenApiMediaType { 647 647 + schema: OpenApiSchema { 648 648 + schema_type: "object".to_string(), 649 649 + format: None, 650 650 + items: None, 651 651 + properties: None, 652 652 + required: None, 653 653 + default: None, 654 654 + }, 655 655 + }); 656 656 + content 657 657 + }), 658 658 + }); 659 659 + 660 660 + responses.insert("404".to_string(), OpenApiResponse { 661 661 + description: "Record not found".to_string(), 662 662 + content: None, 663 663 + }); 664 664 + 665 665 + responses.insert("500".to_string(), OpenApiResponse { 666 666 + description: "Internal server error".to_string(), 667 667 + content: None, 668 668 + }); 669 669 + 670 670 + responses 671 671 + } 672 672 + 673 673 + fn create_mutation_responses() -> HashMap<String, OpenApiResponse> { 674 674 + let mut responses = HashMap::new(); 675 675 + 676 676 + responses.insert("200".to_string(), OpenApiResponse { 677 677 + description: "Successfully created/updated record".to_string(), 678 678 + content: Some({ 679 679 + let mut content = HashMap::new(); 680 680 + content.insert("application/json".to_string(), OpenApiMediaType { 681 681 + schema: OpenApiSchema { 682 682 + schema_type: "object".to_string(), 683 683 + format: None, 684 684 + items: None, 685 685 + properties: Some({ 686 686 + let mut props = HashMap::new(); 687 687 + props.insert("uri".to_string(), OpenApiSchema { 688 688 + schema_type: "string".to_string(), 689 689 + format: None, 690 690 + items: None, 691 691 + properties: None, 692 692 + required: None, 693 693 + default: None, 694 694 + }); 695 695 + props.insert("cid".to_string(), OpenApiSchema { 696 696 + schema_type: "string".to_string(), 697 697 + format: None, 698 698 + items: None, 699 699 + properties: None, 700 700 + required: None, 701 701 + default: None, 702 702 + }); 703 703 + props 704 704 + }), 705 705 + required: Some(vec!["uri".to_string(), "cid".to_string()]), 706 706 + default: None, 707 707 + }, 708 708 + }); 709 709 + content 710 710 + }), 711 711 + }); 712 712 + 713 713 + responses.insert("400".to_string(), OpenApiResponse { 714 714 + description: "Bad request".to_string(), 715 715 + content: None, 716 716 + }); 717 717 + 718 718 + responses.insert("401".to_string(), OpenApiResponse { 719 719 + description: "Unauthorized".to_string(), 720 720 + content: None, 721 721 + }); 722 722 + 723 723 + responses.insert("500".to_string(), OpenApiResponse { 724 724 + description: "Internal server error".to_string(), 725 725 + content: None, 726 726 + }); 727 727 + 728 728 + responses 729 729 + } 730 730 + 731 731 + fn create_delete_responses() -> HashMap<String, OpenApiResponse> { 732 732 + let mut responses = HashMap::new(); 733 733 + 734 734 + responses.insert("200".to_string(), OpenApiResponse { 735 735 + description: "Successfully deleted record".to_string(), 736 736 + content: Some({ 737 737 + let mut content = HashMap::new(); 738 738 + content.insert("application/json".to_string(), OpenApiMediaType { 739 739 + schema: OpenApiSchema { 740 740 + schema_type: "object".to_string(), 741 741 + format: None, 742 742 + items: None, 743 743 + properties: None, 744 744 + required: None, 745 745 + default: None, 746 746 + }, 747 747 + }); 748 748 + content 749 749 + }), 750 750 + }); 751 751 + 752 752 + responses.insert("400".to_string(), OpenApiResponse { 753 753 + description: "Bad request".to_string(), 754 754 + content: None, 755 755 + }); 756 756 + 757 757 + responses.insert("401".to_string(), OpenApiResponse { 758 758 + description: "Unauthorized".to_string(), 759 759 + content: None, 760 760 + }); 761 761 + 762 762 + responses.insert("404".to_string(), OpenApiResponse { 763 763 + description: "Record not found".to_string(), 764 764 + content: None, 765 765 + }); 766 766 + 767 767 + responses.insert("500".to_string(), OpenApiResponse { 768 768 + description: "Internal server error".to_string(), 769 769 + content: None, 770 770 + }); 771 771 + 772 772 + responses 773 773 + } 774 774 + 775 775 + fn string_schema_with_default(default_value: &str) -> OpenApiSchema { 776 776 + OpenApiSchema { 777 777 + schema_type: "string".to_string(), 778 778 + format: None, 779 779 + items: None, 780 780 + properties: None, 781 781 + required: None, 782 782 + default: Some(serde_json::Value::String(default_value.to_string())), 783 783 + } 784 784 + } 785 785 + 786 786 + fn create_record_schema_from_lexicon(lexicon_data: Option<&serde_json::Value>) -> OpenApiSchema { 787 787 + if let Some(lexicon) = lexicon_data { 788 788 + // Get the definitions object directly (it's already parsed JSON, not a string) 789 789 + if let Some(definitions) = lexicon.get("definitions") { 790 790 + if let Some(main_def) = definitions.get("main") { 791 791 + if let Some(record_def) = main_def.get("record") { 792 792 + if let Some(properties) = record_def.get("properties") { 793 793 + // Convert lexicon properties to OpenAPI schema properties 794 794 + let mut openapi_props = HashMap::new(); 795 795 + let mut required_fields = Vec::new(); 796 796 + 797 797 + if let Some(props_obj) = properties.as_object() { 798 798 + for (prop_name, prop_def) in props_obj { 799 799 + if let Some(prop_schema) = convert_lexicon_property_to_openapi(prop_def) { 800 800 + openapi_props.insert(prop_name.clone(), prop_schema); 801 801 + 802 802 + // Check if field is required 803 803 + if let Some(required) = prop_def.get("required") { 804 804 + if required.as_bool().unwrap_or(false) { 805 805 + required_fields.push(prop_name.clone()); 806 806 + } 807 807 + } 808 808 + } 809 809 + } 810 810 + } 811 811 + 812 812 + return OpenApiSchema { 813 813 + schema_type: "object".to_string(), 814 814 + format: None, 815 815 + items: None, 816 816 + properties: Some(openapi_props), 817 817 + required: if required_fields.is_empty() { None } else { Some(required_fields) }, 818 818 + default: None, 819 819 + }; 820 820 + } 821 821 + } 822 822 + } 823 823 + } 824 824 + } 825 825 + 826 826 + // Fallback to generic object schema (without rkey - that's a separate request parameter) 827 827 + OpenApiSchema { 828 828 + schema_type: "object".to_string(), 829 829 + format: None, 830 830 + items: None, 831 831 + properties: Some(HashMap::new()), 832 832 + required: None, 833 833 + default: None, 834 834 + } 835 835 + } 836 836 + 837 837 + fn convert_lexicon_property_to_openapi(prop_def: &serde_json::Value) -> Option<OpenApiSchema> { 838 838 + let prop_type = prop_def.get("type")?.as_str()?; 839 839 + 840 840 + match prop_type { 841 841 + "string" => Some(OpenApiSchema { 842 842 + schema_type: "string".to_string(), 843 843 + format: None, 844 844 + items: None, 845 845 + properties: None, 846 846 + required: None, 847 847 + default: None, 848 848 + }), 849 849 + "integer" => Some(OpenApiSchema { 850 850 + schema_type: "integer".to_string(), 851 851 + format: Some("int64".to_string()), 852 852 + items: None, 853 853 + properties: None, 854 854 + required: None, 855 855 + default: None, 856 856 + }), 857 857 + "boolean" => Some(OpenApiSchema { 858 858 + schema_type: "boolean".to_string(), 859 859 + format: None, 860 860 + items: None, 861 861 + properties: None, 862 862 + required: None, 863 863 + default: None, 864 864 + }), 865 865 + "blob" => Some(OpenApiSchema { 866 866 + schema_type: "object".to_string(), 867 867 + format: None, 868 868 + items: None, 869 869 + properties: Some({ 870 870 + let mut blob_props = HashMap::new(); 871 871 + blob_props.insert("$type".to_string(), OpenApiSchema { 872 872 + schema_type: "string".to_string(), 873 873 + format: None, 874 874 + items: None, 875 875 + properties: None, 876 876 + required: None, 877 877 + default: None, 878 878 + }); 879 879 + blob_props.insert("ref".to_string(), OpenApiSchema { 880 880 + schema_type: "object".to_string(), 881 881 + format: None, 882 882 + items: None, 883 883 + properties: Some({ 884 884 + let mut ref_props = HashMap::new(); 885 885 + ref_props.insert("$link".to_string(), OpenApiSchema { 886 886 + schema_type: "string".to_string(), 887 887 + format: None, 888 888 + items: None, 889 889 + properties: None, 890 890 + required: None, 891 891 + default: None, 892 892 + }); 893 893 + ref_props 894 894 + }), 895 895 + required: Some(vec!["$link".to_string()]), 896 896 + default: None, 897 897 + }); 898 898 + blob_props.insert("mimeType".to_string(), OpenApiSchema { 899 899 + schema_type: "string".to_string(), 900 900 + format: None, 901 901 + items: None, 902 902 + properties: None, 903 903 + required: None, 904 904 + default: None, 905 905 + }); 906 906 + blob_props.insert("size".to_string(), OpenApiSchema { 907 907 + schema_type: "integer".to_string(), 908 908 + format: Some("int64".to_string()), 909 909 + items: None, 910 910 + properties: None, 911 911 + required: None, 912 912 + default: None, 913 913 + }); 914 914 + blob_props 915 915 + }), 916 916 + required: Some(vec!["$type".to_string(), "ref".to_string(), "mimeType".to_string(), "size".to_string()]), 917 917 + default: None, 918 918 + }), 919 919 + "array" => { 920 920 + if let Some(items_def) = prop_def.get("items") { 921 921 + if let Some(items_schema) = convert_lexicon_property_to_openapi(items_def) { 922 922 + return Some(OpenApiSchema { 923 923 + schema_type: "array".to_string(), 924 924 + format: None, 925 925 + items: Some(Box::new(items_schema)), 926 926 + properties: None, 927 927 + required: None, 928 928 + default: None, 929 929 + }); 930 930 + } 931 931 + } 932 932 + Some(OpenApiSchema { 933 933 + schema_type: "array".to_string(), 934 934 + format: None, 935 935 + items: Some(Box::new(OpenApiSchema { 936 936 + schema_type: "object".to_string(), 937 937 + format: None, 938 938 + items: None, 939 939 + properties: None, 940 940 + required: None, 941 941 + default: None, 942 942 + })), 943 943 + properties: None, 944 944 + required: None, 945 945 + default: None, 946 946 + }) 947 947 + }, 948 948 + "object" => Some(OpenApiSchema { 949 949 + schema_type: "object".to_string(), 950 950 + format: None, 951 951 + items: None, 952 952 + properties: None, 953 953 + required: None, 954 954 + default: None, 955 955 + }), 956 956 + _ => Some(OpenApiSchema { 957 957 + schema_type: "object".to_string(), 958 958 + format: None, 959 959 + items: None, 960 960 + properties: None, 961 961 + required: None, 962 962 + default: None, 963 963 + }), 964 964 + } 965 965 + } 966 966 + 967 967 + fn create_security_schemes() -> HashMap<String, OpenApiSecurityScheme> { 968 968 + let mut schemes = HashMap::new(); 969 969 + 970 970 + schemes.insert("bearerAuth".to_string(), OpenApiSecurityScheme { 971 971 + scheme_type: "http".to_string(), 972 972 + scheme: "bearer".to_string(), 973 973 + bearer_format: None, // OAuth token, not JWT 974 974 + description: "OAuth Bearer token authentication. Use your OAuth access token from the auth server.".to_string(), 975 975 + example: None, 976 976 + }); 977 977 + 978 978 + schemes 979 979 + } 980 980 + 981 981 + fn create_bearer_auth_security() -> Vec<HashMap<String, Vec<String>>> { 982 982 + let mut auth_requirement = HashMap::new(); 983 983 + auth_requirement.insert("bearerAuth".to_string(), vec![]); 984 984 + vec![auth_requirement] 985 985 + }

+2

api/src/main.rs

··· 4 4 mod database; 5 5 mod errors; 6 6 mod handler_jobs; 7 7 + mod handler_openapi_spec; 7 8 mod handler_records; 8 9 mod handler_stats; 9 10 mod handler_sync; ··· 129 130 "/xrpc/social.slices.slice.codegen", 130 131 post(handler_xrpc_codegen::generate_client_xrpc), 131 132 ) 133 133 + .route("/xrpc/social.slices.slice.openapi", get(handler_openapi_spec::get_openapi_spec)) 132 134 // Dynamic collection-specific XRPC endpoints (wildcard routes must come last) 133 135 .route( 134 136 "/xrpc/*method",

+194

frontend/src/pages/SliceApiDocsPage.tsx

··· 1 1 + interface SliceApiDocsPageProps { 2 2 + sliceId: string; 3 3 + sliceName: string; 4 4 + accessToken?: string; 5 5 + currentUser: { 6 6 + isAuthenticated: boolean; 7 7 + username?: string; 8 8 + sub?: string; 9 9 + }; 10 10 + } 11 11 + 12 12 + export function SliceApiDocsPage(props: SliceApiDocsPageProps) { 13 13 + const { sliceId, sliceName, accessToken, currentUser } = props; 14 14 + 15 15 + // Construct the OpenAPI spec URL for this slice 16 16 + const baseUrl = 17 17 + typeof window !== "undefined" 18 18 + ? globalThis.location.origin.replace(":8000", ":3000") // Frontend runs on 8000, API on 3000 19 19 + : "http://localhost:3000"; 20 20 + 21 21 + // Build the slice URI 22 22 + const sliceUri = `at://${currentUser.sub}/social.slices.slice/${sliceId}`; 23 23 + const openApiUrl = `${baseUrl}/xrpc/social.slices.slice.openapi?slice=${encodeURIComponent( 24 24 + sliceUri 25 25 + )}`; 26 26 + 27 27 + return ( 28 28 + <html lang="en"> 29 29 + <head> 30 30 + <meta charset="UTF-8" /> 31 31 + <meta name="viewport" content="width=device-width, initial-scale=1.0" /> 32 32 + <title>API Docs - {sliceName}</title> 33 33 + <script src="https://cdn.tailwindcss.com"></script> 34 34 + </head> 35 35 + <body class="bg-gray-50 min-h-screen"> 36 36 + {/* Header with back button */} 37 37 + <div class="bg-white border-b border-gray-200 px-4 py-4"> 38 38 + <div class="max-w-7xl mx-auto flex items-center justify-between"> 39 39 + <div class="flex items-center"> 40 40 + <a 41 41 + href={`/slices/${sliceId}`} 42 42 + class="text-blue-600 hover:text-blue-800 mr-4 flex items-center" 43 43 + > 44 44 + <svg 45 45 + class="w-4 h-4 mr-1" 46 46 + fill="none" 47 47 + stroke="currentColor" 48 48 + viewBox="0 0 24 24" 49 49 + > 50 50 + <path 51 51 + stroke-linecap="round" 52 52 + stroke-linejoin="round" 53 53 + stroke-width="2" 54 54 + d="M15 19l-7-7 7-7" 55 55 + /> 56 56 + </svg> 57 57 + Back to {sliceName} 58 58 + </a> 59 59 + </div> 60 60 + <div class="text-right"> 61 61 + <h1 class="text-xl font-semibold text-gray-900">API Documentation</h1> 62 62 + <p class="text-gray-600 text-sm"> 63 63 + Interactive OpenAPI docs for your slice 64 64 + </p> 65 65 + </div> 66 66 + </div> 67 67 + </div> 68 68 + 69 69 + {/* Info bar */} 70 70 + <div class="bg-blue-50 border-b border-blue-200 px-4 py-3"> 71 71 + <div class="max-w-7xl mx-auto"> 72 72 + <p class="text-blue-800 text-sm"> 73 73 + <strong>OpenAPI Spec URL:</strong> 74 74 + <code class="ml-2 bg-blue-100 px-2 py-1 rounded text-xs"> 75 75 + {openApiUrl} 76 76 + </code> 77 77 + </p> 78 78 + </div> 79 79 + </div> 80 80 + 81 81 + {/* Scalar API Reference Container - Scrollable */} 82 82 + <div class="w-full"> 83 83 + <div id="scalar-api-reference" class="w-full min-h-screen"> 84 84 + <div class="flex items-center justify-center h-96"> 85 85 + <div class="text-center"> 86 86 + <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-500 mx-auto mb-4"></div> 87 87 + <p class="text-gray-500">Loading API documentation...</p> 88 88 + </div> 89 89 + </div> 90 90 + </div> 91 91 + </div> 92 92 + 93 93 + {/* Load Scalar API Reference */} 94 94 + <script 95 95 + src="https://cdn.jsdelivr.net/npm/@scalar/api-reference" 96 96 + async 97 97 + ></script> 98 98 + 99 99 + {/* Initialize Scalar when the script loads */} 100 100 + <script 101 101 + dangerouslySetInnerHTML={{ 102 102 + __html: ` 103 103 + document.addEventListener('DOMContentLoaded', function() { 104 104 + // Wait for Scalar to be available 105 105 + const initScalar = () => { 106 106 + if (typeof Scalar !== 'undefined' && Scalar.createApiReference) { 107 107 + try { 108 108 + Scalar.createApiReference('#scalar-api-reference', { 109 109 + url: '${openApiUrl}', 110 110 + configuration: { 111 111 + theme: 'alternate', 112 112 + layout: 'modern', 113 113 + showSidebar: true, 114 114 + searchHotKey: 'k', 115 115 + defaultHttpClient: { 116 116 + targetKey: 'javascript', 117 117 + clientKey: 'fetch' 118 118 + } 119 119 + }, 120 120 + // Try to set default parameters 121 121 + variables: { 122 122 + slice: '${sliceUri}' 123 123 + }, 124 124 + // Alternative approach for parameter defaults 125 125 + defaultParameters: { 126 126 + slice: '${sliceUri}' 127 127 + },${accessToken ? ` 128 128 + authentication: { 129 129 + preferredSecurityScheme: 'bearerAuth', 130 130 + http: { 131 131 + bearer: { 132 132 + token: '${accessToken}' 133 133 + } 134 134 + } 135 135 + },` : ''} 136 136 + customCss: \` 137 137 + .scalar-api-reference { 138 138 + width: 100% !important; 139 139 + border: none !important; 140 140 + min-height: 100vh; 141 141 + height: auto !important; 142 142 + } 143 143 + .scalar-api-reference > div { 144 144 + height: auto !important; 145 145 + } 146 146 + \`, 147 147 + onReady: () => { 148 148 + console.log('Scalar API Reference loaded successfully'); 149 149 + }, 150 150 + onError: (error) => { 151 151 + console.error('Failed to load API documentation:', error); 152 152 + document.getElementById('scalar-api-reference').innerHTML = \` 153 153 + <div class="flex items-center justify-center h-64 text-center"> 154 154 + <div> 155 155 + <div class="text-red-500 mb-4"> 156 156 + <svg class="w-12 h-12 mx-auto" fill="none" stroke="currentColor" viewBox="0 0 24 24"> 157 157 + <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" 158 158 + d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4c-.77-.833-1.732-.833-2.464 0L4.35 16.5c-.77.833.192 2.5 1.732 2.5z"/> 159 159 + </svg> 160 160 + </div> 161 161 + <h3 class="text-lg font-medium text-gray-900 mb-2">Failed to load API documentation</h3> 162 162 + <p class="text-gray-600 text-sm mb-4"> 163 163 + Unable to fetch the OpenAPI specification. Please make sure the API server is running. 164 164 + </p> 165 165 + <button 166 166 + onclick="window.location.reload()" 167 167 + class="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded-md text-sm font-medium" 168 168 + > 169 169 + Retry 170 170 + </button> 171 171 + </div> 172 172 + </div> 173 173 + \`; 174 174 + } 175 175 + }); 176 176 + } catch (error) { 177 177 + console.error('Error initializing Scalar:', error); 178 178 + } 179 179 + } else { 180 180 + // Retry after a short delay 181 181 + setTimeout(initScalar, 100); 182 182 + } 183 183 + }; 184 184 + 185 185 + // Start initialization 186 186 + initScalar(); 187 187 + }); 188 188 + `, 189 189 + }} 190 190 + /> 191 191 + </body> 192 192 + </html> 193 193 + ); 194 194 + }

+15

frontend/src/pages/SlicePage.tsx

··· 119 119 120 120 <div className="bg-white rounded-lg shadow-md p-6"> 121 121 <h2 className="text-xl font-semibold text-gray-800 mb-4"> 122 122 + 📖 API Documentation 123 123 + </h2> 124 124 + <p className="text-gray-600 mb-4"> 125 125 + Interactive OpenAPI documentation for your slice's XRPC endpoints. 126 126 + </p> 127 127 + <a 128 128 + href={`/slices/${sliceId}/api-docs`} 129 129 + className="bg-indigo-500 hover:bg-indigo-600 text-white px-4 py-2 rounded" 130 130 + > 131 131 + View API Docs 132 132 + </a> 133 133 + </div> 134 134 + 135 135 + <div className="bg-white rounded-lg shadow-md p-6"> 136 136 + <h2 className="text-xl font-semibold text-gray-800 mb-4"> 122 137 🔄 Sync 123 138 </h2> 124 139 <p className="text-gray-600 mb-4">

+70 -1

frontend/src/routes/pages.tsx

··· 10 10 import { SliceSyncPage } from "../pages/SliceSyncPage.tsx"; 11 11 import { SliceLexiconPage } from "../pages/SliceLexiconPage.tsx"; 12 12 import { SliceCodegenPage } from "../pages/SliceCodegenPage.tsx"; 13 13 + import { SliceApiDocsPage } from "../pages/SliceApiDocsPage.tsx"; 13 14 import { SliceSettingsPage } from "../pages/SliceSettingsPage.tsx"; 14 15 import { SettingsPage } from "../pages/SettingsPage.tsx"; 15 16 16 17 async function handleIndexPage(req: Request): Promise<Response> { 17 18 const context = await withAuth(req); 18 18 - 19 19 + 19 20 // Slice list page - get real slices from AT Protocol 20 21 let slices: Array<{ id: string; name: string; createdAt: string }> = []; 21 22 ··· 357 358 }); 358 359 } 359 360 361 361 + async function handleSliceApiDocsPage( 362 362 + req: Request, 363 363 + params?: URLPatternResult 364 364 + ): Promise<Response> { 365 365 + const context = await withAuth(req); 366 366 + const sliceId = params?.pathname.groups.id; 367 367 + 368 368 + if (!sliceId) { 369 369 + return Response.redirect(new URL("/", req.url), 302); 370 370 + } 371 371 + 372 372 + // Get OAuth access token if available 373 373 + let accessToken: string | undefined; 374 374 + try { 375 375 + const tokens = await atprotoClient.oauth?.ensureValidToken(); 376 376 + accessToken = tokens?.accessToken; 377 377 + } catch (error) { 378 378 + console.log("Could not get OAuth token:", error); 379 379 + } 380 380 + 381 381 + // Get real slice data from AT Protocol 382 382 + let sliceData = { 383 383 + sliceId, 384 384 + sliceName: "Unknown Slice", 385 385 + accessToken, 386 386 + }; 387 387 + 388 388 + if (context.currentUser.isAuthenticated) { 389 389 + try { 390 390 + const sliceUri = buildAtUri({ 391 391 + did: context.currentUser.sub!, 392 392 + collection: "social.slices.slice", 393 393 + rkey: sliceId, 394 394 + }); 395 395 + 396 396 + const sliceRecord = await atprotoClient.social.slices.slice.getRecord({ 397 397 + uri: sliceUri, 398 398 + }); 399 399 + 400 400 + sliceData = { 401 401 + sliceId, 402 402 + sliceName: sliceRecord.value.name, 403 403 + accessToken, 404 404 + }; 405 405 + } catch (error) { 406 406 + console.error("Failed to fetch slice data:", error); 407 407 + // Fall back to default data 408 408 + } 409 409 + } 410 410 + 411 411 + const html = render( 412 412 + <SliceApiDocsPage {...sliceData} currentUser={context.currentUser} /> 413 413 + ); 414 414 + 415 415 + const responseHeaders: Record<string, string> = { 416 416 + "content-type": "text/html", 417 417 + }; 418 418 + 419 419 + return new Response(`<!DOCTYPE html>${html}`, { 420 420 + status: 200, 421 421 + headers: responseHeaders, 422 422 + }); 423 423 + } 424 424 + 360 425 async function handleSettingsPage(req: Request): Promise<Response> { 361 426 const context = await withAuth(req); 362 427 ··· 424 489 { 425 490 pattern: new URLPattern({ pathname: "/slices/:id" }), 426 491 handler: handleSlicePage, 492 492 + }, 493 493 + { 494 494 + pattern: new URLPattern({ pathname: "/slices/:id/api-docs" }), 495 495 + handler: handleSliceApiDocsPage, 427 496 }, 428 497 { 429 498 pattern: new URLPattern({ pathname: "/slices/:id/:tab" }),