Serde Dynamo

https://github.com/zenlist/serde_dynamo
Admin
A Rust crate for serializing and deserializing data between Amazon DynamoDB items and strongly-typed...
Tokens:760
Snippets:3
Trust Score:7.1
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Deserialize DynamoDB Items to Rust Structs using Serde Dynamo

Source: https://github.com/zenlist/serde_dynamo/blob/main/README.md

This snippet demonstrates how to deserialize a list of DynamoDB items into a vector of Rust structs using the `from_items` function from `serde_dynamo`. It assumes you have already fetched items from DynamoDB using `aws-sdk-dynamodb`. The function takes a collection of DynamoDB items and attempts to convert them into the specified Rust type. Error handling is included via the `?` operator.

```rust
use serde::{Deserialize, Serialize};
use serde_dynamo::from_items;

#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: String,
    name: String,
    age: u8,
};

// Assuming 'result' is the response from a DynamoDB scan operation
// let result = client.scan().table_name("user").send().await?;

if let Some(items) = result.items {
    // Deserialize items into a vector of User structs
    let users: Vec<User> = from_items(items)?;
    println!("Got {} users", users.len());
}
```

--------------------------------

### Serialize Rust Struct to DynamoDB Item using Serde Dynamo

Source: https://github.com/zenlist/serde_dynamo/blob/main/README.md

This snippet illustrates how to serialize a Rust struct into a DynamoDB item format that can be written to a DynamoDB table using `aws-sdk-dynamodb`. The `to_item` function from `serde_dynamo` takes a Rust struct and converts it into a `HashMap<String, AttributeValue>`, which is the format expected by the AWS SDK for DynamoDB. This is crucial for creating new entries or updating existing ones.

```rust
use serde::{Deserialize, Serialize};
use serde_dynamo::to_item;
// Assume aws_sdk_dynamodb client is initialized and configured
// use aws_sdk_dynamodb::Client;

#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: String,
    name: String,
    age: u8,
};

// Create a Rust struct instance
let user = User {
    id: "fSsgVtal8TpP".to_string(),
    name: "Arthur Dent".to_string(),
    age: 42,
};

// Serialize the struct into a DynamoDB item format
let item = to_item(user)?;

// Assuming 'client' is an instance of aws_sdk_dynamodb::Client
// let result = client.put_item()
//     .table_name("users")
//     .set_item(Some(item))
//     .send()
//     .await?;

println!("User item created and sent to DynamoDB.");
```

--------------------------------

### Deserialize a Single DynamoDB Item to a Rust Struct using Serde Dynamo

Source: https://github.com/zenlist/serde_dynamo/blob/main/README.md

This code demonstrates deserializing a single DynamoDB item into a Rust struct using `serde_dynamo`'s `from_item` function. This is useful when processing items one by one after fetching them from DynamoDB. The function takes a single DynamoDB item and attempts to convert it into the specified Rust type. Error handling is managed with the `?` operator.

```rust
use serde::{Deserialize, Serialize};
use serde_dynamo::from_item;

#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: String,
    name: String,
    age: u8,
};

// Assuming 'result' is the response from a DynamoDB scan operation
// let result = client.scan().table_name("user").send().await?;

// Process each item individually
if let Some(items) = result.items {
    for item in items {
        // Deserialize a single item into a User struct
        let user: User = from_item(item)?;
        println!("{} is {}", user.name, user.age);
    }
}
```
Tokens:
Raw