robomotion 0.1.3

Official Rust SDK for building Robomotion RPA packages
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

//! Error types for the Robomotion runtime.

use serde::{Deserialize, Serialize};
use thiserror::Error;

/// Result type alias for Robomotion operations.
pub type Result<T> = std::result::Result<T, RobomotionError>;

/// Error type for Robomotion operations.
#[derive(Error, Debug)]
pub enum RobomotionError {
    #[error("Runtime not initialized")]
    NotInitialized,

    #[error("Node handler not found: {0}")]
    HandlerNotFound(String),

    #[error("Factory not found: {0}")]
    FactoryNotFound(String),

    #[error("Variable error: {0}")]
    Variable(String),

    #[error("Serialization error: {0}")]
    Serialization(#[from] serde_json::Error),

    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("gRPC error: {0}")]
    Grpc(#[from] tonic::Status),

    #[error("gRPC transport error: {0}")]
    Transport(#[from] tonic::transport::Error),

    #[error("OAuth error: {0}")]
    OAuth(String),

    #[error("LMO error: {0}")]
    Lmo(String),

    #[error("Compression error: {0}")]
    Compression(String),

    #[error("{code}: {message}")]
    Custom { code: String, message: String },
}

/// Structured error that can be serialized as JSON.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StructuredError {
    pub code: String,
    pub message: String,
}

impl StructuredError {
    /// Create a new structured error.
    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
        Self {
            code: code.into(),
            message: message.into(),
        }
    }
}

impl std::fmt::Display for StructuredError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match serde_json::to_string(self) {
            Ok(json) => write!(f, "{}", json),
            Err(_) => write!(f, "{}: {}", self.code, self.message),
        }
    }
}

impl std::error::Error for StructuredError {}

impl From<StructuredError> for RobomotionError {
    fn from(err: StructuredError) -> Self {
        RobomotionError::Custom {
            code: err.code,
            message: err.message,
        }
    }
}