Uploader

README.md

@@ -71,6 +71,33 @@ subscription { streamHello(name: "GraphQL") { message meta { correlationId } } }
 query { user(id: "demo") { id displayName trusted } }
 ```
 
+Upload mutation (uses the GraphQL `Upload` scalar; send as multipart):
+```graphql
+mutation ($file: Upload!) {
+  uploadAvatar(input: { userId: "demo", avatar: $file }) { userId size }
+}
+```
+```
+curl http://127.0.0.1:8888/graphql \
+  --form 'operations={ "query": "mutation ($file: Upload!) { uploadAvatar(input:{ userId:\"demo\", avatar:$file }) { userId size } }", "variables": { "file": null } }' \
+  --form 'map={ "0": ["variables.file"] }' \
+  --form '0=@./proto/greeter.proto;type=application/octet-stream'
+```
+
+Multi-upload mutation (list of `Upload`):
+```graphql
+mutation ($files: [Upload!]!) {
+  uploadAvatars(input: { userId: "demo", avatars: $files }) { userId sizes }
+}
+```
+```
+curl http://127.0.0.1:8888/graphql \
+  --form 'operations={ "query": "mutation ($files: [Upload!]!) { uploadAvatars(input:{ userId:\"demo\", avatars:$files }) { userId sizes } }", "variables": { "files": [null, null] } }' \
+  --form 'map={ "0": ["variables.files.0"], "1": ["variables.files.1"] }' \
+  --form '0=@./proto/greeter.proto;type=application/octet-stream' \
+  --form '1=@./README.md;type=text/plain'
+```
+
 ## How it fits together
 A quick view of how protobuf descriptors, the generated schema, and gRPC clients are wired to serve GraphQL over HTTP and WebSocket:
 ```mermaid
@@ -176,11 +203,13 @@ let builder = Gateway::builder()
 - `int32`/`uint32` -> `Int`
 - `int64`/`uint64` -> `String` (to avoid precision loss)
 - `float`/`double` -> `Float`
-- `bytes` -> `String` (base64)
+- `bytes` -> `Upload` (inputs via multipart) / `String` (base64 responses)
 - `repeated` -> `[T]`
 - `message` -> `Object` / `InputObject`
 - `enum` -> `Enum`
 
+`Upload` inputs follow the GraphQL multipart request spec and are valid on mutations.
+
 ## Development
 - Format: `cargo fmt`
 - Lint/tests: `cargo test`

examples/greeter/main.rs

@@ -7,6 +7,7 @@ use std::time::Duration;
 use anyhow::Result;
 use futures::StreamExt;
 use grpc_graphql_gateway::{Gateway, GrpcClient};
+use tokio::fs;
 use tokio::sync::RwLock;
 use tokio_stream::wrappers::IntervalStream;
 use tokio_stream::Stream;
@@ -18,7 +19,10 @@ pub mod greeter {
 }
 
 use greeter::greeter_server::{Greeter, GreeterServer};
-use greeter::{GetUserRequest, GreetMeta, HelloReply, HelloRequest, UpdateGreetingRequest, User};
+use greeter::{
+    GetUserRequest, GreetMeta, HelloReply, HelloRequest, UpdateGreetingRequest, UploadAvatarReply,
+    UploadAvatarRequest, UploadAvatarsReply, UploadAvatarsRequest, User,
+};
 
 const DESCRIPTORS: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/greeter_descriptor.bin"));
 const GRPC_ADDR: &str = "127.0.0.1:50051";
@@ -105,6 +109,8 @@ fn print_examples(addr: SocketAddr) {
         "  subscription {{ streamHello(name:\"GraphQL\") {{ message meta {{ correlationId }} }} }}"
     );
     println!("  query {{ user(id:\"demo\") {{ id displayName trusted }} }}");
+    println!("  # Upload (multipart): see README for the curl example");
+    println!("  # Multi-upload (multipart): see README for the curl example");
 }
 
 #[derive(Clone)]
@@ -211,6 +217,69 @@ impl Greeter for ExampleGreeter {
 
         Err(Status::not_found(format!("user {} not found", req.id)))
     }
