use crate::action::{flatten_display_errors, run_guarded, GuardedFuture};
use crate::signal::{create_effect, create_signal, untrack, ReadSignal, WriteSignal};
use std::cell::Cell;
use std::future::Future;
use std::rc::Rc;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ResourceState {
Pending,
Ready,
Error(String),
}
impl ResourceState {
pub fn is_ready(&self) -> bool {
matches!(self, ResourceState::Ready)
}
pub fn is_pending(&self) -> bool {
matches!(self, ResourceState::Pending)
}
pub fn is_error(&self) -> bool {
matches!(self, ResourceState::Error(_))
}
}
pub struct Resource<S, T: 'static> {
state: ReadSignal<ResourceState>,
set_state: WriteSignal<ResourceState>,
value: ReadSignal<Option<T>>,
set_value: WriteSignal<Option<T>>,
source: Rc<dyn Fn() -> S>,
fetcher: Rc<dyn Fn(S) -> GuardedFuture<T>>,
generation: Rc<Cell<u64>>,
suspense: Option<crate::suspense::SourceHandle>,
}
impl<S, T: 'static> Clone for Resource<S, T> {
fn clone(&self) -> Self {
Self {
state: self.state.clone(),
set_state: self.set_state.clone(),
value: self.value.clone(),
set_value: self.set_value.clone(),
source: self.source.clone(),
fetcher: self.fetcher.clone(),
generation: self.generation.clone(),
suspense: self.suspense.clone(),
}
}
}
impl<S, T> Resource<S, T>
where
S: 'static,
T: Clone + 'static,
{
pub fn state(&self) -> ReadSignal<ResourceState> {
self.state.clone()
}
pub fn value(&self) -> ReadSignal<Option<T>> {
self.value.clone()
}
pub fn refetch(&self) {
let input = untrack(|| (self.source)());
self.fetch(input);
}
fn fetch(&self, input: S) {
let set_state = self.set_state.clone();
let set_value = self.set_value.clone();
run_guarded(
&self.generation,
|| self.set_state.set(ResourceState::Pending),
|| (self.fetcher)(input),
move |outcome| match outcome {
Ok(value) => {
set_value.set(Some(value));
set_state.set(ResourceState::Ready);
}
Err(message) => set_state.set(ResourceState::Error(message)),
},
);
}
}
impl<S, T> Resource<S, T>
where
S: 'static,
T: Clone + Send + 'static,
{
pub fn with_server_loader<L, Fut, E>(self, loader: L) -> Self
where
L: FnOnce() -> Fut,
Fut: Future<Output = Result<T, E>> + Send + 'static,
E: std::fmt::Display + 'static,
{
#[cfg(not(target_arch = "wasm32"))]
{
let already_loaded = untrack(|| self.value.with(Option::is_some));
if !already_loaded && crate::render_stream::stream_active() {
let future = loader();
let set_state = self.set_state.clone();
let set_value = self.set_value.clone();
let registered = crate::render_stream::register_server_loader(
async move { future.await.map_err(|error| error.to_string()) },
move |outcome: Result<T, String>| match outcome {
Ok(value) => {
set_value.set(Some(value));
set_state.set(ResourceState::Ready);
}
Err(message) => set_state.set(ResourceState::Error(message)),
},
);
if registered {
if let Some(handle) = &self.suspense {
handle.mark_streamable();
}
}
}
}
#[cfg(target_arch = "wasm32")]
let _ = loader;
self
}
}
pub fn create_resource<S, T, Src, F, Fut, E>(source: Src, fetcher: F) -> Resource<S, T>
where
S: 'static,
T: Clone + 'static,
Src: Fn() -> S + 'static,
F: Fn(S) -> Fut + 'static,
Fut: Future<Output = Result<T, E>> + 'static,
E: std::fmt::Display + 'static,
{
build(None, source, fetcher)
}
pub fn create_resource_with_initial<S, T, Src, F, Fut, E>(
initial: Option<T>,
source: Src,
fetcher: F,
) -> Resource<S, T>
where
S: 'static,
T: Clone + 'static,
Src: Fn() -> S + 'static,
F: Fn(S) -> Fut + 'static,
Fut: Future<Output = Result<T, E>> + 'static,
E: std::fmt::Display + 'static,
{
build(initial, source, fetcher)
}
fn build<S, T, Src, F, Fut, E>(initial: Option<T>, source: Src, fetcher: F) -> Resource<S, T>
where
S: 'static,
T: Clone + 'static,
Src: Fn() -> S + 'static,
F: Fn(S) -> Fut + 'static,
Fut: Future<Output = Result<T, E>> + 'static,
E: std::fmt::Display + 'static,
{
let has_initial = initial.is_some();
let (state, set_state) = create_signal(if has_initial {
ResourceState::Ready
} else {
ResourceState::Pending
});
let (value, set_value) = create_signal(initial);
let suspense = crate::suspense::use_suspense().map(|boundary| {
let state = state.clone();
let value = value.clone();
boundary.register(move || state.get().is_pending() && value.with(Option::is_none))
});
let resource = Resource {
state,
set_state,
value,
set_value,
source: Rc::new(source),
fetcher: flatten_display_errors(fetcher),
generation: Rc::new(Cell::new(0)),
suspense,
};
let tracked = resource.clone();
let first_run = Cell::new(true);
create_effect(move || {
let input = (tracked.source)();
if first_run.replace(false) && has_initial {
return;
}
tracked.fetch(input);
});
resource
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_resource_without_initial_renders_pending_on_the_server() {
let (id, _set_id) = create_signal(1u32);
let resource =
create_resource(move || id.get(), |n: u32| async move { Ok::<_, String>(n) });
assert!(resource.state().get().is_pending());
assert_eq!(resource.value().get(), None);
}
#[test]
fn a_resource_with_initial_renders_ready_on_the_server() {
let (id, _set_id) = create_signal(1u32);
let resource = create_resource_with_initial(
Some(42u32),
move || id.get(),
|n: u32| async move { Ok::<_, String>(n) },
);
assert!(resource.state().get().is_ready());
assert_eq!(resource.value().get(), Some(42));
}
#[test]
fn source_changes_and_refetch_are_inert_on_the_server() {
let (id, set_id) = create_signal(1u32);
let resource = create_resource_with_initial(
Some(10u32),
move || id.get(),
|n: u32| async move { Ok::<_, String>(n) },
);
set_id.set(2);
set_id.set(3);
resource.refetch();
assert!(
resource.state().get().is_ready(),
"no executor means no fetch: state must not move to Pending"
);
assert_eq!(resource.value().get(), Some(10));
}
#[test]
fn clones_share_the_same_signals() {
let (id, _set_id) = create_signal(1u32);
let resource = create_resource_with_initial(
Some(5u32),
move || id.get(),
|n: u32| async move { Ok::<_, String>(n) },
);
let observer = resource.clone();
assert!(observer.state().get().is_ready());
assert_eq!(observer.value().get(), Some(5));
}
#[test]
fn a_none_initial_behaves_like_no_initial() {
let (id, _set_id) = create_signal(1u32);
let resource = create_resource_with_initial(
None::<u32>,
move || id.get(),
|n: u32| async move { Ok::<_, String>(n) },
);
assert!(resource.state().get().is_pending());
assert_eq!(resource.value().get(), None);
}
}