Skip to main content

ironflow_api/
response.rs

1//! Standard response types and helpers for the REST API.
2//!
3//! All successful responses are wrapped in the [`ApiResponse`] envelope
4//! with optional pagination metadata.
5
6use axum::Json;
7use serde::Serialize;
8
9/// Pagination metadata.
10///
11/// Included in the response when the endpoint returns paginated results.
12///
13/// # Examples
14///
15/// ```
16/// use ironflow_api::response::ApiMeta;
17///
18/// let meta = ApiMeta {
19///     page: Some(1),
20///     per_page: Some(20),
21///     total: Some(100),
22/// };
23/// assert_eq!(meta.page, Some(1));
24/// ```
25#[derive(Debug, Serialize, Clone)]
26pub struct ApiMeta {
27    /// Current page number (1-based).
28    pub page: Option<u32>,
29    /// Items per page.
30    pub per_page: Option<u32>,
31    /// Total number of items matching the filter.
32    pub total: Option<u64>,
33}
34
35impl ApiMeta {
36    /// Create an empty metadata object (no pagination).
37    pub fn empty() -> Self {
38        ApiMeta {
39            page: None,
40            per_page: None,
41            total: None,
42        }
43    }
44
45    /// Create pagination metadata.
46    pub fn paginated(page: u32, per_page: u32, total: u64) -> Self {
47        ApiMeta {
48            page: Some(page),
49            per_page: Some(per_page),
50            total: Some(total),
51        }
52    }
53}
54
55/// Standard response envelope for all successful API responses.
56///
57/// Serialized as: `{ "data": ..., "meta": { "page": ..., "total": ... } }`
58///
59/// # Examples
60///
61/// ```
62/// use ironflow_api::response::ApiResponse;
63///
64/// let response = ApiResponse {
65///     data: "hello".to_string(),
66///     meta: None,
67/// };
68/// assert_eq!(response.data, "hello");
69/// ```
70#[derive(Debug, Serialize)]
71pub struct ApiResponse<T: Serialize> {
72    /// The response payload.
73    pub data: T,
74    /// Optional pagination metadata.
75    pub meta: Option<ApiMeta>,
76}
77
78/// Helper to wrap data in a successful response without pagination.
79///
80/// # Examples
81///
82/// ```no_run
83/// use ironflow_api::response::ok;
84///
85/// # async fn handler() {
86/// let data = vec!["a", "b"];
87/// let response = ok(data);
88/// // Returns: { "data": ["a", "b"] }
89/// # }
90/// ```
91pub fn ok<T: Serialize>(data: T) -> Json<ApiResponse<T>> {
92    Json(ApiResponse { data, meta: None })
93}
94
95/// Helper to wrap paginated data in a successful response.
96///
97/// # Examples
98///
99/// ```no_run
100/// use ironflow_api::response::ok_paged;
101///
102/// # async fn handler() {
103/// let data = vec!["a", "b"];
104/// let response = ok_paged(data, 1, 20, 100);
105/// // Returns: { "data": ["a", "b"], "meta": { "page": 1, "per_page": 20, "total": 100 } }
106/// # }
107/// ```
108pub fn ok_paged<T: Serialize>(
109    data: T,
110    page: u32,
111    per_page: u32,
112    total: u64,
113) -> Json<ApiResponse<T>> {
114    Json(ApiResponse {
115        data,
116        meta: Some(ApiMeta::paginated(page, per_page, total)),
117    })
118}
119
120#[cfg(test)]
121mod tests {
122    use super::*;
123
124    #[test]
125    fn api_meta_empty() {
126        let meta = ApiMeta::empty();
127        assert_eq!(meta.page, None);
128        assert_eq!(meta.per_page, None);
129        assert_eq!(meta.total, None);
130    }
131
132    #[test]
133    fn api_meta_paginated() {
134        let meta = ApiMeta::paginated(2, 50, 200);
135        assert_eq!(meta.page, Some(2));
136        assert_eq!(meta.per_page, Some(50));
137        assert_eq!(meta.total, Some(200));
138    }
139
140    #[test]
141    fn api_response_serialize() {
142        let response = ApiResponse {
143            data: vec![1, 2, 3],
144            meta: None,
145        };
146        let json = serde_json::to_value(&response).expect("serialize");
147        assert_eq!(json["data"], serde_json::json!([1, 2, 3]));
148        assert_eq!(json["meta"], serde_json::Value::Null);
149    }
150
151    #[test]
152    fn api_response_with_meta_serialize() {
153        let response = ApiResponse {
154            data: vec!["a"],
155            meta: Some(ApiMeta::paginated(1, 10, 50)),
156        };
157        let json = serde_json::to_value(&response).expect("serialize");
158        assert_eq!(json["data"], serde_json::json!(["a"]));
159        assert_eq!(json["meta"]["page"], 1);
160        assert_eq!(json["meta"]["per_page"], 10);
161        assert_eq!(json["meta"]["total"], 50);
162    }
163}