Asynchronous client for Misskey.

We provide four components in this crate:

• Clients that handles the connection between Misskey. As Misskey provides HTTP and WebSocket interfaces to interact with, we have [HttpClient] and [WebSocketClient] implementations correspondingly.
• API bindings, including requests/responses of [endpoints][endpoint] and messages on [channels][streaming::channel].
• Abstraction that connects API datatypes and client implementations: [Request][endpoint::Request], [ConnectChannelRequest][streaming::ConnectChannelRequest], etc.
• High-level API for easier handling of various functionalities: [ClientExt] and others.

Examples

Create a note:

use misskey::prelude::*;
use misskey::HttpClient;

# #[tokio::main]
# async fn main() -> anyhow::Result<()> {
let client = HttpClient::builder("https://your.instance.example/api/")
.token("API_TOKEN")
.build()?;

client.create_note("Hello, Misskey").await?;
# Ok(())
# }

Automatically follow-back:

use futures::stream::TryStreamExt;
use misskey::prelude::*;
use misskey::streaming::channel::main::MainStreamEvent;
use misskey::WebSocketClient;

# #[tokio::main]
# async fn main() -> anyhow::Result<()> {
let client = WebSocketClient::builder("wss://your.instance.example/streaming")
.token("YOUR_API_TOKEN")
.connect()
.await?;

// Connect to the main stream.
// The main stream is a channel that streams events about the connected account.
let mut stream = client.main_stream().await?;

// Wait for the next event in the main stream.
while let Some(event) = stream.try_next().await? {
match event {
// Check if the event is 'followed' and the user is not a bot
MainStreamEvent::Followed(user) if !user.is_bot => {
println!("followed from @{}", user.username);

// Follow back `user` if you haven't already.
if !client.is_following(&user).await? {
client.follow(&user).await?;
}
}
// other events are just ignored here
_ => {}
}
}
# Ok(())
# }

See the example directory for more examples.

Feature flags

• http-client: Enables the HTTP client which is capable for uploading files. Enabled by default.
• websocket-client: Enables the WebSocket client which is capable for streaming. Enabled by default.
• tokio-runtime: Use the tokio v0.3 runtime in the WebSocket client. Enabled by default.
• tokio02-runtime: Use the tokio v0.2 runtime in the WebSocket client.
• async-std-runtime: Use the async-std runtime in the WebSocket client.
• aid: Assume that the aid ID generation method is used in the targeted Misskey instance. Enabled by default.
• meid: Assume that the meid ID generation method is used in the targeted Misskey instance.
• ulid: Assume that the ulid ID generation method is used in the targeted Misskey instance.
• objectid: Assume that the objectid ID generation method is used in the targeted Misskey instance.
• and version flags, as described in version flags section.

Specifying Misskey version

We have a set of feature flags to specify the targeted Misskey version. The latest one (12-63-0) is enabled as a default. You can opt-in to compile for prior Misskey version by using default-features = false and the corresponding feature flag.

For example, to compile for Misskey v12.33.0 with WebSocket client on async-std runtime, add the following to your Cargo.toml file:

[dependencies.misskey]
version = "0.2"
default-features = false
features = ["12-31-0", "websocket-client", "async-std-runtime", "aid"]