che-rest 0.4.0

Typed REST framework and project tooling for che-orm applications
Documentation
use std::{any::Any, future::Future, path::Path, pin::Pin, sync::Arc};

use che_orm::Database;

use crate::{AppConfig, AppResult, auth::User};
use crate::{app_channels::AppChannels, channels::Channels, signals::SignalBus};

pub type CurrentUserResolver = Arc<
    dyn for<'a> Fn(
            &'a AppState,
            &'a User,
        ) -> Pin<
            Box<dyn Future<Output = AppResult<Option<Arc<dyn Any + Send + Sync>>>> + Send + 'a>,
        > + Send
        + Sync,
>;

#[derive(Clone)]
pub struct AppState {
    pub config: AppConfig,
    database: Database,
    app_channels: AppChannels,
    signals: SignalBus,
    current_user_resolver: Option<CurrentUserResolver>,
    pub(crate) sync_effects_lock: Arc<tokio::sync::Mutex<()>>,
    pub(crate) sync_lifecycle: Arc<
        std::sync::RwLock<
            std::collections::HashMap<String, Vec<Arc<dyn crate::sync::SyncLifecycle>>>,
        >,
    >,
}

impl AppState {
    pub fn from_database(database: Database) -> Self {
        Self {
            config: AppConfig::default(),
            database,
            app_channels: AppChannels::new(),
            signals: SignalBus::new(),
            current_user_resolver: None,
            sync_effects_lock: Arc::default(),
            sync_lifecycle: Arc::default(),
        }
    }

    pub async fn from_config_file(path: impl AsRef<Path>) -> AppResult<Self> {
        let config = AppConfig::from_file(path)?;
        let database = config.database.connect().await?;
        Ok(Self {
            config,
            database,
            app_channels: AppChannels::new(),
            signals: SignalBus::new(),
            current_user_resolver: None,
            sync_effects_lock: Arc::default(),
            sync_lifecycle: Arc::default(),
        })
    }

    pub fn database(&self) -> &Database {
        &self.database
    }

    /// Replace the database handle while preserving configuration and application services.
    pub fn with_database(mut self, database: Database) -> Self {
        self.database = database;
        self
    }

    pub fn channels(&self) -> &Channels {
        &self.signals
    }

    pub fn app_channels(&self) -> &AppChannels {
        &self.app_channels
    }

    pub fn signals(&self) -> &SignalBus {
        &self.signals
    }

    pub fn with_current_user_resolver<T, F>(mut self, resolver: F) -> Self
    where
        T: Send + Sync + 'static,
        F: for<'a> Fn(&'a AppState, &'a User) -> CurrentUserResolverFuture<'a, T>
            + Send
            + Sync
            + 'static,
    {
        self.current_user_resolver = Some(Arc::new(move |state, user| {
            let future = resolver(state, user);
            Box::pin(async move {
                future
                    .await
                    .map(|user| user.map(|user| Arc::new(user) as Arc<dyn Any + Send + Sync>))
            })
        }));
        self
    }

    pub(crate) async fn resolve_current_user(
        &self,
        user: &User,
    ) -> AppResult<Option<Arc<dyn Any + Send + Sync>>> {
        match &self.current_user_resolver {
            Some(resolver) => resolver(self, user).await,
            None => Ok(None),
        }
    }
}

pub type CurrentUserResolverFuture<'a, T> =
    Pin<Box<dyn Future<Output = AppResult<Option<T>>> + Send + 'a>>;