deez 0.1.1

abstraction for DynamoDB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

A DynamoDB abstraction for Rust
==========================================================
[![Crates.io](https://img.shields.io/crates/v/deez.svg)](https://crates.io/crates/deez)

Deez is a DynamoDB abstraction for implementing Single Table Design easily,
inspired by [ElectroDB](https://github.com/tywalch/electrodb).

## Getting Started

Define a schema for your entities:

```rust
use aws_sdk_dynamodb::types::AttributeValue;
use deez::{DeezEntity, DeezError, DeezMeta, Index, IndexKeys, Key, Meta};
use std::collections::HashMap;
use uuid::Uuid;

const TABLE_NAME: &str = "TaskTable";
const PRIMARY: Index = Index::Primary;
const GSI1: Index = Index::Gsi1("gsi1");
const GSI2: Index = Index::Gsi2("gsi2");

#[derive(Debug, Default, DeezEntity)]
struct Task {
    task_id: String,
    project: String,
    employee: String,
    description: String,
}

impl DeezMeta for Task {
    fn meta(&self) -> Meta {
        Meta {
            table: TABLE_NAME,
            service: "TaskService",
            entity: "Task",
        }
    }

    fn indexes(&self) -> HashMap<Index, IndexKeys> {
        let mut m = HashMap::new();
        m.insert(
            PRIMARY,
            IndexKeys {
                partition_key: Key {
                    field: "pk",
                    composite: vec!["task_id"],
                },
                sort_key: Key {
                    field: "sk",
                    composite: vec!["project", "employee"],
                },
            },
        );
        m.insert(
            GSI1,
            IndexKeys {
                partition_key: Key {
                    field: "gsi1pk",
                    composite: vec!["project"],
                },
                sort_key: Key {
                    field: "gsi1sk",
                    composite: vec!["employee", "task"],
                },
            },
        );
        m.insert(
            GSI2,
            IndexKeys {
                partition_key: Key {
                    field: "gsi2pk",
                    composite: vec!["employee"],
                },
                sort_key: Key {
                    field: "gsi2sk",
                    composite: vec!["project", "task"],
                },
            },
        );
        m
    }

    fn generated() -> Self {
        Task {
            task_id: Uuid::new_v4().to_string(),
            ..Default::default()
        }
    }
}
```

Create a client to interact with your entities:

```rust
use aws_sdk_dynamodb::Client;
use deez::Deez;

#[tokio::main]
async fn main() {
    // local configuration
    let ddb_client = Client::new(
        &aws_config::from_env()
            .endpoint_url("http://localhost:8000")
            .region("us-east-1")
            .load()
            .await,
    );

    let deez = Deez::new(ddb_client);

    // create
    deez.create(&Task {
        project: "foo project".to_string(),
        employee: "Bill Bar".to_string(),
        description: "nothin' but chillin' 20's".to_string(),
        ..Task::generated()
    })
    .unwrap()
    .send()
    .await
    .unwrap();

    // convenience macro for simple queries
    let result = query_Task!(
        deez,
        GSI1,
        Task {
            project: "foo project".to_string(),
            ..Default::default()
        }
    );

    println!("{:#?}", result);
}
```

Read the full list of methods on [docs.rs](https://docs.rs/deez/0.1.0/deez/struct.Deez.html)