サービスビルダー

use wakuwaku::ServiceBuilder;

#[derive(Clone)]
pub struct AppConfig {
    pub grpc_addr: SocketAddr,
}

pub fn basics() {
    let services = ServiceBuilder::new(AppConfig { grpc_addr: "[::]:50051".parse().unwrap() })
        .push(AccountStore::default())
        .push(Mailer::default());

    let config: &AppConfig = services.provide::<AppConfig, _>();
    let mailer: &Mailer = services.provide::<Mailer, _>();
    let _ = (config, mailer);
}

ServiceBuilder<Mailer, ServiceBuilder<AccountStore, ServiceBuilder<AppConfig>>>

pub trait ServiceCreation {
    type Dep: Clone;

    fn create_service(dep: Self::Dep) -> Self;
}

pub struct ExpireSessions {
    sessions: SessionStore,
}

impl ServiceCreation for ExpireSessions {
    type Dep = SessionStore;
    fn create_service(sessions: SessionStore) -> Self {
        Self { sessions }
    }
}

/// Login sessions and when they expire.
#[derive(Clone, Default)]
pub struct SessionStore {
    expires_at: Arc<Mutex<HashMap<String, SystemTime>>>,
}

use std::time::Duration;

use wakuwaku::deps::kanau::processor::Processor;
use wakuwaku::{CronJob, CronJobInterval, CronTick};

/// Built from two registered values, so it implements no `ServiceCreation`.
pub struct SendInvoices {
    pub accounts: AccountStore,
    pub mailer: Mailer,
}

impl Processor<CronTick> for SendInvoices {
    type Output = ();
    type Error = MailError;

    async fn process(&self, _tick: CronTick) -> Result<(), MailError> {
        for account in self.accounts.with_open_invoices() {
            self.mailer.send_invoice(&account).await?;
        }
        Ok(())
    }
}

impl CronJob for SendInvoices {
    const INTERVAL: CronJobInterval = CronJobInterval::AfterFinish(Duration::from_secs(60 * 60));
}

let (_services, cron) = ServiceBuilder::new(AccountStore::default())
    .push(SessionStore::default())
    .push(Mailer::default())
    .cron_job::<ExpireSessions, _>()
    .compose_cron_job(|s| SendInvoices {
        accounts: s.provide::<AccountStore, _>().clone(),
        mailer: s.provide::<Mailer, _>().clone(),
    })
    .start();

/// Account queries on top of the store.
#[derive(Clone)]
pub struct AccountRepo {
    store: AccountStore,
}

impl ServiceCreation for AccountRepo {
    type Dep = AccountStore;
    fn create_service(store: AccountStore) -> Self {
        Self { store }
    }
}

/// Billing logic shared by several components. Cheap to clone: it holds handles.
#[derive(Clone)]
pub struct Billing {
    accounts: AccountRepo,
    mailer: Mailer,
}

let services = ServiceBuilder::new(AccountStore::default())
    .push(Mailer::default())
    // From one registered dependency, through `ServiceCreation`.
    .construct_subservice::<AccountRepo, _>()
    // From several, through a closure.
    .compose_subservice(|s| Billing {
        accounts: s.provide::<AccountRepo, _>().clone(),
        mailer: s.provide::<Mailer, _>().clone(),
    });

// Both jobs implement `ServiceCreation` with `type Dep = Billing`.
let (_services, cron) = services
    .cron_job::<CloseBillingPeriod, _>()
    .cron_job::<RemindOverdue, _>()
    .start();

let services = ServiceBuilder::new(AccountStore::default())
    .push(SessionStore::default())
    .push(AuditLog::default())
    .push(Mailer::default());

let (services, consumers) = services
    .iggy_consumer::<SendWelcomeMail, _, _>()
    .start(iggy.clone(), ConsumerConfig::new("shop", "accounts", vec![0]))
    .await?;

let (services, add_grpc) = services
    .grpc_service::<AccountsServer<_>, AccountsService, _>(AccountsServer::new)
    .compose_grpc_service(|s| {
        AdminServer::new(AdminService {
            store: s.provide::<AccountStore, _>().clone(),
            audit: s.provide::<AuditLog, _>().clone(),
        })
    })
    .into_router_fn();

let (_services, cron) = services.cron_job::<ExpireSessions, _>().start();

use wakuwaku::services::builder::{Here, There};

#[derive(Clone)]
pub struct HttpClient {
    pub base_url: &'static str,
}

let services = ServiceBuilder::new(HttpClient { base_url: "https://payments.example" })
    .push(HttpClient { base_url: "https://mail.example" });

// `Here` is the most recent push; each `There` steps one push back.
let mail = services.provide::<HttpClient, Here>();
let payments = services.provide::<HttpClient, There<Here>>();

let (_services, cron) = ServiceBuilder::new(HttpClient { base_url: "https://payments.example" })
    .push(HttpClient { base_url: "https://mail.example" })
    .cron_job::<PingPayments, There<Here>>() // the payments client
    .start();

#[derive(Clone)]
pub struct PaymentsClient(pub HttpClient);

#[derive(Clone)]
pub struct MailClient(pub HttpClient);

let services = ServiceBuilder::new(PaymentsClient(HttpClient { base_url: "https://payments.example" }))
    .push(MailClient(HttpClient { base_url: "https://mail.example" }));

let payments = services.provide::<PaymentsClient, _>();

use wakuwaku::services::builder::{ProvideAt, ServiceBuilderPosition};

/// Works with any builder that has exactly one `AppConfig` somewhere in it.
pub fn grpc_addr<S, I>(services: &S) -> SocketAddr
where
    S: ProvideAt<AppConfig, I>,
    I: ServiceBuilderPosition,
{
    services.provide_at().grpc_addr
}

/// Registers the session infrastructure on top of any builder.
pub fn with_sessions<H, C>(
    services: ServiceBuilder<H, C>,
) -> ServiceBuilder<Mailer, ServiceBuilder<SessionStore, ServiceBuilder<H, C>>> {
    services.push(SessionStore::default()).push(Mailer::default())
}

let services = with_sessions(ServiceBuilder::new(AppConfig {
    grpc_addr: "[::]:50051".parse().unwrap(),
}));
let addr = grpc_addr(&services);

let (_services, cron) = ServiceBuilder::new(Mailer) // no SessionStore registered
    .cron_job::<ExpireSessions, _>()
    .start();

error[E0277]: the trait bound `(): ProvideAt<SessionStore, _>` is not satisfied
   |
37 |         .cron_job::<ExpireSessions, _>()
   |          ^^^^^^^^ the trait `ProvideAt<SessionStore, _>` is not implemented for `()`
   |
   = note: required for `ServiceBuilder<Mailer>` to implement `ProvideAt<SessionStore, There<_>>`
note: required by a bound in `ServiceBuilder::<Head, Chain>::cron_job`

#[derive(Clone)]
struct Db(&'static str);

let services = ServiceBuilder::new(Db("primary")).push(Db("replica"));
let _db: &Db = services.provide::<Db, _>();

error[E0283]: type annotations needed
  |
8 |     let _db: &Db = services.provide::<Db, _>();
  |                             -------       ^ cannot infer type of the type parameter `I` declared on the method `provide`
  |
  = note: multiple `impl`s satisfying `ServiceBuilder<Db, ServiceBuilder<Db>>: ProvideAt<Db, _>` found in the `wakuwaku` crate:
          - impl<Head, T, Chain, I> ProvideAt<T, There<I>> for ServiceBuilder<Head, Chain>
          - impl<T, Chain> ProvideAt<T, Here> for ServiceBuilder<T, Chain>;