add xrpc for open api generation for slices, add a new page to frontend to render the open api spec and interact with the api with Scalar

api/.spectral.yaml

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

api/src/handler_openapi_spec.rs

···
+use axum::{
+    extract::{Query, State},
+    http::StatusCode,
+    response::Json,
+};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use crate::AppState;
+
+#[derive(Deserialize)]
+pub struct OpenApiParams {
+    pub slice: String,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiSpec {
+    openapi: String,
+    info: OpenApiInfo,
+    servers: Vec<OpenApiServer>,
+    paths: HashMap<String, HashMap<String, OpenApiOperation>>,
+    components: OpenApiComponents,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiInfo {
+    title: String,
+    version: String,
+    description: String,
+    contact: OpenApiContact,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiContact {
+    name: String,
+    url: String,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiServer {
+    url: String,
+    description: String,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiOperation {
+    #[serde(rename = "operationId")]
+    operation_id: String,
+    summary: String,
+    description: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    parameters: Option<Vec<OpenApiParameter>>,
+    #[serde(rename = "requestBody", skip_serializing_if = "Option::is_none")]
+    request_body: Option<OpenApiRequestBody>,
+    responses: HashMap<String, OpenApiResponse>,
+    tags: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    security: Option<Vec<HashMap<String, Vec<String>>>>,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiParameter {
+    name: String,
+    #[serde(rename = "in")]
+    location: String,
+    description: String,
+    required: bool,
+    schema: OpenApiSchema,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    example: Option<String>,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiRequestBody {
+    description: String,
+    content: HashMap<String, OpenApiMediaType>,
+    required: bool,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiMediaType {
+    schema: OpenApiSchema,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiResponse {
+    description: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    content: Option<HashMap<String, OpenApiMediaType>>,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiSchema {
+    #[serde(rename = "type")]
+    schema_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    format: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    items: Option<Box<OpenApiSchema>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    properties: Option<HashMap<String, OpenApiSchema>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    required: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    default: Option<serde_json::Value>,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiSecurityScheme {
+    #[serde(rename = "type")]
+    scheme_type: String,
+    scheme: String,
+    #[serde(rename = "bearerFormat", skip_serializing_if = "Option::is_none")]
+    bearer_format: Option<String>,
+    description: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    example: Option<String>,
+}
+
+#[derive(Serialize, Clone)]
+pub struct OpenApiComponents {
+    schemas: HashMap<String, OpenApiSchema>,
+    #[serde(rename = "securitySchemes", skip_serializing_if = "Option::is_none")]
+    security_schemes: Option<HashMap<String, OpenApiSecurityScheme>>,
+}
+
+pub async fn get_openapi_spec(
+    State(state): State<AppState>,
+    Query(params): Query<OpenApiParams>,
+) -> Result<Json<OpenApiSpec>, StatusCode> {
+    // Get collections for this slice
+    let slice_collections = state
+        .database
+        .get_slice_collections_list(&params.slice)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    if slice_collections.is_empty() {
+        return Err(StatusCode::NOT_FOUND);
+    }
+
+    // Get lexicon definitions for this slice
+    let mut collection_lexicons = HashMap::new();
+    if let Ok(lexicons) = state.database.get_lexicons_by_slice(&params.slice).await {
+        for lexicon in lexicons {
+            if let Some(nsid) = lexicon.get("nsid").and_then(|v| v.as_str()) {
+                collection_lexicons.insert(nsid.to_string(), lexicon);
+            }
+        }
+    }
+
+    let mut paths = HashMap::new();
+    let mut schemas = HashMap::new();
+
+    // Create OpenAPI paths for each collection
+    for collection in slice_collections {
+        let lexicon_data = collection_lexicons.get(&collection);
+        create_collection_paths(&collection, &params.slice, lexicon_data, &mut paths);
+        create_collection_schemas(&collection, lexicon_data, &mut schemas);
+    }
+
+    let spec = OpenApiSpec {
+        openapi: "3.0.3".to_string(),
+        info: OpenApiInfo {
+            title: format!("Slice API: {}", params.slice),
+            version: "1.0.0".to_string(),
+            description: format!("Dynamically generated OpenAPI specification for slice: {}", params.slice),
+            contact: OpenApiContact {
+                name: "Slice API".to_string(),
+                url: "https://github.com/anthropics/slice".to_string(),
+            },
+        },
+        servers: vec![OpenApiServer {
+            url: "/xrpc".to_string(),
+            description: "XRPC endpoint base".to_string(),
+        }],
+        paths,
+        components: OpenApiComponents { 
+            schemas,
+            security_schemes: Some(create_security_schemes()),
+        },
+    };
+
+    Ok(Json(spec))
+}
+
+fn create_collection_paths(collection: &str, slice_uri: &str, lexicon_data: Option<&serde_json::Value>, paths: &mut HashMap<String, HashMap<String, OpenApiOperation>>) {
+    // List operation (GET)
+    let list_path = format!("/{}.list", collection);
+    let mut list_operations = HashMap::new();
+    list_operations.insert("get".to_string(), OpenApiOperation {
+        operation_id: format!("list{}", collection.replace(".", "_")),
+        summary: format!("List {} records", collection),
+        description: format!("List records from the {} collection", collection),
+        parameters: Some(vec![
+            OpenApiParameter {
+                name: "slice".to_string(),
+                location: "query".to_string(),
+                description: "Slice URI to filter records by".to_string(),
+                required: true,
+                schema: string_schema_with_default(slice_uri),
+                example: Some(slice_uri.to_string()),
+            },
+            OpenApiParameter {
+                name: "author".to_string(),
+                location: "query".to_string(),
+                description: "Filter by author DID".to_string(),
+                required: false,
+                schema: OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+            OpenApiParameter {
+                name: "limit".to_string(),
+                location: "query".to_string(),
+                description: "Maximum number of records to return".to_string(),
+                required: false,
+                schema: OpenApiSchema {
+                    schema_type: "integer".to_string(),
+                    format: Some("int32".to_string()),
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+            OpenApiParameter {
+                name: "cursor".to_string(),
+                location: "query".to_string(),
+                description: "Pagination cursor".to_string(),
+                required: false,
+                schema: OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+        ]),
+        request_body: None,
+        responses: create_list_responses(),
+        tags: vec![collection.to_string()],
+        security: None, // No auth required for read operations
+    });
+    paths.insert(list_path, list_operations);
+
+    // Get operation (GET)
+    let get_path = format!("/{}.get", collection);
+    let mut get_operations = HashMap::new();
+    get_operations.insert("get".to_string(), OpenApiOperation {
+        operation_id: format!("get{}", collection.replace(".", "_")),
+        summary: format!("Get {} record", collection),
+        description: format!("Get a specific record from the {} collection", collection),
+        parameters: Some(vec![
+            OpenApiParameter {
+                name: "slice".to_string(),
+                location: "query".to_string(),
+                description: "Slice URI to filter records by".to_string(),
+                required: true,
+                schema: string_schema_with_default(slice_uri),
+                example: Some(slice_uri.to_string()),
+            },
+            OpenApiParameter {
+                name: "uri".to_string(),
+                location: "query".to_string(),
+                description: "AT Protocol URI of the record".to_string(),
+                required: true,
+                schema: OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+        ]),
+        request_body: None,
+        responses: create_get_responses(),
+        tags: vec![collection.to_string()],
+        security: None, // No auth required for read operations
+    });
+    paths.insert(get_path, get_operations);
+
+    // Search operation (GET)
+    let search_path = format!("/{}.searchRecords", collection);
+    let mut search_operations = HashMap::new();
+    search_operations.insert("get".to_string(), OpenApiOperation {
+        operation_id: format!("search{}", collection.replace(".", "_")),
+        summary: format!("Search {} records", collection),
+        description: format!("Search records in the {} collection", collection),
+        parameters: Some(vec![
+            OpenApiParameter {
+                name: "slice".to_string(),
+                location: "query".to_string(),
+                description: "Slice URI to filter records by".to_string(),
+                required: true,
+                schema: string_schema_with_default(slice_uri),
+                example: Some(slice_uri.to_string()),
+            },
+            OpenApiParameter {
+                name: "query".to_string(),
+                location: "query".to_string(),
+                description: "Search query string".to_string(),
+                required: true,
+                schema: OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+            OpenApiParameter {
+                name: "field".to_string(),
+                location: "query".to_string(),
+                description: "Specific field to search in".to_string(),
+                required: false,
+                schema: OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+            OpenApiParameter {
+                name: "limit".to_string(),
+                location: "query".to_string(),
+                description: "Maximum number of records to return".to_string(),
+                required: false,
+                schema: OpenApiSchema {
+                    schema_type: "integer".to_string(),
+                    format: Some("int32".to_string()),
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+            OpenApiParameter {
+                name: "cursor".to_string(),
+                location: "query".to_string(),
+                description: "Pagination cursor".to_string(),
+                required: false,
+                schema: OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+                example: None,
+            },
+        ]),
+        request_body: None,
+        responses: create_list_responses(),
+        tags: vec![collection.to_string()],
+        security: None, // No auth required for read operations
+    });
+    paths.insert(search_path, search_operations);
+
+    // Create operation (POST)
+    let create_path = format!("/{}.create", collection);
+    let mut create_operations = HashMap::new();
+
+    // Generate schema from lexicon if available
+    let record_schema = if let Some(lexicon) = lexicon_data {
+        create_record_schema_from_lexicon(Some(lexicon))
+    } else {
+        OpenApiSchema {
+            schema_type: "object".to_string(),
+            format: None,
+            items: None,
+            properties: None,
+            required: None,
+            default: None,
+        }
+    };
+
+    create_operations.insert("post".to_string(), OpenApiOperation {
+        operation_id: format!("create{}", collection.replace(".", "_")),
+        summary: format!("Create {} record", collection),
+        description: format!("Create a new record in the {} collection", collection),
+        parameters: None,
+        request_body: Some(OpenApiRequestBody {
+            description: "Record data to create".to_string(),
+            content: {
+                let mut content = HashMap::new();
+                content.insert("application/json".to_string(), OpenApiMediaType {
+                    schema: record_schema.clone(),
+                });
+                content
+            },
+            required: true,
+        }),
+        responses: create_mutation_responses(),
+        tags: vec![collection.to_string()],
+        security: Some(create_bearer_auth_security()), // Auth required for mutations
+    });
+    paths.insert(create_path, create_operations);
+
+    // Update operation (POST)
+    let update_path = format!("/{}.update", collection);
+    let mut update_operations = HashMap::new();
+    update_operations.insert("post".to_string(), OpenApiOperation {
+        operation_id: format!("update{}", collection.replace(".", "_")),
+        summary: format!("Update {} record", collection),
+        description: format!("Update an existing record in the {} collection", collection),
+        parameters: None,
+        request_body: Some(OpenApiRequestBody {
+            description: "Record data and rkey to update".to_string(),
+            content: {
+                let mut content = HashMap::new();
+                content.insert("application/json".to_string(), OpenApiMediaType {
+                    schema: OpenApiSchema {
+                        schema_type: "object".to_string(),
+                        format: None,
+                        items: None,
+                        properties: Some({
+                            let mut props = HashMap::new();
+                            props.insert("rkey".to_string(), OpenApiSchema {
+                                schema_type: "string".to_string(),
+                                format: None,
+                                items: None,
+                                properties: None,
+                                required: None,
+                                default: None,
+                            });
+                            props.insert("record".to_string(), record_schema.clone());
+                            props
+                        }),
+                        required: Some(vec!["rkey".to_string(), "record".to_string()]),
+                        default: None,
+                    },
+                });
+                content
+            },
+            required: true,
+        }),
+        responses: create_mutation_responses(),
+        tags: vec![collection.to_string()],
+        security: Some(create_bearer_auth_security()), // Auth required for mutations
+    });
+    paths.insert(update_path, update_operations);
+
+    // Delete operation (POST)
+    let delete_path = format!("/{}.delete", collection);
+    let mut delete_operations = HashMap::new();
+    delete_operations.insert("post".to_string(), OpenApiOperation {
+        operation_id: format!("delete{}", collection.replace(".", "_")),
+        summary: format!("Delete {} record", collection),
+        description: format!("Delete a record from the {} collection", collection),
+        parameters: None,
+        request_body: Some(OpenApiRequestBody {
+            description: "Record key to delete".to_string(),
+            content: {
+                let mut content = HashMap::new();
+                content.insert("application/json".to_string(), OpenApiMediaType {
+                    schema: OpenApiSchema {
+                        schema_type: "object".to_string(),
+                        format: None,
+                        items: None,
+                        properties: Some({
+                            let mut props = HashMap::new();
+                            props.insert("rkey".to_string(), OpenApiSchema {
+                                schema_type: "string".to_string(),
+                                format: None,
+                                items: None,
+                                properties: None,
+                                required: None,
+                                default: None,
+                            });
+                            props
+                        }),
+                        required: Some(vec!["rkey".to_string()]),
+                        default: None,
+                    },
+                });
+                content
+            },
+            required: true,
+        }),
+        responses: create_delete_responses(),
+        tags: vec![collection.to_string()],
+        security: Some(create_bearer_auth_security()), // Auth required for mutations
+    });
+    paths.insert(delete_path, delete_operations);
+}
+
+fn create_collection_schemas(_collection: &str, _lexicon_data: Option<&serde_json::Value>, schemas: &mut HashMap<String, OpenApiSchema>) {
+    // IndexedRecord schema
+    let mut record_props = HashMap::new();
+    record_props.insert("uri".to_string(), OpenApiSchema {
+        schema_type: "string".to_string(),
+        format: None,
+        items: None,
+        properties: None,
+        required: None,
+                    default: None,
+    });
+    record_props.insert("cid".to_string(), OpenApiSchema {
+        schema_type: "string".to_string(),
+        format: None,
+        items: None,
+        properties: None,
+        required: None,
+                    default: None,
+    });
+    record_props.insert("did".to_string(), OpenApiSchema {
+        schema_type: "string".to_string(),
+        format: None,
+        items: None,
+        properties: None,
+        required: None,
+                    default: None,
+    });
+    record_props.insert("collection".to_string(), OpenApiSchema {
+        schema_type: "string".to_string(),
+        format: None,
+        items: None,
+        properties: None,
+        required: None,
+                    default: None,
+    });
+    record_props.insert("value".to_string(), OpenApiSchema {
+        schema_type: "object".to_string(),
+        format: None,
+        items: None,
+        properties: None,
+        required: None,
+                    default: None,
+    });
+    record_props.insert("indexed_at".to_string(), OpenApiSchema {
+        schema_type: "string".to_string(),
+        format: Some("date-time".to_string()),
+        items: None,
+        properties: None,
+        required: None,
+                    default: None,
+    });
+
+    schemas.insert("IndexedRecord".to_string(), OpenApiSchema {
+        schema_type: "object".to_string(),
+        format: None,
+        items: None,
+        properties: Some(record_props),
+        required: Some(vec!["uri".to_string(), "cid".to_string(), "did".to_string(), "collection".to_string(), "value".to_string(), "indexed_at".to_string()]),
+                    default: None,
+    });
+
+    // ListRecordsOutput schema
+    let mut list_props = HashMap::new();
+    list_props.insert("records".to_string(), OpenApiSchema {
+        schema_type: "array".to_string(),
+        format: None,
+        items: Some(Box::new(OpenApiSchema {
+            schema_type: "object".to_string(),
+            format: None,
+            items: None,
+            properties: None,
+            required: None,
+            default: None,
+        })),
+        properties: None,
+        required: None,
+        default: None,
+    });
+    list_props.insert("cursor".to_string(), OpenApiSchema {
+        schema_type: "string".to_string(),
+        format: None,
+        items: None,
+        properties: None,
+        required: None,
+                    default: None,
+    });
+
+    schemas.insert("ListRecordsOutput".to_string(), OpenApiSchema {
+        schema_type: "object".to_string(),
+        format: None,
+        items: None,
+        properties: Some(list_props),
+        required: Some(vec!["records".to_string()]),
+                    default: None,
+    });
+}
+
+fn create_list_responses() -> HashMap<String, OpenApiResponse> {
+    let mut responses = HashMap::new();
+
+    responses.insert("200".to_string(), OpenApiResponse {
+        description: "Successfully retrieved records".to_string(),
+        content: Some({
+            let mut content = HashMap::new();
+            content.insert("application/json".to_string(), OpenApiMediaType {
+                schema: OpenApiSchema {
+                    schema_type: "object".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+            });
+            content
+        }),
+    });
+
+    responses.insert("400".to_string(), OpenApiResponse {
+        description: "Bad request".to_string(),
+        content: None,
+    });
+
+    responses.insert("500".to_string(), OpenApiResponse {
+        description: "Internal server error".to_string(),
+        content: None,
+    });
+
+    responses
+}
+
+fn create_get_responses() -> HashMap<String, OpenApiResponse> {
+    let mut responses = HashMap::new();
+
+    responses.insert("200".to_string(), OpenApiResponse {
+        description: "Successfully retrieved record".to_string(),
+        content: Some({
+            let mut content = HashMap::new();
+            content.insert("application/json".to_string(), OpenApiMediaType {
+                schema: OpenApiSchema {
+                    schema_type: "object".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+            });
+            content
+        }),
+    });
+
+    responses.insert("404".to_string(), OpenApiResponse {
+        description: "Record not found".to_string(),
+        content: None,
+    });
+
+    responses.insert("500".to_string(), OpenApiResponse {
+        description: "Internal server error".to_string(),
+        content: None,
+    });
+
+    responses
+}
+
+fn create_mutation_responses() -> HashMap<String, OpenApiResponse> {
+    let mut responses = HashMap::new();
+
+    responses.insert("200".to_string(), OpenApiResponse {
+        description: "Successfully created/updated record".to_string(),
+        content: Some({
+            let mut content = HashMap::new();
+            content.insert("application/json".to_string(), OpenApiMediaType {
+                schema: OpenApiSchema {
+                    schema_type: "object".to_string(),
+                    format: None,
+                    items: None,
+                    properties: Some({
+                        let mut props = HashMap::new();
+                        props.insert("uri".to_string(), OpenApiSchema {
+                            schema_type: "string".to_string(),
+                            format: None,
+                            items: None,
+                            properties: None,
+                            required: None,
+                            default: None,
+                        });
+                        props.insert("cid".to_string(), OpenApiSchema {
+                            schema_type: "string".to_string(),
+                            format: None,
+                            items: None,
+                            properties: None,
+                            required: None,
+                            default: None,
+                        });
+                        props
+                    }),
+                    required: Some(vec!["uri".to_string(), "cid".to_string()]),
+                    default: None,
+                },
+            });
+            content
+        }),
+    });
+
+    responses.insert("400".to_string(), OpenApiResponse {
+        description: "Bad request".to_string(),
+        content: None,
+    });
+
+    responses.insert("401".to_string(), OpenApiResponse {
+        description: "Unauthorized".to_string(),
+        content: None,
+    });
+
+    responses.insert("500".to_string(), OpenApiResponse {
+        description: "Internal server error".to_string(),
+        content: None,
+    });
+
+    responses
+}
+
+fn create_delete_responses() -> HashMap<String, OpenApiResponse> {
+    let mut responses = HashMap::new();
+
+    responses.insert("200".to_string(), OpenApiResponse {
+        description: "Successfully deleted record".to_string(),
+        content: Some({
+            let mut content = HashMap::new();
+            content.insert("application/json".to_string(), OpenApiMediaType {
+                schema: OpenApiSchema {
+                    schema_type: "object".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+            default: None,
+                },
+            });
+            content
+        }),
+    });
+
+    responses.insert("400".to_string(), OpenApiResponse {
+        description: "Bad request".to_string(),
+        content: None,
+    });
+
+    responses.insert("401".to_string(), OpenApiResponse {
+        description: "Unauthorized".to_string(),
+        content: None,
+    });
+
+    responses.insert("404".to_string(), OpenApiResponse {
+        description: "Record not found".to_string(),
+        content: None,
+    });
+
+    responses.insert("500".to_string(), OpenApiResponse {
+        description: "Internal server error".to_string(),
+        content: None,
+    });
+
+    responses
+}
+
+fn string_schema_with_default(default_value: &str) -> OpenApiSchema {
+    OpenApiSchema {
+        schema_type: "string".to_string(),
+        format: None,
+        items: None,
+        properties: None,
+        required: None,
+        default: Some(serde_json::Value::String(default_value.to_string())),
+    }
+}
+
+fn create_record_schema_from_lexicon(lexicon_data: Option<&serde_json::Value>) -> OpenApiSchema {
+    if let Some(lexicon) = lexicon_data {
+        // Get the definitions object directly (it's already parsed JSON, not a string)
+        if let Some(definitions) = lexicon.get("definitions") {
+                if let Some(main_def) = definitions.get("main") {
+                    if let Some(record_def) = main_def.get("record") {
+                        if let Some(properties) = record_def.get("properties") {
+                    // Convert lexicon properties to OpenAPI schema properties
+                    let mut openapi_props = HashMap::new();
+                    let mut required_fields = Vec::new();
+
+                    if let Some(props_obj) = properties.as_object() {
+                        for (prop_name, prop_def) in props_obj {
+                            if let Some(prop_schema) = convert_lexicon_property_to_openapi(prop_def) {
+                                openapi_props.insert(prop_name.clone(), prop_schema);
+
+                                // Check if field is required
+                                if let Some(required) = prop_def.get("required") {
+                                    if required.as_bool().unwrap_or(false) {
+                                        required_fields.push(prop_name.clone());
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    return OpenApiSchema {
+                        schema_type: "object".to_string(),
+                        format: None,
+                        items: None,
+                        properties: Some(openapi_props),
+                        required: if required_fields.is_empty() { None } else { Some(required_fields) },
+                        default: None,
+                    };
+                        }
+                    }
+                }
+        }
+    }
+
+    // Fallback to generic object schema (without rkey - that's a separate request parameter)
+    OpenApiSchema {
+        schema_type: "object".to_string(),
+        format: None,
+        items: None,
+        properties: Some(HashMap::new()),
+        required: None,
+        default: None,
+    }
+}
+
+fn convert_lexicon_property_to_openapi(prop_def: &serde_json::Value) -> Option<OpenApiSchema> {
+    let prop_type = prop_def.get("type")?.as_str()?;
+
+    match prop_type {
+        "string" => Some(OpenApiSchema {
+            schema_type: "string".to_string(),
+            format: None,
+            items: None,
+            properties: None,
+            required: None,
+            default: None,
+        }),
+        "integer" => Some(OpenApiSchema {
+            schema_type: "integer".to_string(),
+            format: Some("int64".to_string()),
+            items: None,
+            properties: None,
+            required: None,
+            default: None,
+        }),
+        "boolean" => Some(OpenApiSchema {
+            schema_type: "boolean".to_string(),
+            format: None,
+            items: None,
+            properties: None,
+            required: None,
+            default: None,
+        }),
+        "blob" => Some(OpenApiSchema {
+            schema_type: "object".to_string(),
+            format: None,
+            items: None,
+            properties: Some({
+                let mut blob_props = HashMap::new();
+                blob_props.insert("$type".to_string(), OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+                    default: None,
+                });
+                blob_props.insert("ref".to_string(), OpenApiSchema {
+                    schema_type: "object".to_string(),
+                    format: None,
+                    items: None,
+                    properties: Some({
+                        let mut ref_props = HashMap::new();
+                        ref_props.insert("$link".to_string(), OpenApiSchema {
+                            schema_type: "string".to_string(),
+                            format: None,
+                            items: None,
+                            properties: None,
+                            required: None,
+                            default: None,
+                        });
+                        ref_props
+                    }),
+                    required: Some(vec!["$link".to_string()]),
+                    default: None,
+                });
+                blob_props.insert("mimeType".to_string(), OpenApiSchema {
+                    schema_type: "string".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+                    default: None,
+                });
+                blob_props.insert("size".to_string(), OpenApiSchema {
+                    schema_type: "integer".to_string(),
+                    format: Some("int64".to_string()),
+                    items: None,
+                    properties: None,
+                    required: None,
+                    default: None,
+                });
+                blob_props
+            }),
+            required: Some(vec!["$type".to_string(), "ref".to_string(), "mimeType".to_string(), "size".to_string()]),
+            default: None,
+        }),
+        "array" => {
+            if let Some(items_def) = prop_def.get("items") {
+                if let Some(items_schema) = convert_lexicon_property_to_openapi(items_def) {
+                    return Some(OpenApiSchema {
+                        schema_type: "array".to_string(),
+                        format: None,
+                        items: Some(Box::new(items_schema)),
+                        properties: None,
+                        required: None,
+                        default: None,
+                    });
+                }
+            }
+            Some(OpenApiSchema {
+                schema_type: "array".to_string(),
+                format: None,
+                items: Some(Box::new(OpenApiSchema {
+                    schema_type: "object".to_string(),
+                    format: None,
+                    items: None,
+                    properties: None,
+                    required: None,
+                    default: None,
+                })),
+                properties: None,
+                required: None,
+                default: None,
+            })
+        },
+        "object" => Some(OpenApiSchema {
+            schema_type: "object".to_string(),
+            format: None,
+            items: None,
+            properties: None,
+            required: None,
+            default: None,
+        }),
+        _ => Some(OpenApiSchema {
+            schema_type: "object".to_string(),
+            format: None,
+            items: None,
+            properties: None,
+            required: None,
+            default: None,
+        }),
+    }
+}
+
+fn create_security_schemes() -> HashMap<String, OpenApiSecurityScheme> {
+    let mut schemes = HashMap::new();
+    
+    schemes.insert("bearerAuth".to_string(), OpenApiSecurityScheme {
+        scheme_type: "http".to_string(),
+        scheme: "bearer".to_string(),
+        bearer_format: None, // OAuth token, not JWT
+        description: "OAuth Bearer token authentication. Use your OAuth access token from the auth server.".to_string(),
+        example: None,
+    });
+    
+    schemes
+}
+
+fn create_bearer_auth_security() -> Vec<HashMap<String, Vec<String>>> {
+    let mut auth_requirement = HashMap::new();
+    auth_requirement.insert("bearerAuth".to_string(), vec![]);
+    vec![auth_requirement]
+}

api/src/main.rs

···
 mod database;
 mod errors;
 mod handler_jobs;
+mod handler_openapi_spec;
 mod handler_records;
 mod handler_stats;
 mod handler_sync;
···
             "/xrpc/social.slices.slice.codegen",
             post(handler_xrpc_codegen::generate_client_xrpc),
         )
+        .route("/xrpc/social.slices.slice.openapi", get(handler_openapi_spec::get_openapi_spec))
         // Dynamic collection-specific XRPC endpoints (wildcard routes must come last)
         .route(
             "/xrpc/*method",

frontend/src/pages/SliceApiDocsPage.tsx

···
+interface SliceApiDocsPageProps {
+  sliceId: string;
+  sliceName: string;
+  accessToken?: string;
+  currentUser: {
+    isAuthenticated: boolean;
+    username?: string;
+    sub?: string;
+  };
+}
+
+export function SliceApiDocsPage(props: SliceApiDocsPageProps) {
+  const { sliceId, sliceName, accessToken, currentUser } = props;
+
+  // Construct the OpenAPI spec URL for this slice
+  const baseUrl =
+    typeof window !== "undefined"
+      ? globalThis.location.origin.replace(":8000", ":3000") // Frontend runs on 8000, API on 3000
+      : "http://localhost:3000";
+
+  // Build the slice URI
+  const sliceUri = `at://${currentUser.sub}/social.slices.slice/${sliceId}`;
+  const openApiUrl = `${baseUrl}/xrpc/social.slices.slice.openapi?slice=${encodeURIComponent(
+    sliceUri
+  )}`;
+
+  return (
+    <html lang="en">
+      <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>API Docs - {sliceName}</title>
+        <script src="https://cdn.tailwindcss.com"></script>
+      </head>
+      <body class="bg-gray-50 min-h-screen">
+      {/* Header with back button */}
+      <div class="bg-white border-b border-gray-200 px-4 py-4">
+        <div class="max-w-7xl mx-auto flex items-center justify-between">
+          <div class="flex items-center">
+            <a
+              href={`/slices/${sliceId}`}
+              class="text-blue-600 hover:text-blue-800 mr-4 flex items-center"
+            >
+              <svg
+                class="w-4 h-4 mr-1"
+                fill="none"
+                stroke="currentColor"
+                viewBox="0 0 24 24"
+              >
+                <path
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  stroke-width="2"
+                  d="M15 19l-7-7 7-7"
+                />
+              </svg>
+              Back to {sliceName}
+            </a>
+          </div>
+          <div class="text-right">
+            <h1 class="text-xl font-semibold text-gray-900">API Documentation</h1>
+            <p class="text-gray-600 text-sm">
+              Interactive OpenAPI docs for your slice
+            </p>
+          </div>
+        </div>
+      </div>
+
+        {/* Info bar */}
+        <div class="bg-blue-50 border-b border-blue-200 px-4 py-3">
+          <div class="max-w-7xl mx-auto">
+            <p class="text-blue-800 text-sm">
+              <strong>OpenAPI Spec URL:</strong>
+              <code class="ml-2 bg-blue-100 px-2 py-1 rounded text-xs">
+                {openApiUrl}
+              </code>
+            </p>
+          </div>
+        </div>
+
+        {/* Scalar API Reference Container - Scrollable */}
+        <div class="w-full">
+          <div id="scalar-api-reference" class="w-full min-h-screen">
+            <div class="flex items-center justify-center h-96">
+              <div class="text-center">
+                <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-500 mx-auto mb-4"></div>
+                <p class="text-gray-500">Loading API documentation...</p>
+              </div>
+            </div>
+          </div>
+        </div>
+
+      {/* Load Scalar API Reference */}
+      <script
+        src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"
+        async
+      ></script>
+
+      {/* Initialize Scalar when the script loads */}
+      <script
+        dangerouslySetInnerHTML={{
+          __html: `
+            document.addEventListener('DOMContentLoaded', function() {
+              // Wait for Scalar to be available
+              const initScalar = () => {
+                if (typeof Scalar !== 'undefined' && Scalar.createApiReference) {
+                  try {
+                    Scalar.createApiReference('#scalar-api-reference', {
+                      url: '${openApiUrl}',
+                      configuration: {
+                        theme: 'alternate',
+                        layout: 'modern',
+                        showSidebar: true,
+                        searchHotKey: 'k',
+                        defaultHttpClient: {
+                          targetKey: 'javascript',
+                          clientKey: 'fetch'
+                        }
+                      },
+                      // Try to set default parameters
+                      variables: {
+                        slice: '${sliceUri}'
+                      },
+                      // Alternative approach for parameter defaults
+                      defaultParameters: {
+                        slice: '${sliceUri}'
+                      },${accessToken ? `
+                      authentication: {
+                        preferredSecurityScheme: 'bearerAuth',
+                        http: {
+                          bearer: {
+                            token: '${accessToken}'
+                          }
+                        }
+                      },` : ''}
+                      customCss: \`
+                        .scalar-api-reference {
+                          width: 100% !important;
+                          border: none !important;
+                          min-height: 100vh;
+                          height: auto !important;
+                        }
+                        .scalar-api-reference > div {
+                          height: auto !important;
+                        }
+                      \`,
+                      onReady: () => {
+                        console.log('Scalar API Reference loaded successfully');
+                      },
+                      onError: (error) => {
+                        console.error('Failed to load API documentation:', error);
+                        document.getElementById('scalar-api-reference').innerHTML = \`
+                          <div class="flex items-center justify-center h-64 text-center">
+                            <div>
+                              <div class="text-red-500 mb-4">
+                                <svg class="w-12 h-12 mx-auto" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                  <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                        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"/>
+                                </svg>
+                              </div>
+                              <h3 class="text-lg font-medium text-gray-900 mb-2">Failed to load API documentation</h3>
+                              <p class="text-gray-600 text-sm mb-4">
+                                Unable to fetch the OpenAPI specification. Please make sure the API server is running.
+                              </p>
+                              <button
+                                onclick="window.location.reload()"
+                                class="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded-md text-sm font-medium"
+                              >
+                                Retry
+                              </button>
+                            </div>
+                          </div>
+                        \`;
+                      }
+                    });
+                  } catch (error) {
+                    console.error('Error initializing Scalar:', error);
+                  }
+                } else {
+                  // Retry after a short delay
+                  setTimeout(initScalar, 100);
+                }
+              };
+
+              // Start initialization
+              initScalar();
+            });
+          `,
+        }}
+      />
+      </body>
+    </html>
+  );
+}

frontend/src/pages/SlicePage.tsx

···
 
           <div className="bg-white rounded-lg shadow-md p-6">
             <h2 className="text-xl font-semibold text-gray-800 mb-4">
+              📖 API Documentation
+            </h2>
+            <p className="text-gray-600 mb-4">
+              Interactive OpenAPI documentation for your slice's XRPC endpoints.
+            </p>
+            <a
+              href={`/slices/${sliceId}/api-docs`}
+              className="bg-indigo-500 hover:bg-indigo-600 text-white px-4 py-2 rounded"
+            >
+              View API Docs
+            </a>
+          </div>
+
+          <div className="bg-white rounded-lg shadow-md p-6">
+            <h2 className="text-xl font-semibold text-gray-800 mb-4">
               🔄 Sync
             </h2>
             <p className="text-gray-600 mb-4">

frontend/src/routes/pages.tsx

···
 import { SliceSyncPage } from "../pages/SliceSyncPage.tsx";
 import { SliceLexiconPage } from "../pages/SliceLexiconPage.tsx";
 import { SliceCodegenPage } from "../pages/SliceCodegenPage.tsx";
+import { SliceApiDocsPage } from "../pages/SliceApiDocsPage.tsx";
 import { SliceSettingsPage } from "../pages/SliceSettingsPage.tsx";
 import { SettingsPage } from "../pages/SettingsPage.tsx";
 
 async function handleIndexPage(req: Request): Promise<Response> {
   const context = await withAuth(req);
-  
+
   // Slice list page - get real slices from AT Protocol
   let slices: Array<{ id: string; name: string; createdAt: string }> = [];
 
···
   });
 }
 
+async function handleSliceApiDocsPage(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const context = await withAuth(req);
+  const sliceId = params?.pathname.groups.id;
+
+  if (!sliceId) {
+    return Response.redirect(new URL("/", req.url), 302);
+  }
+
+  // Get OAuth access token if available
+  let accessToken: string | undefined;
+  try {
+    const tokens = await atprotoClient.oauth?.ensureValidToken();
+    accessToken = tokens?.accessToken;
+  } catch (error) {
+    console.log("Could not get OAuth token:", error);
+  }
+
+  // Get real slice data from AT Protocol
+  let sliceData = {
+    sliceId,
+    sliceName: "Unknown Slice",
+    accessToken,
+  };
+
+  if (context.currentUser.isAuthenticated) {
+    try {
+      const sliceUri = buildAtUri({
+        did: context.currentUser.sub!,
+        collection: "social.slices.slice",
+        rkey: sliceId,
+      });
+
+      const sliceRecord = await atprotoClient.social.slices.slice.getRecord({
+        uri: sliceUri,
+      });
+
+      sliceData = {
+        sliceId,
+        sliceName: sliceRecord.value.name,
+        accessToken,
+      };
+    } catch (error) {
+      console.error("Failed to fetch slice data:", error);
+      // Fall back to default data
+    }
+  }
+
+  const html = render(
+    <SliceApiDocsPage {...sliceData} currentUser={context.currentUser} />
+  );
+
+  const responseHeaders: Record<string, string> = {
+    "content-type": "text/html",
+  };
+
+  return new Response(`<!DOCTYPE html>${html}`, {
+    status: 200,
+    headers: responseHeaders,
+  });
+}
+
 async function handleSettingsPage(req: Request): Promise<Response> {
   const context = await withAuth(req);
 
···
   {
     pattern: new URLPattern({ pathname: "/slices/:id" }),
     handler: handleSlicePage,
+  },
+  {
+    pattern: new URLPattern({ pathname: "/slices/:id/api-docs" }),
+    handler: handleSliceApiDocsPage,
   },
   {
     pattern: new URLPattern({ pathname: "/slices/:id/:tab" }),