remove .bak ugh

api/src/api/xrpc_dynamic.rs.bak

···
-use atproto_client::com::atproto::repo::{
-    CreateRecordRequest, CreateRecordResponse, DeleteRecordRequest, PutRecordRequest,
-    PutRecordResponse, create_record, delete_record, put_record,
-};
-use axum::{
-    extract::{Path, Query, State},
-    http::HeaderMap,
-    response::Json,
-};
-use chrono::Utc;
-use serde::Deserialize;
-
-use crate::AppState;
-use crate::auth::{
-    extract_bearer_token, get_atproto_auth_for_user_cached, verify_oauth_token_cached,
-};
-use crate::errors::AppError;
-use crate::models::{
-    IndexedRecord, Record, SliceRecordsOutput, SliceRecordsParams, SortField, WhereCondition,
-};
-use std::collections::HashMap;
-
-
-#[derive(Deserialize)]
-pub struct GetRecordParams {
-    pub uri: String,
-    pub slice: String,
-}
-
-// Dynamic XRPC handler that routes based on method name (for GET requests)
-pub async fn dynamic_xrpc_handler(
-    Path(method): Path<String>,
-    State(state): State<AppState>,
-    Query(params): Query<serde_json::Value>,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Parse the XRPC method (e.g., "social.grain.gallery.getRecords")
-    if method.ends_with(".getRecords") {
-        let collection = method.trim_end_matches(".getRecords").to_string();
-        dynamic_get_records_handler(collection, state, params).await
-    } else if method.ends_with(".countRecords") {
-        let collection = method.trim_end_matches(".countRecords").to_string();
-        dynamic_count_records_handler(collection, state, params).await
-    } else if method.ends_with(".getRecord") {
-        let collection = method.trim_end_matches(".getRecord").to_string();
-        dynamic_get_record_impl(collection, state, params).await
-    } else {
-        Err(AppError::NotFound("Unknown XRPC method".to_string()))
-    }
-}
-
-// Dynamic XRPC handler for POST requests (create, update, delete)
-pub async fn dynamic_xrpc_post_handler(
-    Path(method): Path<String>,
-    State(state): State<AppState>,
-    headers: HeaderMap,
-    Json(body): Json<serde_json::Value>,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Handle dynamic collection methods (e.g., social.grain.gallery.createRecord)
-    if method.ends_with(".getRecords") {
-        let collection = method.trim_end_matches(".getRecords").to_string();
-        dynamic_get_records_post_handler(collection, state, body).await
-    } else if method.ends_with(".countRecords") {
-        let collection = method.trim_end_matches(".countRecords").to_string();
-        dynamic_count_records_post_handler(collection, state, body).await
-    } else if method.ends_with(".createRecord") {
-        let collection = method.trim_end_matches(".createRecord").to_string();
-        dynamic_collection_create_impl(state, headers, body, collection).await
-    } else if method.ends_with(".updateRecord") {
-        let collection = method.trim_end_matches(".updateRecord").to_string();
-        dynamic_collection_update_impl(state, headers, body, collection).await
-    } else if method.ends_with(".deleteRecord") {
-        let collection = method.trim_end_matches(".deleteRecord").to_string();
-        dynamic_collection_delete_impl(state, headers, body, collection).await
-    } else {
-        Err(AppError::NotFound("Method not found".to_string()))
-    }
-}
-
-// Handler for get records using unified where clause approach
-async fn dynamic_get_records_handler(
-    collection: String,
-    state: AppState,
-    params: serde_json::Value,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Parse parameters into SliceRecordsParams format
-    let slice = params
-        .get("slice")
-        .and_then(|v| v.as_str())
-        .ok_or(AppError::BadRequest("Missing slice parameter".to_string()))?
-        .to_string();
-
-    let limit = params.get("limit").and_then(|v| {
-        if let Some(s) = v.as_str() {
-            s.parse::<i32>().ok()
-        } else {
-            v.as_i64().map(|i| i as i32)
-        }
-    });
-
-    let cursor = params
-        .get("cursor")
-        .and_then(|v| v.as_str())
-        .map(|s| s.to_string());
-
-    // Parse sortBy from params - convert legacy sort string to new array format if present
-    let sort_by = params.get("sort").and_then(|v| v.as_str()).map(|sort_str| {
-        // Convert legacy "field:direction" format to new array format
-        let mut sort_fields = Vec::new();
-        for sort_item in sort_str.split(',') {
-            let parts: Vec<&str> = sort_item.trim().split(':').collect();
-            if parts.len() == 2 {
-                sort_fields.push(SortField {
-                    field: parts[0].trim().to_string(),
-                    direction: parts[1].trim().to_string(),
-                });
-            } else if parts.len() == 1 && !parts[0].is_empty() {
-                // Default to ascending if no direction specified
-                sort_fields.push(SortField {
-                    field: parts[0].trim().to_string(),
-                    direction: "asc".to_string(),
-                });
-            }
-        }
-        sort_fields
-    });
-
-    // Parse where conditions from query params if present
-    let mut where_conditions = HashMap::new();
-
-    // Handle legacy author/authors params by converting to where clause
-    if let Some(author_str) = params.get("author").and_then(|v| v.as_str()) {
-        where_conditions.insert(
-            "did".to_string(),
-            WhereCondition {
-                eq: Some(serde_json::Value::String(author_str.to_string())),
-                in_values: None,
-                contains: None,
-            },
-        );
-    } else if let Some(authors_str) = params.get("authors").and_then(|v| v.as_str()) {
-        let authors: Vec<serde_json::Value> = authors_str
-            .split(',')
-            .map(|s| serde_json::Value::String(s.trim().to_string()))
-            .collect();
-        where_conditions.insert(
-            "did".to_string(),
-            WhereCondition {
-                eq: None,
-                in_values: Some(authors),
-                contains: None,
-            },
-        );
-    }
-
-    // Handle legacy query param by converting to where clause with contains
-    if let Some(query_str) = params.get("query").and_then(|v| v.as_str()) {
-        let field = params
-            .get("field")
-            .and_then(|v| v.as_str())
-            .unwrap_or("text"); // Default to text field for search
-        where_conditions.insert(
-            field.to_string(),
-            WhereCondition {
-                eq: None,
-                in_values: None,
-                contains: Some(query_str.to_string()),
-            },
-        );
-    }
-
-    // Add collection filter to where conditions
-    where_conditions.insert(
-        "collection".to_string(),
-        WhereCondition {
-            eq: Some(serde_json::Value::String(collection.clone())),
-            in_values: None,
-            contains: None,
-        },
-    );
-
-    let where_clause = Some(crate::models::WhereClause {
-        conditions: where_conditions,
-        or_conditions: None,
-    });
-
-    let records_params = SliceRecordsParams {
-        slice,
-        limit,
-        cursor,
-        where_clause,
-        sort_by: sort_by.clone(),
-    };
-
-    // First verify the collection belongs to this slice
-    let slice_collections = state
-        .database
-        .get_slice_collections_list(&records_params.slice)
-        .await
-        .map_err(|_| AppError::Internal("Database error".to_string()))?;
-
-    // Special handling: network.slices.lexicon is always allowed as it defines the schema
-    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
-        return Err(AppError::NotFound("Collection not found".to_string()));
-    }
-
-    // Use the unified database method
-    match state
-        .database
-        .get_slice_collections_records(
-            &records_params.slice,
-            records_params.limit,
-            records_params.cursor.as_deref(),
-            sort_by.as_ref(),
-            records_params.where_clause.as_ref(),
-        )
-        .await
-    {
-        Ok((records, cursor)) => {
-            // No need to filter - collection filter is in the SQL query now
-
-            let indexed_records: Vec<IndexedRecord> = records
-                .into_iter()
-                .map(|record| IndexedRecord {
-                    uri: record.uri,
-                    cid: record.cid,
-                    did: record.did,
-                    collection: record.collection,
-                    value: record.json,
-                    indexed_at: record.indexed_at.to_rfc3339(),
-                })
-                .collect();
-
-            let output = SliceRecordsOutput {
-                records: indexed_records,
-                cursor,
-            };
-
-            Ok(Json(
-                serde_json::to_value(output).map_err(|_| AppError::Internal("Serialization error".to_string()))?,
-            ))
-        }
-        Err(_) => Err(AppError::Internal("Database error".to_string())),
-    }
-}
-
-// Implementation for get record
-async fn dynamic_get_record_impl(
-    collection: String,
-    state: AppState,
-    params: serde_json::Value,
-) -> Result<Json<serde_json::Value>, AppError> {
-    let get_params: GetRecordParams =
-        serde_json::from_value(params).map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?;
-
-    // First verify the collection belongs to this slice
-    let slice_collections = state
-        .database
-        .get_slice_collections_list(&get_params.slice)
-        .await
-        .map_err(|_| AppError::Internal("Database error".to_string()))?;
-
-    // Special handling: network.slices.lexicon is always allowed as it defines the schema
-    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
-        return Err(AppError::NotFound("Collection not found".to_string()));
-    }
-
-    // Use direct database query by URI for efficiency
-    match state.database.get_record(&get_params.uri).await {
-        Ok(Some(record)) => {
-            let json_value =
-                serde_json::to_value(record).map_err(|_| AppError::Internal("Serialization error".to_string()))?;
-            Ok(Json(json_value))
-        }
-        Ok(None) => Err(AppError::NotFound("Record not found".to_string())),
-        Err(_e) => Err(AppError::Internal("Database error".to_string())),
-    }
-}
-
-// Handler for get records via POST with JSON body
-async fn dynamic_get_records_post_handler(
-    collection: String,
-    state: AppState,
-    body: serde_json::Value,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Parse the JSON body into SliceRecordsParams
-    let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?;
-
-    // First verify the collection belongs to this slice
-    let slice_collections = state
-        .database
-        .get_slice_collections_list(&records_params.slice)
-        .await
-        .map_err(|_| AppError::Internal("Database error".to_string()))?;
-
-    // Special handling: network.slices.lexicon is always allowed as it defines the schema
-    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
-        return Err(AppError::NotFound("Collection not found".to_string()));
-    }
-
-    // Add collection filter to where conditions
-    let mut where_clause = records_params
-        .where_clause
-        .unwrap_or(crate::models::WhereClause {
-            conditions: HashMap::new(),
-            or_conditions: None,
-        });
-    where_clause.conditions.insert(
-        "collection".to_string(),
-        WhereCondition {
-            eq: Some(serde_json::Value::String(collection.clone())),
-            in_values: None,
-            contains: None,
-        },
-    );
-    records_params.where_clause = Some(where_clause);
-
-    // Use the unified database method
-    match state
-        .database
-        .get_slice_collections_records(
-            &records_params.slice,
-            records_params.limit,
-            records_params.cursor.as_deref(),
-            records_params.sort_by.as_ref(),
-            records_params.where_clause.as_ref(),
-        )
-        .await
-    {
-        Ok((records, cursor)) => {
-            // No need to filter - collection filter is in the SQL query now
-
-            // Transform Record to IndexedRecord for the response
-            let indexed_records: Vec<IndexedRecord> = records
-                .into_iter()
-                .map(|record| IndexedRecord {
-                    uri: record.uri,
-                    cid: record.cid,
-                    did: record.did,
-                    collection: record.collection,
-                    value: record.json,
-                    indexed_at: record.indexed_at.to_rfc3339(),
-                })
-                .collect();
-
-            let output = SliceRecordsOutput {
-                records: indexed_records,
-                cursor,
-            };
-
-            Ok(Json(serde_json::to_value(output).map_err(|e| AppError::Internal(format!("Serialization error: {}", e)))?))
-        }
-        Err(e) => Err(AppError::Internal(format!("Database error: {}", e))),
-    }
-}
-
-// Dynamic count records handler for GET requests
-async fn dynamic_count_records_handler(
-    collection: String,
-    state: AppState,
-    params: serde_json::Value,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Convert query parameters to SliceRecordsParams
-    let mut records_params: SliceRecordsParams =
-        serde_json::from_value(params).map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?;
-
-    // First verify the collection belongs to this slice
-    let slice_collections = state
-        .database
-        .get_slice_collections_list(&records_params.slice)
-        .await
-        .map_err(|_| AppError::Internal("Database error".to_string()))?;
-
-    // Special handling: network.slices.lexicon is always allowed as it defines the schema
-    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
-        return Err(AppError::NotFound("Collection not found".to_string()));
-    }
-
-    // Add collection filter to where conditions
-    let mut where_clause = records_params
-        .where_clause
-        .unwrap_or(crate::models::WhereClause {
-            conditions: HashMap::new(),
-            or_conditions: None,
-        });
-    where_clause.conditions.insert(
-        "collection".to_string(),
-        WhereCondition {
-            eq: Some(collection.clone().into()),
-            contains: None,
-            in_values: None,
-        },
-    );
-    records_params.where_clause = Some(where_clause);
-
-    match state
-        .database
-        .count_slice_collections_records(
-            &records_params.slice,
-            records_params.where_clause.as_ref(),
-        )
-        .await
-    {
-        Ok(count) => Ok(Json(serde_json::json!({
-            "success": true,
-            "count": count,
-            "message": null
-        }))),
-        Err(_) => Ok(Json(serde_json::json!({
-            "success": false,
-            "count": 0,
-            "message": "Failed to count records"
-        }))),
-    }
-}
-
-// Dynamic count records handler for POST requests
-async fn dynamic_count_records_post_handler(
-    collection: String,
-    state: AppState,
-    body: serde_json::Value,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Parse the JSON body into SliceRecordsParams
-    let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?;
-
-    // First verify the collection belongs to this slice
-    let slice_collections = state
-        .database
-        .get_slice_collections_list(&records_params.slice)
-        .await
-        .map_err(|_| AppError::Internal("Database error".to_string()))?;
-
-    // Special handling: network.slices.lexicon is always allowed as it defines the schema
-    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
-        return Err(AppError::NotFound("Collection not found".to_string()));
-    }
-
-    // Add collection filter to where conditions
-    let mut where_clause = records_params
-        .where_clause
-        .unwrap_or(crate::models::WhereClause {
-            conditions: HashMap::new(),
-            or_conditions: None,
-        });
-    where_clause.conditions.insert(
-        "collection".to_string(),
-        WhereCondition {
-            eq: Some(collection.clone().into()),
-            in_values: None,
-            contains: None,
-        },
-    );
-    records_params.where_clause = Some(where_clause);
-
-    match state
-        .database
-        .count_slice_collections_records(
-            &records_params.slice,
-            records_params.where_clause.as_ref(),
-        )
-        .await
-    {
-        Ok(count) => Ok(Json(serde_json::json!({
-            "success": true,
-            "count": count,
-            "message": null
-        }))),
-        Err(_) => Ok(Json(serde_json::json!({
-            "success": false,
-            "count": 0,
-            "message": "Failed to count records"
-        }))),
-    }
-}
-
-// Dynamic collection create (e.g., social.grain.gallery.createRecord)
-async fn dynamic_collection_create_impl(
-    state: AppState,
-    headers: HeaderMap,
-    body: serde_json::Value,
-    collection: String,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Extract and verify OAuth token
-    let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
-    let user_info = verify_oauth_token_cached(
-        &token,
-        &state.config.auth_base_url,
-        Some(state.auth_cache.clone()),
-    )
-    .await
-    .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?;
-
-    // Get AT Protocol DPoP auth and PDS URL (with caching)
-    let (dpop_auth, pds_url) = get_atproto_auth_for_user_cached(
-        &token,
-        &state.config.auth_base_url,
-        Some(state.auth_cache.clone()),
-    )
-    .await
-    .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?;
-
-    // Extract the repo DID from user info
-    let repo = user_info.did.unwrap_or(user_info.sub);
-
-    // Create HTTP client
-    let http_client = reqwest::Client::new();
-
-    // Extract slice URI, rkey, and record value from structured body
-    let slice_uri = body
-        .get("slice")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))?
-        .to_string();
-
-    let record_key = body
-        .get("rkey")
-        .and_then(|v| v.as_str())
-        .filter(|s| !s.is_empty()) // Filter out empty strings
-        .map(|s| s.to_string());
-
-    let record_data = body
-        .get("record")
-        .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))?
-        .clone();
-
-    // Validate the record against its lexicon
-
-    // For network.slices.lexicon collection, validate against the system slice
-    let validation_slice_uri = if collection == "network.slices.lexicon" {
-        &state.config.system_slice_uri
-    } else {
-        &slice_uri
-    };
-
-    // Get lexicons for validation
-    match state
-        .database
-        .get_lexicons_by_slice(validation_slice_uri)
-        .await
-    {
-        Ok(lexicons) if !lexicons.is_empty() => {
-            if let Err(e) =
-                slices_lexicon::validate_record(lexicons, &collection, record_data.clone())
-            {
-                return Err(AppError::BadRequest(format!("ValidationError: {}", e)));
-            }
-        }
-        _ => {
-            // If no lexicons found, continue without validation (backwards compatibility)
-        }
-    }
-
-    // Create record using AT Protocol functions with DPoP
-
-    let create_request = CreateRecordRequest {
-        repo: repo.clone(),
-        collection: collection.clone(),
-        record_key,
-        record: record_data.clone(),
-        swap_commit: None,
-        validate: false,
-    };
-
-    let result = create_record(
-        &http_client,
-        &atproto_client::client::Auth::DPoP(dpop_auth),
-        &pds_url,
-        create_request,
-    )
-    .await
-    .map_err(|_e| AppError::Internal("AT Protocol request failed".to_string()))?;
-
-    // Extract URI and CID from the response enum
-    let (uri, cid) = match result {
-        CreateRecordResponse::StrongRef { uri, cid, .. } => (uri, cid),
-        CreateRecordResponse::Error(_e) => {
-            return Err(AppError::Internal("AT Protocol response error".to_string()));
-        }
-    };
-
-    // Also store in local database for indexing
-    let record = Record {
-        uri: uri.clone(),
-        cid: cid.clone(),
-        did: repo,
-        collection,
-        json: record_data,
-        indexed_at: Utc::now(),
-        slice_uri: Some(slice_uri),
-    };
-
-    // Store in local database (ignore errors as AT Protocol operation succeeded)
-    let _insert_result = state.database.insert_record(&record).await;
-
-    Ok(Json(serde_json::json!({
-        "uri": uri,
-        "cid": cid,
-    })))
-}
-
-// Dynamic collection update (e.g., social.grain.gallery.updateRecord)
-async fn dynamic_collection_update_impl(
-    state: AppState,
-    headers: HeaderMap,
-    body: serde_json::Value,
-    collection: String,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Extract and verify OAuth token
-    let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
-    let user_info = verify_oauth_token_cached(
-        &token,
-        &state.config.auth_base_url,
-        Some(state.auth_cache.clone()),
-    )
-    .await
-    .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?;
-
-    // Get AT Protocol DPoP auth and PDS URL (with caching)
-    let (dpop_auth, pds_url) = get_atproto_auth_for_user_cached(
-        &token,
-        &state.config.auth_base_url,
-        Some(state.auth_cache.clone()),
-    )
-    .await
-    .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?;
-
-    // Extract slice URI, rkey, and record value from structured body
-    let slice_uri = body
-        .get("slice")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))?
-        .to_string();
-
-    let rkey = body
-        .get("rkey")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))?
-        .to_string();
-
-    let record_data = body
-        .get("record")
-        .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))?
-        .clone();
-
-    // Extract repo from user info
-    let repo = user_info.did.unwrap_or(user_info.sub);
-
-    // Validate the record against its lexicon
-
-    // For network.slices.lexicon collection, validate against the system slice
-    let validation_slice_uri = if collection == "network.slices.lexicon" {
-        &state.config.system_slice_uri
-    } else {
-        &slice_uri
-    };
-
-    // Get lexicons for validation
-    match state
-        .database
-        .get_lexicons_by_slice(validation_slice_uri)
-        .await
-    {
-        Ok(lexicons) if !lexicons.is_empty() => {
-            if let Err(e) =
-                slices_lexicon::validate_record(lexicons, &collection, record_data.clone())
-            {
-                return Err(AppError::BadRequest(format!("ValidationError: {}", e)));
-            }
-        }
-        _ => {
-            // If no lexicons found, continue without validation (backwards compatibility)
-        }
-    }
-
-    // Create HTTP client
-    let http_client = reqwest::Client::new();
-
-    // Update record using AT Protocol functions with DPoP
-    let put_request = PutRecordRequest {
-        repo: repo.clone(),
-        collection: collection.clone(),
-        record_key: rkey,
-        record: record_data.clone(),
-        swap_record: None,
-        swap_commit: None,
-        validate: false,
-    };
-
-    let result = put_record(
-        &http_client,
-        &atproto_client::client::Auth::DPoP(dpop_auth),
-        &pds_url,
-        put_request,
-    )
-    .await
-    .map_err(|_| AppError::Internal("AT Protocol request failed".to_string()))?;
-
-    // Extract URI and CID from the response enum
-    let (uri, cid) = match result {
-        PutRecordResponse::StrongRef { uri, cid, .. } => (uri, cid),
-        PutRecordResponse::Error(_) => {
-            return Err(AppError::Internal("AT Protocol response error".to_string()));
-        }
-    };
-
-    // Also update in local database for indexing
-    let record = Record {
-        uri: uri.clone(),
-        cid: cid.clone(),
-        did: repo,
-        collection,
-        json: record_data,
-        indexed_at: Utc::now(),
-        slice_uri: Some(slice_uri),
-    };
-
-    // Update in local database (ignore errors as AT Protocol operation succeeded)
-    let _ = state.database.update_record(&record).await;
-
-    Ok(Json(serde_json::json!({
-        "uri": uri,
-        "cid": cid,
-    })))
-}
-
-// Dynamic collection delete (e.g., social.grain.gallery.delete)
-async fn dynamic_collection_delete_impl(
-    state: AppState,
-    headers: HeaderMap,
-    body: serde_json::Value,
-    collection: String,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Extract and verify OAuth token
-    let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
-    let user_info = verify_oauth_token_cached(
-        &token,
-        &state.config.auth_base_url,
-        Some(state.auth_cache.clone()),
-    )
-    .await
-    .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?;
-
-    // Get AT Protocol DPoP auth and PDS URL (with caching)
-    let (dpop_auth, pds_url) = get_atproto_auth_for_user_cached(
-        &token,
-        &state.config.auth_base_url,
-        Some(state.auth_cache.clone()),
-    )
-    .await
-    .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?;
-
-    // Extract repo and rkey from body
-    let repo = user_info.did.unwrap_or(user_info.sub);
-    let rkey = body["rkey"]
-        .as_str()
-        .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))?
-        .to_string();
-
-    // Create HTTP client
-    let http_client = reqwest::Client::new();
-
-    // Delete record using AT Protocol functions with DPoP
-    let delete_request = DeleteRecordRequest {
-        repo: repo.clone(),
-        collection: collection.clone(),
-        record_key: rkey.clone(),
-        swap_record: None,
-        swap_commit: None,
-    };
-
-    delete_record(
-        &http_client,
-        &atproto_client::client::Auth::DPoP(dpop_auth),
-        &pds_url,
-        delete_request,
-    )
-    .await
-    .map_err(|_| AppError::Internal("AT Protocol request failed".to_string()))?;
-
-    // Also delete from local database (from all slices)
-    let uri = format!("at://{}/{}/{}", repo, collection, rkey);
-
-    // Handle cascade deletion before deleting the record
-    if let Err(e) = state.database.handle_cascade_deletion(&uri, &collection).await {
-        tracing::warn!("Cascade deletion failed for {}: {}", uri, e);
-    }
-
-    let _ = state.database.delete_record_by_uri(&uri, None).await;
-
-    Ok(Json(serde_json::json!({})))
-}