arangoq 0.3.4

An AQL query builder layer and ArangoDb client for 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

use crate::{ArangoConnection, ArangoQuery, ArangoResponse};
use actix::prelude::*;
use log::debug;
use serde::de::DeserializeOwned;
use serde::Serialize;

pub struct DbQuery<T>(pub ArangoQuery, pub std::marker::PhantomData<T>);

impl<T: 'static> Message for DbQuery<T> {
    type Result = Result<ArangoResponse<T>, reqwest::Error>;
}

/// This is an actix async actor using reqwest async client.
/// Usage:
///
/// ```ignore
/// use arangoq::{ArangoActor, ArangoConnection};
/// use reqwest::r#async::Client;
/// use actix::prelude::*;
/// use actix_web::{App, HttpServer};
/// let sys = actix::System::new("auth-proxy");
/// let connection = ArangoConnection {
///    host: std::sync::Arc::new(format!("{}/_db/{}/_api/cursor", db_conn, db_name)),
///    client: std::sync::Arc::new(Client::new()),
/// };
/// let addr = ArangoActor {connection: connection.clone()}.start();
/// HttpServer::new(move || {
///     App::new()
///         .data(addr.clone())
/// });
/// sys.run();
/// ```
pub struct ArangoActorAsync {
    pub connection: ArangoConnection,
}

impl Actor for ArangoActorAsync {
    type Context = actix::Context<Self>;

    fn started(&mut self, _ctx: &mut Self::Context) {
        debug!("ArangoActorAsync alive.");
    }
}

impl<T: 'static + Serialize + DeserializeOwned + std::fmt::Debug + Send> Handler<DbQuery<T>>
    for ArangoActorAsync
{
    type Result = ResponseFuture<Result<ArangoResponse<T>, reqwest::Error>>;

    fn handle(&mut self, msg: DbQuery<T>, _ctx: &mut Context<Self>) -> Self::Result {
        let query = msg.0;
        let dbc = &self.connection;
        Box::pin(query.try_exec::<T>(dbc))
    }
}

impl Message for ArangoQuery {
    type Result = Result<ArangoResponse<serde_json::Value>, reqwest::Error>;
}
impl Handler<ArangoQuery> for ArangoActorAsync {
    type Result = ResponseFuture<Result<ArangoResponse<serde_json::Value>, reqwest::Error>>;

    fn handle(&mut self, query: ArangoQuery, _ctx: &mut Context<Self>) -> Self::Result {
        let dbc = &self.connection;
        Box::pin(query.try_exec::<serde_json::Value>(dbc))
    }
}