add blob field transformation in mutations from graphql to atproto format

api/src/graphql/schema_builder.rs

···
                 let type_name = nsid_to_type_name(nsid);
 
                 // Add create mutation
-                mutation = add_create_mutation(mutation, &type_name, nsid, database.clone(), slice_uri.clone());
+                mutation = add_create_mutation(mutation, &type_name, nsid, &fields, database.clone(), slice_uri.clone());
 
                 // Add update mutation
-                mutation = add_update_mutation(mutation, &type_name, nsid, database.clone(), slice_uri.clone());
+                mutation = add_update_mutation(mutation, &type_name, nsid, &fields, database.clone(), slice_uri.clone());
 
                 // Add delete mutation
                 mutation = add_delete_mutation(mutation, &type_name, nsid, database.clone(), slice_uri.clone());
···
     input
 }
 
+/// Transforms blob 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(
+    mut data: serde_json::Value,
+    fields: &[GraphQLField],
+) -> serde_json::Value {
+    if let serde_json::Value::Object(ref mut map) = data {
+        for field in fields {
+            if let Some(field_value) = map.get_mut(&field.name) {
+                match &field.field_type {
+                    GraphQLType::Blob => {
+                        // Transform single blob field
+                        if let Some(blob_obj) = field_value.as_object_mut() {
+                            // 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)
+                                let link_obj = serde_json::json!({
+                                    "$link": cid
+                                });
+                                blob_obj.insert("ref".to_string(), link_obj);
+                            }
+                        }
+                    }
+                    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);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    _ => {} // Other field types don't need transformation
+                }
+            }
+        }
+    }
+
+    data
+}
+
 /// Adds a create mutation for a collection
 fn add_create_mutation(
     mutation: Object,
     type_name: &str,
     nsid: &str,
+    fields: &[GraphQLField],
     database: Database,
     slice_uri: String,
 ) -> Object {
     let mutation_name = format!("create{}", type_name);
     let nsid = nsid.to_string();
     let nsid_clone = nsid.clone();
+    let fields = fields.to_vec();
 
     mutation.field(
         Field::new(
···
                 let db = database.clone();
                 let slice = slice_uri.clone();
                 let collection = nsid.clone();
+                let fields = fields.clone();
 
                 FieldFuture::new(async move {
                     // Get GraphQL context which contains auth info
···
                         .ok_or_else(|| Error::new("Missing input argument"))?;
 
                     // Convert GraphQL value to JSON using deserialize
-                    let record_data: serde_json::Value = input.deserialize()
+                    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);
 
                     // Optional rkey argument
                     let rkey = ctx.args.get("rkey")
···
     mutation: Object,
     type_name: &str,
     nsid: &str,
+    fields: &[GraphQLField],
     database: Database,
     slice_uri: String,
 ) -> Object {
     let mutation_name = format!("update{}", type_name);
     let nsid = nsid.to_string();
     let nsid_clone = nsid.clone();
+    let fields = fields.to_vec();
 
     mutation.field(
         Field::new(
···
                 let db = database.clone();
                 let slice = slice_uri.clone();
                 let collection = nsid.clone();
+                let fields = fields.clone();
 
                 FieldFuture::new(async move {
                     // Get GraphQL context which contains auth info
···
                         .ok_or_else(|| Error::new("Missing input argument"))?;
 
                     // Convert GraphQL value to JSON using deserialize
-                    let record_data: serde_json::Value = input.deserialize()
+                    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);
 
                     // Verify OAuth token and get user info
                     let user_info = crate::auth::verify_oauth_token_cached(