+
+    async fn upload_avatar(
+        &self,
+        request: Request<UploadAvatarRequest>,
+    ) -> Result<Response<UploadAvatarReply>, Status> {
+        let req = request.into_inner();
+        if self.lookup_user(&req.user_id).await.is_none() {
+            return Err(Status::not_found(format!("user {} not found", req.user_id)));
+        }
+
+        let mut path = std::env::temp_dir();
+        path.push(format!(
+            "greeter_avatar_{}.bin",
+            safe_filename(&req.user_id)
+        ));
+        fs::write(&path, &req.avatar)
+            .await
+            .map_err(|e| Status::internal(format!("failed to write avatar: {e}")))?;
+        info!("stored avatar for {} at {}", req.user_id, path.display());
+
+        let size = req.avatar.len() as u64;
+        let reply = UploadAvatarReply {
+            user_id: req.user_id,
+            size,
+        };
+        Ok(Response::new(reply))
+    }
+
+    async fn upload_avatars(
+        &self,
+        request: Request<UploadAvatarsRequest>,
+    ) -> Result<Response<UploadAvatarsReply>, Status> {
+        let req = request.into_inner();
+        if self.lookup_user(&req.user_id).await.is_none() {
+            return Err(Status::not_found(format!("user {} not found", req.user_id)));
+        }
+
+        let mut sizes = Vec::with_capacity(req.avatars.len());
+        for (idx, blob) in req.avatars.iter().enumerate() {
+            let mut path = std::env::temp_dir();
+            path.push(format!(
+                "greeter_avatar_{}_{}.bin",
+                safe_filename(&req.user_id),
+                idx
+            ));
+            fs::write(&path, blob)
+                .await
+                .map_err(|e| Status::internal(format!("failed to write avatar: {e}")))?;
+            info!(
+                "stored avatar {} for {} at {}",
+                idx,
+                req.user_id,
+                path.display()
+            );
+            sizes.push(blob.len() as u64);
+        }
+
+        let reply = UploadAvatarsReply {
+            user_id: req.user_id,
+            sizes,
+        };
+        Ok(Response::new(reply))
+    }
 }
 
 impl ExampleGreeter {
@@ -239,3 +308,10 @@ fn normalize_name(name: String) -> String {
         name
     }
 }
+
+fn safe_filename(input: &str) -> String {
+    input
+        .chars()
+        .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
+        .collect()
+}

proto/greeter.proto

@@ -33,6 +33,26 @@ message GetUserRequest {
   string id = 1 [(graphql.field) = {required: true}];
 }
 
+message UploadAvatarRequest {
+  string user_id = 1 [(graphql.field) = {required: true, name: "userId"}];
+  bytes avatar = 2 [(graphql.field) = {required: true}];
+}
+
+message UploadAvatarReply {
+  string user_id = 1 [(graphql.field) = {name: "userId"}];
+  uint64 size = 2;
+}
+
+message UploadAvatarsRequest {
+  string user_id = 1 [(graphql.field) = {required: true, name: "userId"}];
+  repeated bytes avatars = 2 [(graphql.field) = {required: true}];
+}
+
+message UploadAvatarsReply {
+  string user_id = 1 [(graphql.field) = {name: "userId"}];
+  repeated uint64 sizes = 2;
+}
+
 service Greeter {
   option (graphql.service) = {
     host: "http://127.0.0.1:50051"
@@ -70,4 +90,22 @@ service Greeter {
       response { required: true }
     };
   }
+
+  rpc UploadAvatar(UploadAvatarRequest) returns (UploadAvatarReply) {
+    option (graphql.schema) = {
+      type: MUTATION
+      name: "uploadAvatar"
+      request { name: "input" }
+      response { required: true }
+    };
+  }
+
+  rpc UploadAvatars(UploadAvatarsRequest) returns (UploadAvatarsReply) {
+    option (graphql.schema) = {
+      type: MUTATION
+      name: "uploadAvatars"
+      request { name: "input" }
+      response { required: true }
+    };
+  }
 }