use gpui::{App, Task};
use super::{
invalidate, mutation::MutationOptions, options::BoxFuture, services::task_cx, use_mutation,
Mutation, QueryKey, TaskCx,
};
use crate::Cx;
pub trait Procedure: Copy + Send + Sync + 'static {
type Input: Clone + Send + 'static;
type Output: Send + 'static;
type Error: Send + 'static;
fn run(&self, cx: TaskCx, input: Self::Input) -> BoxFuture<Result<Self::Output, Self::Error>>;
fn invalidates(&self) -> Vec<QueryKey> {
Vec::new()
}
fn mutation_options(&self) -> MutationOptions<Self::Input, Self::Output, Self::Error> {
let procedure = *self;
let name = std::any::type_name::<Self>()
.rsplit("::")
.next()
.unwrap_or("procedure");
self.invalidates().into_iter().fold(
MutationOptions::new(move |cx, input| procedure.run(cx, input))
.key(crate::query_key![name]),
MutationOptions::invalidates,
)
}
fn call(
&self,
cx: &mut App,
input: Self::Input,
) -> Task<Result<Self::Output, Option<Self::Error>>> {
let running = crate::runtime::spawn(self.run(task_cx(cx), input));
let invalidates = self.invalidates();
cx.spawn(async move |cx| {
let result = running.await.map_err(|_| None)?;
if result.is_ok() {
cx.update(|cx| {
for prefix in &invalidates {
invalidate(cx, prefix);
}
})
.ok();
}
result.map_err(Some)
})
}
}
#[track_caller]
pub fn use_procedure<P: Procedure>(
cx: &mut Cx,
procedure: P,
) -> Mutation<P::Input, P::Output, P::Error> {
use_mutation(cx, procedure.mutation_options())
}