(rust): Parse the event in lambda handler

Author: alex9smith

lambda/rust/Cargo.lock

@@ -7,4 +7,6 @@ edition = "2021"
 aws_lambda_events = { version = "0.15.1", default-features = false, features = ["sqs"] }
 
 lambda_runtime = "0.13.0"
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"
 tokio = { version = "1", features = ["macros"] }

lambda/rust/Cargo.toml

@@ -1,27 +1,67 @@
-use lambda_runtime::{tracing, Error, LambdaEvent};
 use aws_lambda_events::event::sqs::SqsEvent;
+use lambda_runtime::{Error, LambdaEvent};
+use serde::{Deserialize, Serialize};
+use serde_json;
 
-/// This is the main body for the function.
-/// Write your code inside it.
-/// There are some code example in the following URLs:
-/// - https://github.com/awslabs/aws-lambda-rust-runtime/tree/main/examples
-/// - https://github.com/aws-samples/serverless-rust-demo/
-pub(crate)async fn function_handler(event: LambdaEvent<SqsEvent>) -> Result<(), Error> {
+#[derive(Deserialize, Serialize, Default)]
+pub struct User {
+    id: String,
+    session_id: String,
+    devide_id: Option<String>,
+}
+
+#[derive(Deserialize, Serialize, Default)]
+pub struct Event {
+    event_id: String,
+    user: User,
+    emitter_code: u32,
+    action: String,
+}
+
+pub(crate) async fn function_handler(lambda_event: LambdaEvent<SqsEvent>) -> Result<(), Error> {
     // Extract some useful information from the request
-    let payload = event.payload;
-    tracing::info!("Payload: {:?}", payload);
+    let payload = lambda_event.payload;
+    for message in payload.records {
+        let event: Event = serde_json::from_str(&message.body.unwrap()).unwrap();
+    }
 
     Ok(())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use aws_lambda_events::sqs::SqsMessage;
     use lambda_runtime::{Context, LambdaEvent};
+    use std::collections::HashMap;
+
+    fn build_message(body: &str) -> SqsMessage {
+        SqsMessage {
+            message_id: None,
+            receipt_handle: None,
+            aws_region: None,
+            body: Some(body.to_string()),
+            md5_of_body: None,
+            md5_of_message_attributes: None,
+            event_source: None,
+            event_source_arn: None,
+            attributes: HashMap::new(),
+            message_attributes: HashMap::new(),
+        }
+    }
+
+    fn build_event(body: &str) -> SqsEvent {
+        SqsEvent {
+            records: vec![build_message(body)],
+        }
+    }
 
     #[tokio::test]
     async fn test_event_handler() {
-        let event = LambdaEvent::new(SqsEvent::default(), Context::default());
+        let event = LambdaEvent::new(
+            build_event(&serde_json::to_string(&Event::default()).unwrap()),
+            Context::default(),
+        );
         let response = function_handler(event).await.unwrap();
         assert_eq!((), response);
     }

lambda/rust/src/event_handler.rs

@@ -3,7 +3,6 @@ use lambda_runtime::{run, service_fn, tracing, Error};
 mod event_handler;
 use event_handler::function_handler;
 
-
 #[tokio::main]
 async fn main() -> Result<(), Error> {
     tracing::init_default_subscriber();