add: post image uploads (supporter)

crates/app/src/image.rs

@@ -4,6 +4,7 @@ use axum::{
     http::{StatusCode, header::CONTENT_TYPE},
 };
 use axum_extra::extract::Multipart;
+use serde::de::DeserializeOwned;
 use std::{fs::File, io::BufWriter};
 
 /// An image extractor accepting:
@@ -80,3 +81,85 @@ pub fn save_buffer(path: &str, bytes: Vec<u8>, format: image::ImageFormat) -> st
 
     Ok(())
 }
+
+/// A file extractor accepting:
+/// * `multipart/form-data`
+///
+/// Will also attempt to parse out the **last** field in the multipart upload
+/// as the given struct from JSON. Every other field is put into a vector of bytes,
+/// as they are seen as raw binary data.
+pub struct JsonMultipart<T: DeserializeOwned>(pub Vec<Bytes>, pub T);
+
+impl<S, T> FromRequest<S> for JsonMultipart<T>
+where
+    Bytes: FromRequest<S>,
+    S: Send + Sync,
+    T: DeserializeOwned,
+{
+    type Rejection = (StatusCode, String);
+
+    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
+        let Some(content_type) = req.headers().get(CONTENT_TYPE) else {
+            return Err((
+                StatusCode::BAD_REQUEST,
+                "no content type header".to_string(),
+            ));
+        };
+
+        let content_type = content_type.to_str().unwrap();
+
+        if !content_type.starts_with("multipart/form-data") {
+            return Err((
+                StatusCode::BAD_REQUEST,
+                "expected multipart/form-data".to_string(),
+            ));
+        }
+
+        let mut multipart = Multipart::from_request(req, state).await.map_err(|_| {
+            (
+                StatusCode::BAD_REQUEST,
+                "could not read multipart".to_string(),
+            )
+        })?;
+
+        let mut body: Vec<Bytes> = {
+            let mut out = Vec::new();
+
+            while let Ok(Some(field)) = multipart.next_field().await {
+                out.push(field.bytes().await.map_err(|_| {
+                    (
+                        StatusCode::BAD_REQUEST,
+                        "could not read field as bytes".to_string(),
+                    )
+                })?);
+            }
+
+            out
+        };
+
+        let last = match body.pop() {
+            Some(b) => b,
+            None => {
+                return Err((
+                    StatusCode::BAD_REQUEST,
+                    "could not read json data".to_string(),
+                ));
+            }
+        };
+
+        let json: T = match serde_json::from_str(&match String::from_utf8(last.to_vec()) {
+            Ok(s) => s,
+            Err(_) => return Err((StatusCode::BAD_REQUEST, "json data isn't utf8".to_string())),
+        }) {
+            Ok(s) => s,
+            Err(_) => {
+                return Err((
+                    StatusCode::BAD_REQUEST,
+                    "could not parse json data as json".to_string(),
+                ));
+            }
+        };
+
+        Ok(Self(body, json))
+    }
+}