truto 0.1.0

Rust SDK for the Truto REST API
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

//! Unified API: one schema across every integration in a category.

use reqwest::Method;
use serde::Serialize;

use super::seg;
use crate::models::{UnifiedApiMetaResponse, UnifiedMetaGetResponse};
use crate::{Client, Pager, Record, Request};

/// The Unified API (`/unified/{model}/{resource}`).
///
/// Items are [`Record`]s; call `.typed::<YourType>()` on any request or
/// pager to decode into your own type instead.
#[derive(Debug, Clone, Copy)]
pub struct UnifiedApi<'a> {
    client: &'a Client,
}

impl<'a> UnifiedApi<'a> {
    pub(crate) fn new(client: &'a Client) -> Self {
        Self { client }
    }

    fn path(model: &str, resource: &str) -> String {
        format!("unified/{}/{}", seg(model), seg(resource))
    }

    fn req(&self, method: Method, path: String, integrated_account_id: &str) -> Request<Record> {
        let mut req = self.client.request(method, path);
        req.query_ref()
            .insert("integrated_account_id", integrated_account_id);
        req
    }

    /// List records (`GET /unified/{model}/{resource}`).
    pub fn list(&self, model: &str, resource: &str, integrated_account_id: &str) -> Pager<Record> {
        let mut pager = self.client.pager(Self::path(model, resource));
        pager
            .query_ref()
            .insert("integrated_account_id", integrated_account_id);
        pager
    }

    /// Get one record.
    pub fn get(
        &self,
        model: &str,
        resource: &str,
        id: &str,
        integrated_account_id: &str,
    ) -> Request<Record> {
        let path = format!("{}/{}", Self::path(model, resource), seg(id));
        self.req(Method::GET, path, integrated_account_id)
    }

    /// Create a record.
    pub fn create(
        &self,
        model: &str,
        resource: &str,
        integrated_account_id: &str,
        body: impl Serialize,
    ) -> Request<Record> {
        self.req(
            Method::POST,
            Self::path(model, resource),
            integrated_account_id,
        )
        .body(body)
    }

    /// Update a record (PATCH).
    pub fn update(
        &self,
        model: &str,
        resource: &str,
        id: &str,
        integrated_account_id: &str,
        body: impl Serialize,
    ) -> Request<Record> {
        let path = format!("{}/{}", Self::path(model, resource), seg(id));
        self.req(Method::PATCH, path, integrated_account_id)
            .body(body)
    }

    /// Delete a record.
    pub fn delete(
        &self,
        model: &str,
        resource: &str,
        id: &str,
        integrated_account_id: &str,
    ) -> Request<Record> {
        let path = format!("{}/{}", Self::path(model, resource), seg(id));
        self.req(Method::DELETE, path, integrated_account_id)
    }

    /// Call a custom method (`POST /unified/{model}/{resource}/{method}`).
    /// Add a body with `.body(..)` if the method takes one.
    pub fn custom_method(
        &self,
        model: &str,
        resource: &str,
        method: &str,
        integrated_account_id: &str,
    ) -> Request<Record> {
        let path = format!("{}/{}", Self::path(model, resource), seg(method));
        self.req(Method::POST, path, integrated_account_id)
    }

    /// An integration's mapping metadata for one unified method
    /// (`GET /unified/{model}/{resource}/{integration_name}/meta/{method}`).
    pub fn meta(
        &self,
        model: &str,
        resource: &str,
        integration_name: &str,
        method: &str,
    ) -> Request<UnifiedApiMetaResponse> {
        self.client.request(
            Method::GET,
            format!(
                "{}/{}/meta/{}",
                Self::path(model, resource),
                seg(integration_name),
                seg(method)
            ),
        )
    }

    /// Resources and methods of a unified model that an integration supports
    /// (`GET /unified/meta/{model}/{integration_name}`).
    pub fn model_meta(
        &self,
        model: &str,
        integration_name: &str,
    ) -> Request<UnifiedMetaGetResponse> {
        self.client.request(
            Method::GET,
            format!("unified/meta/{}/{}", seg(model), seg(integration_name)),
        )
    }
}