1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

use crate::{registry, InputValueType, Type, Value};
use std::borrow::Cow;

/// Uploaded file
///
/// **Reference:** <https://github.com/jaydenseric/graphql-multipart-request-spec>
///
///
/// Graphql supports file uploads via `multipart/form-data`.
/// Enable this feature by accepting an argument of type `Upload` (single file) or
/// `Vec<Upload>` (multiple files) in your mutation like in the example blow.
///
///
/// # Example
/// *[Full Example](<https://github.com/sunli829/async-graphql/blob/master/async-graphql-actix-web/examples/upload-file.rs>)*
///
/// ```
/// use async_graphql::Upload;
///
/// struct MutationRoot;
///
/// #[async_graphql::Object]
/// impl MutationRoot {
///     #[field]
///     async fn upload(&self, file: Upload) -> bool {
///         println!(
///             "upload: filename={} size={}",
///             file.filename,
///             file.content.len()
///         );
///         true
///     }
/// }
///
/// ```
/// # Example Curl Request
/// Assuming you have defined your MutationRoot like in the example above,
/// you can now upload a file `myFile.txt` with the below curl command:
///
/// ```curl
/// curl 'localhost:8000' \
/// --form 'operations={
///         "query": "mutation ($file: Upload!) { upload(file: $file)  }",
///         "variables": { "file": null }}' \
/// --form 'map={ "0": ["variables.file"] }' \
/// --form '0=@myFile.txt'
/// ```
pub struct Upload {
    /// Filename
    pub filename: String,

    /// Content type, such as `application/json`, `image/jpg` ...
    pub content_type: Option<String>,

    /// File content
    pub content: Vec<u8>,
}

impl<'a> Type for Upload {
    fn type_name() -> Cow<'static, str> {
        Cow::Borrowed("Upload")
    }

    fn create_type_info(registry: &mut registry::Registry) -> String {
        registry.create_type::<Self, _>(|_| registry::Type::Scalar {
            name: Self::type_name().to_string(),
            description: None,
            is_valid: |value| match value {
                Value::String(s) => s.starts_with("file:"),
                _ => false,
            },
        })
    }
}

impl<'a> InputValueType for Upload {
    fn parse(value: &Value) -> Option<Self> {
        if let Value::String(s) = value {
            if s.starts_with("file:") {
                let s = &s[5..];
                if let Some(idx) = s.find('|') {
                    let name_and_type = &s[..idx];
                    let content_b64 = &s[idx + 1..];
                    if let Some(type_idx) = name_and_type.find(':') {
                        let name = &name_and_type[..type_idx];
                        let mime_type = &name_and_type[type_idx + 1..];
                        let content = base64::decode(content_b64).ok().unwrap_or_default();
                        return Some(Self {
                            filename: name.to_string(),
                            content_type: Some(mime_type.to_string()),
                            content,
                        });
                    } else {
                        let content = base64::decode(content_b64).ok().unwrap_or_default();
                        return Some(Self {
                            filename: name_and_type.to_string(),
                            content_type: None,
                            content,
                        });
                    }
                }
            }
        }
        None
    }
}