A DynamoDB abstraction for Rust

Deez is a DynamoDB abstraction for implementing Single Table Design easily, inspired by ElectroDB.

Getting Started

Define a schema for your entities using the Deez procedural macro. Doing so will derive the From conversion traits for your structs and the HashMap<String, AttributeValue> type used by the aws_sdk_dynamodb library, with some additional features for facilitating Single Table Design.

```rust use awssdkdynamodb::types::AttributeValue; use deez::*; use std::collections::HashMap; use uuid::Uuid;

[derive(Debug, Clone, Deez)]

[deez_schema(table = "TaskTable", service = "TaskService", entity = "Task")]

[deezschema(primaryhash = "pk", primary_range = "sk")]

[deezschema(gsi1name = "gsi1", gsi1hash = "gsi1pk", gsi1range = "gsi1sk")]

[deezschema(gsi2name = "gsi2", gsi2hash = "gsi2pk", gsi2range = "gsi2sk")]

pub struct Task { #[deezprimary(key = "hash")] #[deezgsi1(key = "range", position = 1)] #[deezgsi2(key = "range", position = 1)] pub taskid: Option, #[deezprimary(key = "range", position = 1)] #[deezgsi1(key = "hash")] #[deezgsi2(key = "range")] pub project: Option, #[deezprimary(key = "range")] #[deezgsi1(key = "range")] #[deezgsi2(key = "hash")] pub employee: Option, pub description: String, #[deezignore(ignore)] pub somemetadata: String, }

impl Default for Task { fn default() -> Self { Task { taskid: Some(Uuid::newv4().tostring()), project: Some("".tostring()), employee: Some("".tostring()), description: "".tostring(), somemetadata: "".tostring(), } } } ```

Now you can convert your struct to a HashMap that you can pass directly to the DynamoDB client.

```rust let task = Task { project: Some("fooproject".tostring()), employee: Some("e42069".tostring()), description: "nothin' but chillin' 20's".tostring(), somemetadata: "baz".tostring(), ..Default::default() };

let map: HashMap = task.into(); println!("{:#?}", map);

// keys are generated based on schema! // output: // { // "pk": S("$TaskService#Task#taskid1885ea1d-e296-4c0f-9fbf-863b1318c698"), <- // "sk": S("$Task#employeee42069#projectfooproject"), <- // "gsi1pk": S("$TaskService#Task#projectfooproject"), <- // "gsi1sk": S("$Task#employeee42069#taskid1885ea1d-e296-4c0f-9fbf-863b1318c698"), <- // "gsi2pk": S("$TaskService#Task#employeee42069"), <- // "gsi2sk": S("$Task#projectfooproject#taskid1885ea1d-e296-4c0f-9fbf-863b1318c698"), <- // "taskid": S("1885ea1d-e296-4c0f-9fbf-863b1318c698"), // "project": S("foo_project"), // "employee": S("e42069"), // "description": S("nothin' but chillin' 20's"), // } ```

The following example shows a practical use-case interacting with DynamoDB client:

```rust use anyhow::Result; use awssdkdynamodb::Client;

[tokio::main]

async fn main() -> Result<()> { // local configuration let client = Client::new( &awsconfig::fromenv() .endpoint_url("http://localhost:8000") .region("us-east-1") .load() .await, );

// `create` convenience macro utilizes the `attribute_not_exists()` parameter
// to ensure records are only “created” and not overwritten when inserting
// new records into the table.
create!(
    client;
    Task {
        project: Some("foo_project".to_string()),
        employee: Some("e42069".to_string()),
        description: "nothin' but chillin' 20's".to_string(),
        some_metadata: "baz".to_string(),
        ..Default::default()
    }
)?;

let keys = Task {
    task_id: Some("1a2b3c4d".to_string()),
    project: Some("foo_project".to_string()),
    employee: Some("e42069".to_string()),
    ..Default::default()
}
.primary_keys();

// `vec_from_query` macro handles the process of converting the response
// back to `Vec<Task>`.
let tasks = vec_from_query!(
    client
        .query()
        .table_name(Task::table_name())
        .key_condition_expression("#pk = :pk and begins_with(#sk, :sk)")
        .set_expression_attribute_names(Some(HashMap::from([
            ("#pk".to_string(), keys.hash.field()),
            ("#sk".to_string(), keys.range.field()),
        ])))
        .set_expression_attribute_values(Some(HashMap::from([
            (":pk".to_string(), keys.hash.av()),
            (":sk".to_string(), keys.range.av()),
        ])))
        .send()
        .await?

    => TaskItems
);

// do something with `tasks`...

Ok(())

} ```