Replace mime crate with mediatype crate

Author: AdamSteinberg1

codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/ServerCargoDependency.kt

@@ -18,7 +18,7 @@ object ServerCargoDependency {
     val AsyncTrait: CargoDependency = CargoDependency("async-trait", CratesIo("0.1"))
     val FormUrlEncoded: CargoDependency = CargoDependency("form_urlencoded", CratesIo("1"))
     val FuturesUtil: CargoDependency = CargoDependency("futures-util", CratesIo("0.3"))
-    val Mime: CargoDependency = CargoDependency("mime", CratesIo("0.3"))
+    val MediaType: CargoDependency = CargoDependency("mediatype", CratesIo("0.19.15"))
     val Nom: CargoDependency = CargoDependency("nom", CratesIo("7"))
     val OnceCell: CargoDependency = CargoDependency("once_cell", CratesIo("1.13"))
     val PinProjectLite: CargoDependency = CargoDependency("pin-project-lite", CratesIo("0.2"))

codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/protocols/ServerHttpBoundProtocolGenerator.kt

@@ -185,7 +185,7 @@ class ServerHttpBoundProtocolTraitImplGenerator(
         "header_util" to RuntimeType.smithyHttp(runtimeConfig).resolve("header"),
         "Hyper" to RuntimeType.Hyper,
         "LazyStatic" to RuntimeType.LazyStatic,
-        "Mime" to ServerCargoDependency.Mime.toType(),
+        "MediaType" to ServerCargoDependency.MediaType.toType(),
         "Nom" to ServerCargoDependency.Nom.toType(),
         "OnceCell" to RuntimeType.OnceCell,
         "PercentEncoding" to RuntimeType.PercentEncoding,
@@ -237,18 +237,16 @@ class ServerHttpBoundProtocolTraitImplGenerator(
         }
         val verifyAcceptHeaderStaticContentTypeInit = writable {
             httpBindingResolver.responseContentType(operationShape)?.also { contentType ->
-                val init = when (contentType) {
-                    "application/json" -> "const $staticContentType: #{Mime}::Mime = #{Mime}::APPLICATION_JSON;"
-                    "application/octet-stream" -> "const $staticContentType: #{Mime}::Mime = #{Mime}::APPLICATION_OCTET_STREAM;"
-                    "application/x-www-form-urlencoded" -> "const $staticContentType: #{Mime}::Mime = #{Mime}::APPLICATION_WWW_FORM_URLENCODED;"
-                    else ->
-                        """
-                        static $staticContentType: #{OnceCell}::sync::Lazy<#{Mime}::Mime> = #{OnceCell}::sync::Lazy::new(|| {
-                            ${contentType.dq()}.parse::<#{Mime}::Mime>().expect("BUG: MIME parsing failed, content_type is not valid")
-                        });
-                        """
-                }
-                rustTemplate(init, *codegenScope)
+                val (type, subtype) = contentType.split('/')
+                rustTemplate(
+                    """
+                    const $staticContentType: #{MediaType}::MediaType = #{MediaType}::MediaType::new(
+                        #{MediaType}::Name::new_unchecked(${type.dq()}),
+                        #{MediaType}::Name::new_unchecked(${subtype.dq()})
+                    );
+                    """,
+                    *codegenScope,
+                )
             }
         }
         // This checks for the expected `Content-Type` header if the `@httpPayload` trait is present, as dictated by

rust-runtime/aws-smithy-http-server/Cargo.toml

@@ -30,7 +30,7 @@ http = "0.2"
 http-body = "0.4"
 hyper = { version = "0.14.26", features = ["server", "http1", "http2", "tcp", "stream"] }
 lambda_http = { version = "0.8.0", optional = true }
-mime = "0.3.4"
+mediatype = "0.19.15"
 nom = "7"
 once_cell = "1.13"
 pin-project-lite = "0.2"

rust-runtime/aws-smithy-http-server/src/protocol/mod.rs

@@ -40,10 +40,8 @@ pub mod test_helpers {
 }
 
 #[allow(clippy::result_large_err)]
-fn parse_mime(content_type: &str) -> Result<mime::Mime, MissingContentTypeReason> {
-    content_type
-        .parse::<mime::Mime>()
-        .map_err(MissingContentTypeReason::MimeParseError)
+fn parse_mime(content_type: &str) -> Result<mediatype::MediaType, MissingContentTypeReason> {
+    mediatype::MediaType::parse(content_type).map_err(MissingContentTypeReason::MimeParseError)
 }
 
 /// When there are no modeled inputs,
@@ -52,15 +50,11 @@ fn parse_mime(content_type: &str) -> Result<mime::Mime, MissingContentTypeReason
 pub fn content_type_header_empty_body_no_modeled_input(
     headers: &SmithyHeaders,
 ) -> Result<(), MissingContentTypeReason> {
-    if headers.contains_key(http::header::CONTENT_TYPE) {
-        let found_mime = headers
-            .get(http::header::CONTENT_TYPE)
-            .unwrap() // The header is present, `unwrap` will not panic.
-            .parse::<mime::Mime>()
-            .map_err(MissingContentTypeReason::MimeParseError)?;
+    if let Some(header) = headers.get(http::header::CONTENT_TYPE) {
+        let found_mime = parse_mime(header)?;
         Err(MissingContentTypeReason::UnexpectedMimeType {
             expected_mime: None,
-            found_mime: Some(found_mime),
+            found_mime: Some(found_mime.into()),
         })
     } else {
         Ok(())
@@ -102,28 +96,28 @@ fn content_type_header_classifier(
     let found_mime = parse_mime(content_type)?;
     // There is a `content-type` header.
     // If there is an implied content type, they must match.
-    if let Some(expected_content_type) = expected_content_type {
-        let expected_mime = expected_content_type
-            .parse::<mime::Mime>()
-            // `expected_content_type` comes from the codegen.
-            .expect("BUG: MIME parsing failed, `expected_content_type` is not valid. Please file a bug report under https://github.com/smithy-lang/smithy-rs/issues");
-        if expected_content_type != found_mime {
-            return Err(MissingContentTypeReason::UnexpectedMimeType {
-                expected_mime: Some(expected_mime),
-                found_mime: Some(found_mime),
-            });
-        }
-    } else {
+
+    let Some(expected_content_type) = expected_content_type else {
         // `content-type` header and no modeled input (mismatch).
         return Err(MissingContentTypeReason::UnexpectedMimeType {
             expected_mime: None,
-            found_mime: Some(found_mime),
+            found_mime: Some(found_mime.into()),
+        })
+    };
+
+    let expected_mime = mediatype::MediaType::parse(expected_content_type)
+            // `expected_content_type` comes from the codegen.
+            .expect("BUG: MIME parsing failed, `expected_content_type` is not valid. Please file a bug report under https://github.com/smithy-lang/smithy-rs/issues");
+    if expected_mime != found_mime {
+        return Err(MissingContentTypeReason::UnexpectedMimeType {
+            expected_mime: Some(expected_mime.into()),
+            found_mime: Some(found_mime.into()),
         });
     }
     Ok(())
 }
 
-pub fn accept_header_classifier(headers: &HeaderMap, content_type: &mime::Mime) -> bool {
+pub fn accept_header_classifier(headers: &HeaderMap, content_type: &mediatype::MediaType) -> bool {
     if !headers.contains_key(http::header::ACCEPT) {
         return true;
     }
@@ -143,15 +137,15 @@ pub fn accept_header_classifier(headers: &HeaderMap, content_type: &mime::Mime)
                  */
                 .flat_map(|s| s.split(',').map(|typ| typ.split(';').next().unwrap().trim()))
         })
-        .filter_map(|h| h.parse::<mime::Mime>().ok())
+        .filter_map(|h| mediatype::MediaType::parse(h).ok())
         .any(|mim| {
-            let typ = content_type.type_();
-            let subtype = content_type.subtype();
+            let typ = content_type.ty;
+            let subtype = content_type.subty;
             // Accept: */*, type/*, type/subtype
-            match (mim.type_(), mim.subtype()) {
-                (t, s) if t == typ && s == subtype => true,
-                (t, mime::STAR) if t == typ => true,
-                (mime::STAR, mime::STAR) => true,
+            match (mim.ty.as_str(), mim.subty.as_str()) {
+                (t, s) if typ == t && subtype == s => true,
+                (t, "*") if typ == t => true,
+                ("*", "*") => true,
                 _ => false,
             }
         })
@@ -221,11 +215,8 @@ mod tests {
                             expected_mime,
                             found_mime,
                         } => {
-                            assert_eq!(
-                                expected_mime.unwrap(),
-                                "application/json".parse::<mime::Mime>().unwrap()
-                            );
-                            assert_eq!(found_mime, invalid_mime.parse::<mime::Mime>().ok());
+                            assert_eq!(expected_mime.unwrap(), mediatype::media_type!(APPLICATION / JSON));
+                            assert_eq!(found_mime, invalid_mime.parse::<mediatype::MediaTypeBuf>().ok());
                         }
                         _ => panic!("Unexpected `MissingContentTypeReason`: {}", e),
                     },
@@ -262,7 +253,7 @@ mod tests {
         let valid_request = req_accept("text/strings, application/json, invalid");
         assert!(accept_header_classifier(
             &valid_request,
-            &"application/json".parse().unwrap()
+            &mediatype::MediaType::parse("application/json").unwrap()
         ));
     }
 
@@ -271,7 +262,7 @@ mod tests {
         let invalid_request = req_accept("text/invalid, invalid, invalid/invalid");
         assert!(!accept_header_classifier(
             &invalid_request,
-            &"application/json".parse().unwrap()
+            &mediatype::media_type!(APPLICATION / JSON)
         ));
     }
 
@@ -280,7 +271,7 @@ mod tests {
         let valid_request = req_accept("application/*");
         assert!(accept_header_classifier(
             &valid_request,
-            &"application/json".parse().unwrap()
+            &mediatype::media_type!(APPLICATION / JSON)
         ));
     }
 
@@ -289,15 +280,15 @@ mod tests {
         let valid_request = req_accept("*/*");
         assert!(accept_header_classifier(
             &valid_request,
-            &"application/json".parse().unwrap()
+            &mediatype::media_type!(APPLICATION / JSON)
         ));
     }
 
     #[test]
     fn valid_empty_accept_header_classifier() {
         assert!(accept_header_classifier(
             &HeaderMap::new(),
-            &"application/json".parse().unwrap()
+            &mediatype::media_type!(APPLICATION / JSON)
         ));
     }
 
@@ -306,7 +297,7 @@ mod tests {
         let valid_request = req_accept("application/json; q=30, */*");
         assert!(accept_header_classifier(
             &valid_request,
-            &"application/json".parse().unwrap()
+            &mediatype::media_type!(APPLICATION / JSON)
         ));
     }
 
@@ -315,7 +306,7 @@ mod tests {
         let valid_request = req_accept("application/json");
         assert!(accept_header_classifier(
             &valid_request,
-            &"application/json".parse().unwrap()
+            &mediatype::media_type!(APPLICATION / JSON)
         ));
     }
 }

rust-runtime/aws-smithy-http-server/src/rejection.rs

@@ -16,11 +16,11 @@ pub enum MissingContentTypeReason {
     #[error("`Content-Type` header value is not a valid HTTP header value: {0}")]
     ToStrError(http::header::ToStrError),
     #[error("invalid `Content-Type` header value mime type: {0}")]
-    MimeParseError(mime::FromStrError),
+    MimeParseError(mediatype::MediaTypeError),
     #[error("unexpected `Content-Type` header value; expected {expected_mime:?}, found {found_mime:?}")]
     UnexpectedMimeType {
-        expected_mime: Option<mime::Mime>,
-        found_mime: Option<mime::Mime>,
+        expected_mime: Option<mediatype::MediaTypeBuf>,
+        found_mime: Option<mediatype::MediaTypeBuf>,
     },
 }