leash-sdk 0.4.0

Rust SDK for the Leash platform — unified async client for auth, env, and integrations.
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

//! Typed integration namespaces — Gmail, Calendar, Drive, Linear, plus the
//! generic [`Provider`] escape hatch for providers without typed wrappers yet
//! (Slack, GitHub, HubSpot, …).
//!
//! Mirrors `leash.integrations` in the TS / Python / Go SDKs. Every call
//! routes through `crate::transport::Transport` which enforces the platform
//! contract (X-API-Key + Cookie only, never `Authorization: Bearer`).

mod calendar;
mod drive;
mod gmail;
mod linear;
pub mod types;

pub use calendar::Calendar;
pub use drive::Drive;
pub use gmail::Gmail;
pub use linear::Linear;

use crate::errors::Result;
use crate::transport::Transport;

/// `leash.integrations()` — typed providers plus a generic escape hatch.
#[derive(Debug, Clone)]
pub struct Integrations {
    transport: Transport,
}

impl Integrations {
    pub(crate) fn new(transport: Transport) -> Self {
        Self { transport }
    }

    /// Gmail provider.
    pub fn gmail(&self) -> Gmail {
        Gmail::new(self.transport.clone())
    }

    /// Google Calendar provider (canonical name).
    pub fn calendar(&self) -> Calendar {
        Calendar::new(self.transport.clone())
    }

    /// Alias of [`Self::calendar`] matching the TS / Python long-form name.
    pub fn google_calendar(&self) -> Calendar {
        self.calendar()
    }

    /// Google Drive provider (canonical name).
    pub fn drive(&self) -> Drive {
        Drive::new(self.transport.clone())
    }

    /// Alias of [`Self::drive`] matching the TS / Python long-form name.
    pub fn google_drive(&self) -> Drive {
        self.drive()
    }

    /// Linear provider.
    pub fn linear(&self) -> Linear {
        Linear::new(self.transport.clone())
    }

    /// Generic escape hatch — call any provider action by name.
    ///
    /// Use this for providers without typed wrappers yet (Slack, GitHub,
    /// HubSpot, Jira, Gong, Slite, BigQuery, custom MCP servers, …).
    ///
    /// ```no_run
    /// # async fn example(client: &leash_sdk::Leash) -> leash_sdk::Result<()> {
    /// let res = client
    ///     .integrations()
    ///     .provider("slack")
    ///     .call("post_message", serde_json::json!({ "channel": "#general", "text": "hi" }))
    ///     .await?;
    /// # let _ = res;
    /// # Ok(()) }
    /// ```
    pub fn provider(&self, name: impl Into<String>) -> Provider {
        Provider {
            transport: self.transport.clone(),
            name: name.into(),
        }
    }
}

/// Generic provider invoker — no typed shape, just a pass-through of action +
/// body. Returned by [`Integrations::provider`].
#[derive(Debug, Clone)]
pub struct Provider {
    transport: Transport,
    name: String,
}

impl Provider {
    /// Provider id this caller is bound to.
    pub fn name(&self) -> &str {
        &self.name
    }

    /// POST to `/api/integrations/{name}/{action}` with the given body and
    /// return the raw JSON `data` field (or the raw response when there's no
    /// envelope).
    pub async fn call(&self, action: &str, body: serde_json::Value) -> Result<serde_json::Value> {
        self.transport.integrations_call(&self.name, action, &body).await
    }
}