cronback-api-model 0.1.0

A set of API models for [cronback](https://cronback.me) API protocol. 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

use chrono::{DateTime, Utc};
#[cfg(feature = "dto")]
use dto::{FromProto, IntoProto};
#[cfg(feature = "dto")]
use lib::types::RunId;
use serde::{Deserialize, Serialize};
use serde_with::{serde_as, skip_serializing_none};
use strum::Display;

use super::{Action, Attempt, Payload};
#[cfg(not(feature = "dto"))]
use crate::RunId;

#[cfg_attr(feature = "client", non_exhaustive)]
#[derive(
    Debug, Display, Deserialize, PartialEq, Serialize, Clone, Copy, Default,
)]
#[cfg_attr(
    feature = "dto",
    derive(IntoProto),
    proto(target = "proto::scheduler_proto::RunMode")
)]
#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
#[cfg_attr(feature = "clap", clap(rename_all = "snake_case"))]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RunMode {
    Sync,
    #[default]
    Async,
}

#[derive(Debug, Display, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "client", non_exhaustive)]
#[cfg_attr(
    feature = "dto",
    derive(FromProto),
    proto(target = "proto::run_proto::RunStatus")
)]
#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
#[cfg_attr(feature = "clap", clap(rename_all = "snake_case"))]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RunStatus {
    Attempting,
    Succeeded,
    Failed,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(
    feature = "server",
    derive(Default),
    serde(default),
    serde(deny_unknown_fields)
)]
pub struct RunTrigger {
    pub mode: RunMode,
}

#[serde_as]
#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[cfg_attr(
    feature = "dto",
    derive(FromProto),
    proto(target = "proto::run_proto::Run")
)]
#[cfg_attr(feature = "server", serde(deny_unknown_fields))]
pub struct Run {
    #[cfg_attr(feature = "dto", proto(required))]
    pub id: RunId,
    #[cfg_attr(feature = "dto", proto(required))]
    pub created_at: DateTime<Utc>,
    pub payload: Option<Payload>,
    #[cfg_attr(feature = "dto", proto(required))]
    pub action: Action,
    pub status: RunStatus,
    pub latest_attempt: Option<Attempt>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[cfg_attr(
    feature = "dto",
    derive(FromProto),
    proto(target = "proto::dispatcher_proto::GetRunResponse")
)]
pub struct GetRunResponse {
    #[serde(flatten)]
    #[cfg_attr(feature = "dto", proto(required))]
    pub run: Run,
}

#[cfg(test)]
mod test {
    use super::{RunMode, RunStatus};

    #[test]
    fn run_mode_to_string() {
        assert_eq!(RunMode::Sync.to_string(), "sync");
        assert_eq!(RunMode::Async.to_string(), "async");
    }

    #[test]
    fn run_status_to_string() {
        assert_eq!(RunStatus::Attempting.to_string(), "attempting");
        assert_eq!(RunStatus::Succeeded.to_string(), "succeeded");
        assert_eq!(RunStatus::Failed.to_string(), "failed");
    }
}