Struct revolt_database::MongoDb

pub struct MongoDb(pub Client, pub String);

MongoDB implementation

Tuple Fields

0: Client

1: String

Implementations

impl MongoDb

pub fn db(&self) -> Database

Get the Revolt database

pub fn col<T>(&self, collection: &str) -> Collection<T>

Get a collection by its name

pub async fn insert_one<T: Serialize>( &self, collection: &'static str, document: T ) -> Result<InsertOneResult>

Insert one document into a collection

pub async fn count_documents( &self, collection: &'static str, projection: Document ) -> Result<u64>

Count documents by projection

pub async fn find_with_options<O, T: DeserializeOwned + Unpin + Send + Sync>( &self, collection: &'static str, projection: Document, options: O ) -> Result<Vec<T>>where O: Into<Option<FindOptions>>,

Find multiple documents in a collection with options

pub async fn find<T: DeserializeOwned + Unpin + Send + Sync>( &self, collection: &'static str, projection: Document ) -> Result<Vec<T>>

Find multiple documents in a collection

pub async fn find_one_with_options<O, T: DeserializeOwned + Unpin + Send + Sync>( &self, collection: &'static str, projection: Document, options: O ) -> Result<Option<T>>where O: Into<Option<FindOneOptions>>,

Find one document with options

pub async fn find_one<T: DeserializeOwned + Unpin + Send + Sync>( &self, collection: &'static str, projection: Document ) -> Result<Option<T>>

Find one document

pub async fn find_one_by_id<T: DeserializeOwned + Unpin + Send + Sync>( &self, collection: &'static str, id: &str ) -> Result<Option<T>>

Find one document by its ID

pub async fn update_one<P, T: Serialize>( &self, collection: &'static str, projection: Document, partial: T, remove: Vec<&dyn IntoDocumentPath>, prefix: P ) -> Result<UpdateResult>where P: Into<Option<String>>,

Update one document given a projection, partial document, and list of paths to unset

pub async fn update_one_by_id<P, T: Serialize>( &self, collection: &'static str, id: &str, partial: T, remove: Vec<&dyn IntoDocumentPath>, prefix: P ) -> Result<UpdateResult>where P: Into<Option<String>>,

Update one document given an ID, partial document, and list of paths to unset

pub async fn delete_one( &self, collection: &'static str, projection: Document ) -> Result<DeleteResult>

Delete one document by the given projection

pub async fn delete_one_by_id( &self, collection: &'static str, id: &str ) -> Result<DeleteResult>

Delete one document by the given ID

Methods from Deref<Target = Client>

pub fn selection_criteria(&self) -> Option<&SelectionCriteria>

Gets the default selection criteria the Client uses for operations..

pub fn read_concern(&self) -> Option<&ReadConcern>

Gets the default read concern the Client uses for operations.

pub fn write_concern(&self) -> Option<&WriteConcern>

Gets the default write concern the Client uses for operations.

pub fn database(&self, name: &str) -> Database

Gets a handle to a database specified by name in the cluster the Client is connected to. The Database options (e.g. read preference and write concern) will default to those of the Client.

This method does not send or receive anything across the wire to the database, so it can be used repeatedly without incurring any costs from I/O.

pub fn database_with_options( &self, name: &str, options: DatabaseOptions ) -> Database

Gets a handle to a database specified by name in the cluster the Client is connected to. Operations done with this Database will use the options specified by options by default and will otherwise default to those of the Client.

This method does not send or receive anything across the wire to the database, so it can be used repeatedly without incurring any costs from I/O.

pub fn default_database(&self) -> Option<Database>

Gets a handle to the default database specified in the ClientOptions or MongoDB connection string used to construct this Client.

If no default database was specified, None will be returned.

pub async fn list_databases( &self, filter: impl Into<Option<Document>>, options: impl Into<Option<ListDatabasesOptions>> ) -> impl Future<Output = Result<Vec<DatabaseSpecification, Global>, Error>>

Gets information about each database present in the cluster the Client is connected to.

pub async fn list_databases_with_session( &self, filter: impl Into<Option<Document>>, options: impl Into<Option<ListDatabasesOptions>>, session: &mut ClientSession ) -> impl Future<Output = Result<Vec<DatabaseSpecification, Global>, Error>>

Gets information about each database present in the cluster the Client is connected to using the provided ClientSession.

pub async fn list_database_names( &self, filter: impl Into<Option<Document>>, options: impl Into<Option<ListDatabasesOptions>> ) -> impl Future<Output = Result<Vec<String, Global>, Error>>

Gets the names of the databases present in the cluster the Client is connected to.

pub async fn start_session( &self, options: impl Into<Option<SessionOptions>> ) -> impl Future<Output = Result<ClientSession, Error>>

Starts a new ClientSession.

pub async fn watch( &self, pipeline: impl IntoIterator<Item = Document>, options: impl Into<Option<ChangeStreamOptions>> ) -> impl Future<Output = Result<ChangeStream<ChangeStreamEvent<Document>>, Error>>

Starts a new ChangeStream that receives events for all changes in the cluster. The stream does not observe changes from system collections or the “config”, “local” or “admin” databases. Note that this method (watch on a cluster) is only supported in MongoDB 4.0 or greater.

See the documentation here on change streams.

Change streams require either a “majority” read concern or no read concern. Anything else will cause a server error.

Note that using a $project stage to remove any of the _id operationType or ns fields will cause an error. The driver requires these fields to support resumability. For more information on resumability, see the documentation for ChangeStream

If the pipeline alters the structure of the returned events, the parsed type will need to be changed via ChangeStream::with_type.

pub async fn watch_with_session( &self, pipeline: impl IntoIterator<Item = Document>, options: impl Into<Option<ChangeStreamOptions>>, session: &mut ClientSession ) -> impl Future<Output = Result<SessionChangeStream<ChangeStreamEvent<Document>>, Error>>

Starts a new SessionChangeStream that receives events for all changes in the cluster using the provided ClientSession. See Client::watch for more information.

Trait Implementations

impl AbstractAttachments for MongoDb

fn insert_attachment<'life0, 'life1, 'async_trait>( &'life0 self, attachment: &'life1 File ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert attachment into database.

fn find_and_use_attachment<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, id: &'life1 str, tag: &'life2 str, parent_type: &'life3 str, parent_id: &'life4 str ) -> Pin<Box<dyn Future<Output = Result<File>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Find an attachment by its details and mark it as used by a given parent.

fn mark_attachment_as_reported<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark an attachment as having been reported.

fn mark_attachment_as_deleted<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark an attachment as having been deleted.

fn mark_attachments_as_deleted<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark multiple attachments as having been deleted.

impl AbstractBots for MongoDb

fn insert_bot<'life0, 'life1, 'async_trait>( &'life0 self, bot: &'life1 Bot ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert new bot into the database

fn fetch_bot<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Bot>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a bot by its id

fn fetch_bot_by_token<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Bot>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a bot by its token

fn fetch_bots_by_user<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Bot>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch bots owned by a user

fn get_number_of_bots_by_user<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the number of bots owned by a user

fn update_bot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, partial: &'life2 PartialBot, remove: Vec<FieldsBot> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update bot with new information

fn delete_bot<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a bot from the database

impl AbstractChannelInvites for MongoDb

fn insert_invite<'life0, 'life1, 'async_trait>( &'life0 self, invite: &'life1 Invite ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert a new invite into the database

fn fetch_invite<'life0, 'life1, 'async_trait>( &'life0 self, code: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Invite>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch an invite by the code

fn fetch_invites_for_server<'life0, 'life1, 'async_trait>( &'life0 self, server_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Invite>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all invites for a server

fn delete_invite<'life0, 'life1, 'async_trait>( &'life0 self, code: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete an invite by its code

impl AbstractChannelUnreads for MongoDb

fn acknowledge_message<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, channel_id: &'life1 str, user_id: &'life2 str, message_id: &'life3 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Acknowledge a message.

fn acknowledge_channels<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_id: &'life1 str, channel_ids: &'life2 [String] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Acknowledge many channels.

fn add_mention_to_unread<'a, 'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, channel_id: &'life1 str, user_id: &'life2 str, message_ids: &'life3 [String] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a mention.

fn fetch_unreads<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<ChannelUnread>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all channel unreads for a user.

impl AbstractChannels for MongoDb

fn insert_channel<'life0, 'life1, 'async_trait>( &'life0 self, channel: &'life1 Channel ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert a new channel in the database

fn fetch_channel<'life0, 'life1, 'async_trait>( &'life0 self, channel_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Channel>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a channel from the database

fn fetch_channels<'a, 'life0, 'async_trait>( &'life0 self, ids: &'a [String] ) -> Pin<Box<dyn Future<Output = Result<Vec<Channel>>> + Send + 'async_trait>>where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

Fetch all channels from the database

fn find_direct_messages<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Channel>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all direct messages for a user

fn add_user_to_group<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, channel: &'life1 str, user: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert a user to a group

fn set_channel_role_permission<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, channel: &'life1 str, role: &'life2 str, permissions: OverrideField ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert channel role permissions

fn find_saved_messages_channel<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Channel>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn find_direct_message_channel<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_a: &'life1 str, user_b: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Channel>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn update_channel<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, channel: &'life2 PartialChannel, remove: Vec<FieldsChannel> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn remove_user_from_group<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, channel: &'life1 str, user: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn delete_channel<'life0, 'life1, 'async_trait>( &'life0 self, channel: &'life1 Channel ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl AbstractEmojis for MongoDb

fn insert_emoji<'life0, 'life1, 'async_trait>( &'life0 self, emoji: &'life1 Emoji ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert emoji into database.

fn fetch_emoji<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Emoji>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch an emoji by its id

fn fetch_emoji_by_parent_id<'life0, 'life1, 'async_trait>( &'life0 self, parent_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Emoji>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch emoji by their parent id

fn fetch_emoji_by_parent_ids<'life0, 'life1, 'async_trait>( &'life0 self, parent_ids: &'life1 [String] ) -> Pin<Box<dyn Future<Output = Result<Vec<Emoji>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch emoji by their parent ids

fn detach_emoji<'life0, 'life1, 'async_trait>( &'life0 self, emoji: &'life1 Emoji ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Detach an emoji by its id

impl AbstractMessages for MongoDb

fn insert_message<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 Message ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert a new message into the database

fn fetch_message<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Message>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a message by its id

fn fetch_messages<'life0, 'async_trait>( &'life0 self, query: MessageQuery ) -> Pin<Box<dyn Future<Output = Result<Vec<Message>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Fetch multiple messages by given query

fn update_message<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, message: &'life2 PartialMessage ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update a given message with new information

fn append_message<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, append: &'life2 AppendMessage ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Append information to a given message

fn add_reaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, id: &'life1 str, emoji: &'life2 str, user: &'life3 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a new reaction to a message

fn remove_reaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, id: &'life1 str, emoji: &'life2 str, user: &'life3 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Remove a reaction from a message

fn clear_reaction<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, emoji: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Remove reaction from a message

fn delete_message<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a message from the database by its id

fn delete_messages<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, channel: &'life1 str, ids: &'life2 [String] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete messages from a channel by their ids and corresponding channel id

impl AbstractMigrations for MongoDb

fn migrate_database<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<(), ()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Migrate the database

impl AbstractRatelimitEvents for MongoDb

fn insert_ratelimit_event<'life0, 'life1, 'async_trait>( &'life0 self, event: &'life1 RatelimitEvent ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert a new ratelimit event

fn has_ratelimited<'life0, 'life1, 'async_trait>( &'life0 self, target_id: &'life1 str, event_type: RatelimitEventType, period: Duration, count: usize ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count number of events in given duration and check if we’ve hit the limit

impl AbstractServerBans for MongoDb

fn insert_ban<'life0, 'life1, 'async_trait>( &'life0 self, ban: &'life1 ServerBan ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert new ban into database

fn fetch_ban<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, server_id: &'life1 str, user_id: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<ServerBan>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch a server ban by server and user id

fn fetch_bans<'life0, 'life1, 'async_trait>( &'life0 self, server_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<ServerBan>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all bans in a server

fn delete_ban<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 MemberCompositeKey ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a ban from the database

impl AbstractServerMembers for MongoDb

fn insert_member<'life0, 'life1, 'async_trait>( &'life0 self, member: &'life1 Member ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert a new server member into the database

fn fetch_member<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, server_id: &'life1 str, user_id: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Member>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch a server member by their id

fn fetch_all_members<'a, 'life0, 'life1, 'async_trait>( &'life0 self, server_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Member>>> + Send + 'async_trait>>where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all members in a server

fn fetch_all_memberships<'a, 'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Member>>> + Send + 'async_trait>>where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all memberships for a user

fn fetch_members<'a, 'life0, 'life1, 'async_trait>( &'life0 self, server_id: &'life1 str, ids: &'a [String] ) -> Pin<Box<dyn Future<Output = Result<Vec<Member>>> + Send + 'async_trait>>where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch multiple members by their ids

fn fetch_member_count<'life0, 'life1, 'async_trait>( &'life0 self, server_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch member count of a server

fn fetch_server_count<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch server count of a user

fn update_member<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 MemberCompositeKey, partial: &'life2 PartialMember, remove: Vec<FieldsMember> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update information for a server member

fn delete_member<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 MemberCompositeKey ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a server member by their id

impl AbstractServers for MongoDb

fn insert_server<'life0, 'life1, 'async_trait>( &'life0 self, server: &'life1 Server ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert a new server into database

fn fetch_server<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Server>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a server by its id

fn fetch_servers<'a, 'life0, 'async_trait>( &'life0 self, ids: &'a [String] ) -> Pin<Box<dyn Future<Output = Result<Vec<Server>>> + Send + 'async_trait>>where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

Fetch a servers by their ids

fn update_server<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, partial: &'life2 PartialServer, remove: Vec<FieldsServer> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update a server with new information

fn delete_server<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a server by its id

fn insert_role<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, server_id: &'life1 str, role_id: &'life2 str, role: &'life3 Role ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Insert a new role into server object

fn update_role<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, server_id: &'life1 str, role_id: &'life2 str, partial: &'life3 PartialRole, remove: Vec<FieldsRole> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Update an existing role on a server

fn delete_role<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, server_id: &'life1 str, role_id: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a role from a server

Also updates channels and members.

impl AbstractUserSettings for MongoDb

fn fetch_user_settings<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, filter: &'life2 [String] ) -> Pin<Box<dyn Future<Output = Result<UserSettings>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch a subset of user settings

fn set_user_settings<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, settings: &'life2 UserSettings ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update a subset of user settings

fn delete_user_settings<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete all user settings

impl AbstractUsers for MongoDb

fn insert_user<'life0, 'life1, 'async_trait>( &'life0 self, user: &'life1 User ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert a new user into the database

fn fetch_user<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<User>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a user from the database

fn fetch_user_by_username<'life0, 'life1, 'async_trait>( &'life0 self, username: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<User>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a user from the database by their username

fn fetch_user_by_token<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<User>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a user from the database by their session token

fn fetch_users<'a, 'life0, 'async_trait>( &'life0 self, ids: &'a [String] ) -> Pin<Box<dyn Future<Output = Result<Vec<User>>> + Send + 'async_trait>>where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

Fetch multiple users by their ids

fn fetch_discriminators_in_use<'life0, 'life1, 'async_trait>( &'life0 self, username: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all discriminators in use for a username

fn fetch_mutual_user_ids<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_a: &'life1 str, user_b: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch ids of users that both users are friends with

fn fetch_mutual_channel_ids<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_a: &'life1 str, user_b: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch ids of channels that both users are in

fn fetch_mutual_server_ids<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_a: &'life1 str, user_b: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch ids of servers that both users share

fn update_user<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, partial: &'life2 PartialUser, remove: Vec<FieldsUser> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update a user by their id given some data

fn set_relationship<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, user_id: &'life1 str, target_id: &'life2 str, relationship: &'life3 RelationshipStatus ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Set relationship with another user

This should use pull_relationship if relationship is None.

fn pull_relationship<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_id: &'life1 str, target_id: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Remove relationship with another user

fn delete_user<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a user by their id

impl AbstractWebhooks for MongoDb

fn insert_webhook<'life0, 'life1, 'async_trait>( &'life0 self, webhook: &'life1 Webhook ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert new webhook into the database

fn fetch_webhook<'life0, 'life1, 'async_trait>( &'life0 self, webhook_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Webhook>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch webhook by id

fn fetch_webhooks_for_channel<'life0, 'life1, 'async_trait>( &'life0 self, channel_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Webhook>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch webhooks for channel

fn update_webhook<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, webhook_id: &'life1 str, partial: &'life2 PartialWebhook, remove: &'life3 [FieldsWebhook] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Update webhook with new information

fn delete_webhook<'life0, 'life1, 'async_trait>( &'life0 self, webhook_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete webhook by id

impl Clone for MongoDb

fn clone(&self) -> MongoDb

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for MongoDb

type Target = Client

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl AbstractDatabase for MongoDb