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 faciliting 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: String, #[deezprimary(key = "range", position = 1)] #[deezgsi1(key = "hash")] #[deezgsi2(key = "range")] pub project: String, #[deezprimary(key = "range")] #[deezgsi1(key = "range")] #[deezgsi2(key = "hash")] pub employee: String, pub description: String, #[deezignore(ignore)] pub somemetadata: String, }

impl Default for Task { fn default() -> Self { Task { taskid: Uuid::newv4().tostring(), project: "".tostring(), employee: "".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 { taskid: "1a2b3c4d".tostring(), project: "fooproject".tostring(), employee: "e42069".tostring(), description: "nothin' but chillin' 20's".tostring(), somemetadata: "baz".tostring(), };

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

// output: // { // "pk": S("$TaskService#Task#taskid1a2b3c4d"), <- keys generated based on schema // "sk": S("$Task#employeee42069#projectfooproject"), <- // "gsi1pk": S("$TaskService#Task#projectfooproject"), <- // "gsi1sk": S("$Task#employeee42069#taskid1a2b3c4d"), <- // "gsi2pk": S("$TaskService#Task#employeee42069"), <- // "gsi2sk": S("$Task#projectfooproject#taskid1a2b3c4d"), <- // "employee": S("e42069"), // "project": S("fooproject"), // "description": S("nothin' but chillin' 20's"), // "task_id": S("1a2b3c4d"), // } ```

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

```rust use awssdkdynamodb::Client;

[tokio::main]

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

// `create` example
let task = Task {
    project: "foo_project".to_string(),
    employee: "e42069".to_string(),
    description: "nothin' but chillin' 20's".to_string(),
    some_metadata: "baz".to_string(),
    ..Default::default()
};

client
    .put_item()
    .table_name(Task::table_name())
    .condition_expression("attribute_not_exists(#pk) AND attribute_not_exists(#sk)")
    .set_expression_attribute_names(Some(HashMap::from([
        (
            "#pk".to_string(),
            task.index_key(Index::Primary, Key::Hash).field,
        ),
        (
            "#sk".to_string(),
            task.index_key(Index::Primary, Key::Range).field,
        ),
    ])))
    .set_item(Some(task.into())) // <- pass in struct directly using .into()
    .send()
    .await
    .unwrap();

// `query` example
let keys = Task {
    task_id: "a145d3f8-4420-4c22-9178-00240102048a".to_string(),
    project: "foo_project".to_string(),
    employee: "e42069".to_string(),
    ..Default::default()
}
.index_keys_av(Index::Primary);

let task_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.composite),
        (":sk".to_string(), keys.range.composite),
    ])))
    .send()
    .await
    .unwrap();

let items = TaskItems::from(task_query.items().unwrap()).items(); // returns `Vec<Task>`

} ```