awslabs · bassmanitram · Oct 18, 2024 · Oct 19, 2024 · Oct 19, 2024 · Oct 22, 2024
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
+    "json-impl",
     "lambda-http",
     "lambda-integration-tests",
     "lambda-runtime-api-client",

diff --git a/README.md b/README.md
@@ -54,7 +54,7 @@ If you'd like to manually create your first function, the code below shows you a
 
 ```rust,no_run
 use lambda_runtime::{service_fn, LambdaEvent, Error};
-use serde_json::{json, Value};
+use aws_lambda_json_impl::{json, Value};
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
@@ -375,7 +375,7 @@ To serialize and deserialize events and responses, we suggest using the [`serde`
 
 ```rust,no_run
 use serde::{Serialize, Deserialize};
-use serde_json::json;
+use aws_lambda_json_impl::json;
 use std::error::Error;
 
 #[derive(Serialize, Deserialize)]

diff --git a/examples/advanced-sqs-multiple-functions-shared-data/producer/src/main.rs b/examples/advanced-sqs-multiple-functions-shared-data/producer/src/main.rs
@@ -1,6 +1,6 @@
 use lambda_runtime::{service_fn, tracing, Error, LambdaEvent};
 use pizza_lib::Pizza;
-use serde_json::{json, Value};
+use aws_lambda_json_impl::{json, Value};
 
 struct SQSManager {
     client: aws_sdk_sqs::Client,

diff --git a/examples/basic-error-handling/src/main.rs b/examples/basic-error-handling/src/main.rs
@@ -1,7 +1,7 @@
 /// See https://github.com/awslabs/aws-lambda-rust-runtime for more info on Rust runtime for AWS Lambda
 use lambda_runtime::{service_fn, tracing, Error, LambdaEvent};
 use serde::{Deserialize, Serialize};
-use serde_json::json;
+use aws_lambda_json_impl::json;
 use std::fs::File;
 
 /// A simple Lambda request structure with just one field

diff --git a/examples/basic-streaming-response/src/main.rs b/examples/basic-streaming-response/src/main.rs
@@ -3,7 +3,7 @@ use lambda_runtime::{
     streaming::{channel, Body, Response},
     tracing, Error, LambdaEvent,
 };
-use serde_json::Value;
+use aws_lambda_json_impl::Value;
 use std::{thread, time::Duration};
 
 async fn func(_event: LambdaEvent<Value>) -> Result<Response<Body>, Error> {

diff --git a/examples/http-axum-apigw-authorizer/src/main.rs b/examples/http-axum-apigw-authorizer/src/main.rs
@@ -7,7 +7,7 @@ use axum::{
     Router,
 };
 use lambda_http::{run, tracing, Error, RequestExt};
-use serde_json::{json, Value};
+use aws_lambda_json_impl::{json, Value};
 use std::{collections::HashMap, env::set_var};
 
 struct AuthorizerField(String);

diff --git a/examples/http-axum-middleware/src/main.rs b/examples/http-axum-middleware/src/main.rs
@@ -12,7 +12,7 @@
 use axum::{response::Json, routing::post, Router};
 use lambda_http::request::RequestContext::ApiGatewayV1;
 use lambda_http::{run, tracing, Error};
-use serde_json::{json, Value};
+use aws_lambda_json_impl::{json, Value};
 
 // Sample middleware that logs the request id
 async fn mw_sample(req: axum::extract::Request, next: axum::middleware::Next) -> impl axum::response::IntoResponse {

diff --git a/examples/http-axum/src/main.rs b/examples/http-axum/src/main.rs
@@ -16,7 +16,7 @@ use axum::{
 };
 use lambda_http::{run, tracing, Error};
 use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
+use aws_lambda_json_impl::{json, Value};
 use std::env::set_var;
 
 #[derive(Deserialize, Serialize)]

diff --git a/examples/lambda-rds-iam-auth/src/main.rs b/examples/lambda-rds-iam-auth/src/main.rs
@@ -5,7 +5,7 @@ use aws_sigv4::{
     sign::v4,
 };
 use lambda_runtime::{run, service_fn, Error, LambdaEvent};
-use serde_json::{json, Value};
+use aws_lambda_json_impl::{json, Value};
 use sqlx::postgres::PgConnectOptions;
 use std::env;
 use std::time::{Duration, SystemTime};

diff --git a/json-impl/Cargo.toml b/json-impl/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "aws_lambda_json_impl"
+version = "0.15.1"
+description = "AWS Lambda JSON adapter switch between serde_json and simd_json"
+authors = [
+  "Martin Bartmett <[email protected]>",
+]
+license = "MIT"
+homepage = "https://github.com/awslabs/aws-lambda-rust-runtime"
+repository = "https://github.com/awslabs/aws-lambda-rust-runtime"
+readme = "README.md"
+keywords = ["lambda", "aws", "amazon", "events", "S3", "json"]
+categories = ["api-bindings", "encoding", "web-programming"]
+edition = "2021"
+
+[features]
+default = [ ]
+simd = [ "simd-json/ordered-float", "value-trait/ordered-float" ]
+
+[dependencies]
+serde_json = { version = "^1", features = ["raw_value"] }
+#simd-json = { version = "^0", optional = true }
+simd-json = { git = "https://github.com/simd-lite/simd-json.git", branch = "main", optional = true }
+value-trait = { version = "^0", optional = true }
+bytes = { workspace = true }
+serde = { version = "^1", no-default-features = true }
diff --git a/json-impl/src/lib.rs b/json-impl/src/lib.rs
@@ -0,0 +1,93 @@
+// Using serde_json as the JSON handler
+#[cfg(not(feature = "simd"))]
+pub use serde::*;
+// Using simd_json as the JSON handler
+#[cfg(feature = "simd")]
+pub use simd::*;
+
+// Implementations
+
+#[cfg(not(feature = "simd"))]
+mod serde {
+    use bytes::Bytes;
+    use serde::de::DeserializeOwned;
+    pub use serde_json::{
+        self, error::Error as JsonError, from_reader, from_slice, from_str, from_value, json, to_string,
+        to_string_pretty, to_value, to_writer, value::RawValue, Deserializer as JsonDeserializer, Value,
+        to_vec,
+    };
+    pub fn from_bytes<T>(b: Bytes) -> serde_json::Result<T>
+    where
+    T: DeserializeOwned,
+    {
+        from_slice(&b)
+    }
+
+    pub fn from_string<T>(s: String) -> serde_json::Result<T>
+    where
+    T: DeserializeOwned,
+    {
+        from_str(s.as_str())
+    }
+
+    pub fn from_vec<T>(v: Vec<u8>) -> serde_json::Result<T>
+    where
+    T: DeserializeOwned,
+    {
+        from_slice(&v)
+    }
+}
+
+#[cfg(feature = "simd")]
+mod simd {
+    use bytes::Bytes;
+    use serde::de::DeserializeOwned;
+    pub use simd_json::{
+        self,
+        json,
+        owned::Value,
+        serde::{
+            from_owned_value as from_value,
+            from_reader,
+            from_str,   //THIS requires a mutable string slice AND is unsafe
+            from_slice, //THIS requires a mutable slice!
+            to_owned_value as to_value,
+            to_string,
+            to_string_pretty,
+            to_writer,
+            to_vec,
+        },
+        tape::Value as RawValue, //THIS is gonna be the fun one!
+        Deserializer as JsonDeserializer,
+        Error as JsonError,
+    };
+    pub use value_trait::prelude::*;
+
+    pub fn from_bytes<T>(b: Bytes) -> simd_json::Result<T>
+    where
+    T: DeserializeOwned,
+    {
+        match b.try_into_mut() {
+            Ok(mut b) => from_slice(&mut b),
+            Err(b) => {
+                let mut v = b.to_vec();
+                from_slice(&mut v)
+            }
+        }
+    }
+
+    pub fn from_string<T>(mut s: String) -> simd_json::Result<T>
+    where
+    T: DeserializeOwned,
+    {
+        unsafe{ from_str(s.as_mut_str()) }
+    }
+
+    pub fn from_vec<T>(mut v: Vec<u8>) -> simd_json::Result<T>
+    where
+    T: DeserializeOwned,
+    {
+        from_slice(&mut v)
+    }
+}
+
diff --git a/lambda-events/Cargo.toml b/lambda-events/Cargo.toml
@@ -29,11 +29,14 @@ query_map = { version = "^0.7", features = [
 ], optional = true }
 serde = { version = "^1", features = ["derive"] }
 serde_with = { version = "^3", features = ["json"], optional = true }
-serde_json = "^1"
+aws_lambda_json_impl = { path = "../json-impl" }
 serde_dynamo = { version = "^4.1", optional = true }
 
 [features]
 default = [
+
+#  "simd_json",
+
   "activemq",
   "alb",
   "apigw",
@@ -123,3 +126,4 @@ sqs = ["serde_with"]
 streams = []
 documentdb = []
 eventbridge = ["chrono", "serde_with"]
+simd_json = [ "aws_lambda_json_impl/simd" ]
diff --git a/lambda-events/src/custom_serde/codebuild_time.rs b/lambda-events/src/custom_serde/codebuild_time.rs
@@ -78,14 +78,14 @@ mod tests {
             #[serde(with = "str_time")]
             pub date: TestTime,
         }
-        let data = serde_json::json!({
+        let data = aws_lambda_json_impl::json!({
             "date": "Sep 1, 2017 4:12:29 PM"
         });
 
         let expected = NaiveDateTime::parse_from_str("Sep 1, 2017 4:12:29 PM", CODEBUILD_TIME_FORMAT)
             .unwrap()
             .and_utc();
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert_eq!(expected, decoded.date);
     }
 
@@ -96,14 +96,14 @@ mod tests {
             #[serde(with = "optional_time")]
             pub date: Option<TestTime>,
         }
-        let data = serde_json::json!({
+        let data = aws_lambda_json_impl::json!({
             "date": "Sep 1, 2017 4:12:29 PM"
         });
 
         let expected = NaiveDateTime::parse_from_str("Sep 1, 2017 4:12:29 PM", CODEBUILD_TIME_FORMAT)
             .unwrap()
             .and_utc();
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert_eq!(Some(expected), decoded.date);
     }
 }
diff --git a/lambda-events/src/custom_serde/headers.rs b/lambda-events/src/custom_serde/headers.rs
@@ -145,13 +145,13 @@ mod tests {
             #[serde(deserialize_with = "deserialize_headers", default)]
             pub headers: HeaderMap,
         }
-        let data = serde_json::json!({
+        let data = aws_lambda_json_impl::json!({
             "not_headers": {}
         });
 
         let expected = HeaderMap::new();
 
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert_eq!(expected, decoded.headers);
     }
 
@@ -163,16 +163,16 @@ mod tests {
             #[serde(serialize_with = "serialize_multi_value_headers")]
             headers: HeaderMap,
         }
-        let data = serde_json::json!({
+        let data = aws_lambda_json_impl::json!({
             "headers": {
                 "Accept": ["*/*"]
             }
         });
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert_eq!(&"*/*", decoded.headers.get("Accept").unwrap());
 
-        let recoded = serde_json::to_value(decoded).unwrap();
-        let decoded: Test = serde_json::from_value(recoded).unwrap();
+        let recoded = aws_lambda_json_impl::to_value(decoded).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(recoded).unwrap();
         assert_eq!(&"*/*", decoded.headers.get("Accept").unwrap());
     }
 
@@ -183,9 +183,9 @@ mod tests {
             #[serde(deserialize_with = "deserialize_headers")]
             headers: HeaderMap,
         }
-        let data = serde_json::json!({ "headers": null });
+        let data = aws_lambda_json_impl::json!({ "headers": null });
 
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert!(decoded.headers.is_empty());
     }
 
@@ -203,23 +203,23 @@ mod tests {
 
         let content_disposition =
             "inline; filename=\"Schillers schönste Szenenanweisungen -Kabale und Liebe.mp4.avif\"";
-        let data = serde_json::json!({
+        let data = aws_lambda_json_impl::json!({
             "headers": {
                 "Content-Disposition": content_disposition
             },
             "multi_value_headers": {
                 "Content-Disposition": content_disposition
             }
         });
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert_eq!(content_disposition, decoded.headers.get("Content-Disposition").unwrap());
         assert_eq!(
             content_disposition,
             decoded.multi_value_headers.get("Content-Disposition").unwrap()
         );
 
-        let recoded = serde_json::to_value(decoded).unwrap();
-        let decoded: Test = serde_json::from_value(recoded).unwrap();
+        let recoded = aws_lambda_json_impl::to_value(decoded).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(recoded).unwrap();
         assert_eq!(content_disposition, decoded.headers.get("Content-Disposition").unwrap());
         assert_eq!(
             content_disposition,

diff --git a/lambda-events/src/custom_serde/http_method.rs b/lambda-events/src/custom_serde/http_method.rs
@@ -67,13 +67,13 @@ mod tests {
             #[serde(with = "crate::custom_serde::http_method")]
             pub method: http::Method,
         }
-        let data = serde_json::json!({
+        let data = aws_lambda_json_impl::json!({
             "method": "DELETE"
         });
-        let decoded: Test = serde_json::from_value(data.clone()).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data.clone()).unwrap();
         assert_eq!(http::Method::DELETE, decoded.method);
 
-        let recoded = serde_json::to_value(decoded).unwrap();
+        let recoded = aws_lambda_json_impl::to_value(decoded).unwrap();
         assert_eq!(data, recoded);
     }
 
@@ -86,21 +86,21 @@ mod tests {
             #[serde(default)]
             pub method: Option<http::Method>,
         }
-        let data = serde_json::json!({
+        let data = aws_lambda_json_impl::json!({
             "method": "DELETE"
         });
-        let decoded: Test = serde_json::from_value(data.clone()).unwrap();
+        let decoded: Test = aws_lambda_json_impl::from_value(data.clone()).unwrap();
         assert_eq!(Some(http::Method::DELETE), decoded.method);
 
-        let recoded = serde_json::to_value(decoded).unwrap();
+        let recoded = aws_lambda_json_impl::to_value(decoded).unwrap();
         assert_eq!(data, recoded);
 
-        let data = serde_json::json!({ "method": null });
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let data = aws_lambda_json_impl::json!({ "method": null });
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert_eq!(None, decoded.method);
 
-        let data = serde_json::json!({});
-        let decoded: Test = serde_json::from_value(data).unwrap();
+        let data = aws_lambda_json_impl::json!({});
+        let decoded: Test = aws_lambda_json_impl::from_value(data).unwrap();
         assert_eq!(None, decoded.method);
     }
 }