slack-rs 0.1.70

A Slack CLI tool with OAuth authentication, profile management, and API access
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

//! Unified output envelope for all commands
//!
//! Provides a consistent output structure with response and metadata

use serde::{Deserialize, Serialize};
use serde_json::Value;

/// Unified command response with envelope
#[derive(Debug, Serialize, Deserialize)]
pub struct CommandResponse {
    /// Schema version for introspection
    #[serde(rename = "schemaVersion")]
    pub schema_version: u32,

    /// Response type identifier for introspection
    #[serde(rename = "type")]
    pub response_type: String,

    /// Indicates if the operation was successful
    pub ok: bool,

    /// Original API response
    pub response: Value,

    /// Execution metadata
    pub meta: CommandMeta,
}

/// Command execution metadata
#[derive(Debug, Serialize, Deserialize)]
pub struct CommandMeta {
    pub profile_name: Option<String>,
    pub team_id: String,
    pub user_id: String,
    pub method: String,
    pub command: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub token_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub idempotency_key: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub idempotency_status: Option<String>,
}

impl CommandResponse {
    /// Create a new command response with metadata
    pub fn new(
        response: Value,
        profile_name: Option<String>,
        team_id: String,
        user_id: String,
        method: String,
        command: String,
    ) -> Self {
        // Extract 'ok' from Slack API response if present
        let ok = response
            .as_object()
            .and_then(|obj| obj.get("ok"))
            .and_then(|v| v.as_bool())
            .unwrap_or(true);

        // Generate type from method (e.g., "conversations.list" -> "conversations.list")
        let response_type = method.clone();

        Self {
            schema_version: 1,
            response_type,
            ok,
            response,
            meta: CommandMeta {
                profile_name,
                team_id,
                user_id,
                method,
                command,
                token_type: None,
                idempotency_key: None,
                idempotency_status: None,
            },
        }
    }

    /// Create a new command response with metadata including token type
    pub fn with_token_type(
        response: Value,
        profile_name: Option<String>,
        team_id: String,
        user_id: String,
        method: String,
        command: String,
        token_type: Option<String>,
    ) -> Self {
        // Extract 'ok' from Slack API response if present
        let ok = response
            .as_object()
            .and_then(|obj| obj.get("ok"))
            .and_then(|v| v.as_bool())
            .unwrap_or(true);

        // Generate type from method (e.g., "conversations.list" -> "conversations.list")
        let response_type = method.clone();

        Self {
            schema_version: 1,
            response_type,
            ok,
            response,
            meta: CommandMeta {
                profile_name,
                team_id,
                user_id,
                method,
                command,
                token_type,
                idempotency_key: None,
                idempotency_status: None,
            },
        }
    }

    /// Set idempotency metadata
    pub fn with_idempotency(mut self, key: String, status: String) -> Self {
        self.meta.idempotency_key = Some(key);
        self.meta.idempotency_status = Some(status);
        self
    }
}