triplox-client 0.1.0-alpha.5

HTTP/2 client for Triplox, a Datalog database.
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

use anyhow::{Error, Result};
use edn::query::ParsedQuery;

use crate::ops::{QueryArg, TxOp};
use crate::query::QueryResult;
use crate::transaction::{TransactionResult, TxKey};

#[allow(async_fn_in_trait)]
pub trait SubmitNode {
    async fn submit_tx<O: IntoTxOp>(&self, ops: Vec<O>) -> Result<TxKey, Error>;
    async fn execute_tx<O: IntoTxOp>(&self, ops: Vec<O>) -> Result<TransactionResult, Error>;
}

/// Per-element conversion to `TxOp`. Lets `submit_tx`/`execute_tx` accept
/// either `Vec<TxOp>` or `Vec<&str>`/`Vec<String>` (each string parsed as one EDN tx op).
pub trait IntoTxOp {
    fn into_tx_op(self) -> Result<TxOp, Error>;
}

impl IntoTxOp for TxOp {
    fn into_tx_op(self) -> Result<TxOp, Error> {
        Ok(self)
    }
}

impl IntoTxOp for &str {
    fn into_tx_op(self) -> Result<TxOp, Error> {
        self.parse()
    }
}

impl IntoTxOp for String {
    fn into_tx_op(self) -> Result<TxOp, Error> {
        self.as_str().into_tx_op()
    }
}

pub fn collect_tx_ops<O: IntoTxOp>(ops: Vec<O>) -> Result<Vec<TxOp>, Error> {
    ops.into_iter().map(IntoTxOp::into_tx_op).collect()
}

pub trait IntoQuery {
    fn into_query(self) -> Result<ParsedQuery, Error>;
}

impl IntoQuery for ParsedQuery {
    fn into_query(self) -> Result<ParsedQuery, Error> {
        Ok(self)
    }
}

// TODO: consider using Cow or a lifetime on the trait to avoid cloning
impl IntoQuery for &ParsedQuery {
    fn into_query(self) -> Result<ParsedQuery, Error> {
        Ok(self.clone())
    }
}

impl IntoQuery for &str {
    fn into_query(self) -> Result<ParsedQuery, Error> {
        self.parse()
            .map_err(|e| anyhow::anyhow!("EDN parse error: {}", e))
    }
}

impl IntoQuery for String {
    fn into_query(self) -> Result<ParsedQuery, Error> {
        self.as_str().into_query()
    }
}

#[allow(async_fn_in_trait)]
pub trait Database {
    async fn query(&self, query: impl IntoQuery) -> Result<QueryResult, Error>;

    async fn query_with_args(
        &self,
        query: &ParsedQuery,
        args: &[QueryArg],
    ) -> Result<QueryResult, Error>;
}

#[allow(async_fn_in_trait)]
pub trait QueryNode {
    type DB: Database;
    async fn db(&self) -> Result<Self::DB, Error>;
    async fn db_as_of(&self, tx_key: TxKey) -> Result<Self::DB, Error>;
}