arangors 0.6.0

Rust driver for ArangoDB
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#![allow(unused_imports)]
#![allow(unused_parens)]

use anyhow::Error;

use arangors::{document::options::InsertOptions, Collection, Connection};

use arangors::document::{
    options::{RemoveOptions, ReplaceOptions, UpdateOptions},
    response::DocumentResponse,
};
use serde::{Deserialize, Serialize};
use serde_json::json;

const URL: &str = "http://localhost:8529";

#[derive(Serialize, Deserialize, Debug)]
struct User {
    first_name: String,
    last_name: String,
    email: String,
}

#[cfg_attr(feature = "reqwest_async", tokio::main)]
#[cfg_attr(feature = "surf_async", async_std::main)]
#[cfg_attr(feature = "reqwest_blocking", maybe_async::must_be_sync)]
async fn main() -> Result<(), Error> {
    let collection_name = "test_collection_document_example";

    let conn = Connection::establish_jwt(URL, "username", "password").await?;
    let database = conn.db("test_db").await?;
    database.create_collection(collection_name).await.unwrap();
    let collection = database.collection(collection_name).await?;

    let new_user = User {
        first_name: "John".to_string(),
        last_name: "Doe".to_string(),
        email: "john.doe@who".to_string(),
    };

    // create a document
    let new_doc_response = collection
        .create_document(new_user, InsertOptions::builder().return_new(true).build())
        .await
        .unwrap();

    let new_doc = new_doc_response.new_doc();
    eprintln!(
        "Your new document should have been created -> {:?} ",
        new_doc
    );

    // update a document
    let header = new_doc_response.header().unwrap();
    let _key = &header._key;

    let patch = json!({"last_name" : "Doh"});
    let update_doc_response = collection
        .update_document(
            _key,
            patch,
            UpdateOptions::builder()
                .return_new(true)
                .return_old(true)
                .build(),
        )
        .await
        .unwrap();

    let new_doc = update_doc_response.new_doc();
    eprintln!("John Doe is now John Doh -> {:?}", new_doc);

    let old_doc = update_doc_response.old_doc();
    eprintln!("John Doh was called John Doe before ->  {:?}", old_doc);

    // update a document with default option
    let header = update_doc_response.header().unwrap();
    let old_rev = &header._rev;

    let patch = json!({"email" : "john.doh@who"});
    // use Default::default() to set default options
    let update_doc_response = collection
        .update_document(_key, patch, Default::default())
        .await
        .unwrap();

    let header = update_doc_response.header().unwrap();
    let _rev = &header._rev;

    if old_rev != _rev {
        eprintln!("John Doh has changed his address email");
    }

    // replace a document
    let replace = User {
        first_name: "Bob".to_string(),
        last_name: "Johnson".to_string(),
        email: "bob.Johnson@internet".to_string(),
    };

    let replace_doc_response = collection
        .replace_document(
            _key,
            replace,
            ReplaceOptions::builder()
                .return_new(true)
                .return_old(true)
                .build(),
            Some(_rev.to_string()),
        )
        .await
        .unwrap();

    let new_doc = replace_doc_response.new_doc();
    eprintln!(
        "John Doh found his identity, his real name is Bob Johnson with email \
         bob.Johnson@internet@-> {:?}",
        new_doc
    );

    let old_doc = replace_doc_response.old_doc();
    eprintln!(
        "Bob Johnson was called John Doh because he did not remember who he was ->  {:?}",
        old_doc
    );

    // remove a document
    let remove_doc_response: DocumentResponse<User> = collection
        .remove_document(
            _key,
            RemoveOptions::builder().return_old(true).build(),
            None,
        )
        .await
        .unwrap();

    let old_doc = remove_doc_response.old_doc();
    eprintln!(
        "Bob Johnson has been removed from the Database which helps people to remember their \
         identity ->  {:?}",
        old_doc
    );

    // cleanup
    database.drop_collection(collection_name).await.unwrap();

    Ok(())
}

#[cfg(not(any(
    feature = "reqwest_blocking",
    feature = "reqwest_async",
    feature = "surf_async"
)))]
fn main() {}