aragog 0.10.1

A simple lightweight object-document mapper 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

use arangors::client::reqwest::ReqwestClient;
use arangors::{
    collection::{options::CreateOptions, Collection, CollectionType},
    ClientError, Database,
};
use serde::{Deserialize, Serialize};

use crate::schema::SchemaDatabaseOperation;

/// Aragog schema representation of an ArangoDB Collection.
/// This struct is meant to load/generate the schema file.
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct CollectionSchema {
    /// Collection name
    pub name: String,
    /// Defines if the collection a edge collection
    pub is_edge_collection: bool,
    /// Defins if the collection requests wait for the operations to be written on disk
    ///
    /// If set on `true` the requests might be slower. By default, `false` is used
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wait_for_sync: Option<bool>,
}

impl CollectionSchema {
    /// Initializes a new collection schema with the collection name and a flag to define if
    /// it's an edge collection or not.
    pub fn new(name: &str, is_edge_collection: bool, wait_for_sync: Option<bool>) -> Self {
        Self {
            name: name.to_string(),
            is_edge_collection,
            wait_for_sync,
        }
    }
}

#[maybe_async::maybe_async]
impl SchemaDatabaseOperation for CollectionSchema {
    type PoolType = Collection<ReqwestClient>;

    async fn apply_to_database(
        &self,
        database: &Database<ReqwestClient>,
        silent: bool,
    ) -> Result<Option<Self::PoolType>, ClientError> {
        log::debug!("Creating Collection {}", &self.name);
        let creation_settings = CreateOptions::builder()
            .name(&self.name)
            .collection_type(if self.is_edge_collection {
                CollectionType::Edge
            } else {
                CollectionType::Document
            })
            .wait_for_sync(self.wait_for_sync.unwrap_or(false))
            .build();
        let res = database
            .create_collection_with_options(creation_settings, Default::default())
            .await;
        Self::handle_pool_result(res, silent)
    }

    async fn drop(&self, database: &Database<ReqwestClient>) -> Result<(), ClientError> {
        log::debug!("Deleting Collection {}", &self.name);
        database.drop_collection(&self.name).await?;
        Ok(())
    }

    async fn get(&self, database: &Database<ReqwestClient>) -> Result<Self::PoolType, ClientError> {
        database.collection(&self.name).await
    }
}