diff --git a/.github/actions/rust-build/action.yml b/.github/actions/rust-build/action.yml
new file mode 100644
index 00000000..85b5c0e8
--- /dev/null
+++ b/.github/actions/rust-build/action.yml
@@ -0,0 +1,26 @@
+name: "Rust builds"
+description: "Builds, tests, and formats Rust code"
+inputs:
+ package:
+ required: true
+ description: "the Rust package to test"
+ toolchain:
+ required: true
+ description: "the Rust toolchain to use"
+
+runs:
+ using: "composite"
+ steps:
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: ${{ inputs.toolchain }}
+ components: clippy, rustfmt
+ - uses: Swatinem/rust-cache@v2
+
+ - name: Build
+ shell: bash
+ run: cargo build --all-features --verbose --package ${{ inputs.package }}
+
+ - name: Run tests
+ shell: bash
+ run: cargo test --all-features --verbose --package ${{ inputs.package }}
diff --git a/.github/workflows/build-events.yml b/.github/workflows/build-events.yml
new file mode 100644
index 00000000..dbf9a0ae
--- /dev/null
+++ b/.github/workflows/build-events.yml
@@ -0,0 +1,28 @@
+name: Check Lambda Events
+
+on:
+ push:
+ paths:
+ - 'lambda-events/**'
+ pull_request:
+ paths:
+ - 'lambda-events/**'
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ toolchain:
+ - "1.62.0" # Current MSRV
+ - stable
+ env:
+ RUST_BACKTRACE: 1
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Build events
+ uses: ./.github/actions/rust-build
+ with:
+ package: aws_lambda_events
+ toolchain: ${{ matrix.toolchain}}
diff --git a/.github/workflows/build-extension.yml b/.github/workflows/build-extension.yml
new file mode 100644
index 00000000..0905f289
--- /dev/null
+++ b/.github/workflows/build-extension.yml
@@ -0,0 +1,39 @@
+name: Check Lambda Runtime
+
+on:
+ push:
+ paths:
+ - 'lambda-runtime-api-client/**'
+ - 'lambda-extension/**'
+
+ pull_request:
+ paths:
+ - 'lambda-runtime-api-client/**'
+ - 'lambda-extension/**'
+
+
+jobs:
+ build-runtime:
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ toolchain:
+ - "1.62.0" # Current MSRV
+ - stable
+ env:
+ RUST_BACKTRACE: 1
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Build Runtime API Client
+ uses: ./.github/actions/rust-build
+ with:
+ package: lambda_runtime_api_client
+ toolchain: ${{ matrix.toolchain}}
+
+
+ - name: Build Extensions runtime
+ uses: ./.github/actions/rust-build
+ with:
+ package: lambda-extension
+ toolchain: ${{ matrix.toolchain}}
diff --git a/.github/workflows/build-runtime.yml b/.github/workflows/build-runtime.yml
new file mode 100644
index 00000000..68913c95
--- /dev/null
+++ b/.github/workflows/build-runtime.yml
@@ -0,0 +1,45 @@
+name: Check Lambda Runtime
+
+on:
+ push:
+ paths:
+ - 'lambda-runtime-api-client/**'
+ - 'lambda-runtime/**'
+ - 'lambda-http/**'
+
+ pull_request:
+ paths:
+ - 'lambda-runtime-api-client/**'
+ - 'lambda-runtime/**'
+ - 'lambda-http/**'
+
+jobs:
+ build-runtime:
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ toolchain:
+ - "1.62.0" # Current MSRV
+ - stable
+ env:
+ RUST_BACKTRACE: 1
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Build Runtime API Client
+ uses: ./.github/actions/rust-build
+ with:
+ package: lambda_runtime_api_client
+ toolchain: ${{ matrix.toolchain}}
+
+ - name: Build Functions runtime
+ uses: ./.github/actions/rust-build
+ with:
+ package: lambda_runtime
+ toolchain: ${{ matrix.toolchain}}
+
+ - name: Build HTTP layer
+ uses: ./.github/actions/rust-build
+ with:
+ package: lambda_http
+ toolchain: ${{ matrix.toolchain}}
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
deleted file mode 100644
index 370d8249..00000000
--- a/.github/workflows/build.yml
+++ /dev/null
@@ -1,93 +0,0 @@
-name: Rust
-
-on: [push, pull_request, workflow_dispatch]
-
-jobs:
- build:
- runs-on: ${{ matrix.os }}
- strategy:
- fail-fast: false
- matrix:
- os:
- - ubuntu-latest
- - macOS-latest
- toolchain:
- - "1.62.0" # Current MSRV
- - stable
- - beta
- - nightly
- target:
- - ""
- - x86_64-unknown-linux-musl
- include:
- - rust: nightly
- allow_failure: true
- env:
- RUST_BACKTRACE: 1
- steps:
- - uses: actions/checkout@v3
- - uses: dtolnay/rust-toolchain@master
- with:
- toolchain: ${{ matrix.toolchain }}
- - uses: Swatinem/rust-cache@v2
-
- - name: Build
- run: cargo build --all --verbose
- env:
- TARGET: ${{ matrix.target }}
- continue-on-error: ${{ matrix.allow_failure }}
- - name: Run tests
- run: cargo test --all --verbose
- env:
- TARGET: ${{ matrix.target }}
- continue-on-error: ${{ matrix.allow_failure }}
- formatting:
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v2
- - uses: dtolnay/rust-toolchain@master
- with:
- toolchain: stable
- - uses: Swatinem/rust-cache@v2
-
- - name: Run fmt check
- run: cargo fmt --all -- --check
- - name: Run clippy check
- run: cargo clippy --all-features -- -D warnings
-
- check-examples:
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v3
- - uses: dtolnay/rust-toolchain@master
- with:
- toolchain: stable
- - uses: Swatinem/rust-cache@v2
-
- - name: Check examples
- working-directory: examples
- shell: bash
- run: ./check-examples.sh
-
- # publish rustdoc to a gh-pages branch on pushes to main
- # this can be helpful to those depending on the mainline branch
- publish-docs:
- if: github.ref == 'refs/heads/main'
- runs-on: ubuntu-latest
- needs: [build]
- steps:
- - uses: actions/checkout@v3
- - uses: dtolnay/rust-toolchain@master
- with:
- toolchain: stable
- - uses: Swatinem/rust-cache@v2
-
- - name: Generate Docs
- run: |
- cargo doc --no-deps
- echo "" > target/doc/index.html
- - name: Publish
- uses: peaceiris/actions-gh-pages@v3
- with:
- github_token: ${{ secrets.GITHUB_TOKEN }}
- publish_dir: ./target/doc
diff --git a/.github/workflows/check-examples.yml b/.github/workflows/check-examples.yml
new file mode 100644
index 00000000..ba7bc709
--- /dev/null
+++ b/.github/workflows/check-examples.yml
@@ -0,0 +1,16 @@
+name: Check examples
+
+on: [push, pull_request]
+
+jobs:
+ check:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v3
+ - uses: dtolnay/rust-toolchain@stable
+ - uses: Swatinem/rust-cache@v2
+
+ - name: Check examples
+ working-directory: examples
+ shell: bash
+ run: ./check-examples.sh
\ No newline at end of file
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
new file mode 100644
index 00000000..f18d1f83
--- /dev/null
+++ b/.github/workflows/format.yml
@@ -0,0 +1,55 @@
+name: Formatting and Linting
+
+on: [push, pull_request]
+
+jobs:
+ check:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v3
+ - uses: dtolnay/rust-toolchain@stable
+ - uses: Swatinem/rust-cache@v2
+
+ - name: Run fmt check
+ id: cargoFmt
+ shell: bash
+ run: cargo fmt --all -- --check
+ - name: Notify fmt check
+ if: failure() && steps.cargoFmt.outcome == 'failure'
+ uses: actions/github-script@v6
+ with:
+ script: |
+ const message = `👋 It looks like your code is not formatted like we expect.
+
+ Please run \`cargo fmt\` and push the code again.`;
+
+ await github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: message,
+ });
+ core.setFailed('It looks like there are formatting errors');
+
+ - name: Run clippy check
+ id: cargoClippy
+ shell: bash
+ run: cargo clippy --workspace --all-features -- -D warnings
+ - name: Notify fmt check
+ if: failure() && steps.cargoClippy.outcome == 'failure'
+ uses: actions/github-script@v6
+ with:
+ script: |
+ const message = `👋 It looks like your code has some linting issues.
+
+ Please run \`cargo clippy --fix\` and push the code again.`;
+
+ await github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: message,
+ });
+ core.setFailed('It looks like there are linting errors');
+
+
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 7361557e..48bcd5db 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,8 @@ members = [
"lambda-integration-tests",
"lambda-runtime-api-client",
"lambda-runtime",
- "lambda-extension"
+ "lambda-extension",
+ "lambda-events"
]
exclude = ["examples"]
diff --git a/README.md b/README.md
index 8fdd232c..157c1c98 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@ This package makes it easy to run AWS Lambda Functions written in Rust. This wor
- [](https://docs.rs/lambda_runtime) **`lambda-runtime`** is a library that provides a Lambda runtime for applications written in Rust.
- [](https://docs.rs/lambda_http) **`lambda-http`** is a library that makes it easy to write API Gateway proxy event focused Lambda functions in Rust.
- [](https://docs.rs/lambda-extension) **`lambda-extension`** is a library that makes it easy to write Lambda Runtime Extensions in Rust.
+- [](https://docs.rs/aws_lambda_events) **`lambda-events`** is a library with strongly-typed Lambda event structs in Rust.
- [](https://docs.rs/lambda_runtime_api_client) **`lambda-runtime-api-client`** is a shared library between the lambda runtime and lambda extension libraries that includes a common API client to talk with the AWS Lambda Runtime API.
The Rust runtime client is an experimental package. It is subject to change and intended only for evaluation purposes.
diff --git a/examples/advanced-sqs-partial-batch-failures/Cargo.toml b/examples/advanced-sqs-partial-batch-failures/Cargo.toml
index 06e56053..0dfe49d9 100644
--- a/examples/advanced-sqs-partial-batch-failures/Cargo.toml
+++ b/examples/advanced-sqs-partial-batch-failures/Cargo.toml
@@ -8,8 +8,8 @@ serde = "^1"
serde_derive = "^1"
serde_with = { version = "^2", features = ["json"], optional = true }
serde_json = "^1"
-aws_lambda_events = "0.7.3"
-lambda_runtime = "0.7"
+aws_lambda_events = { path = "../../lambda-events" }
+lambda_runtime = { path = "../../lambda-runtime" }
tokio = { version = "1", features = ["macros"] }
futures = "0.3"
tracing = { version = "0.1", features = ["log"] }
diff --git a/examples/basic-s3-thumbnail/Cargo.toml b/examples/basic-s3-thumbnail/Cargo.toml
index dfa6d69b..0ef0d463 100644
--- a/examples/basic-s3-thumbnail/Cargo.toml
+++ b/examples/basic-s3-thumbnail/Cargo.toml
@@ -15,7 +15,7 @@ edition = "2021"
# and it will keep the alphabetic ordering for you.
[dependencies]
-aws_lambda_events = "0.7.2"
+aws_lambda_events = { path = "../../lambda-events" }
lambda_runtime = { path = "../../lambda-runtime" }
serde = "1"
tokio = { version = "1", features = ["macros"] }
diff --git a/examples/basic-sqs/Cargo.toml b/examples/basic-sqs/Cargo.toml
index 086a22dc..a1b11567 100644
--- a/examples/basic-sqs/Cargo.toml
+++ b/examples/basic-sqs/Cargo.toml
@@ -15,7 +15,7 @@ edition = "2021"
# and it will keep the alphabetic ordering for you.
[dependencies]
-aws_lambda_events = "0.7.2"
+aws_lambda_events = { path = "../../lambda-events" }
lambda_runtime = { path = "../../lambda-runtime" }
serde = "1.0.136"
tokio = { version = "1", features = ["macros"] }
diff --git a/lambda-events/Cargo.toml b/lambda-events/Cargo.toml
new file mode 100644
index 00000000..225d9d8f
--- /dev/null
+++ b/lambda-events/Cargo.toml
@@ -0,0 +1,117 @@
+[package]
+name = "aws_lambda_events"
+version = "0.9.0"
+description = "AWS Lambda event definitions"
+authors = [
+ "Christian Legnitto ",
+ "Sam Rijs ",
+ "David Calavera ",
+]
+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"]
+categories = ["api-bindings", "encoding", "web-programming"]
+
+[dependencies]
+base64 = "0.13"
+http = "0.2"
+http-body = "0.4"
+http-serde = "^1"
+serde = "^1"
+serde_derive = "^1"
+serde_with = { version = "^2", features = ["json"], optional = true }
+serde_json = "^1"
+serde_dynamo = { version = "^4.1", optional = true }
+bytes = { version = "1", features = ["serde"] }
+chrono = { version = "0.4.23", default-features = false, features = [
+ "clock",
+ "serde",
+ "std",
+] }
+query_map = { version = "^0.6", features = ["serde", "url-query"] }
+flate2 = { version = "1.0.24", optional = true }
+
+[dev-dependencies]
+pretty_assertions = "1.3"
+
+[features]
+default = [
+ "activemq",
+ "alb",
+ "apigw",
+ "appsync",
+ "autoscaling",
+ "chime_bot",
+ "clientvpn",
+ "cloudwatch_events",
+ "cloudwatch_logs",
+ "code_commit",
+ "codebuild",
+ "codedeploy",
+ "codepipeline_cloudwatch",
+ "codepipeline_job",
+ "cognito",
+ "config",
+ "connect",
+ "dynamodb",
+ "ecr_scan",
+ "firehose",
+ "iam",
+ "iot",
+ "iot_1_click",
+ "iot_button",
+ "iot_deprecated",
+ "kafka",
+ "kinesis",
+ "kinesis_analytics",
+ "lambda_function_urls",
+ "lex",
+ "rabbitmq",
+ "s3",
+ "s3_batch_job",
+ "ses",
+ "sns",
+ "sqs",
+ "streams",
+]
+
+activemq = []
+alb = []
+apigw = []
+appsync = []
+autoscaling = []
+chime_bot = []
+clientvpn = []
+cloudwatch_events = []
+cloudwatch_logs = ["flate2"]
+code_commit = []
+codebuild = []
+codedeploy = []
+codepipeline = []
+codepipeline_cloudwatch = []
+codepipeline_job = []
+cognito = []
+config = []
+connect = []
+dynamodb = ["streams", "serde_dynamo"]
+ecr_scan = []
+firehose = []
+iam = []
+iot = ["iam"]
+iot_1_click = []
+iot_button = []
+iot_deprecated = ["iot"]
+kafka = []
+kinesis = []
+kinesis_analytics = ["kinesis"]
+lambda_function_urls = []
+lex = []
+rabbitmq = []
+s3 = []
+s3_batch_job = ["s3"]
+ses = []
+sns = ["serde_with"]
+sqs = ["serde_with"]
+streams = []
diff --git a/lambda-events/README.md b/lambda-events/README.md
new file mode 100644
index 00000000..0813c63a
--- /dev/null
+++ b/lambda-events/README.md
@@ -0,0 +1,34 @@
+# AWS Lambda Events
+
+[![crates.io][crate-image]][crate-link]
+[![Documentation][docs-image]][docs-link]
+
+This crate provides strongly-typed [AWS Lambda event structs](https://docs.aws.amazon.com/lambda/latest/dg/invoking-lambda-function.html) in Rust.
+
+## Installation
+
+Add the dependency with Cargo: `cargo add aws_lambda_events`.
+
+## Usage
+
+The crate itself has no AWS Lambda handler logic and instead exists to serialize
+and deserialize AWS Lambda events into strongly-typed Rust structs.
+
+The types
+defined in this crate are usually used with handlers / runtimes provided by the [official Rust runtime](https://github.com/awslabs/aws-lambda-rust-runtime).
+
+For a list of supported AWS Lambda events and services, see [the crate reference documentation](https://docs.rs/aws_lambda_events).
+
+## Conditional compilation of features
+
+This crate divides all Lambda Events into features named after the service that the events are generated from. By default all events are enabled when you include this crate as a dependency to your project. If you only want to import specific events from this crate, you can disable the default features, and enable only the events that you need. This will make your project to compile a little bit faster, since rustc doesn't need to compile events that you're not going to use. Here's an example on how to do that:
+
+```
+cargo add aws_lambda_events --no-default-features --features apigw,alb
+```
+
+[//]: # 'badges'
+[crate-image]: https://img.shields.io/crates/v/aws_lambda_events.svg
+[crate-link]: https://crates.io/crates/aws_lambda_events
+[docs-image]: https://docs.rs/aws_lambda_events/badge.svg
+[docs-link]: https://docs.rs/aws_lambda_events
\ No newline at end of file
diff --git a/lambda-events/src/custom_serde/codebuild_time.rs b/lambda-events/src/custom_serde/codebuild_time.rs
new file mode 100644
index 00000000..c57ccd6a
--- /dev/null
+++ b/lambda-events/src/custom_serde/codebuild_time.rs
@@ -0,0 +1,105 @@
+use chrono::{DateTime, TimeZone, Utc};
+use serde::de::{Deserialize, Deserializer, Error as DeError, Visitor};
+use serde::ser::Serializer;
+use std::fmt;
+
+// Jan 2, 2006 3:04:05 PM
+const CODEBUILD_TIME_FORMAT: &str = "%b %e, %Y %l:%M:%S %p";
+
+struct TimeVisitor;
+impl<'de> Visitor<'de> for TimeVisitor {
+ type Value = DateTime;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "valid codebuild time: {}", CODEBUILD_TIME_FORMAT)
+ }
+
+ fn visit_str(self, val: &str) -> Result {
+ Utc.datetime_from_str(val, CODEBUILD_TIME_FORMAT)
+ .map_err(|e| DeError::custom(format!("Parse error {} for {}", e, val)))
+ }
+}
+
+pub(crate) mod str_time {
+ use super::*;
+
+ pub(crate) fn deserialize<'de, D>(d: D) -> Result, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ d.deserialize_str(TimeVisitor)
+ }
+
+ pub fn serialize(date: &DateTime, ser: S) -> Result {
+ let s = format!("{}", date.format(CODEBUILD_TIME_FORMAT));
+ ser.serialize_str(&s)
+ }
+}
+
+pub(crate) mod optional_time {
+ use super::*;
+
+ pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let s: Option = Option::deserialize(deserializer)?;
+ if let Some(val) = s {
+ let visitor = TimeVisitor {};
+ return visitor.visit_str(&val).map(Some);
+ }
+
+ Ok(None)
+ }
+
+ pub fn serialize(date: &Option>, ser: S) -> Result {
+ if let Some(date) = date {
+ return str_time::serialize(date, ser);
+ }
+
+ ser.serialize_none()
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ type TestTime = DateTime;
+
+ #[test]
+ fn test_deserialize_codebuild_time() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(with = "str_time")]
+ pub date: TestTime,
+ }
+ let data = json!({
+ "date": "Sep 1, 2017 4:12:29 PM"
+ });
+
+ let expected = Utc
+ .datetime_from_str("Sep 1, 2017 4:12:29 PM", CODEBUILD_TIME_FORMAT)
+ .unwrap();
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.date);
+ }
+
+ #[test]
+ fn test_deserialize_codebuild_optional_time() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(with = "optional_time")]
+ pub date: Option,
+ }
+ let data = json!({
+ "date": "Sep 1, 2017 4:12:29 PM"
+ });
+
+ let expected = Utc
+ .datetime_from_str("Sep 1, 2017 4:12:29 PM", CODEBUILD_TIME_FORMAT)
+ .unwrap();
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(Some(expected), decoded.date);
+ }
+}
diff --git a/lambda-events/src/custom_serde/float_unix_epoch.rs b/lambda-events/src/custom_serde/float_unix_epoch.rs
new file mode 100644
index 00000000..54fc64e4
--- /dev/null
+++ b/lambda-events/src/custom_serde/float_unix_epoch.rs
@@ -0,0 +1,109 @@
+use serde::{de, ser};
+use std::fmt;
+
+use chrono::offset::TimeZone;
+use chrono::{DateTime, LocalResult, Utc};
+
+enum SerdeError {
+ NonExistent { timestamp: V },
+ Ambiguous { timestamp: V, min: D, max: D },
+}
+
+fn ne_timestamp(ts: T) -> SerdeError {
+ SerdeError::NonExistent:: { timestamp: ts }
+}
+
+impl fmt::Debug for SerdeError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "ChronoSerdeError({})", self)
+ }
+}
+
+impl fmt::Display for SerdeError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ SerdeError::NonExistent { ref timestamp } => {
+ write!(f, "value is not a legal timestamp: {}", timestamp)
+ }
+ SerdeError::Ambiguous {
+ ref timestamp,
+ ref min,
+ ref max,
+ } => write!(
+ f,
+ "value is an ambiguous timestamp: {}, could be either of {}, {}",
+ timestamp, min, max
+ ),
+ }
+ }
+}
+
+fn serde_from(me: LocalResult, ts: &V) -> Result
+where
+ E: de::Error,
+ V: fmt::Display,
+ T: fmt::Display,
+{
+ match me {
+ LocalResult::None => Err(E::custom(ne_timestamp(ts))),
+ LocalResult::Ambiguous(min, max) => Err(E::custom(SerdeError::Ambiguous {
+ timestamp: ts,
+ min,
+ max,
+ })),
+ LocalResult::Single(val) => Ok(val),
+ }
+}
+
+struct SecondsFloatTimestampVisitor;
+
+/// Serialize a UTC datetime into an float number of seconds since the epoch
+/// ```
+pub fn serialize(dt: &DateTime, serializer: S) -> Result
+where
+ S: ser::Serializer,
+{
+ serializer.serialize_i64(dt.timestamp_millis() / 1000)
+}
+
+/// Deserialize a `DateTime` from a float seconds timestamp
+pub fn deserialize<'de, D>(d: D) -> Result, D::Error>
+where
+ D: de::Deserializer<'de>,
+{
+ d.deserialize_f64(SecondsFloatTimestampVisitor)
+}
+
+impl<'de> de::Visitor<'de> for SecondsFloatTimestampVisitor {
+ type Value = DateTime;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("a unix timestamp as a float")
+ }
+
+ /// Deserialize a timestamp in seconds since the epoch
+ fn visit_u64(self, value: u64) -> Result, E>
+ where
+ E: de::Error,
+ {
+ serde_from(Utc.timestamp_opt(value as i64, 0), &value)
+ }
+
+ /// Deserialize a timestamp in seconds since the epoch
+ fn visit_i64(self, value: i64) -> Result, E>
+ where
+ E: de::Error,
+ {
+ serde_from(Utc.timestamp_opt(value, 0), &value)
+ }
+
+ /// Deserialize a timestamp in seconds since the epoch
+ fn visit_f64(self, value: f64) -> Result, E>
+ where
+ E: de::Error,
+ {
+ let time_ms = (value.fract() * 1_000_000.).floor() as u32;
+ let time_s = value.trunc() as i64;
+ serde_from(Utc.timestamp_opt(time_s, time_ms), &value)
+ }
+}
diff --git a/lambda-events/src/custom_serde/headers.rs b/lambda-events/src/custom_serde/headers.rs
new file mode 100644
index 00000000..904ccd9b
--- /dev/null
+++ b/lambda-events/src/custom_serde/headers.rs
@@ -0,0 +1,189 @@
+use http::header::HeaderName;
+use http::{HeaderMap, HeaderValue};
+use serde::de::{self, Deserializer, Error as DeError, MapAccess, Unexpected, Visitor};
+use serde::ser::{Error as SerError, SerializeMap, Serializer};
+use std::{borrow::Cow, fmt};
+
+/// Serialize a http::HeaderMap into a serde str => Vec map
+pub(crate) fn serialize_multi_value_headers(headers: &HeaderMap, serializer: S) -> Result
+where
+ S: Serializer,
+{
+ let mut map = serializer.serialize_map(Some(headers.keys_len()))?;
+ for key in headers.keys() {
+ let mut map_values = Vec::new();
+ for value in headers.get_all(key) {
+ map_values.push(value.to_str().map_err(S::Error::custom)?)
+ }
+ map.serialize_entry(key.as_str(), &map_values)?;
+ }
+ map.end()
+}
+
+/// Serialize a http::HeaderMap into a serde str => str map
+pub(crate) fn serialize_headers(headers: &HeaderMap, serializer: S) -> Result
+where
+ S: Serializer,
+{
+ let mut map = serializer.serialize_map(Some(headers.keys_len()))?;
+ for key in headers.keys() {
+ let map_value = headers[key].to_str().map_err(S::Error::custom)?;
+ map.serialize_entry(key.as_str(), map_value)?;
+ }
+ map.end()
+}
+
+#[derive(serde::Deserialize)]
+#[serde(untagged)]
+enum OneOrMore<'a> {
+ One(Cow<'a, str>),
+ Strings(Vec>),
+ Bytes(Vec>),
+}
+
+struct HeaderMapVisitor {
+ is_human_readable: bool,
+}
+
+impl<'de> Visitor<'de> for HeaderMapVisitor {
+ type Value = HeaderMap;
+
+ // Format a message stating what data this Visitor expects to receive.
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("lots of things can go wrong with HeaderMap")
+ }
+
+ fn visit_unit(self) -> Result
+ where
+ E: DeError,
+ {
+ Ok(HeaderMap::default())
+ }
+
+ fn visit_none(self) -> Result
+ where
+ E: DeError,
+ {
+ Ok(HeaderMap::default())
+ }
+
+ fn visit_some(self, deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_map(self)
+ }
+
+ fn visit_map(self, mut access: M) -> Result
+ where
+ M: MapAccess<'de>,
+ {
+ let mut map = HeaderMap::with_capacity(access.size_hint().unwrap_or(0));
+
+ if !self.is_human_readable {
+ while let Some((key, arr)) = access.next_entry::, Vec>>()? {
+ let key = HeaderName::from_bytes(key.as_bytes())
+ .map_err(|_| de::Error::invalid_value(Unexpected::Str(&key), &self))?;
+ for val in arr {
+ let val = HeaderValue::from_bytes(&val)
+ .map_err(|_| de::Error::invalid_value(Unexpected::Bytes(&val), &self))?;
+ map.append(&key, val);
+ }
+ }
+ } else {
+ while let Some((key, val)) = access.next_entry::, OneOrMore>()? {
+ let key = HeaderName::from_bytes(key.as_bytes())
+ .map_err(|_| de::Error::invalid_value(Unexpected::Str(&key), &self))?;
+ match val {
+ OneOrMore::One(val) => {
+ let val = val
+ .parse()
+ .map_err(|_| de::Error::invalid_value(Unexpected::Str(&val), &self))?;
+ map.insert(key, val);
+ }
+ OneOrMore::Strings(arr) => {
+ for val in arr {
+ let val = val
+ .parse()
+ .map_err(|_| de::Error::invalid_value(Unexpected::Str(&val), &self))?;
+ map.append(&key, val);
+ }
+ }
+ OneOrMore::Bytes(arr) => {
+ for val in arr {
+ let val = HeaderValue::from_bytes(&val)
+ .map_err(|_| de::Error::invalid_value(Unexpected::Bytes(&val), &self))?;
+ map.append(&key, val);
+ }
+ }
+ };
+ }
+ }
+ Ok(map)
+ }
+}
+
+/// Implementation detail.
+pub(crate) fn deserialize_headers<'de, D>(de: D) -> Result
+where
+ D: Deserializer<'de>,
+{
+ let is_human_readable = de.is_human_readable();
+ de.deserialize_option(HeaderMapVisitor { is_human_readable })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_deserialize_missing_http_headers() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ pub headers: HeaderMap,
+ }
+ let data = json!({
+ "not_headers": {}
+ });
+
+ let expected = HeaderMap::new();
+
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.headers);
+ }
+
+ #[test]
+ fn test_serialize_headers() {
+ #[derive(Deserialize, Serialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_multi_value_headers")]
+ headers: HeaderMap,
+ }
+ let data = json!({
+ "headers": {
+ "Accept": ["*/*"]
+ }
+ });
+ let decoded: Test = serde_json::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();
+ assert_eq!(&"*/*", decoded.headers.get("Accept").unwrap());
+ }
+
+ #[test]
+ fn test_null_headers() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_headers")]
+ headers: HeaderMap,
+ }
+ let data = json!({ "headers": null });
+
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert!(decoded.headers.is_empty());
+ }
+}
diff --git a/lambda-events/src/custom_serde/http_method.rs b/lambda-events/src/custom_serde/http_method.rs
new file mode 100644
index 00000000..6060a429
--- /dev/null
+++ b/lambda-events/src/custom_serde/http_method.rs
@@ -0,0 +1,103 @@
+use http::Method;
+use serde::de::{Deserialize, Deserializer, Error as DeError, Unexpected, Visitor};
+use serde::ser::Serializer;
+use std::fmt;
+
+pub fn serialize(method: &Method, ser: S) -> Result {
+ ser.serialize_str(method.as_str())
+}
+
+struct MethodVisitor;
+impl<'de> Visitor<'de> for MethodVisitor {
+ type Value = Method;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "valid method name")
+ }
+
+ fn visit_str(self, val: &str) -> Result {
+ if val.is_empty() {
+ Ok(Method::GET)
+ } else {
+ val.parse()
+ .map_err(|_| DeError::invalid_value(Unexpected::Str(val), &self))
+ }
+ }
+}
+
+pub fn deserialize<'de, D>(de: D) -> Result
+where
+ D: Deserializer<'de>,
+{
+ de.deserialize_str(MethodVisitor)
+}
+
+pub fn deserialize_optional<'de, D>(deserializer: D) -> Result, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ let s: Option = Option::deserialize(deserializer)?;
+ if let Some(val) = s {
+ let visitor = MethodVisitor {};
+ return visitor.visit_str(&val).map(Some);
+ }
+
+ Ok(None)
+}
+
+pub fn serialize_optional(method: &Option, ser: S) -> Result {
+ if let Some(method) = method {
+ return serialize(method, ser);
+ }
+
+ ser.serialize_none()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_http_method_serializer() {
+ #[derive(Deserialize, Serialize)]
+ struct Test {
+ #[serde(with = "crate::custom_serde::http_method")]
+ pub method: http::Method,
+ }
+ let data = json!({
+ "method": "DELETE"
+ });
+ let decoded: Test = serde_json::from_value(data.clone()).unwrap();
+ assert_eq!(http::Method::DELETE, decoded.method);
+
+ let recoded = serde_json::to_value(decoded).unwrap();
+ assert_eq!(data, recoded);
+ }
+
+ #[test]
+ fn test_http_optional_method_serializer() {
+ #[derive(Deserialize, Serialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_optional")]
+ #[serde(serialize_with = "serialize_optional")]
+ #[serde(default)]
+ pub method: Option,
+ }
+ let data = json!({
+ "method": "DELETE"
+ });
+ let decoded: Test = serde_json::from_value(data.clone()).unwrap();
+ assert_eq!(Some(http::Method::DELETE), decoded.method);
+
+ let recoded = serde_json::to_value(decoded).unwrap();
+ assert_eq!(data, recoded);
+
+ let data = json!({ "method": null });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(None, decoded.method);
+
+ let data = json!({});
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(None, decoded.method);
+ }
+}
diff --git a/lambda-events/src/custom_serde/mod.rs b/lambda-events/src/custom_serde/mod.rs
new file mode 100644
index 00000000..964f460e
--- /dev/null
+++ b/lambda-events/src/custom_serde/mod.rs
@@ -0,0 +1,455 @@
+#[allow(unused)]
+use base64::{decode, encode};
+use chrono::{DateTime, Duration, TimeZone, Utc};
+use serde;
+use serde::de::{Deserialize, Deserializer, Error as DeError};
+use serde::ser::Serializer;
+use std::collections::HashMap;
+
+#[cfg(feature = "codebuild")]
+pub(crate) mod codebuild_time;
+#[cfg(feature = "codebuild")]
+pub type CodeBuildNumber = f32;
+
+#[cfg(any(
+ feature = "alb",
+ feature = "apigw",
+ feature = "s3",
+ feature = "iot",
+ feature = "lambda_function_urls"
+))]
+mod headers;
+#[cfg(any(
+ feature = "alb",
+ feature = "apigw",
+ feature = "s3",
+ feature = "iot",
+ feature = "lambda_function_urls"
+))]
+pub(crate) use self::headers::*;
+
+#[cfg(feature = "dynamodb")]
+pub(crate) mod float_unix_epoch;
+
+#[cfg(any(feature = "alb", feature = "apigw"))]
+pub(crate) mod http_method;
+
+fn normalize_timestamp<'de, D>(deserializer: D) -> Result<(u64, u64), D::Error>
+where
+ D: Deserializer<'de>,
+{
+ #[derive(Deserialize)]
+ #[serde(untagged)]
+ enum StringOrNumber {
+ String(String),
+ Float(f64),
+ Int(u64),
+ }
+
+ let input: f64 = match StringOrNumber::deserialize(deserializer)? {
+ StringOrNumber::String(s) => s.parse::().map_err(DeError::custom)?,
+ StringOrNumber::Float(f) => f,
+ StringOrNumber::Int(i) => i as f64,
+ };
+
+ // We need to do this due to floating point issues.
+ let input_as_string = format!("{}", input);
+ let parts: Result, _> = input_as_string
+ .split('.')
+ .map(|x| x.parse::().map_err(DeError::custom))
+ .collect();
+ let parts = parts?;
+ if parts.len() > 1 {
+ Ok((parts[0], parts[1]))
+ } else {
+ Ok((parts[0], 0))
+ }
+}
+
+pub(crate) fn serialize_milliseconds(date: &DateTime, serializer: S) -> Result
+where
+ S: Serializer,
+{
+ let ts_with_millis = date.timestamp_millis();
+ serializer.serialize_str(&ts_with_millis.to_string())
+}
+
+pub(crate) fn deserialize_milliseconds<'de, D>(deserializer: D) -> Result, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ let (whole, frac) = normalize_timestamp(deserializer)?;
+ assert_eq!(frac, 0);
+ let seconds: f64 = whole as f64 / 1000.0;
+ let milliseconds: u32 = (seconds.fract() * 1000f64) as u32;
+ let nanos = milliseconds * 1_000_000;
+ Utc.timestamp_opt(seconds as i64, nanos)
+ .latest()
+ .ok_or_else(|| D::Error::custom("invalid timestamp"))
+}
+
+pub(crate) fn serialize_seconds(date: &DateTime, serializer: S) -> Result
+where
+ S: Serializer,
+{
+ let seconds = date.timestamp();
+ let milliseconds = date.timestamp_subsec_millis();
+ let whole_seconds = seconds + (milliseconds as i64 / 1000);
+ let subsec_millis = milliseconds % 1000;
+ if milliseconds > 0 {
+ let combined = format!("{}.{:03}", whole_seconds, subsec_millis);
+ serializer.serialize_str(&combined)
+ } else {
+ serializer.serialize_str(&whole_seconds.to_string())
+ }
+}
+
+#[allow(dead_code)]
+pub(crate) fn deserialize_seconds<'de, D>(deserializer: D) -> Result, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ let (whole, frac) = normalize_timestamp(deserializer)?;
+ let seconds = whole;
+ let nanos = frac * 1_000_000;
+ Utc.timestamp_opt(seconds as i64, nanos as u32)
+ .latest()
+ .ok_or_else(|| D::Error::custom("invalid timestamp"))
+}
+
+pub(crate) fn deserialize_base64<'de, D>(deserializer: D) -> Result, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ let s: String = String::deserialize(deserializer)?;
+ decode(s).map_err(DeError::custom)
+}
+
+pub(crate) fn serialize_base64(value: &[u8], serializer: S) -> Result
+where
+ S: Serializer,
+{
+ serializer.serialize_str(&encode(value))
+}
+
+/// Deserializes `HashMap<_>`, mapping JSON `null` to an empty map.
+pub(crate) fn deserialize_lambda_map<'de, D, K, V>(deserializer: D) -> Result, D::Error>
+where
+ D: Deserializer<'de>,
+ K: serde::Deserialize<'de>,
+ K: std::hash::Hash,
+ K: std::cmp::Eq,
+ V: serde::Deserialize<'de>,
+{
+ // https://github.com/serde-rs/serde/issues/1098
+ let opt = Option::deserialize(deserializer)?;
+ Ok(opt.unwrap_or_default())
+}
+
+#[cfg(feature = "dynamodb")]
+/// Deserializes `Item`, mapping JSON `null` to an empty item.
+pub(crate) fn deserialize_lambda_dynamodb_item<'de, D>(deserializer: D) -> Result
+where
+ D: Deserializer<'de>,
+{
+ // https://github.com/serde-rs/serde/issues/1098
+ let opt = Option::deserialize(deserializer)?;
+ Ok(opt.unwrap_or_default())
+}
+
+pub(crate) fn serialize_duration_seconds(duration: &Duration, serializer: S) -> Result
+where
+ S: Serializer,
+{
+ let seconds = duration.num_seconds();
+
+ serializer.serialize_i64(seconds)
+}
+
+pub(crate) fn deserialize_duration_seconds<'de, D>(deserializer: D) -> Result
+where
+ D: Deserializer<'de>,
+{
+ let seconds = f64::deserialize(deserializer)?;
+ Ok(Duration::seconds(seconds as i64))
+}
+
+pub(crate) fn serialize_duration_minutes(duration: &Duration, serializer: S) -> Result
+where
+ S: Serializer,
+{
+ let minutes = duration.num_minutes();
+
+ serializer.serialize_i64(minutes)
+}
+
+pub(crate) fn deserialize_duration_minutes<'de, D>(deserializer: D) -> Result
+where
+ D: Deserializer<'de>,
+{
+ let minutes = f64::deserialize(deserializer)?;
+ Ok(Duration::minutes(minutes as i64))
+}
+
+/// Deserializes `HashMap<_>`, mapping JSON `null` to an empty map.
+#[cfg(any(
+ feature = "alb",
+ feature = "apigw",
+ feature = "cloudwatch_events",
+ feature = "code_commit",
+ test
+))]
+pub(crate) fn deserialize_nullish_boolean<'de, D>(deserializer: D) -> Result
+where
+ D: Deserializer<'de>,
+{
+ // https://github.com/serde-rs/serde/issues/1098
+ let opt = Option::deserialize(deserializer)?;
+ Ok(opt.unwrap_or_default())
+}
+
+#[cfg(test)]
+#[allow(deprecated)]
+mod test {
+ use super::*;
+ use chrono::TimeZone;
+ use serde_json;
+
+ #[test]
+ fn test_deserialize_base64() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_base64")]
+ v: Vec,
+ }
+ let data = json!({
+ "v": "SGVsbG8gV29ybGQ=",
+ });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(String::from_utf8(decoded.v).unwrap(), "Hello World".to_string());
+ }
+
+ #[test]
+ fn test_serialize_base64() {
+ #[derive(Serialize)]
+ struct Test {
+ #[serde(serialize_with = "serialize_base64")]
+ v: Vec,
+ }
+ let instance = Test {
+ v: "Hello World".as_bytes().to_vec(),
+ };
+ let encoded = serde_json::to_string(&instance).unwrap();
+ assert_eq!(encoded, r#"{"v":"SGVsbG8gV29ybGQ="}"#.to_string());
+ }
+
+ #[test]
+ fn test_deserialize_milliseconds() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_milliseconds")]
+ v: DateTime,
+ }
+ let expected = Utc.ymd(2017, 10, 5).and_hms_nano(15, 33, 44, 302_000_000);
+
+ // Test parsing strings.
+ let data = json!({
+ "v": "1507217624302",
+ });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.v,);
+ // Test parsing ints.
+ let decoded: Test = serde_json::from_slice(r#"{"v":1507217624302}"#.as_bytes()).unwrap();
+ assert_eq!(expected, decoded.v,);
+ // Test parsing floats.
+ let data = json!({
+ "v": 1507217624302.0,
+ });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.v,);
+ }
+
+ #[test]
+ fn test_serialize_milliseconds() {
+ #[derive(Serialize)]
+ struct Test {
+ #[serde(serialize_with = "serialize_milliseconds")]
+ v: DateTime,
+ }
+ let instance = Test {
+ v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 99_888_777),
+ };
+ let encoded = serde_json::to_string(&instance).unwrap();
+ assert_eq!(encoded, String::from(r#"{"v":"427683600099"}"#));
+ }
+
+ #[test]
+ fn test_serialize_seconds() {
+ #[derive(Serialize)]
+ struct Test {
+ #[serde(serialize_with = "serialize_seconds")]
+ v: DateTime,
+ }
+
+ // Make sure nanoseconds are chopped off.
+ let instance = Test {
+ v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 99),
+ };
+ let encoded = serde_json::to_string(&instance).unwrap();
+ assert_eq!(encoded, String::from(r#"{"v":"427683600"}"#));
+
+ // Make sure milliseconds are included.
+ let instance = Test {
+ v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 2_000_000),
+ };
+ let encoded = serde_json::to_string(&instance).unwrap();
+ assert_eq!(encoded, String::from(r#"{"v":"427683600.002"}"#));
+
+ // Make sure milliseconds are included.
+ let instance = Test {
+ v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 1_234_000_000),
+ };
+ let encoded = serde_json::to_string(&instance).unwrap();
+ assert_eq!(encoded, String::from(r#"{"v":"427683601.234"}"#));
+ }
+
+ #[test]
+ fn test_deserialize_map() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ v: HashMap,
+ }
+ let input = json!({
+ "v": {},
+ });
+ let decoded: Test = serde_json::from_value(input).unwrap();
+ assert_eq!(HashMap::new(), decoded.v);
+
+ let input = json!({
+ "v": null,
+ });
+ let decoded: Test = serde_json::from_value(input).unwrap();
+ assert_eq!(HashMap::new(), decoded.v);
+ }
+
+ #[cfg(feature = "dynamodb")]
+ #[test]
+ fn test_deserialize_lambda_dynamodb_item() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_lambda_dynamodb_item")]
+ v: serde_dynamo::Item,
+ }
+ let input = json!({
+ "v": {},
+ });
+ let decoded: Test = serde_json::from_value(input).unwrap();
+ assert_eq!(serde_dynamo::Item::from(HashMap::new()), decoded.v);
+
+ let input = json!({
+ "v": null,
+ });
+ let decoded: Test = serde_json::from_value(input).unwrap();
+ assert_eq!(serde_dynamo::Item::from(HashMap::new()), decoded.v);
+ }
+
+ #[test]
+ fn test_deserialize_duration_seconds() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_duration_seconds")]
+ v: Duration,
+ }
+
+ let expected = Duration::seconds(36);
+
+ let data = json!({
+ "v": 36,
+ });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.v,);
+
+ let data = json!({
+ "v": 36.1,
+ });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.v,);
+ }
+
+ #[test]
+ fn test_serialize_duration_seconds() {
+ #[derive(Serialize)]
+ struct Test {
+ #[serde(serialize_with = "serialize_duration_seconds")]
+ v: Duration,
+ }
+ let instance = Test {
+ v: Duration::seconds(36),
+ };
+ let encoded = serde_json::to_string(&instance).unwrap();
+ assert_eq!(encoded, String::from(r#"{"v":36}"#));
+ }
+
+ #[test]
+ fn test_deserialize_duration_minutes() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(deserialize_with = "deserialize_duration_minutes")]
+ v: Duration,
+ }
+
+ let expected = Duration::minutes(36);
+
+ let data = json!({
+ "v": 36,
+ });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.v,);
+
+ let data = json!({
+ "v": 36.1,
+ });
+ let decoded: Test = serde_json::from_value(data).unwrap();
+ assert_eq!(expected, decoded.v,);
+ }
+
+ #[test]
+ fn test_serialize_duration_minutes() {
+ #[derive(Serialize)]
+ struct Test {
+ #[serde(serialize_with = "serialize_duration_minutes")]
+ v: Duration,
+ }
+ let instance = Test {
+ v: Duration::minutes(36),
+ };
+ let encoded = serde_json::to_string(&instance).unwrap();
+ assert_eq!(encoded, String::from(r#"{"v":36}"#));
+ }
+
+ #[test]
+ fn test_deserialize_nullish_boolean() {
+ #[derive(Deserialize)]
+ struct Test {
+ #[serde(default, deserialize_with = "deserialize_nullish_boolean")]
+ v: bool,
+ }
+
+ let test = r#"{"v": null}"#;
+ let decoded: Test = serde_json::from_str(test).unwrap();
+ assert_eq!(false, decoded.v);
+
+ let test = r#"{}"#;
+ let decoded: Test = serde_json::from_str(test).unwrap();
+ assert_eq!(false, decoded.v);
+
+ let test = r#"{"v": true}"#;
+ let decoded: Test = serde_json::from_str(test).unwrap();
+ assert_eq!(true, decoded.v);
+
+ let test = r#"{"v": false}"#;
+ let decoded: Test = serde_json::from_str(test).unwrap();
+ assert_eq!(false, decoded.v);
+ }
+}
diff --git a/lambda-events/src/encodings.rs b/lambda-events/src/encodings.rs
new file mode 100644
index 00000000..ecd32340
--- /dev/null
+++ b/lambda-events/src/encodings.rs
@@ -0,0 +1,449 @@
+use super::custom_serde::*;
+use chrono::{DateTime, Duration, Utc};
+use std::{borrow::Cow, mem::take, ops::Deref, ops::DerefMut, pin::Pin, task::Poll};
+
+use base64::display::Base64Display;
+use bytes::Bytes;
+use http_body::{Body as HttpBody, SizeHint};
+use serde::de::{Deserialize, Deserializer, Error as DeError, Visitor};
+use serde::ser::{Error as SerError, Serialize, Serializer};
+
+pub type Error = Box;
+
+/// Binary data encoded in base64.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+pub struct Base64Data(
+ #[serde(deserialize_with = "deserialize_base64")]
+ #[serde(serialize_with = "serialize_base64")]
+ pub Vec,
+);
+
+impl Deref for Base64Data {
+ type Target = Vec;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl DerefMut for Base64Data {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+/// Timestamp with millisecond precision.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct MillisecondTimestamp(
+ #[serde(deserialize_with = "deserialize_milliseconds")]
+ #[serde(serialize_with = "serialize_milliseconds")]
+ pub DateTime,
+);
+
+impl Deref for MillisecondTimestamp {
+ type Target = DateTime;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl DerefMut for MillisecondTimestamp {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+/// Timestamp with second precision.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct SecondTimestamp(
+ #[serde(deserialize_with = "deserialize_seconds")]
+ #[serde(serialize_with = "serialize_seconds")]
+ pub DateTime,
+);
+
+impl Deref for SecondTimestamp {
+ type Target = DateTime;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl DerefMut for SecondTimestamp {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+/// Duration with second precision.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct SecondDuration(
+ #[serde(deserialize_with = "deserialize_duration_seconds")]
+ #[serde(serialize_with = "serialize_duration_seconds")]
+ pub Duration,
+);
+
+impl Deref for SecondDuration {
+ type Target = Duration;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl DerefMut for SecondDuration {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+/// Duration with minute precision.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct MinuteDuration(
+ #[serde(deserialize_with = "deserialize_duration_minutes")]
+ #[serde(serialize_with = "serialize_duration_minutes")]
+ pub Duration,
+);
+
+impl Deref for MinuteDuration {
+ type Target = Duration;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl DerefMut for MinuteDuration {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+/// Representation of http request and response bodies as supported
+/// by API Gateway and ALBs.
+///
+/// These come in three flavors
+/// * `Empty` ( no body )
+/// * `Text` ( text data )
+/// * `Binary` ( binary data )
+///
+/// Body types can be `Deref` and `AsRef`'d into `[u8]` types much like the [hyper crate](https://crates.io/crates/hyper)
+///
+/// # Examples
+///
+/// Body types are inferred with `From` implementations.
+///
+/// ## Text
+///
+/// Types like `String`, `str` whose type reflects
+/// text produce `Body::Text` variants
+///
+/// ```
+/// assert!(match aws_lambda_events::encodings::Body::from("text") {
+/// aws_lambda_events::encodings::Body::Text(_) => true,
+/// _ => false
+/// })
+/// ```
+///
+/// ## Binary
+///
+/// Types like `Vec` and `&[u8]` whose types reflect raw bytes produce `Body::Binary` variants
+///
+/// ```
+/// assert!(match aws_lambda_events::encodings::Body::from("text".as_bytes()) {
+/// aws_lambda_events::encodings::Body::Binary(_) => true,
+/// _ => false
+/// })
+/// ```
+///
+/// `Binary` responses bodies will automatically get based64 encoded to meet API Gateway's response expectations.
+///
+/// ## Empty
+///
+/// The unit type ( `()` ) whose type represents an empty value produces `Body::Empty` variants
+///
+/// ```
+/// assert!(match aws_lambda_events::encodings::Body::from(()) {
+/// aws_lambda_events::encodings::Body::Empty => true,
+/// _ => false
+/// })
+/// ```
+///
+///
+/// For more information about API Gateway's body types,
+/// refer to [this documentation](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html).
+#[derive(Debug, Default, Eq, PartialEq)]
+pub enum Body {
+ /// An empty body
+ #[default]
+ Empty,
+ /// A body containing string data
+ Text(String),
+ /// A body containing binary data
+ Binary(Vec),
+}
+
+impl Body {
+ /// Decodes body, if needed.
+ ///
+ /// # Panics
+ ///
+ /// Panics when aws communicates to handler that request is base64 encoded but
+ /// it can not be base64 decoded
+ pub fn from_maybe_encoded(is_base64_encoded: bool, body: &str) -> Body {
+ if is_base64_encoded {
+ Body::from(::base64::decode(body).expect("failed to decode aws base64 encoded body"))
+ } else {
+ Body::from(body)
+ }
+ }
+}
+
+impl From<()> for Body {
+ fn from(_: ()) -> Self {
+ Body::Empty
+ }
+}
+
+impl<'a> From<&'a str> for Body {
+ fn from(s: &'a str) -> Self {
+ Body::Text(s.into())
+ }
+}
+
+impl From for Body {
+ fn from(b: String) -> Self {
+ Body::Text(b)
+ }
+}
+
+impl From> for Body {
+ #[inline]
+ fn from(cow: Cow<'static, str>) -> Body {
+ match cow {
+ Cow::Borrowed(b) => Body::from(b.to_owned()),
+ Cow::Owned(o) => Body::from(o),
+ }
+ }
+}
+
+impl From> for Body {
+ #[inline]
+ fn from(cow: Cow<'static, [u8]>) -> Body {
+ match cow {
+ Cow::Borrowed(b) => Body::from(b),
+ Cow::Owned(o) => Body::from(o),
+ }
+ }
+}
+
+impl From> for Body {
+ fn from(b: Vec) -> Self {
+ Body::Binary(b)
+ }
+}
+
+impl<'a> From<&'a [u8]> for Body {
+ fn from(b: &'a [u8]) -> Self {
+ Body::Binary(b.to_vec())
+ }
+}
+
+impl Deref for Body {
+ type Target = [u8];
+
+ #[inline]
+ fn deref(&self) -> &Self::Target {
+ self.as_ref()
+ }
+}
+
+impl AsRef<[u8]> for Body {
+ #[inline]
+ fn as_ref(&self) -> &[u8] {
+ match self {
+ Body::Empty => &[],
+ Body::Text(ref bytes) => bytes.as_ref(),
+ Body::Binary(ref bytes) => bytes.as_ref(),
+ }
+ }
+}
+
+impl Clone for Body {
+ fn clone(&self) -> Self {
+ match self {
+ Body::Empty => Body::Empty,
+ Body::Text(ref bytes) => Body::Text(bytes.clone()),
+ Body::Binary(ref bytes) => Body::Binary(bytes.clone()),
+ }
+ }
+}
+
+impl Serialize for Body {
+ fn serialize(&self, serializer: S) -> Result
+ where
+ S: Serializer,
+ {
+ match self {
+ Body::Text(data) => {
+ serializer.serialize_str(::std::str::from_utf8(data.as_ref()).map_err(S::Error::custom)?)
+ }
+ Body::Binary(data) => serializer.collect_str(&Base64Display::with_config(data, base64::STANDARD)),
+ Body::Empty => serializer.serialize_unit(),
+ }
+ }
+}
+
+impl<'de> Deserialize<'de> for Body {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct BodyVisitor;
+
+ impl<'de> Visitor<'de> for BodyVisitor {
+ type Value = Body;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+ formatter.write_str("string")
+ }
+
+ fn visit_str(self, value: &str) -> Result
+ where
+ E: DeError,
+ {
+ Ok(Body::from(value))
+ }
+ }
+
+ deserializer.deserialize_str(BodyVisitor)
+ }
+}
+
+impl HttpBody for Body {
+ type Data = Bytes;
+ type Error = Error;
+
+ fn poll_data(
+ self: Pin<&mut Self>,
+ _cx: &mut std::task::Context<'_>,
+ ) -> Poll>> {
+ let body = take(self.get_mut());
+ Poll::Ready(match body {
+ Body::Empty => None,
+ Body::Text(s) => Some(Ok(s.into())),
+ Body::Binary(b) => Some(Ok(b.into())),
+ })
+ }
+
+ fn poll_trailers(
+ self: Pin<&mut Self>,
+ _cx: &mut std::task::Context<'_>,
+ ) -> Poll, Self::Error>> {
+ Poll::Ready(Ok(None))
+ }
+
+ fn is_end_stream(&self) -> bool {
+ matches!(self, Body::Empty)
+ }
+
+ fn size_hint(&self) -> SizeHint {
+ match self {
+ Body::Empty => SizeHint::default(),
+ Body::Text(ref s) => SizeHint::with_exact(s.len() as u64),
+ Body::Binary(ref b) => SizeHint::with_exact(b.len() as u64),
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json;
+ use std::collections::HashMap;
+
+ #[test]
+ fn body_has_default() {
+ assert_eq!(Body::default(), Body::Empty);
+ }
+
+ #[test]
+ fn from_unit() {
+ assert_eq!(Body::from(()), Body::Empty);
+ }
+
+ #[test]
+ fn from_str() {
+ match Body::from(String::from("foo").as_str()) {
+ Body::Text(_) => (),
+ not => panic!("expected Body::Text(...) got {:?}", not),
+ }
+ }
+
+ #[test]
+ fn from_string() {
+ match Body::from(String::from("foo")) {
+ Body::Text(_) => (),
+ not => panic!("expected Body::Text(...) got {:?}", not),
+ }
+ }
+
+ #[test]
+ fn from_cow_str() {
+ match Body::from(Cow::from("foo")) {
+ Body::Text(_) => (),
+ not => panic!("expected Body::Text(...) got {:?}", not),
+ }
+ }
+
+ #[test]
+ fn from_cow_bytes() {
+ match Body::from(Cow::from("foo".as_bytes())) {
+ Body::Binary(_) => (),
+ not => panic!("expected Body::Binary(...) got {:?}", not),
+ }
+ }
+
+ #[test]
+ fn from_bytes() {
+ match Body::from("foo".as_bytes()) {
+ Body::Binary(_) => (),
+ not => panic!("expected Body::Binary(...) got {:?}", not),
+ }
+ }
+
+ #[test]
+ fn serialize_text() {
+ let mut map = HashMap::new();
+ map.insert("foo", Body::from("bar"));
+ assert_eq!(serde_json::to_string(&map).unwrap(), r#"{"foo":"bar"}"#);
+ }
+
+ #[test]
+ fn serialize_binary() {
+ let mut map = HashMap::new();
+ map.insert("foo", Body::from("bar".as_bytes()));
+ assert_eq!(serde_json::to_string(&map).unwrap(), r#"{"foo":"YmFy"}"#);
+ }
+
+ #[test]
+ fn serialize_empty() {
+ let mut map = HashMap::new();
+ map.insert("foo", Body::Empty);
+ assert_eq!(serde_json::to_string(&map).unwrap(), r#"{"foo":null}"#);
+ }
+
+ #[test]
+ fn serialize_from_maybe_encoded() {
+ match Body::from_maybe_encoded(false, "foo") {
+ Body::Text(_) => (),
+ not => panic!("expected Body::Text(...) got {:?}", not),
+ }
+
+ match Body::from_maybe_encoded(true, "Zm9v") {
+ Body::Binary(b) => assert_eq!(&[102, 111, 111], b.as_slice()),
+ not => panic!("expected Body::Text(...) got {:?}", not),
+ }
+ }
+}
diff --git a/lambda-events/src/event/activemq/mod.rs b/lambda-events/src/event/activemq/mod.rs
new file mode 100644
index 00000000..fcb490ec
--- /dev/null
+++ b/lambda-events/src/event/activemq/mod.rs
@@ -0,0 +1,66 @@
+use crate::custom_serde::*;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActiveMqEvent {
+ #[serde(default)]
+ pub event_source: Option,
+ #[serde(default)]
+ pub event_source_arn: Option,
+ pub messages: Vec,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActiveMqMessage {
+ #[serde(default)]
+ #[serde(rename = "messageID")]
+ pub message_id: Option,
+ #[serde(default)]
+ pub message_type: Option,
+ pub timestamp: i64,
+ pub delivery_mode: i64,
+ #[serde(default)]
+ #[serde(rename = "correlationID")]
+ pub correlation_id: Option,
+ #[serde(default)]
+ pub reply_to: Option,
+ pub destination: ActiveMqDestination,
+ pub redelivered: bool,
+ #[serde(default)]
+ pub type_: Option,
+ pub expiration: i64,
+ pub priority: i64,
+ #[serde(default)]
+ pub data: Option,
+ pub broker_in_time: i64,
+ pub broker_out_time: i64,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub properties: HashMap,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActiveMqDestination {
+ #[serde(default)]
+ pub physical_name: Option,
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ extern crate serde_json;
+
+ #[test]
+ #[cfg(feature = "activemq")]
+ fn example_activemq_event() {
+ let data = include_bytes!("../../fixtures/example-activemq-event.json");
+ let parsed: ActiveMqEvent = serde_json::from_slice(data).unwrap();
+ let output: String = serde_json::to_string(&parsed).unwrap();
+ let reparsed: ActiveMqEvent = serde_json::from_slice(output.as_bytes()).unwrap();
+ assert_eq!(parsed, reparsed);
+ }
+}
diff --git a/lambda-events/src/event/alb/mod.rs b/lambda-events/src/event/alb/mod.rs
new file mode 100644
index 00000000..b9a69ce5
--- /dev/null
+++ b/lambda-events/src/event/alb/mod.rs
@@ -0,0 +1,98 @@
+use crate::custom_serde::{http_method, serialize_headers, serialize_multi_value_headers};
+use crate::encodings::Body;
+use http::{HeaderMap, Method};
+use query_map::QueryMap;
+
+/// `AlbTargetGroupRequest` contains data originating from the ALB Lambda target group integration
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AlbTargetGroupRequest {
+ #[serde(with = "http_method")]
+ pub http_method: Method,
+ #[serde(default)]
+ pub path: Option,
+ #[serde(default)]
+ pub query_string_parameters: QueryMap,
+ #[serde(default)]
+ pub multi_value_query_string_parameters: QueryMap,
+ #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+ #[serde(serialize_with = "serialize_headers")]
+ pub headers: HeaderMap,
+ #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+ #[serde(serialize_with = "serialize_multi_value_headers")]
+ pub multi_value_headers: HeaderMap,
+ pub request_context: AlbTargetGroupRequestContext,
+ pub is_base64_encoded: bool,
+ pub body: Option,
+}
+
+/// `AlbTargetGroupRequestContext` contains the information to identify the load balancer invoking the lambda
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AlbTargetGroupRequestContext {
+ pub elb: ElbContext,
+}
+
+/// `ElbContext` contains the information to identify the ARN invoking the lambda
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ElbContext {
+ /// nolint: stylecheck
+ #[serde(default)]
+ pub target_group_arn: Option,
+}
+
+/// `AlbTargetGroupResponse` configures the response to be returned by the ALB Lambda target group for the request
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AlbTargetGroupResponse {
+ pub status_code: i64,
+ #[serde(default)]
+ pub status_description: Option,
+ #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+ #[serde(serialize_with = "serialize_headers")]
+ pub headers: HeaderMap,
+ #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+ #[serde(serialize_with = "serialize_multi_value_headers")]
+ pub multi_value_headers: HeaderMap,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub body: Option,
+ pub is_base64_encoded: bool,
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ extern crate serde_json;
+
+ #[test]
+ #[cfg(feature = "alb")]
+ fn example_alb_lambda_target_request_headers_only() {
+ let data = include_bytes!("../../fixtures/example-alb-lambda-target-request-headers-only.json");
+ let parsed: AlbTargetGroupRequest = serde_json::from_slice(data).unwrap();
+ let output: String = serde_json::to_string(&parsed).unwrap();
+ let reparsed: AlbTargetGroupRequest = serde_json::from_slice(output.as_bytes()).unwrap();
+ assert_eq!(parsed, reparsed);
+ }
+
+ #[test]
+ #[cfg(feature = "alb")]
+ fn example_alb_lambda_target_request_multivalue_headers() {
+ let data = include_bytes!("../../fixtures/example-alb-lambda-target-request-multivalue-headers.json");
+ let parsed: AlbTargetGroupRequest = serde_json::from_slice(data).unwrap();
+ let output: String = serde_json::to_string(&parsed).unwrap();
+ let reparsed: AlbTargetGroupRequest = serde_json::from_slice(output.as_bytes()).unwrap();
+ assert_eq!(parsed, reparsed);
+ }
+
+ #[test]
+ #[cfg(feature = "alb")]
+ fn example_alb_lambda_target_response() {
+ let data = include_bytes!("../../fixtures/example-alb-lambda-target-response.json");
+ let parsed: AlbTargetGroupResponse = serde_json::from_slice(data).unwrap();
+ let output: String = serde_json::to_string(&parsed).unwrap();
+ let reparsed: AlbTargetGroupResponse = serde_json::from_slice(output.as_bytes()).unwrap();
+ assert_eq!(parsed, reparsed);
+ }
+}
diff --git a/lambda-events/src/event/apigw/mod.rs b/lambda-events/src/event/apigw/mod.rs
new file mode 100644
index 00000000..80063911
--- /dev/null
+++ b/lambda-events/src/event/apigw/mod.rs
@@ -0,0 +1,911 @@
+use crate::custom_serde::{
+ deserialize_headers, deserialize_lambda_map, deserialize_nullish_boolean, http_method, serialize_headers,
+ serialize_multi_value_headers,
+};
+use crate::encodings::Body;
+use http::{HeaderMap, Method};
+use query_map::QueryMap;
+use serde::de::DeserializeOwned;
+use serde::ser::Serialize;
+use serde_json::Value;
+use std::collections::HashMap;
+
+/// `ApiGatewayProxyRequest` contains data coming from the API Gateway proxy
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayProxyRequest
+where
+ T1: DeserializeOwned,
+ T1: Serialize,
+{
+ /// The resource path defined in API Gateway
+ #[serde(default)]
+ pub resource: Option,
+ /// The url path for the caller
+ #[serde(default)]
+ pub path: Option,
+ #[serde(with = "http_method")]
+ pub http_method: Method,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_headers")]
+ pub headers: HeaderMap,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_multi_value_headers")]
+ pub multi_value_headers: HeaderMap,
+ #[serde(default, deserialize_with = "query_map::serde::standard::deserialize_empty")]
+ pub query_string_parameters: QueryMap,
+ #[serde(default, deserialize_with = "query_map::serde::standard::deserialize_empty")]
+ pub multi_value_query_string_parameters: QueryMap,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub path_parameters: HashMap,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub stage_variables: HashMap,
+ #[serde(default)]
+ #[serde(bound = "")]
+ pub request_context: ApiGatewayProxyRequestContext,
+ #[serde(default)]
+ pub body: Option,
+ #[serde(default, deserialize_with = "deserialize_nullish_boolean")]
+ pub is_base64_encoded: bool,
+}
+
+/// `ApiGatewayProxyResponse` configures the response to be returned by API Gateway for the request
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayProxyResponse {
+ pub status_code: i64,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_headers")]
+ pub headers: HeaderMap,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_multi_value_headers")]
+ pub multi_value_headers: HeaderMap,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub body: Option,
+ #[serde(default, deserialize_with = "deserialize_nullish_boolean")]
+ pub is_base64_encoded: bool,
+}
+
+/// `ApiGatewayProxyRequestContext` contains the information to identify the AWS account and resources invoking the
+/// Lambda function. It also includes Cognito identity information for the caller.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayProxyRequestContext
+where
+ T1: DeserializeOwned,
+ T1: Serialize,
+{
+ #[serde(default)]
+ pub account_id: Option,
+ #[serde(default)]
+ pub resource_id: Option,
+ pub operation_name: Option,
+ #[serde(default)]
+ pub stage: Option,
+ #[serde(default)]
+ pub domain_name: Option,
+ #[serde(default)]
+ pub domain_prefix: Option,
+ #[serde(default)]
+ pub request_id: Option,
+ #[serde(default)]
+ pub protocol: Option,
+ #[serde(default)]
+ pub identity: ApiGatewayRequestIdentity,
+ #[serde(default)]
+ pub resource_path: Option,
+ #[serde(default)]
+ pub path: Option,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ #[serde(bound = "")]
+ pub authorizer: HashMap,
+ #[serde(with = "http_method")]
+ pub http_method: Method,
+ #[serde(default)]
+ pub request_time: Option,
+ pub request_time_epoch: i64,
+ /// The API Gateway rest API Id
+ #[serde(default)]
+ #[serde(rename = "apiId")]
+ pub apiid: Option,
+}
+
+/// `ApiGatewayV2httpRequest` contains data coming from the new HTTP API Gateway
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequest {
+ #[serde(default)]
+ pub version: Option,
+ #[serde(default)]
+ pub route_key: Option,
+ #[serde(default)]
+ pub raw_path: Option,
+ #[serde(default)]
+ pub raw_query_string: Option,
+ pub cookies: Option>,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_headers")]
+ pub headers: HeaderMap,
+ #[serde(
+ default,
+ deserialize_with = "query_map::serde::aws_api_gateway_v2::deserialize_empty"
+ )]
+ pub query_string_parameters: QueryMap,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub path_parameters: HashMap,
+ pub request_context: ApiGatewayV2httpRequestContext,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub stage_variables: HashMap,
+ pub body: Option,
+ #[serde(default)]
+ pub is_base64_encoded: bool,
+}
+
+/// `ApiGatewayV2httpRequestContext` contains the information to identify the AWS account and resources invoking the Lambda function.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContext
+where
+ T1: DeserializeOwned,
+ T1: Serialize,
+{
+ #[serde(default)]
+ pub route_key: Option,
+ #[serde(default)]
+ pub account_id: Option,
+ #[serde(default)]
+ pub stage: Option,
+ #[serde(default)]
+ pub request_id: Option,
+ #[serde(bound = "", default)]
+ pub authorizer: Option>,
+ /// The API Gateway HTTP API Id
+ #[serde(default)]
+ #[serde(rename = "apiId")]
+ pub apiid: Option,
+ #[serde(default)]
+ pub domain_name: Option,
+ #[serde(default)]
+ pub domain_prefix: Option,
+ #[serde(default)]
+ pub time: Option,
+ pub time_epoch: i64,
+ pub http: ApiGatewayV2httpRequestContextHttpDescription,
+ pub authentication: Option,
+}
+
+/// `ApiGatewayV2httpRequestContextAuthorizerDescription` contains authorizer information for the request context.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextAuthorizerDescription
+where
+ T1: DeserializeOwned,
+ T1: Serialize,
+{
+ pub jwt: Option,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ #[serde(bound = "")]
+ pub lambda: HashMap,
+ pub iam: Option,
+}
+
+/// `ApiGatewayV2httpRequestContextAuthorizerJwtDescription` contains JWT authorizer information for the request context.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextAuthorizerJwtDescription {
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub claims: HashMap,
+ pub scopes: Option>,
+}
+
+/// `ApiGatewayV2httpRequestContextAuthorizerIamDescription` contains IAM information for the request context.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextAuthorizerIamDescription {
+ #[serde(default)]
+ pub access_key: Option,
+ #[serde(default)]
+ pub account_id: Option,
+ #[serde(default)]
+ pub caller_id: Option,
+ pub cognito_identity: Option,
+ #[serde(default)]
+ pub principal_org_id: Option,
+ #[serde(default)]
+ pub user_arn: Option,
+ #[serde(default)]
+ pub user_id: Option,
+}
+
+/// `ApiGatewayV2httpRequestContextAuthorizerCognitoIdentity` contains Cognito identity information for the request context.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextAuthorizerCognitoIdentity {
+ pub amr: Vec,
+ #[serde(default)]
+ pub identity_id: Option,
+ #[serde(default)]
+ pub identity_pool_id: Option,
+}
+
+/// `ApiGatewayV2httpRequestContextHttpDescription` contains HTTP information for the request context.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextHttpDescription {
+ #[serde(with = "http_method")]
+ pub method: Method,
+ #[serde(default)]
+ pub path: Option,
+ #[serde(default)]
+ pub protocol: Option,
+ #[serde(default)]
+ pub source_ip: Option,
+ #[serde(default)]
+ pub user_agent: Option,
+}
+
+/// `ApiGatewayV2httpResponse` configures the response to be returned by API Gateway V2 for the request
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpResponse {
+ pub status_code: i64,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_headers")]
+ pub headers: HeaderMap,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_multi_value_headers")]
+ pub multi_value_headers: HeaderMap,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub body: Option,
+ #[serde(default, deserialize_with = "deserialize_nullish_boolean")]
+ pub is_base64_encoded: bool,
+ pub cookies: Vec,
+}
+
+/// `ApiGatewayRequestIdentity` contains identity information for the request caller.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayRequestIdentity {
+ #[serde(default)]
+ pub cognito_identity_pool_id: Option,
+ #[serde(default)]
+ pub account_id: Option,
+ #[serde(default)]
+ pub cognito_identity_id: Option,
+ #[serde(default)]
+ pub caller: Option,
+ #[serde(default)]
+ pub api_key: Option,
+ #[serde(default)]
+ pub api_key_id: Option,
+ #[serde(default)]
+ pub access_key: Option,
+ #[serde(default)]
+ pub source_ip: Option,
+ #[serde(default)]
+ pub cognito_authentication_type: Option,
+ #[serde(default)]
+ pub cognito_authentication_provider: Option,
+ /// nolint: stylecheck
+ #[serde(default)]
+ pub user_arn: Option,
+ #[serde(default)]
+ pub user_agent: Option,
+ #[serde(default)]
+ pub user: Option,
+}
+
+/// `ApiGatewayWebsocketProxyRequest` contains data coming from the API Gateway proxy
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayWebsocketProxyRequest
+where
+ T1: DeserializeOwned,
+ T1: Serialize,
+ T2: DeserializeOwned,
+ T2: Serialize,
+{
+ /// The resource path defined in API Gateway
+ #[serde(default)]
+ pub resource: Option,
+ /// The url path for the caller
+ #[serde(default)]
+ pub path: Option,
+ #[serde(deserialize_with = "http_method::deserialize_optional")]
+ #[serde(serialize_with = "http_method::serialize_optional")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ #[serde(default)]
+ pub http_method: Option,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_headers")]
+ pub headers: HeaderMap,
+ #[serde(deserialize_with = "deserialize_headers", default)]
+ #[serde(serialize_with = "serialize_multi_value_headers")]
+ pub multi_value_headers: HeaderMap,
+ #[serde(default, deserialize_with = "query_map::serde::standard::deserialize_empty")]
+ pub query_string_parameters: QueryMap,
+ #[serde(default, deserialize_with = "query_map::serde::standard::deserialize_empty")]
+ pub multi_value_query_string_parameters: QueryMap,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub path_parameters: HashMap,
+ #[serde(deserialize_with = "deserialize_lambda_map")]
+ #[serde(default)]
+ pub stage_variables: HashMap,
+ #[serde(bound = "", default)]
+ pub request_context: ApiGatewayWebsocketProxyRequestContext,
+ #[serde(default)]
+ pub body: Option,
+ #[serde(default, deserialize_with = "deserialize_nullish_boolean")]
+ pub is_base64_encoded: bool,
+}
+
+/// `ApiGatewayWebsocketProxyRequestContext` contains the information to identify
+/// the AWS account and resources invoking the Lambda function. It also includes
+/// Cognito identity information for the caller.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayWebsocketProxyRequestContext
+where
+ T1: DeserializeOwned,
+ T1: Serialize,
+ T2: DeserializeOwned,
+ T2: Serialize,
+{
+ #[serde(default)]
+ pub account_id: Option,
+ #[serde(default)]
+ pub resource_id: Option,
+ #[serde(default)]
+ pub stage: Option,
+ #[serde(default)]
+ pub request_id: Option,
+ #[serde(default)]
+ pub identity: ApiGatewayRequestIdentity,
+ #[serde(default)]
+ pub resource_path: Option,
+ #[serde(bound = "")]
+ pub authorizer: Option,
+ #[serde(deserialize_with = "http_method::deserialize_optional")]
+ #[serde(serialize_with = "http_method::serialize_optional")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ #[serde(default)]
+ pub http_method: Option,
+ /// The API Gateway rest API Id
+ #[serde(default)]
+ #[serde(rename = "apiId")]
+ pub apiid: Option,
+ pub connected_at: i64,
+ #[serde(default)]
+ pub connection_id: Option,
+ #[serde(default)]
+ pub domain_name: Option,
+ #[serde(default)]
+ pub error: Option,
+ #[serde(default)]
+ pub event_type: Option,
+ #[serde(default)]
+ pub extended_request_id: Option,
+ #[serde(default)]
+ pub integration_latency: Option,
+ #[serde(default)]
+ pub message_direction: Option,
+ #[serde(bound = "")]
+ pub message_id: Option,
+ #[serde(default)]
+ pub request_time: Option,
+ pub request_time_epoch: i64,
+ #[serde(default)]
+ pub route_key: Option,
+ #[serde(default)]
+ pub status: Option,
+}
+
+/// `ApiGatewayCustomAuthorizerRequestTypeRequestIdentity` contains identity information for the request caller including certificate information if using mTLS.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayCustomAuthorizerRequestTypeRequestIdentity {
+ #[serde(default)]
+ pub api_key_id: Option,
+ #[serde(default)]
+ pub api_key: Option,
+ #[serde(default)]
+ pub source_ip: Option,
+ #[serde(default)]
+ pub client_cert: Option,
+}
+
+/// `ApiGatewayCustomAuthorizerRequestTypeRequestIdentityClientCert` contains certificate information for the request caller if using mTLS.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayCustomAuthorizerRequestTypeRequestIdentityClientCert {
+ #[serde(default)]
+ pub client_cert_pem: Option,
+ #[serde(default)]
+ #[serde(rename = "issuerDN")]
+ pub issuer_dn: Option,
+ #[serde(default)]
+ pub serial_number: Option,
+ #[serde(default)]
+ #[serde(rename = "subjectDN")]
+ pub subject_dn: Option,
+ pub validity: ApiGatewayCustomAuthorizerRequestTypeRequestIdentityClientCertValidity,
+}
+
+/// `ApiGatewayCustomAuthorizerRequestTypeRequestIdentityClientCertValidity` contains certificate validity information for the request caller if using mTLS.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayCustomAuthorizerRequestTypeRequestIdentityClientCertValidity {
+ #[serde(default)]
+ pub not_after: Option,
+ #[serde(default)]
+ pub not_before: Option,
+}
+
+/// `ApiGatewayV2httpRequestContextAuthentication` contains authentication context information for the request caller including client certificate information if using mTLS.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextAuthentication {
+ #[serde(default)]
+ pub client_cert: Option,
+}
+
+/// `ApiGatewayV2httpRequestContextAuthenticationClientCert` contains client certificate information for the request caller if using mTLS.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextAuthenticationClientCert {
+ #[serde(default)]
+ pub client_cert_pem: Option,
+ #[serde(default)]
+ #[serde(rename = "issuerDN")]
+ pub issuer_dn: Option,
+ #[serde(default)]
+ pub serial_number: Option,
+ #[serde(default)]
+ #[serde(rename = "subjectDN")]
+ pub subject_dn: Option,
+ pub validity: ApiGatewayV2httpRequestContextAuthenticationClientCertValidity,
+}
+
+/// `ApiGatewayV2httpRequestContextAuthenticationClientCertValidity` contains client certificate validity information for the request caller if using mTLS.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiGatewayV2httpRequestContextAuthenticationClientCertValidity {
+ #[serde(default)]
+ pub not_after: Option,
+ #[serde(default)]
+ pub not_before: Option