cronback-client 0.1.0

A client library for https://cronback.me service. Cronback provides developers a reliable and flexible solution to schedule one-time, recurring cron, and on-demand webhooks.
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

use cronback_api_model::{
    Paginated,
    Pagination,
    Run,
    RunMode,
    RunTrigger,
    TriggersFilter,
};
use http::Method;

use crate::client::RequestRunner;
use crate::{Response, Result, Trigger};

/// Create a new trigger from JSON definition.
///
/// We intentionally don't accept [`Trigger`] here since API is designed to
/// be more relaxed than the required fields in Trigger model. If we
/// accepted [`Trigger`] as input, the trigger defaults will be set on
/// the client side and not server side. To want to make it easy to
/// change those defaults on the server side without having to release a
/// new client version.
pub async fn create_from_json(
    client: &impl RequestRunner,
    trigger_req: serde_json::Value,
) -> Result<Response<Trigger>> {
    let path = client.make_url("/v1/triggers")?;
    client.run_with_body(Method::POST, path, trigger_req).await
}
/// Retrieve a trigger by name.
pub async fn get<T>(
    client: &impl RequestRunner,
    name: T,
) -> Result<Response<Trigger>>
where
    T: AsRef<str>,
{
    let path = client.make_url(&format!("/v1/triggers/{}", name.as_ref()))?;
    client.run(Method::GET, path).await
}

/// Retrieve list of triggers for a project.
pub async fn list(
    client: &impl RequestRunner,
    pagination: Option<Pagination>,
    filter: Option<TriggersFilter>,
) -> Result<Response<Paginated<Trigger>>> {
    let mut path = client.make_url("/v1/triggers")?;
    if let Some(pagination) = pagination {
        if let Some(cursor) = pagination.cursor {
            path.query_pairs_mut().append_pair("cursor", &cursor);
        }
        if let Some(limit) = pagination.limit {
            path.query_pairs_mut()
                .append_pair("limit", &limit.to_string());
        }
    }

    if let Some(filter) = filter {
        for status in filter.status {
            path.query_pairs_mut()
                .append_pair("status", &status.to_string());
        }
    }

    client.run(Method::GET, path).await
}

/// Cancel a `scheduled` trigger.
pub async fn cancel<T>(
    client: &impl RequestRunner,
    name: T,
) -> Result<Response<Trigger>>
where
    T: AsRef<str>,
{
    let path = format!("/v1/triggers/{}/cancel", name.as_ref());
    let path = client.make_url(&path)?;

    client.run(Method::POST, path).await
}

/// Pause a `scheduled` trigger.
pub async fn pause<T>(
    client: &impl RequestRunner,
    name: T,
) -> Result<Response<Trigger>>
where
    T: AsRef<str>,
{
    let path = format!("/v1/triggers/{}/pause", name.as_ref());
    let path = client.make_url(&path)?;

    client.run(Method::POST, path).await
}

/// Resume a `paused` trigger.
pub async fn resume<T>(
    client: &impl RequestRunner,
    name: T,
) -> Result<Response<Trigger>>
where
    T: AsRef<str>,
{
    let path = format!("/v1/triggers/{}/resume", name.as_ref());
    let path = client.make_url(&path)?;

    client.run(Method::POST, path).await
}

/// Run the trigger immediately
pub async fn run<T>(
    client: &impl RequestRunner,
    name: T,
    mode: RunMode,
) -> Result<Response<Run>>
where
    T: AsRef<str>,
{
    let path = format!("/v1/triggers/{}/run", name.as_ref());
    let path = client.make_url(&path)?;

    let body = RunTrigger { mode };

    client.run_with_body(Method::POST, path, body).await
}

/// Permanently delete a trigger.
pub async fn delete<T>(
    client: &impl RequestRunner,
    name: T,
) -> Result<Response<()>>
where
    T: AsRef<str>,
{
    let path = format!("/v1/triggers/{}", name.as_ref());
    let path = client.make_url(&path)?;

    client.run(Method::DELETE, path).await
}