Garmelon/cove
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move functions to EuphVault and add EuphRoomVault

Browse source 
This commit moves all euph_* functions from Vault to EuphVault. The
previous EuphVault is now called EuphRoomVault and re-exports all
room-based functions from the EuphVault. It also implements MsgStore.
This commit is contained in:
Joscha 2022-09-09 18:52:54 +02:00
parent ff56bb2678
commit da2c3d86f5
9 changed files with 148 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

34
src/euph/room.rs
View file

@ -20,7 +20,7 @@ use tokio_tungstenite::tungstenite::handshake::client::Response;
use tokio_tungstenite::tungstenite::http::{header, HeaderValue};
use crate::macros::ok_or_return;
use crate::vault::{EuphVault, Vault};
use crate::vault::{EuphRoomVault, EuphVault};
const TIMEOUT: Duration = Duration::from_secs(30);
const RECONNECT_INTERVAL: Duration = Duration::from_secs(5);
@ -61,7 +61,7 @@ struct State {
username: Option<String>,
force_username: bool,
password: Option<String>,
vault: EuphVault,
vault: EuphRoomVault,
conn_tx: Option<ConnTx>,
/// `None` before any `snapshot-event`, then either `Some(None)` or
@ -107,7 +107,7 @@ impl State {
}
async fn reconnect(
vault: &EuphVault,
vault: &EuphRoomVault,
name: &str,
event_tx: &mpsc::UnboundedSender<Event>,
) -> anyhow::Result<()> {
@ -140,8 +140,8 @@ impl State {
}
}
async fn get_cookies(vault: &Vault) -> String {
let cookie_jar = vault.euph_cookies().await;
async fn get_cookies(vault: &EuphVault) -> String {
let cookie_jar = vault.cookies().await;
let cookies = cookie_jar
.iter()
.map(|c| format!("{}", c.stripped()))
@ -149,7 +149,7 @@ impl State {
cookies.join("; ")
}
fn update_cookies(vault: &Vault, response: &Response) {
fn update_cookies(vault: &EuphVault, response: &Response) {
let mut cookie_jar = CookieJar::new();
for (name, value) in response.headers() {
@ -160,10 +160,13 @@ impl State {
}
}
vault.euph_set_cookies(cookie_jar);
vault.set_cookies(cookie_jar);
}
async fn connect(vault: &EuphVault, name: &str) -> anyhow::Result<Option<(ConnTx, ConnRx)>> {
async fn connect(
vault: &EuphRoomVault,
name: &str,
) -> anyhow::Result<Option<(ConnTx, ConnRx)>> {
let uri = format!("wss://euphoria.io/room/{name}/ws?h=1");
let mut request = uri.into_client_request().expect("valid request");
let cookies = Self::get_cookies(vault.vault()).await;
@ -304,7 +307,7 @@ impl State {
if let Some(last_msg_id) = &mut self.last_msg_id {
let id = d.0.id;
self.vault
.add_message(d.0.clone(), *last_msg_id, own_user_id);
.add_msg(Box::new(d.0.clone()), *last_msg_id, own_user_id);
*last_msg_id = Some(id);
} else {
bail!("send event before snapshot event");
@ -315,7 +318,7 @@ impl State {
self.vault.join(Time::now());
self.last_msg_id = Some(d.log.last().map(|m| m.id));
let own_user_id = self.own_user_id().await;
self.vault.add_messages(d.log.clone(), None, own_user_id);
self.vault.add_msgs(d.log.clone(), None, own_user_id);
if let Some(username) = &self.username {
if self.force_username || d.nick.is_none() {
@ -325,15 +328,14 @@ impl State {
}
Data::LogReply(d) => {
let own_user_id = self.own_user_id().await;
self.vault
.add_messages(d.log.clone(), d.before, own_user_id);
self.vault.add_msgs(d.log.clone(), d.before, own_user_id);
}
Data::SendReply(d) => {
let own_user_id = self.own_user_id().await;
if let Some(last_msg_id) = &mut self.last_msg_id {
let id = d.0.id;
self.vault
.add_message(d.0.clone(), *last_msg_id, own_user_id);
.add_msg(Box::new(d.0.clone()), *last_msg_id, own_user_id);
*last_msg_id = Some(id);
} else {
bail!("send reply before snapshot event");
@ -378,7 +380,7 @@ impl State {
}
}
async fn request_logs(vault: EuphVault, conn_tx: ConnTx) -> anyhow::Result<()> {
async fn request_logs(vault: EuphRoomVault, conn_tx: ConnTx) -> anyhow::Result<()> {
let before = match vault.last_span().await {
Some((None, _)) => return Ok(()), // Already at top of room history
Some((Some(before), _)) => Some(before),
@ -457,7 +459,7 @@ pub struct Room {
impl Room {
pub fn new(
vault: EuphVault,
vault: EuphRoomVault,
username: Option<String>,
force_username: bool,
password: Option<String>,
@ -465,7 +467,7 @@ impl Room {
let (canary_tx, canary_rx) = oneshot::channel();
let (event_tx, event_rx) = mpsc::unbounded_channel();
let (euph_room_event_tx, euph_room_event_rx) = mpsc::unbounded_channel();
let ephemeral = vault.vault().ephemeral();
let ephemeral = vault.vault().vault().ephemeral();
let state = State {
name: vault.room().to_string(),

11
src/export.rs
View file

@ -6,7 +6,7 @@ mod text;
use std::fs::File;
use std::io::{BufWriter, Write};
use crate::vault::Vault;
use crate::vault::EuphVault;
#[derive(Debug, Clone, Copy, clap::ValueEnum)]
pub enum Format {
@ -60,13 +60,13 @@ pub struct Args {
out: String,
}
pub async fn export(vault: &Vault, mut args: Args) -> anyhow::Result<()> {
pub async fn export(vault: &EuphVault, mut args: Args) -> anyhow::Result<()> {
if args.out.ends_with('/') {
args.out.push_str("%r.%e");
}
let rooms = if args.all {
let mut rooms = vault.euph_rooms().await;
let mut rooms = vault.rooms().await;
rooms.sort_unstable();
rooms
} else {
@ -83,10 +83,11 @@ pub async fn export(vault: &Vault, mut args: Args) -> anyhow::Result<()> {
let out = format_out(&args.out, &room, args.format);
println!("Exporting &{room} as {} to {out}", args.format.name());
let vault = vault.room(room);
let mut file = BufWriter::new(File::create(out)?);
match args.format {
Format::Text => text::export_to_file(vault, room, &mut file).await?,
Format::Json => json::export_to_file(vault, room, &mut file).await?,
Format::Text => text::export_to_file(&vault, &mut file).await?,
Format::Json => json::export_to_file(&vault, &mut file).await?,
}
file.flush()?;
}

7
src/export/json.rs
View file

@ -1,17 +1,14 @@
use std::fs::File;
use std::io::{BufWriter, Write};
use crate::vault::Vault;
use crate::vault::EuphRoomVault;
const CHUNK_SIZE: usize = 10000;
pub async fn export_to_file(
vault: &Vault,
room: String,
vault: &EuphRoomVault,
file: &mut BufWriter<File>,
) -> anyhow::Result<()> {
let vault = vault.euph(room);
write!(file, "[")?;
let mut total = 0;

13
src/export/text.rs
View file

@ -7,27 +7,24 @@ use time::macros::format_description;
use unicode_width::UnicodeWidthStr;
use crate::euph::SmallMessage;
use crate::store::{MsgStore, Tree};
use crate::vault::Vault;
use crate::store::Tree;
use crate::vault::EuphRoomVault;
const TIME_FORMAT: &[FormatItem<'_>] =
format_description!("[year]-[month]-[day] [hour]:[minute]:[second]");
const TIME_EMPTY: &str = " ";
pub async fn export_to_file(
vault: &Vault,
room: String,
vault: &EuphRoomVault,
file: &mut BufWriter<File>,
) -> anyhow::Result<()> {
let vault = vault.euph(room);
let mut exported_trees = 0;
let mut exported_msgs = 0;
let mut tree_id = vault.first_tree_id().await;
while let Some(some_tree_id) = tree_id {
let tree = vault.tree(&some_tree_id).await;
let tree = vault.tree(some_tree_id).await;
write_tree(file, &tree, some_tree_id, 0)?;
tree_id = vault.next_tree_id(&some_tree_id).await;
tree_id = vault.next_tree_id(some_tree_id).await;
exported_trees += 1;
exported_msgs += tree.len();

4
src/main.rs
View file

@ -143,7 +143,7 @@ async fn main() -> anyhow::Result<()> {
match args.command.unwrap_or_default() {
Command::Run => run(config, &vault, args.measure_widths).await?,
Command::Export(args) => export::export(&vault, args).await?,
Command::Export(args) => export::export(&vault.euph(), args).await?,
Command::Gc => {
println!("Cleaning up and compacting vault");
println!("This may take a while...");
@ -151,7 +151,7 @@ async fn main() -> anyhow::Result<()> {
}
Command::ClearCookies => {
println!("Clearing cookies");
vault.euph_set_cookies(CookieJar::new());
vault.euph().set_cookies(CookieJar::new());
}
}

13
src/ui/euph/room.rs
View file

@ -13,7 +13,6 @@ use toss::terminal::Terminal;
use crate::config;
use crate::euph::{self, EuphRoomEvent};
use crate::macros::{ok_or_return, some_or_return};
use crate::store::MsgStore;
use crate::ui::chat::{ChatState, Reaction};
use crate::ui::input::{key, InputEvent, KeyBindingsList};
use crate::ui::widgets::border::Border;
@ -25,7 +24,7 @@ use crate::ui::widgets::padding::Padding;
use crate::ui::widgets::text::Text;
use crate::ui::widgets::BoxedWidget;
use crate::ui::UiEvent;
use crate::vault::EuphVault;
use crate::vault::EuphRoomVault;
use super::account::{self, AccountUiState};
use super::links::{self, LinksState};
@ -65,13 +64,13 @@ pub struct EuphRoom {
ui_event_tx: mpsc::UnboundedSender<UiEvent>,
vault: EuphVault,
vault: EuphRoomVault,
room: Option<euph::Room>,
state: State,
popups: VecDeque<RoomPopup>,
chat: ChatState<euph::SmallMessage, EuphVault>,
chat: ChatState<euph::SmallMessage, EuphRoomVault>,
last_msg_sent: Option<oneshot::Receiver<Snowflake>>,
nick_list: ListState<String>,
@ -80,7 +79,7 @@ pub struct EuphRoom {
impl EuphRoom {
pub fn new(
config: config::EuphRoom,
vault: EuphVault,
vault: EuphRoomVault,
ui_event_tx: mpsc::UnboundedSender<UiEvent>,
) -> Self {
Self {
@ -368,7 +367,7 @@ impl EuphRoom {
}
key!('I') => {
if let Some(id) = self.chat.cursor().await {
if let Some(msg) = self.vault.msg(&id).await {
if let Some(msg) = self.vault.msg(id).await {
self.state = State::Links(LinksState::new(&msg.content));
}
}
@ -415,7 +414,7 @@ impl EuphRoom {
if let key!('I') = event {
if let Some(id) = self.chat.cursor().await {
if let Some(msg) = self.vault.msg(&id).await {
if let Some(msg) = self.vault.msg(id).await {
self.state = State::Links(LinksState::new(&msg.content));
}
}

7
src/ui/rooms.rs
View file

@ -82,7 +82,7 @@ impl Rooms {
self.euph_rooms.entry(name.clone()).or_insert_with(|| {
EuphRoom::new(
self.config.euph_room(&name),
self.vault.euph(name),
self.vault.euph().room(name),
self.ui_event_tx.clone(),
)
})
@ -97,7 +97,8 @@ impl Rooms {
async fn stabilize_rooms(&mut self) {
let mut rooms_set = self
.vault
.euph_rooms()
.euph()
.rooms()
.await
.into_iter()
.collect::<HashSet<_>>();
@ -484,7 +485,7 @@ impl Rooms {
key!(Esc) => self.state = State::ShowList,
key!(Enter) if editor.text() == *name => {
self.euph_rooms.remove(name);
self.vault.euph(name.clone()).delete();
self.vault.euph().room(name.clone()).delete();
self.state = State::ShowList;
}
_ => {

9
src/vault.rs
View file

@ -9,7 +9,7 @@ use rusqlite::Connection;
use tokio::sync::{mpsc, oneshot};
use self::euph::EuphRequest;
pub use self::euph::EuphVault;
pub use self::euph::{EuphRoomVault, EuphVault};
enum Request {
Close(oneshot::Sender<()>),
@ -40,11 +40,8 @@ impl Vault {
let _ = rx.await;
}
pub fn euph(&self, room: String) -> EuphVault {
EuphVault {
vault: self.clone(),
room,
}
pub fn euph(&self) -> EuphVault {
EuphVault::new(self.clone())
}
}

213
src/vault/euph.rs
View file

@ -54,146 +54,114 @@ impl From<EuphRequest> for super::Request {
#[derive(Debug, Clone)]
pub struct EuphVault {
pub(super) vault: super::Vault,
pub(super) room: String,
vault: super::Vault,
}
impl EuphVault {
pub(crate) fn new(vault: super::Vault) -> Self {
Self { vault }
}
pub fn vault(&self) -> &super::Vault {
&self.vault
}
pub fn room(&self, name: String) -> EuphRoomVault {
EuphRoomVault {
vault: self.clone(),
room: name,
}
}
}
#[derive(Debug, Clone)]
pub struct EuphRoomVault {
vault: EuphVault,
room: String,
}
impl EuphRoomVault {
pub fn vault(&self) -> &EuphVault {
&self.vault
}
pub fn room(&self) -> &str {
&self.room
}
pub fn join(&self, time: Time) {
self.vault.euph_join(self.room.clone(), time);
}
pub fn delete(self) {
self.vault.euph_delete(self.room.clone());
}
pub fn add_message(
&self,
msg: Message,
prev_msg_id: Option<Snowflake>,
own_user_id: Option<UserId>,
) {
self.vault
.euph_add_msg(self.room.clone(), Box::new(msg), prev_msg_id, own_user_id);
}
pub fn add_messages(
&self,
msgs: Vec<Message>,
next_msg_id: Option<Snowflake>,
own_user_id: Option<UserId>,
) {
self.vault
.euph_add_msgs(self.room.clone(), msgs, next_msg_id, own_user_id);
}
pub async fn last_span(&self) -> Option<(Option<Snowflake>, Option<Snowflake>)> {
self.vault.euph_last_span(self.room.clone()).await
}
pub async fn full_msg(&self, id: Snowflake) -> Option<Message> {
self.vault.euph_full_msg(self.room.clone(), id).await
}
pub async fn chunk_at_offset(&self, amount: usize, offset: usize) -> Vec<Message> {
self.vault
.euph_chunk_at_offset(self.room.clone(), amount, offset)
.await
}
}
#[async_trait]
impl MsgStore<SmallMessage> for EuphVault {
impl MsgStore<SmallMessage> for EuphRoomVault {
async fn path(&self, id: &Snowflake) -> Path<Snowflake> {
self.vault.euph_path(self.room.clone(), *id).await
self.path(*id).await
}
async fn msg(&self, id: &Snowflake) -> Option<SmallMessage> {
self.vault.euph_msg(self.room.clone(), *id).await
self.msg(*id).await
}
async fn tree(&self, tree_id: &Snowflake) -> Tree<SmallMessage> {
self.vault.euph_tree(self.room.clone(), *tree_id).await
self.tree(*tree_id).await
}
async fn first_tree_id(&self) -> Option<Snowflake> {
self.vault.euph_first_tree_id(self.room.clone()).await
self.first_tree_id().await
}
async fn last_tree_id(&self) -> Option<Snowflake> {
self.vault.euph_last_tree_id(self.room.clone()).await
self.last_tree_id().await
}
async fn prev_tree_id(&self, tree_id: &Snowflake) -> Option<Snowflake> {
self.vault
.euph_prev_tree_id(self.room.clone(), *tree_id)
.await
self.prev_tree_id(*tree_id).await
}
async fn next_tree_id(&self, tree_id: &Snowflake) -> Option<Snowflake> {
self.vault
.euph_next_tree_id(self.room.clone(), *tree_id)
.await
self.next_tree_id(*tree_id).await
}
async fn oldest_msg_id(&self) -> Option<Snowflake> {
self.vault.euph_oldest_msg_id(self.room.clone()).await
self.oldest_msg_id().await
}
async fn newest_msg_id(&self) -> Option<Snowflake> {
self.vault.euph_newest_msg_id(self.room.clone()).await
self.newest_msg_id().await
}
async fn older_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
self.vault.euph_older_msg_id(self.room.clone(), *id).await
self.older_msg_id(*id).await
}
async fn newer_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
self.vault.euph_newer_msg_id(self.room.clone(), *id).await
self.newer_msg_id(*id).await
}
async fn oldest_unseen_msg_id(&self) -> Option<Snowflake> {
self.vault
.euph_oldest_unseen_msg_id(self.room.clone())
.await
self.oldest_unseen_msg_id().await
}
async fn newest_unseen_msg_id(&self) -> Option<Snowflake> {
self.vault
.euph_newest_unseen_msg_id(self.room.clone())
.await
self.newest_unseen_msg_id().await
}
async fn older_unseen_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
self.vault
.euph_older_unseen_msg_id(self.room.clone(), *id)
.await
self.older_unseen_msg_id(*id).await
}
async fn newer_unseen_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
self.vault
.euph_newer_unseen_msg_id(self.room.clone(), *id)
.await
self.newer_unseen_msg_id(*id).await
}
async fn unseen_msgs_count(&self) -> usize {
self.vault.euph_unseen_msgs_count(self.room.clone()).await
self.unseen_msgs_count().await
}
async fn set_seen(&self, id: &Snowflake, seen: bool) {
self.vault.euph_set_seen(self.room.clone(), *id, seen);
self.set_seen(*id, seen);
}
async fn set_older_seen(&self, id: &Snowflake, seen: bool) {
self.vault.euph_set_older_seen(self.room.clone(), *id, seen);
self.set_older_seen(*id, seen);
}
}
@ -201,29 +169,47 @@ trait Request {
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()>;
}
macro_rules! requests_helper {
macro_rules! requests_vault_fn {
( $var:ident : $fn:ident( $( $arg:ident : $ty:ty ),* ) ) => {
pub fn $fn(&self, $( $arg: $ty ),* ) {
pub fn $fn(&self $( , $arg: $ty )* ) {
let request = EuphRequest::$var($var { $( $arg, )* });
let _ = self.tx.send(request.into());
let _ = self.vault.tx.send(request.into());
}
};
( $var:ident : $fn:ident( $( $arg:ident : $ty:ty ),* ) -> $res:ty ) => {
pub async fn $fn(&self, $( $arg: $ty ),* ) -> $res {
pub async fn $fn(&self $( , $arg: $ty )* ) -> $res {
let (tx, rx) = oneshot::channel();
let request = EuphRequest::$var($var {
$( $arg, )*
result: tx,
});
let _ = self.tx.send(request.into());
let _ = self.vault.tx.send(request.into());
rx.await.unwrap()
}
};
}
// This doesn't match the type of the `room` argument because that's apparently
// impossible to match to `String`. See also the readme of
// https://github.com/danielhenrymantilla/rust-defile for a description of this
// phenomenon and some examples.
macro_rules! requests_room_vault_fn {
( $fn:ident ( room: $mustbestring:ty $( , $arg:ident : $ty:ty )* ) ) => {
pub fn $fn(&self $( , $arg: $ty )* ) {
self.vault.$fn(self.room.clone() $( , $arg )* );
}
};
( $fn:ident ( room: $mustbestring:ty $( , $arg:ident : $ty:ty )* ) -> $res:ty ) => {
pub async fn $fn(&self $( , $arg: $ty )* ) -> $res {
self.vault.$fn(self.room.clone() $( , $arg )* ).await
}
};
( $( $tt:tt )* ) => { };
}
macro_rules! requests {
( $(
$var:ident : $fn:ident( $( $arg:ident : $ty:ty ),* ) $( -> $res:ty )? ;
$var:ident : $fn:ident ( $( $arg:ident : $ty:ty ),* ) $( -> $res:ty )? ;
)* ) => {
$(
pub(super) struct $var {
@ -245,46 +231,51 @@ macro_rules! requests {
}
}
impl super::Vault {
$( requests_helper!($var : $fn( $( $arg: $ty ),* ) $( -> $res )? );)*
impl EuphVault {
$( requests_vault_fn!($var : $fn( $( $arg: $ty ),* ) $( -> $res )? ); )*
}
impl EuphRoomVault {
$( requests_room_vault_fn!($fn( $( $arg: $ty ),* ) $( -> $res )? ); )*
}
};
}
// TODO Rename `root` to `root_id` or `tree_id`
requests! {
// Cookies
GetCookies : euph_cookies() -> CookieJar;
SetCookies : euph_set_cookies(cookies: CookieJar);
GetCookies : cookies() -> CookieJar;
SetCookies : set_cookies(cookies: CookieJar);
// Rooms
GetRooms : euph_rooms() -> Vec<String>;
Join : euph_join(room: String, time: Time);
Delete : euph_delete(room: String);
GetRooms : rooms() -> Vec<String>;
Join : join(room: String, time: Time);
Delete : delete(room: String);
// Message
AddMsg : euph_add_msg(room: String, msg: Box<Message>, prev_msg_id: Option<Snowflake>, own_user_id: Option<UserId>);
AddMsgs : euph_add_msgs(room: String, msgs: Vec<Message>, next_msg_id: Option<Snowflake>, own_user_id: Option<UserId>);
GetLastSpan : euph_last_span(room: String) -> Option<(Option<Snowflake>, Option<Snowflake>)>;
GetPath : euph_path(room: String, id: Snowflake) -> Path<Snowflake>;
GetMsg : euph_msg(room: String, id: Snowflake) -> Option<SmallMessage>;
GetFullMsg : euph_full_msg(room: String, id: Snowflake) -> Option<Message>;
GetTree : euph_tree(room: String, root: Snowflake) -> Tree<SmallMessage>;
GetFirstTreeId : euph_first_tree_id(room: String) -> Option<Snowflake>;
GetLastTreeId : euph_last_tree_id(room: String) -> Option<Snowflake>;
GetPrevTreeId : euph_prev_tree_id(room: String, root: Snowflake) -> Option<Snowflake>;
GetNextTreeId : euph_next_tree_id(room: String, root: Snowflake) -> Option<Snowflake>;
GetOldestMsgId : euph_oldest_msg_id(room: String) -> Option<Snowflake>;
GetNewestMsgId : euph_newest_msg_id(room: String) -> Option<Snowflake>;
GetOlderMsgId : euph_older_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetNewerMsgId : euph_newer_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetOldestUnseenMsgId : euph_oldest_unseen_msg_id(room: String) -> Option<Snowflake>;
GetNewestUnseenMsgId : euph_newest_unseen_msg_id(room: String) -> Option<Snowflake>;
GetOlderUnseenMsgId : euph_older_unseen_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetNewerUnseenMsgId : euph_newer_unseen_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetUnseenMsgsCount : euph_unseen_msgs_count(room: String) -> usize;
SetSeen : euph_set_seen(room: String, id: Snowflake, seen: bool);
SetOlderSeen : euph_set_older_seen(room: String, id: Snowflake, seen: bool);
GetChunkAtOffset : euph_chunk_at_offset(room: String, amount: usize, offset: usize) -> Vec<Message>;
AddMsg : add_msg(room: String, msg: Box<Message>, prev_msg_id: Option<Snowflake>, own_user_id: Option<UserId>);
AddMsgs : add_msgs(room: String, msgs: Vec<Message>, next_msg_id: Option<Snowflake>, own_user_id: Option<UserId>);
GetLastSpan : last_span(room: String) -> Option<(Option<Snowflake>, Option<Snowflake>)>;
GetPath : path(room: String, id: Snowflake) -> Path<Snowflake>;
GetMsg : msg(room: String, id: Snowflake) -> Option<SmallMessage>;
GetFullMsg : full_msg(room: String, id: Snowflake) -> Option<Message>;
GetTree : tree(room: String, root: Snowflake) -> Tree<SmallMessage>;
GetFirstTreeId : first_tree_id(room: String) -> Option<Snowflake>;
GetLastTreeId : last_tree_id(room: String) -> Option<Snowflake>;
GetPrevTreeId : prev_tree_id(room: String, root: Snowflake) -> Option<Snowflake>;
GetNextTreeId : next_tree_id(room: String, root: Snowflake) -> Option<Snowflake>;
GetOldestMsgId : oldest_msg_id(room: String) -> Option<Snowflake>;
GetNewestMsgId : newest_msg_id(room: String) -> Option<Snowflake>;
GetOlderMsgId : older_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetNewerMsgId : newer_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetOldestUnseenMsgId : oldest_unseen_msg_id(room: String) -> Option<Snowflake>;
GetNewestUnseenMsgId : newest_unseen_msg_id(room: String) -> Option<Snowflake>;
GetOlderUnseenMsgId : older_unseen_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetNewerUnseenMsgId : newer_unseen_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
GetUnseenMsgsCount : unseen_msgs_count(room: String) -> usize;
SetSeen : set_seen(room: String, id: Snowflake, seen: bool);
SetOlderSeen : set_older_seen(room: String, id: Snowflake, seen: bool);
GetChunkAtOffset : chunk_at_offset(room: String, amount: usize, offset: usize) -> Vec<Message>;
}
impl Request for GetCookies {