dink-sdk 0.3.1

Rust SDK for Dink edge mesh platform — JSON-over-NATS RPC for IoT and edge computing
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

use serde::{Deserialize, Serialize};

use crate::error::{DinkError, Result};

/// Platform (management) response envelope.
/// `{"success": true, "data": <T>}` or `{"success": false, "error": {...}}`
#[derive(Debug, Deserialize)]
pub struct PlatformResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub error: Option<ErrorInfo>,
}

/// Service (edge→caller) response envelope.
/// `{"result": <T>, "success": true}` or `{"success": false, "error": {...}}`
#[derive(Debug, Deserialize)]
pub struct ServiceResponse<T> {
    pub success: Option<bool>,
    pub result: Option<T>,
    pub error: Option<ErrorInfo>,
}

/// Error detail included in both platform and service error responses.
#[derive(Debug, Deserialize, Clone)]
pub struct ErrorInfo {
    pub code: String,
    pub message: String,
}

/// Stream initiation request sent to a `.stream` subject.
/// `{"reply_subject": "<inbox>", "data": <req>}`
#[derive(Debug, Serialize)]
pub struct StreamRequest<T: Serialize> {
    pub reply_subject: String,
    pub data: T,
}

/// Ack returned by the edge when it begins streaming.
/// `{"status": "streaming", "cancelSubject": "..."}`
#[derive(Debug, Deserialize)]
pub struct StreamAck {
    pub status: Option<String>,
    #[serde(rename = "cancelSubject")]
    pub cancel_subject: Option<String>,
}

/// Parse a platform (management) response envelope, extracting the `data` field on success.
pub fn parse_platform_response<T: serde::de::DeserializeOwned>(data: &[u8]) -> Result<T> {
    let resp: PlatformResponse<T> = serde_json::from_slice(data)?;
    if resp.success {
        resp.data
            .ok_or_else(|| DinkError::Nats("empty response data".into()))
    } else {
        let err = resp.error.unwrap_or(ErrorInfo {
            code: "UNKNOWN".into(),
            message: "unknown error".into(),
        });
        Err(DinkError::Service {
            service: String::new(),
            method: String::new(),
            code: err.code,
            message: err.message,
        })
    }
}

/// Parse a service (edge) response envelope, extracting the `result` field on success.
///
/// Falls back to deserializing the raw bytes as `T` when neither `result` nor an explicit
/// error is present (some services return bare JSON).
pub fn parse_service_response<T: serde::de::DeserializeOwned>(data: &[u8]) -> Result<T> {
    let resp: ServiceResponse<T> = serde_json::from_slice(data)?;
    if let Some(false) = resp.success {
        let err = resp.error.unwrap_or(ErrorInfo {
            code: "UNKNOWN".into(),
            message: "unknown error".into(),
        });
        return Err(DinkError::Service {
            service: String::new(),
            method: String::new(),
            code: err.code,
            message: err.message,
        });
    }
    if let Some(result) = resp.result {
        return Ok(result);
    }
    // Fallback: try parsing raw bytes as T (bare JSON response).
    serde_json::from_slice(data).map_err(Into::into)
}