Files
lisette/src/app/sync.rs
T
Romulus21andClaude Opus 5.5 6c593b0201 Enregistre les changements d'articles par lots en arrière-plan
Cocher, ajouter, modifier ou supprimer un article s'affiche aussitôt :
le changement attend dans une file, fusionné avec les précédents, puis
part avec les autres en une seule requête, une à la fois. Le serveur
applique le lot dans une transaction et résout les ids temporaires des
articles ajoutés. Sans réseau, le lot est gardé et renvoyé plus tard.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 08:47:25 +02:00

324 lines
11 KiB
Rust

//! Item changes are shown at once and saved in the background: they wait in a
//! queue and leave in batches, one request at a time, so a slow mobile
//! connection never holds the interface back.
use std::time::Duration;
use leptos::ev;
use leptos::prelude::*;
use leptos::task::spawn_local;
use super::Ctx;
use crate::model::{Item, ItemOp, SyncReport};
/// Changes made within this delay leave together.
const DEBOUNCE: Duration = Duration::from_millis(400);
const MAX_RETRY_DELAY: Duration = Duration::from_secs(30);
#[derive(Clone, Copy)]
pub struct Sync(RwSignal<State>);
#[derive(Default)]
struct State {
/// Changes not sent yet.
queue: Vec<ItemOp>,
/// Sent changes, shown until data fetched after they were saved has them.
sent: Vec<Batch>,
/// Batches saved so far.
saved: u32,
/// Real ids of items added here, by temporary id.
ids: Vec<(i64, i64)>,
/// Last temporary id handed out.
last_temp: i64,
/// A flush is planned.
scheduled: bool,
/// A batch is on its way; the next one waits for its answer.
sending: bool,
/// Failed attempts since the last batch got through.
retries: u32,
}
struct Batch {
ops: Vec<ItemOp>,
/// Value of `saved` once this batch was saved.
saved_as: Option<u32>,
}
enum Outcome {
Saved(SyncReport),
Refused(ServerFnError),
Retry(Duration),
}
impl Sync {
pub fn new() -> Self {
Self(RwSignal::new(State::default()))
}
/// Sends what is left when the page is hidden: the phone may freeze it next.
pub fn flush_on_hide(self, ctx: Ctx) {
let handle = window_event_listener(ev::visibilitychange, move |_| {
if document().hidden() {
self.flush(ctx);
}
});
on_cleanup(move || handle.remove());
}
pub fn push(self, ctx: Ctx, op: ItemOp) {
let schedule = self.0.try_update(|state| {
state.push(op);
!std::mem::replace(&mut state.scheduled, true)
});
if schedule == Some(true) {
set_timeout(move || self.flush(ctx), DEBOUNCE);
}
}
/// Saved batches so far: data fetched from now on includes them.
pub fn saved(self) -> u32 {
self.0.try_with_untracked(|state| state.saved).unwrap_or_default()
}
/// Forgets saved changes that data fetched when `saved` batches were
/// saved already shows, so changes made by others since are not masked.
pub fn settle(self, saved: u32) {
self.0.try_update_untracked(|state| {
state.sent.retain(|batch| batch.saved_as.is_none_or(|n| n > saved));
});
}
/// The list's items with the changes not saved or not fetched yet.
pub fn apply(self, list_id: i64, items: &[Item]) -> Vec<Item> {
let mut items = items.to_vec();
self.0.with(|state| {
let ops = state.sent.iter().flat_map(|batch| &batch.ops).chain(&state.queue);
for op in ops {
apply(&mut items, list_id, op);
}
});
items
}
/// The last attempt failed for lack of network; changes are kept.
pub fn offline(self) -> bool {
self.0.with(|state| state.retries > 0)
}
fn flush(self, ctx: Ctx) {
let ops = self.0.try_update(|state| {
state.scheduled = false;
if state.sending || state.queue.is_empty() {
return None;
}
let ops = std::mem::take(&mut state.queue);
state.sent.push(Batch { ops: ops.clone(), saved_as: None });
state.sending = true;
Some(ops)
});
let Some(Some(ops)) = ops else { return };
spawn_local(async move {
let result = crate::api::sync_items(ops).await;
self.answered(ctx, result);
});
}
fn answered(self, ctx: Ctx, result: Result<SyncReport, ServerFnError>) {
let outcome = self.0.try_update(|state| {
state.sending = false;
let mut batch = state.sent.pop().expect("the batch sent is the last one");
match result {
Ok(report) => {
state.saved += 1;
batch.saved_as = Some(state.saved);
state.sent.push(batch);
state.resolve(&report.created);
state.retries = 0;
Outcome::Saved(report)
}
// Refused by the server: retrying would not help.
Err(err @ ServerFnError::ServerError(_)) => {
state.retries = 0;
Outcome::Refused(err)
}
// Not delivered, or the answer was lost: send it again later.
Err(_) => {
state.queue.splice(0..0, batch.ops);
state.retries += 1;
let delay = Duration::from_secs(1 << state.retries.min(5)).min(MAX_RETRY_DELAY);
Outcome::Retry(delay)
}
}
});
match outcome {
None => {}
Some(Outcome::Saved(report)) => {
if let Some(msg) = report.rejected {
ctx.error.set(Some(msg));
}
ctx.refresh.update(|n| *n += 1);
self.flush(ctx);
}
Some(Outcome::Refused(err)) => {
ctx.report(err);
ctx.refresh.update(|n| *n += 1);
self.flush(ctx);
}
Some(Outcome::Retry(delay)) => set_timeout(move || self.flush(ctx), delay),
}
}
}
impl State {
/// Queues the change, merged with the queued ones for the same item.
fn push(&mut self, mut op: ItemOp) {
if let ItemOp::Add { id, .. } = &mut op {
self.last_temp -= 1;
*id = self.last_temp;
} else if let Some(&(_, real)) = self.ids.iter().find(|&&(temp, _)| temp == op.id()) {
// Still open in an editor from before the item was saved.
*op.id_mut() = real;
}
let id = op.id();
let queued_add = self.queue.iter().position(|q| matches!(q, ItemOp::Add { id: added, .. } if *added == id));
match (op, queued_add) {
(ItemOp::Delete { .. }, Some(_)) => self.queue.retain(|q| q.id() != id),
(ItemOp::Update { input, .. }, Some(index)) => {
if let ItemOp::Add { input: added, .. } = &mut self.queue[index] {
*added = input;
}
}
(op @ ItemOp::Delete { .. }, None) => {
self.queue.retain(|q| q.id() != id);
self.queue.push(op);
}
(op @ (ItemOp::Update { .. } | ItemOp::SetChecked { .. }), _) => {
let same_kind = std::mem::discriminant(&op);
self.queue.retain(|q| q.id() != id || std::mem::discriminant(q) != same_kind);
self.queue.push(op);
}
(op, _) => self.queue.push(op),
}
}
/// Swaps temporary ids for the ones the server gave.
fn resolve(&mut self, created: &[(i64, i64)]) {
let ops = self.queue.iter_mut().chain(self.sent.iter_mut().flat_map(|batch| &mut batch.ops));
for op in ops {
if let Some(&(_, real)) = created.iter().find(|&&(temp, _)| temp == op.id()) {
*op.id_mut() = real;
}
}
self.ids.extend_from_slice(created);
}
}
fn apply(items: &mut Vec<Item>, list_id: i64, op: &ItemOp) {
fn find(items: &mut [Item], id: i64) -> Option<&mut Item> {
items.iter_mut().find(|item| item.id == id)
}
match op {
ItemOp::Add { id, list_id: list, input } => {
if *list == list_id && !items.iter().any(|item| item.id == *id) {
items.push(Item {
id: *id,
list_id,
name: input.name.clone(),
quantity: input.quantity,
icon: input.icon,
category: input.category,
checked: false,
});
}
}
ItemOp::Update { id, input } => {
if let Some(item) = find(items, *id) {
item.name = input.name.clone();
item.quantity = input.quantity;
item.icon = input.icon;
item.category = input.category;
}
}
ItemOp::Delete { id } => items.retain(|item| item.id != *id),
ItemOp::SetChecked { id, checked } => {
if let Some(item) = find(items, *id) {
item.checked = *checked;
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::{Category, Icon, ItemInput};
fn input(name: &str) -> ItemInput {
ItemInput { name: name.into(), quantity: None, icon: Icon::Basket, category: Category::Autre }
}
fn add(name: &str) -> ItemOp {
ItemOp::Add { id: 0, list_id: 1, input: input(name) }
}
#[test]
fn merges_queued_changes() {
let mut state = State::default();
state.push(ItemOp::SetChecked { id: 5, checked: true });
state.push(ItemOp::SetChecked { id: 5, checked: false });
state.push(add("Pain"));
state.push(ItemOp::Update { id: -1, input: input("Pain complet") });
assert_eq!(
state.queue,
[
ItemOp::SetChecked { id: 5, checked: false },
ItemOp::Add { id: -1, list_id: 1, input: input("Pain complet") },
]
);
state.push(ItemOp::Delete { id: -1 });
state.push(ItemOp::Delete { id: 5 });
assert_eq!(state.queue, [ItemOp::Delete { id: 5 }]);
}
#[test]
fn resolves_temporary_ids() {
let mut state = State::default();
state.push(add("Pain"));
state.sent.push(Batch { ops: std::mem::take(&mut state.queue), saved_as: None });
state.push(ItemOp::SetChecked { id: -1, checked: true });
state.resolve(&[(-1, 42)]);
assert_eq!(state.queue, [ItemOp::SetChecked { id: 42, checked: true }]);
assert_eq!(state.sent[0].ops[0].id(), 42);
// An editor opened on the temporary item.
state.push(ItemOp::Delete { id: -1 });
assert_eq!(state.queue, [ItemOp::Delete { id: 42 }]);
}
#[test]
fn applies_changes_to_fetched_items() {
let item = Item {
id: 7,
list_id: 1,
name: "Lait".into(),
quantity: None,
icon: Icon::Milk,
category: Category::Frais,
checked: false,
};
let mut items = vec![item];
apply(&mut items, 1, &ItemOp::SetChecked { id: 7, checked: true });
apply(&mut items, 1, &ItemOp::Add { id: -1, list_id: 1, input: input("Pain") });
apply(&mut items, 1, &ItemOp::Add { id: -2, list_id: 2, input: input("Ailleurs") });
assert!(items[0].checked);
assert_eq!(items.len(), 2);
// Already in the fetched data.
apply(&mut items, 1, &ItemOp::Add { id: 7, list_id: 1, input: input("Lait") });
apply(&mut items, 1, &ItemOp::Delete { id: -1 });
assert_eq!(items.len(), 1);
}
}