feat/sqs

Cargo.toml

@@ -1,14 +1,17 @@
 [package]
 name = "lambda_utils"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 authors = ["Ae <hi@angel-estrada.com>"]
 keywords = ["aws", "lambda", "serverless", "rust"]
 
 [dependencies]
-aws-config = "0.52.0"
+aws-config = { version = "1.1.2", features = ["behavior-version-latest"] }
+aws-sdk-sqs = "1.9.0"
+aws-types = "1.1.2"
 aws_lambda_events = "0.7.2"
 lambda_http = "0.7.0"
 mongodb = "2.3.1"
 once_cell = "1.17.0"
+serde_json = "1.0.79"
 tokio = { version = "1.17.0", features = ["full", "test-util"] }

README.md

@@ -0,0 +1,3 @@
+### Lambda Utils
+
+

src/headers.rs

@@ -0,0 +1,35 @@
+use lambda_http::{Request};
+use std::collections::{HashMap};
+use serde_json::{to_string};
+
+pub fn get_header_user_agent(request: &Request) -> String {
+    return request
+        .headers()
+        .get("User-Agent")
+        .map_or_else(
+            || "Unknown User-Agent".to_string(),
+            |header_value| header_value.to_str().unwrap_or("Invalid User-Agent").to_string(),
+        );
+}
+
+pub fn get_header_cookies(request: &Request) -> String {
+    let mut cookies = HashMap::new();
+
+    if let Some(cookie_header) = request.headers().get("Cookie") {
+        if let Ok(cookie_str) = cookie_header.to_str() {
+            cookie_str.split(';').filter_map(|cookie| {
+                let parts: Vec<&str> = cookie.splitn(2, '=').collect();
+
+                if parts.len() == 2 {
+                    Some((parts[0].trim().to_string(), parts[1].trim().to_string()))
+                } else {
+                    None
+                }
+            }).for_each(|(name, value)| {
+                cookies.insert(name, value);
+            });
+        }
+    }
+
+    return to_string(&cookies).unwrap();
+}

src/lib.rs

@@ -1,2 +1,4 @@
+pub mod headers;
 pub mod mongodb;
 pub mod network;
+pub mod sqs;

src/mongodb.rs

@@ -6,12 +6,12 @@ use std::error::Error;
 
 static MONGODB_CLIENT: OnceCell<Client> = OnceCell::new();
 
-pub async fn create_mongodb_client() {
+pub async fn create_mongodb_client() -> Result<(), Box<dyn Error + Send + Sync>> {
     let mongodb_uri = get_mongodb_url_from_env_var().unwrap();
     let client_options = ClientOptions::parse_with_resolver_config(mongodb_uri, ResolverConfig::cloudflare()).await.unwrap();
     let client = Client::with_options(client_options).unwrap();
 
-    return MONGODB_CLIENT.set(client).expect("Should set MongoDB client");
+    return MONGODB_CLIENT.set(client).map_err(|_| "MongoDB client already set".into());
 }
 
 fn get_mongodb_url_from_env_var() -> Result<String, Box<dyn Error + Send + Sync>> {
@@ -32,12 +32,12 @@ pub fn get_mongodb_client() -> Result<&'static Client, Box<dyn Error + Send + Sy
 }
 
 #[cfg(test)]
-use tokio;
-
 #[tokio::test]
 async fn test_create_mongodb_client() {
     env::set_var(get_mongodb_uri_env_key(), "mongodb+srv://foo:bar@cluster0.irqdk.mongodb.net/test");
-    create_mongodb_client().await;
 
+    let client = create_mongodb_client().await;
+
+    assert!(client.is_ok());
     assert!(MONGODB_CLIENT.get().is_some());
 }

src/sqs.rs

@@ -0,0 +1,67 @@
+use aws_sdk_sqs::{Client, Error as SqsError};
+use aws_sdk_sqs::operation::receive_message::{ReceiveMessageOutput};
+use aws_config;
+use std::env;
+use std::error::Error;
+use serde_json::{json, Value};
+
+fn get_sqs_url_from_env_var() -> Result<String, Box<dyn Error + Send + Sync>> {
+    return  env::var(get_sqs_url_env_key()).map_err(|_| "Missing AWS_SQS_URL environment var".into());
+}
+
+fn get_sqs_url_env_key() -> &'static str {
+    return "AWS_SQS_URL";
+}
+
+pub async fn send_to_sqs(data: String) -> Result<(), SqsError> {
+    let config = aws_config::load_from_env().await;
+    let sqs_client = Client::new(&config);
+    let message_body = &data;
+    let queue_url = get_sqs_url_from_env_var().unwrap();
+
+    sqs_client.send_message()
+        .queue_url(&queue_url)
+        .message_body(message_body)
+        .send()
+        .await?;
+
+    Ok(())
+}
+
+pub async fn receive_from_sqs() -> Result<ReceiveMessageOutput, SqsError> {
+    let config = aws_config::load_from_env().await;
+    let sqs_client = Client::new(&config);
+    let queue_url = get_sqs_url_from_env_var().unwrap();
+    let data = sqs_client
+        .receive_message()
+        .queue_url(&queue_url)
+        .send()
+        .await?;
+
+    Ok(data)
+}
+
+pub fn create_mock_object() -> Value {
+    json!({ "hello": "world" })
+}
+
+#[cfg(test)]
+
+#[tokio::test] #[ignore = "ignore for now"]
+async fn test_send_to_sqs() {
+    env::set_var(get_sqs_url_env_key(), "https://sqs.us-east-1.amazonaws.com/0000000000/foo-bar");
+
+    let data = create_mock_object();
+    let client = send_to_sqs(data.to_string()).await.unwrap();
+
+    assert_eq!(client, ());
+}
+
+#[tokio::test] #[ignore = "ignore for now"]
+async fn test_receive_from_sqs() {
+    env::set_var(get_sqs_url_env_key(), "https://sqs.us-east-1.amazonaws.com/0000000000/foo-bar");
+
+    let data: ReceiveMessageOutput = receive_from_sqs().await.unwrap();
+
+    assert_eq!(data.messages.unwrap().len(), 0);
+}