Lines
96.71 %
Functions
59.52 %
Branches
100 %
use std::{ops::Deref, sync::Arc};
use async_trait::async_trait;
use bonsaidb_core::{
circulate::Message,
connection::{AccessPolicy, QueryKey, Range, Sort},
document::OwnedDocument,
keyvalue::KeyValue,
pubsub::{PubSub, Subscriber},
schema::{self, view::map::MappedDocuments, Collection, Map, MappedValue, SerializedView},
transaction::Transaction,
};
use bonsaidb_local::Database;
use crate::{Backend, CustomServer, NoBackend};
/// A database belonging to a [`CustomServer`].
pub struct ServerDatabase<B: Backend = NoBackend> {
pub(crate) server: CustomServer<B>,
pub(crate) db: Database,
}
impl<B: Backend> Deref for ServerDatabase<B> {
type Target = Database;
fn deref(&self) -> &Self::Target {
&self.db
/// Uses `CustomServer`'s `PubSub` relay.
#[async_trait]
impl<B: Backend> PubSub for ServerDatabase<B> {
type Subscriber = ServerSubscriber<B>;
async fn create_subscriber(&self) -> Result<Self::Subscriber, bonsaidb_core::Error> {
Ok(self
.server
.create_subscriber(self.db.name().to_string())
.await)
async fn publish<S: Into<String> + Send, P: serde::Serialize + Sync>(
&self,
topic: S,
payload: &P,
) -> Result<(), bonsaidb_core::Error> {
self.server
.publish_message(self.db.name(), &topic.into(), pot::to_vec(payload)?)
.await;
Ok(())
async fn publish_to_all<P: serde::Serialize + Sync>(
topics: Vec<String>,
.publish_serialized_to_all(self.db.name(), &topics, pot::to_vec(payload)?)
/// A `PubSub` subscriber for a [`CustomServer`].
pub struct ServerSubscriber<B: Backend> {
/// The unique ID of this subscriber.
pub id: u64,
pub(crate) database: String,
pub(crate) receiver: flume::Receiver<Arc<Message>>,
impl<B: Backend> Subscriber for ServerSubscriber<B> {
async fn subscribe_to<S: Into<String> + Send>(
.subscribe_to(self.id, &self.database, topic)
.await
async fn unsubscribe_from(&self, topic: &str) -> Result<(), bonsaidb_core::Error> {
.unsubscribe_from(self.id, &self.database, topic)
fn receiver(&self) -> &'_ flume::Receiver<Arc<Message>> {
&self.receiver
/// Pass-through implementation
impl<B: Backend> bonsaidb_core::connection::Connection for ServerDatabase<B> {
async fn get<C: Collection>(
id: u64,
) -> Result<Option<OwnedDocument>, bonsaidb_core::Error> {
self.db.get::<C>(id).await
async fn get_multiple<C: Collection>(
ids: &[u64],
) -> Result<Vec<OwnedDocument>, bonsaidb_core::Error> {
self.db.get_multiple::<C>(ids).await
async fn list<C: schema::Collection, R: Into<Range<u64>> + Send>(
ids: R,
order: Sort,
limit: Option<usize>,
self.db.list::<C, R>(ids, order, limit).await
async fn query<V: SerializedView>(
key: Option<QueryKey<V::Key>>,
access_policy: AccessPolicy,
) -> Result<Vec<Map<V::Key, V::Value>>, bonsaidb_core::Error>
where
Self: Sized,
{
self.db.query::<V>(key, order, limit, access_policy).await
async fn query_with_docs<V: SerializedView>(
) -> Result<MappedDocuments<OwnedDocument, V>, bonsaidb_core::Error>
self.db
.query_with_docs::<V>(key, order, limit, access_policy)
async fn reduce<V: SerializedView>(
) -> Result<V::Value, bonsaidb_core::Error>
self.db.reduce::<V>(key, access_policy).await
async fn reduce_grouped<V: SerializedView>(
) -> Result<Vec<MappedValue<V::Key, V::Value>>, bonsaidb_core::Error>
self.db.reduce_grouped::<V>(key, access_policy).await
async fn delete_docs<V: SerializedView>(
) -> Result<u64, bonsaidb_core::Error>
self.db.delete_docs::<V>(key, access_policy).await
async fn apply_transaction(
transaction: Transaction,
) -> Result<Vec<bonsaidb_core::transaction::OperationResult>, bonsaidb_core::Error> {
self.db.apply_transaction(transaction).await
async fn list_executed_transactions(
starting_id: Option<u64>,
result_limit: Option<usize>,
) -> Result<Vec<bonsaidb_core::transaction::Executed>, bonsaidb_core::Error> {
.list_executed_transactions(starting_id, result_limit)
async fn last_transaction_id(&self) -> Result<Option<u64>, bonsaidb_core::Error> {
self.db.last_transaction_id().await
async fn compact_collection<C: schema::Collection>(&self) -> Result<(), bonsaidb_core::Error> {
self.db.compact_collection::<C>().await
async fn compact(&self) -> Result<(), bonsaidb_core::Error> {
self.db.compact().await
async fn compact_key_value_store(&self) -> Result<(), bonsaidb_core::Error> {
self.db.compact_key_value_store().await
impl<B: Backend> KeyValue for ServerDatabase<B> {
async fn execute_key_operation(
op: bonsaidb_core::keyvalue::KeyOperation,
) -> Result<bonsaidb_core::keyvalue::Output, bonsaidb_core::Error> {
self.db.execute_key_operation(op).await