add $type key to blob and lexicon ref fields in graphql mutations

Automatically adds $type key when transforming GraphQL data to AT Protocol
format in mutations:
- Blob fields: adds "$type": "blob"
- Lexicon refs: adds "$type": "{ref_nsid}" (e.g., "community.lexicon.location.hthree#main")
- Handles single values, arrays, and nested objects recursively

Renamed transform_blob_fields_for_atproto to transform_fields_for_atproto
to reflect expanded functionality.

api/src/graphql/schema_builder.rs

···
     input
 }
 
-/// Transforms blob fields in record data from GraphQL format to AT Protocol format
+/// Transforms fields in record data from GraphQL format to AT Protocol format
 ///
-/// GraphQL format: `{ref: "bafyrei...", mimeType: "...", size: 123}`
-/// AT Protocol format: `{ref: {$link: "bafyrei..."}, mimeType: "...", size: 123}`
-fn transform_blob_fields_for_atproto(
+/// Blob fields:
+/// - GraphQL format: `{ref: "bafyrei...", mimeType: "...", size: 123}`
+/// - AT Protocol format: `{$type: "blob", ref: {$link: "bafyrei..."}, mimeType: "...", size: 123}`
+///
+/// Lexicon ref fields:
+/// - Adds `$type: "{ref_nsid}"` to objects (e.g., `{$type: "community.lexicon.location.hthree#main", ...}`)
+///
+/// Nested objects:
+/// - Recursively processes nested objects and arrays
+fn transform_fields_for_atproto(
     mut data: serde_json::Value,
     fields: &[GraphQLField],
 ) -> serde_json::Value {
···
                     GraphQLType::Blob => {
                         // Transform single blob field
                         if let Some(blob_obj) = field_value.as_object_mut() {
+                            // Add $type: "blob"
+                            blob_obj.insert("$type".to_string(), serde_json::Value::String("blob".to_string()));
+
                             // Check if ref is a string (GraphQL format)
                             if let Some(serde_json::Value::String(cid)) = blob_obj.get("ref") {
                                 // Transform to {$link: "cid"} (AT Protocol format)
···
                             }
                         }
                     }
-                    GraphQLType::Array(inner) if matches!(inner.as_ref(), GraphQLType::Blob) => {
-                        // Transform array of blobs
-                        if let Some(arr) = field_value.as_array_mut() {
-                            for blob_value in arr {
-                                if let Some(blob_obj) = blob_value.as_object_mut() {
-                                    if let Some(serde_json::Value::String(cid)) = blob_obj.get("ref") {
-                                        let link_obj = serde_json::json!({
-                                            "$link": cid
-                                        });
-                                        blob_obj.insert("ref".to_string(), link_obj);
+                    GraphQLType::LexiconRef(ref_nsid) => {
+                        // Transform lexicon ref field by adding $type
+                        if let Some(ref_obj) = field_value.as_object_mut() {
+                            ref_obj.insert("$type".to_string(), serde_json::Value::String(ref_nsid.clone()));
+                        }
+                    }
+                    GraphQLType::Object(nested_fields) => {
+                        // Recursively transform nested objects
+                        *field_value = transform_fields_for_atproto(field_value.clone(), nested_fields);
+                    }
+                    GraphQLType::Array(inner) => {
+                        match inner.as_ref() {
+                            GraphQLType::Blob => {
+                                // Transform array of blobs
+                                if let Some(arr) = field_value.as_array_mut() {
+                                    for blob_value in arr {
+                                        if let Some(blob_obj) = blob_value.as_object_mut() {
+                                            // Add $type: "blob"
+                                            blob_obj.insert("$type".to_string(), serde_json::Value::String("blob".to_string()));
+
+                                            if let Some(serde_json::Value::String(cid)) = blob_obj.get("ref") {
+                                                let link_obj = serde_json::json!({
+                                                    "$link": cid
+                                                });
+                                                blob_obj.insert("ref".to_string(), link_obj);
+                                            }
+                                        }
                                     }
                                 }
                             }
+                            GraphQLType::LexiconRef(ref_nsid) => {
+                                // Transform array of lexicon refs
+                                if let Some(arr) = field_value.as_array_mut() {
+                                    for ref_value in arr {
+                                        if let Some(ref_obj) = ref_value.as_object_mut() {
+                                            ref_obj.insert("$type".to_string(), serde_json::Value::String(ref_nsid.clone()));
+                                        }
+                                    }
+                                }
+                            }
+                            GraphQLType::Object(nested_fields) => {
+                                // Transform array of objects recursively
+                                if let Some(arr) = field_value.as_array_mut() {
+                                    for item in arr {
+                                        *item = transform_fields_for_atproto(item.clone(), nested_fields);
+                                    }
+                                }
+                            }
+                            _ => {} // Other array types don't need transformation
                         }
                     }
                     _ => {} // Other field types don't need transformation
···
                     let mut record_data: serde_json::Value = input.deserialize()
                         .map_err(|e| Error::new(format!("Failed to deserialize input: {:?}", e)))?;
 
-                    // Transform blob fields from GraphQL format (ref: "cid") to AT Protocol format (ref: {$link: "cid"})
-                    record_data = transform_blob_fields_for_atproto(record_data, &fields);
+                    // Transform fields from GraphQL to AT Protocol format (adds $type, transforms blob refs)
+                    record_data = transform_fields_for_atproto(record_data, &fields);
 
                     // Optional rkey argument
                     let rkey = ctx.args.get("rkey")
···
                     let mut record_data: serde_json::Value = input.deserialize()
                         .map_err(|e| Error::new(format!("Failed to deserialize input: {:?}", e)))?;
 
-                    // Transform blob fields from GraphQL format (ref: "cid") to AT Protocol format (ref: {$link: "cid"})
-                    record_data = transform_blob_fields_for_atproto(record_data, &fields);
+                    // Transform fields from GraphQL to AT Protocol format (adds $type, transforms blob refs)
+                    record_data = transform_fields_for_atproto(record_data, &fields);
 
                     // Verify OAuth token and get user info
                     let user_info = crate::auth::verify_oauth_token_cached(