lineark-sdk 2.1.1

Typed, async-first Rust SDK for the Linear GraphQL 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

//! Cursor-based pagination types.
//!
//! Linear uses Relay-style connections. [`Connection`] wraps a page of nodes
//! with [`PageInfo`] for cursor-based traversal.

use serde::{Deserialize, Serialize};

/// Relay-style page info for cursor-based pagination.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct PageInfo {
    pub has_next_page: bool,
    pub end_cursor: Option<String>,
    pub has_previous_page: Option<bool>,
    pub start_cursor: Option<String>,
}

/// A paginated collection of nodes with page info.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(bound(deserialize = "T: serde::de::DeserializeOwned"))]
pub struct Connection<T> {
    #[serde(default)]
    pub nodes: Vec<T>,
    #[serde(rename = "pageInfo", default)]
    pub page_info: PageInfo,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn page_info_deserializes_camel_case() {
        let json = r#"{
            "hasNextPage": true,
            "endCursor": "abc123",
            "hasPreviousPage": false,
            "startCursor": "xyz"
        }"#;
        let pi: PageInfo = serde_json::from_str(json).unwrap();
        assert!(pi.has_next_page);
        assert_eq!(pi.end_cursor, Some("abc123".to_string()));
        assert_eq!(pi.has_previous_page, Some(false));
        assert_eq!(pi.start_cursor, Some("xyz".to_string()));
    }

    #[test]
    fn page_info_defaults() {
        let json = r#"{}"#;
        let pi: PageInfo = serde_json::from_str(json).unwrap();
        assert!(!pi.has_next_page);
        assert!(pi.end_cursor.is_none());
        assert!(pi.has_previous_page.is_none());
        assert!(pi.start_cursor.is_none());
    }

    #[test]
    fn connection_deserializes_with_nodes() {
        let json = r#"{
            "nodes": [{"value": 1}, {"value": 2}],
            "pageInfo": {"hasNextPage": true, "endCursor": "cur"}
        }"#;
        let conn: Connection<serde_json::Value> = serde_json::from_str(json).unwrap();
        assert_eq!(conn.nodes.len(), 2);
        assert!(conn.page_info.has_next_page);
        assert_eq!(conn.page_info.end_cursor, Some("cur".to_string()));
    }

    #[test]
    fn connection_deserializes_empty_nodes() {
        let json = r#"{
            "nodes": [],
            "pageInfo": {"hasNextPage": false}
        }"#;
        let conn: Connection<serde_json::Value> = serde_json::from_str(json).unwrap();
        assert!(conn.nodes.is_empty());
        assert!(!conn.page_info.has_next_page);
    }

    #[test]
    fn connection_defaults_when_missing() {
        let json = r#"{}"#;
        let conn: Connection<serde_json::Value> = serde_json::from_str(json).unwrap();
        assert!(conn.nodes.is_empty());
        assert!(!conn.page_info.has_next_page);
    }

    #[test]
    fn page_info_serializes_camel_case() {
        let pi = PageInfo {
            has_next_page: true,
            end_cursor: Some("abc".to_string()),
            has_previous_page: Some(false),
            start_cursor: None,
        };
        let json = serde_json::to_value(&pi).unwrap();
        assert_eq!(json["hasNextPage"], true);
        assert_eq!(json["endCursor"], "abc");
    }
}