dynamode 0.1.1

A professional, extensible ODM for AWS DynamoDB in Rust
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

# Dynamode

A professional, ergonomic, and extensible Rust Object-Document Mapper (ODM) for DynamoDB  
Supports **DynamoDB Local** out-of-the-box for fast local development and testing.

---

## 🚀 Features

- Async Rust API for DynamoDB (powered by [aws-sdk-dynamodb](https://crates.io/crates/aws-sdk-dynamodb))
- Define models as Rust structs with familiar traits
- Works with DynamoDB Local for easy testing/development
- Table auto-creation helpers
- CRUD operations: insert, fetch, update, delete
- Query by partition key, full-table scan, and more!
- Ready for expansion: batch ops, GSIs, conditional writes, etc.

---

## 📦 Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
dynamode = { version = "*" }
serde = { version = "*", features = ["derive"] }
tokio = { version = "*", features = ["full"] }
aws-sdk-dynamodb = "*"
aws-config = "*"
async-trait = "*"
```

## 🛠️ Running DynamoDB Local
With Docker (recommended):
```
docker run -d -p 8000:8000 amazon/dynamodb-local
```
Set dummy AWS credentials (required by the SDK):
```
export AWS_ACCESS_KEY_ID=dummy
export AWS_SECRET_ACCESS_KEY=dummy
```
🚗 Quick Example
```
use serde::{Serialize, Deserialize};
use dynamode::agent::DynamodeAgent;
use dynamode::model::DynamoModel;

#[derive(Debug, Serialize, Deserialize)]
struct Car {
    pk: String,
    sk: String,
    brand: String,
    model: String,
    horsepower: i32,
}

#[async_trait::async_trait]
impl DynamoModel for Car {
    fn table_name() -> &'static str { "Cars" }
    fn partition_sort_key(&self) -> (String, String) {
        (self.pk.clone(), self.sk.clone())
    }
}

#[tokio::main]
async fn main() {
    let agent = DynamodeAgent::connect_local().await;

    let car = Car {
        pk: "tesla".into(),
        sk: "model-y".into(),
        brand: "Tesla".into(),
        model: "Model Y".into(),
        horsepower: 420,
    };

    agent.put(&car).await.expect("insert failed");
    let fetched = agent.get::<Car>(("tesla".into(), "model-y".into())).await.expect("get failed");
    println!("Fetched: {:?}", fetched);
}
```
## 📋 Test Example
All features work with cargo test using DynamoDB Local!
Test cases are in main.rs as async functions.

## 🏗️ Table Creation
The first run will auto-create your table if it does not exist (see main.rs example).
You can also create tables manually via the AWS CLI:

```
aws dynamodb create-table \
    --table-name Cars \
    --attribute-definitions AttributeName=pk,AttributeType=S AttributeName=sk,AttributeType=S \
    --key-schema AttributeName=pk,KeyType=HASH AttributeName=sk,KeyType=RANGE \
    --billing-mode PAY_PER_REQUEST \
    --endpoint-url http://localhost:8000 \
    --region us-west-2
```
## ⚡ Tips
Always run DynamoDB Local (docker run -p 8000:8000 amazon/dynamodb-local) before developing or running tests.

Set AWS credentials in your shell session, even for local.

You can extend the agent for batch ops, transactional writes, secondary indexes, and more.

## 🧑‍💻 Contributing
PRs, issues, and feature requests are welcome!
Feel free to fork and build your own supercharged DynamoDB ORM.

## 📝 License
MIT

## 📣 Credits
Built by Rust and DynamoDB fans, with inspiration from the AWS SDK team and open source community.