aymond 0.1.4

A batteries-included client wrapper 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
139
140
141

# aymond

A batteries-included client wrapper for DynamoDB

Builds upon the existing AWS SDK DynamoDB client, providing a high-level interface, somewhat akin to the [DynamoDB Enhanced Java Client](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBEnhanced.html)

## Usage

Item shapes are described by structs:

```rust
#[aymond(item, table)]
struct Car {
    #[hash_key]
    make: String,
    #[sort_key]
    model: String,
    hp: i16,
    variants: Vec<String>,
    production: Production,
}

#[aymond(nested_item)]
struct Production {
    began: i32,
    #[attribute(name = "units_produced")]
    units: i64,
}
```

Interacting with the table is done through a `Table` instance:

```rust
let table = CarTable::new_with_local_config("test", "http://localhost:8000", "us-west-2");
table.create(false).await.expect("Failed to create");
```

Writing an item with `put`:

```rust
let it = Car {
    make: "Porsche".to_string(),
    model: "911".to_string(),
    hp: 518,
    variants: vec![
        "Carrera".into(),
        "Carrera S".into(),
        "Carrera 4S".into(),
        "GT3 RS".into(),
    ],
    production: Production {
        began: 1964,
        units: 1_100_000,
    },
};
table.put(it).await.expect("Failed to write");
```

Reading an item with `get`:

```rust
let _: Option<Car> = table
    .get(|k| k.make("Porsche").model("911"))
    .await
    .expect("Failed to read");
```

<details>
    <summary>Full example</summary>

```rust
use aymond::{prelude::*, shim::futures::StreamExt};

#[aymond(item, table)]
struct Car {
    #[hash_key]
    make: String,
    #[sort_key]
    model: String,
    hp: i16,
    variants: Vec<String>,
    production: Production,
}

#[aymond(nested_item)]
struct Production {
    began: i32,
    #[attribute(name = "units_produced")]
    units: i64,
}

#[tokio::main]
async fn main() {
    // Create a table in local DynamoDB, based on our item schema
    let table = CarTable::new_with_local_config("test", "http://localhost:8000", "us-west-2");
    table.create(false).await.expect("Failed to create");

    // Write
    let it = Car {
        make: "Porsche".to_string(),
        model: "911".to_string(),
        hp: 518,
        variants: vec![
            "Carrera".into(),
            "Carrera S".into(),
            "Carrera 4S".into(),
            "GT3 RS".into(),
        ],
        production: Production {
            began: 1964,
            units: 1_100_000,
        },
    };
    table.put(it).await.expect("Failed to write");

    // Read it back
    let _: Option<Car> = table
        .get(|k| k.make("Porsche").model("911"))
        .await
        .expect("Failed to read");

    // Read it back, with additional options
    let res: Result<_, _> = table
        .get_item(
            |k| k.make("Porsche").model("911"),
            |r| r.consistent_read(true),
        )
        .await;
    let _: Option<Car> = res.ok().and_then(|e| e.item().map(|i| i.into()));
}
```
</details>

## Not (yet) implemented

- Query operation with fluent builder pattern
- Update operation with fluent builder pattern
- Global/local indices
- Optimistic locking with version attribute
- Transaction system, including cross-table
- Projections