Skip to main content

orbital_scheduler/shared/
data_source.rs

1//! Lazy-load data source trait and fetch coordination (SC-11, SC-23).
2
3use std::collections::{HashMap, HashSet};
4use std::future::Future;
5use std::pin::Pin;
6
7use leptos::prelude::{RwSignal, Update, WithUntracked};
8use orbital_date_pickers::DateTimeRange;
9
10use crate::{EventChanges, PlannedEvent, SchedulerError};
11
12/// Cancellation token for lazy-load fetches.
13#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
14pub struct AbortSignal {
15    aborted: bool,
16}
17
18impl AbortSignal {
19    /// Returns whether this fetch has been cancelled.
20    pub fn is_aborted(self) -> bool {
21        self.aborted
22    }
23
24    /// Marks the signal as cancelled.
25    pub fn abort(&mut self) {
26        self.aborted = true;
27    }
28}
29
30type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
31
32/// Async event provider for remote lazy loading (SC-11, SC-23).
33pub trait SchedulerDataSource: Send + Sync {
34    fn get_events(
35        &self,
36        range: DateTimeRange,
37        signal: AbortSignal,
38    ) -> BoxFuture<'_, Result<Vec<PlannedEvent>, SchedulerError>>;
39
40    fn persist_events(&self, changes: EventChanges) -> BoxFuture<'_, Result<(), SchedulerError>>;
41}
42
43/// Static client events or trait-backed remote loading.
44pub enum SchedulerDataSourceMode {
45    /// Static `events` prop on product component.
46    Client(Vec<PlannedEvent>),
47    /// Trait-backed async load ([`SchedulerFeatures::LAZY_LOADING`](crate::SchedulerFeatures::LAZY_LOADING)).
48    Remote(Box<dyn SchedulerDataSource>),
49}
50
51/// Tracks lazy-fetch generations so stale responses are ignored.
52#[derive(Clone, Default)]
53pub struct LazyFetchCoordinator {
54    generation: u32,
55}
56
57impl LazyFetchCoordinator {
58    /// Start a new fetch; returns the generation id for this request.
59    pub fn begin(&mut self) -> u32 {
60        self.generation = self.generation.wrapping_add(1);
61        self.generation
62    }
63
64    /// True when `gen` is still the latest generation (response should be applied).
65    pub fn is_current(&self, gen: u32) -> bool {
66        self.generation == gen
67    }
68}
69
70/// Run [`LazyFetchCoordinator::begin`] and return its result.
71pub fn coordinator_begin(coordinator: RwSignal<LazyFetchCoordinator>) -> u32 {
72    let mut generation = 0;
73    coordinator.update(|c| {
74        generation = c.begin();
75    });
76    generation
77}
78
79/// Whether `generation` is still current on `coordinator`.
80pub fn coordinator_is_current(
81    coordinator: RwSignal<LazyFetchCoordinator>,
82    generation: u32,
83) -> bool {
84    coordinator.with_untracked(|c| c.is_current(generation))
85}
86
87/// Diff two event collections into added, updated, and removed ids.
88pub fn diff_event_changes(before: &[PlannedEvent], after: &[PlannedEvent]) -> EventChanges {
89    let before_map: HashMap<&str, &PlannedEvent> =
90        before.iter().map(|e| (e.id.as_str(), e)).collect();
91    let after_map: HashMap<&str, &PlannedEvent> =
92        after.iter().map(|e| (e.id.as_str(), e)).collect();
93
94    let before_ids: HashSet<&str> = before_map.keys().copied().collect();
95    let after_ids: HashSet<&str> = after_map.keys().copied().collect();
96
97    let added = after
98        .iter()
99        .filter(|e| !before_ids.contains(e.id.as_str()))
100        .cloned()
101        .collect();
102
103    let updated = after
104        .iter()
105        .filter(|e| before_map.get(e.id.as_str()).is_some_and(|prev| prev != e))
106        .cloned()
107        .collect();
108
109    let removed = before_ids
110        .difference(&after_ids)
111        .map(|id| (*id).to_string())
112        .collect();
113
114    EventChanges {
115        added,
116        updated,
117        removed,
118    }
119}
120
121#[cfg(test)]
122mod tests {
123    use super::*;
124    use orbital_base_components::{DatetimeTimezone, OrbitalDateTime, TryFromUnixSeconds};
125
126    fn event(id: &str, title: &str) -> PlannedEvent {
127        let start = OrbitalDateTime::try_from_unix_seconds(1_735_689_600, DatetimeTimezone::Utc)
128            .expect("valid");
129        let end = start.apply_hms(10, 0, 0).expect("valid end");
130        PlannedEvent::new(id, title, start, end)
131    }
132
133    #[test]
134    fn coordinator_increments_generation() {
135        let mut coord = LazyFetchCoordinator::default();
136        let g1 = coord.begin();
137        let g2 = coord.begin();
138        assert_ne!(g1, g2);
139        assert!(coord.is_current(g2));
140        assert!(!coord.is_current(g1));
141    }
142
143    #[test]
144    fn diff_detects_added_updated_removed() {
145        let mut evt1 = event("evt-1", "One");
146        let evt2 = event("evt-2", "Two");
147        let before = vec![evt1.clone(), evt2.clone()];
148
149        evt1.title = "One updated".into();
150        let evt3 = event("evt-3", "Three");
151        let after = vec![evt1.clone(), evt3.clone()];
152        let evt3_added = evt3;
153
154        let changes = diff_event_changes(&before, &after);
155        assert_eq!(changes.added, vec![evt3_added]);
156        assert_eq!(changes.updated, vec![evt1]);
157        assert_eq!(changes.removed, vec!["evt-2".to_string()]);
158    }
159}