From a352593aeda6a1947b62168ad4e5626c87cef5e3 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 01:08:11 +0000 Subject: [PATCH] Order local storage operations across replacement owners --- .../core/storage/ordered_local_storage.dart | 17 +++++++ .../storage/ordered_local_storage_test.dart | 46 +++++++++++++++++++ 2 files changed, 63 insertions(+) create mode 100644 app/lib/core/storage/ordered_local_storage.dart create mode 100644 app/test/core/storage/ordered_local_storage_test.dart diff --git a/app/lib/core/storage/ordered_local_storage.dart b/app/lib/core/storage/ordered_local_storage.dart new file mode 100644 index 00000000..b0877aff --- /dev/null +++ b/app/lib/core/storage/ordered_local_storage.dart @@ -0,0 +1,17 @@ +/// Reads and writes for one persisted key share an order across widget owners. +/// This lets a replacement owner read after an old owner's in-flight write. +/// Completed keys are removed, and one failed operation never blocks the next. +final _pending = >{}; + +Future orderedLocalStorage(Object key, Future Function() operation) { + final previous = _pending[key] ?? Future.value(); + final result = previous.then((_) => operation()); + late final Future completion; + completion = result + .then((_) {}, onError: (Object _, StackTrace _) {}) + .whenComplete(() { + if (identical(_pending[key], completion)) _pending.remove(key); + }); + _pending[key] = completion; + return result; +} diff --git a/app/test/core/storage/ordered_local_storage_test.dart b/app/test/core/storage/ordered_local_storage_test.dart new file mode 100644 index 00000000..881c2811 --- /dev/null +++ b/app/test/core/storage/ordered_local_storage_test.dart @@ -0,0 +1,46 @@ +import 'dart:async'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/storage/ordered_local_storage.dart'; + +void main() { + test( + 'a later read waits for the in-flight write with the same key', + () async { + final gate = Completer(); + final key = Object(); + var stored = 'old'; + final write = orderedLocalStorage(key, () async { + await gate.future; + stored = 'new'; + }); + var read = false; + final reading = orderedLocalStorage(key, () async { + read = true; + return stored; + }); + await Future.delayed(Duration.zero); + expect(read, isFalse); + gate.complete(); + await write; + expect(await reading, 'new'); + }, + ); + test( + 'different keys remain independent, and a failure does not poison a key', + () async { + final blockedKey = Object(); + final gate = Completer(); + final blocked = orderedLocalStorage(blockedKey, () => gate.future); + expect(await orderedLocalStorage(Object(), () async => 'free'), 'free'); + final key = Object(); + await expectLater( + orderedLocalStorage(key, () async => throw StateError('failed')), + throwsStateError, + ); + expect(await orderedLocalStorage(key, () async => 7), 7); + gate.complete(); + await blocked; + }, + ); +}