fix graphql blob ref field to return string instead of object

api/src/graphql/schema_builder.rs

···
 
 /// Container to hold blob data and DID for URL generation
 #[derive(Clone)]
-struct BlobContainer {
-    blob_ref: String,  // CID reference
-    mime_type: String, // MIME type
-    size: i64,         // Size in bytes
-    did: String,       // DID for CDN URL generation
+pub struct BlobContainer {
+    pub blob_ref: String,  // CID reference
+    pub mime_type: String, // MIME type
+    pub size: i64,         // Size in bytes
+    pub did: String,       // DID for CDN URL generation
 }
 
 /// Creates a GraphQL Object type for a record collection

api/src/graphql/schema_ext/blob_upload.rs

···
 //! GraphQL schema extension for blob uploads
 
 use async_graphql::dynamic::{Field, FieldFuture, FieldValue, InputValue, Object, TypeRef};
-use async_graphql::{Error, Value as GraphQLValue};
+use async_graphql::Error;
 use base64::engine::general_purpose;
 use base64::Engine;
 
 use crate::atproto_extensions::upload_blob as atproto_upload_blob;
 use crate::auth;
-
-/// Container for blob upload response
-#[derive(Clone)]
-struct BlobUploadContainer {
-    blob: serde_json::Value,
-}
+use crate::graphql::schema_builder::BlobContainer;
 
 /// Creates the BlobUploadResponse GraphQL type
 pub fn create_blob_upload_response_type() -> Object {
     let mut response = Object::new("BlobUploadResponse");
 
-    response = response.field(Field::new("blob", TypeRef::named_nn("JSON"), |ctx| {
+    // Return the Blob type instead of JSON to ensure consistent ref field handling
+    response = response.field(Field::new("blob", TypeRef::named_nn("Blob"), |ctx| {
         FieldFuture::new(async move {
-            let container = ctx.parent_value.try_downcast_ref::<BlobUploadContainer>()?;
-            // Convert serde_json::Value to async_graphql::Value
-            let graphql_value: GraphQLValue = serde_json::from_value(container.blob.clone())
-                .map_err(|e| async_graphql::Error::new(format!("Failed to convert blob to GraphQL value: {}", e)))?;
-            Ok(Some(graphql_value))
+            // The BlobContainer is passed through from the mutation resolver
+            // The Blob type resolver will handle extracting the fields
+            let container = ctx.parent_value.try_downcast_ref::<BlobContainer>()?;
+            Ok(Some(FieldValue::owned_any(container.clone())))
         })
     }));
 
···
                         .decode(data_base64)
                         .map_err(|e| Error::new(format!("Invalid base64 data: {}", e)))?;
 
+                    // Verify OAuth token to get user info (needed for DID)
+                    let user_info = auth::verify_oauth_token_cached(
+                        token,
+                        &auth_base,
+                        gql_ctx.auth_cache.clone(),
+                    )
+                    .await
+                    .map_err(|e| Error::new(format!("Invalid token: {}", e)))?;
+
                     // Get ATProto DPoP auth and PDS URL for this user
                     let (dpop_auth, pds_url) = auth::get_atproto_auth_for_user_cached(
                         token,
···
                     .await
                     .map_err(|e| Error::new(format!("Failed to upload blob: {}", e)))?;
 
-                    // Convert blob to JSON value
-                    let blob_json = serde_json::to_value(&upload_result.blob)
-                        .map_err(|e| Error::new(format!("Failed to serialize blob: {}", e)))?;
+                    // Extract the DID from user info
+                    let did = user_info.did.unwrap_or(user_info.sub);
+
+                    // Create BlobContainer with flattened ref field (CID string)
+                    // This ensures the GraphQL Blob type returns ref as a String, not an object
+                    let blob_container = BlobContainer {
+                        blob_ref: upload_result.blob.r#ref.link.clone(), // Extract CID from ref.$link
+                        mime_type: upload_result.blob.mime_type.clone(),
+                        size: upload_result.blob.size as i64,
+                        did,
+                    };
 
-                    let container = BlobUploadContainer { blob: blob_json };
-                    Ok(Some(FieldValue::owned_any(container)))
+                    Ok(Some(FieldValue::owned_any(blob_container)))
                 })
             },
         )