anytype 0.3.2

An ergonomic Anytype API client in rust
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

// SPDX-FileCopyrightText: 2025-2026 Steve Schoettler
// SPDX-License-Identifier: Apache-2.0

//! Shared gRPC helpers used across the crate.

use anytype_rpc::auth::with_token;
use tonic::Request;

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

/// Trait for gRPC response error types with `code` and `description` fields.
pub(crate) trait GrpcError {
    fn code(&self) -> i32;
    fn description(&self) -> &str;
}

/// Check a gRPC response error field, returning `Err` if the code is non-zero.
pub(crate) fn ensure_error_ok<T: GrpcError>(error: Option<&T>, action: &str) -> Result<()> {
    if let Some(error) = error
        && error.code() != 0
    {
        return Err(AnytypeError::Other {
            message: format!(
                "{action} failed: {} (code {})",
                error.description(),
                error.code()
            ),
        });
    }
    Ok(())
}

/// Convert a tonic status into an [`AnytypeError`].
#[allow(clippy::needless_pass_by_value)]
pub(crate) fn grpc_status(status: tonic::Status) -> AnytypeError {
    AnytypeError::Other {
        message: format!("gRPC request failed: {status}"),
    }
}

/// Attach a bearer token to a tonic request.
pub(crate) fn with_token_request<T>(request: Request<T>, token: &str) -> Result<Request<T>> {
    with_token(request, token).map_err(|err| AnytypeError::Auth {
        message: err.to_string(),
    })
}

// ---------------------------------------------------------------------------
// GrpcError impls for every response-error type used in the crate
// ---------------------------------------------------------------------------

macro_rules! impl_grpc_error {
    ($($ty:ty),+ $(,)?) => {
        $(
            impl GrpcError for $ty {
                fn code(&self) -> i32 { self.code }
                fn description(&self) -> &str { &self.description }
            }
        )+
    };
}

// chat
use anytype_rpc::anytype::rpc::chat::{
    add_message, delete_message, edit_message_content, get_messages, get_messages_by_ids, read_all,
    read_messages, subscribe_last_messages, subscribe_to_message_previews, toggle_message_reaction,
    unread, unsubscribe, unsubscribe_from_message_previews,
};

impl_grpc_error!(
    add_message::response::Error,
    delete_message::response::Error,
    edit_message_content::response::Error,
    get_messages::response::Error,
    get_messages_by_ids::response::Error,
    read_all::response::Error,
    read_messages::response::Error,
    subscribe_last_messages::response::Error,
    subscribe_to_message_previews::response::Error,
    toggle_message_reaction::response::Error,
    unread::response::Error,
    unsubscribe::response::Error,
    unsubscribe_from_message_previews::response::Error,
);

// file
use anytype_rpc::anytype::rpc::file::{discard_preload, download, upload};

impl_grpc_error!(
    discard_preload::response::Error,
    download::response::Error,
    upload::response::Error,
);

// object
use anytype_rpc::anytype::rpc::object::{list_delete, search_with_meta};

impl_grpc_error!(
    list_delete::response::Error,
    search_with_meta::response::Error,
);

// process
use anytype_rpc::anytype::rpc::process::{
    subscribe as process_subscribe, unsubscribe as process_unsubscribe,
};

impl_grpc_error!(
    process_subscribe::response::Error,
    process_unsubscribe::response::Error,
);

// workspace
use anytype_rpc::anytype::rpc::workspace::open as workspace_open;

impl_grpc_error!(workspace_open::response::Error);