fix: handle backend failures during active sessions (#38)

Co-authored-by: Claude <noreply@anthropic.com>

Author: TheZupZup

app/lib/services/app_state.dart

@@ -144,22 +144,37 @@ class AppState extends ChangeNotifier {
       );
 
   Future<void> loadNotebooks() async {
-    _notebooks = await client.getNotebooks();
-    notifyListeners();
+    try {
+      _notebooks = await client.getNotebooks();
+      notifyListeners();
+    } catch (e) {
+      await _handleBackendFailure(e);
+      rethrow;
+    }
   }
 
   Future<api.Notebook> createNotebook(String name, String color) async {
-    final nb = await client.createNotebook(name: name, color: color);
-    _notebooks.insert(0, nb);
-    notifyListeners();
-    return nb;
+    try {
+      final nb = await client.createNotebook(name: name, color: color);
+      _notebooks.insert(0, nb);
+      notifyListeners();
+      return nb;
+    } catch (e) {
+      await _handleBackendFailure(e);
+      rethrow;
+    }
   }
 
   Future<void> deleteNotebook(String id) async {
-    await client.deleteNotebook(id);
-    _notebooks.removeWhere((n) => n.id == id);
-    if (_selectedNotebook?.id == id) { _selectedNotebook = null; _notes = []; }
-    notifyListeners();
+    try {
+      await client.deleteNotebook(id);
+      _notebooks.removeWhere((n) => n.id == id);
+      if (_selectedNotebook?.id == id) { _selectedNotebook = null; _notes = []; }
+      notifyListeners();
+    } catch (e) {
+      await _handleBackendFailure(e);
+      rethrow;
+    }
   }
 
   void selectNotebook(api.Notebook? nb) {
@@ -171,35 +186,58 @@ class AppState extends ChangeNotifier {
   Future<void> loadNotes({String? notebookId, String? search}) async {
     _isLoading = true;
     notifyListeners();
-    try { _notes = await client.getNotes(notebookId: notebookId, search: search); }
-    catch (_) {}
+    try {
+      _notes = await client.getNotes(notebookId: notebookId, search: search);
+    } catch (e) {
+      await _handleBackendFailure(e);
+    }
     _isLoading = false;
     notifyListeners();
   }
 
   Future<api.Note> createNote({required String title, required String noteType, String template = 'blank'}) async {
-    final note = await client.createNote(
-      title: title, noteType: noteType,
-      notebookId: _selectedNotebook?.id, template: template);
-    _notes.insert(0, note);
-    notifyListeners();
-    return note;
+    try {
+      final note = await client.createNote(
+        title: title, noteType: noteType,
+        notebookId: _selectedNotebook?.id, template: template);
+      _notes.insert(0, note);
+      notifyListeners();
+      return note;
+    } catch (e) {
+      await _handleBackendFailure(e);
+      rethrow;
+    }
   }
 
   Future<void> deleteNote(String id) async {
-    await client.deleteNote(id);
-    _notes.removeWhere((n) => n.id == id);
-    if (_selectedNote?.id == id) _selectedNote = null;
-    notifyListeners();
+    try {
+      await client.deleteNote(id);
+      _notes.removeWhere((n) => n.id == id);
+      if (_selectedNote?.id == id) _selectedNote = null;
+      notifyListeners();
+    } catch (e) {
+      await _handleBackendFailure(e);
+      rethrow;
+    }
   }
 
   Future<void> updateNoteTitle(String id, String title) async {
-    await client.updateNote(id, title: title);
-    await loadNotes(notebookId: _selectedNotebook?.id);
+    try {
+      await client.updateNote(id, title: title);
+      await loadNotes(notebookId: _selectedNotebook?.id);
+    } catch (e) {
+      await _handleBackendFailure(e);
+      rethrow;
+    }
   }
 
   Future<void> savePageText(String noteId, int pageNum, String content) async {
-    await client.savePageText(noteId, pageNum, content);
+    try {
+      await client.savePageText(noteId, pageNum, content);
+    } catch (e) {
+      await _handleBackendFailure(e);
+      rethrow;
+    }
   }
 
   void selectNote(api.Note? note) { _selectedNote = note; notifyListeners(); }
@@ -214,6 +252,7 @@ class AppState extends ChangeNotifier {
     } catch (e) {
       final message = 'Sync failed: $e';
       _finishSync(error: message);
+      await _handleBackendFailure(e);
       return message;
     }
   }
@@ -232,10 +271,25 @@ class AppState extends ChangeNotifier {
       return result;
     } catch (e) {
       _finishSync(error: 'Sync failed: $e');
+      await _handleBackendFailure(e);
       rethrow;
     }
   }
 
+  /// Marks the backend as unavailable after an API call fails mid-session and
+  /// refreshes [_notebooks]/[_notes] from the local SQLite store so the UI can
+  /// keep working offline. Reuses the same flag and message as the
+  /// startup-time path so the existing offline banner kicks in unchanged.
+  Future<void> _handleBackendFailure(Object _) async {
+    final wasAvailable = _isBackendAvailable;
+    _isBackendAvailable = false;
+    _backendErrorMessage = 'Offline mode — backend unavailable';
+    if (wasAvailable) {
+      await _loadLocalFallback();
+    }
+    notifyListeners();
+  }
+
   void _beginSync() {
     _isSyncing = true;
     _syncError = null;

app/test/services/app_state_test.dart

@@ -9,9 +9,10 @@ import 'package:nexanote/services/local_note_service.dart';
 import 'package:nexanote/services/sync_service.dart';
 
 class _StubApi extends api.ApiClient {
-  _StubApi({this.shouldThrow = false, this.pingResult = true})
-      : super(baseUrl: 'http://stub.test');
-  final bool shouldThrow;
+  _StubApi({bool shouldThrow = false, this.pingResult = true})
+      : shouldThrow = shouldThrow,
+        super(baseUrl: 'http://stub.test');
+  bool shouldThrow;
   final bool pingResult;
 
   @override
@@ -133,6 +134,67 @@ void main() {
     expect(onlineState.backendErrorMessage, isNull);
   });
 
+  test('backend failure mid-session flips isBackendAvailable from true to false',
+      () async {
+    await state.initLocal();
+    final localNb = await service.createNotebook('Local NB');
+    await service.createNote('Local note', notebookId: localNb.id);
+
+    final stub = _StubApi();
+    final liveState = AppState(
+      localService: service,
+      clientFactory: (_) => stub,
+    );
+
+    await liveState.connect();
+    expect(liveState.isBackendAvailable, isTrue);
+    expect(liveState.backendErrorMessage, isNull);
+
+    // Simulate the backend going down mid-session.
+    stub.shouldThrow = true;
+    await expectLater(liveState.loadNotebooks(), throwsA(isA<Exception>()));
+
+    expect(liveState.isBackendAvailable, isFalse);
+    expect(liveState.backendErrorMessage, isNotNull);
+    expect(liveState.backendErrorMessage, contains('Offline'));
+    // Local data is still reachable so the UI does not bounce back to
+    // ConnectScreen and the editor keeps working.
+    expect(liveState.hasLocalData, isTrue);
+    expect(liveState.notebooks.map((n) => n.name), contains('Local NB'));
+    expect(liveState.notes.map((n) => n.title), contains('Local note'));
+
+    // SQLite save/load keeps working independently of the backend flag.
+    await liveState.localService.createNote('Written offline',
+        notebookId: localNb.id);
+    final notes =
+        await liveState.localService.getNotesForNotebook(localNb.id);
+    expect(notes.map((n) => n.title), contains('Written offline'));
+  });
+
+  test('syncNow marks backend unavailable when sync fails mid-session',
+      () async {
+    await state.initLocal();
+    final stub = _StubApi();
+    final liveState = AppState(
+      localService: service,
+      clientFactory: (_) => stub,
+    );
+
+    await liveState.connect();
+    expect(liveState.isBackendAvailable, isTrue);
+
+    stub.shouldThrow = true;
+    final svc = SyncService(apiClient: stub, local: service);
+    await expectLater(
+        liveState.syncNow(service: svc), throwsA(isA<Exception>()));
+
+    expect(liveState.isSyncing, isFalse);
+    expect(liveState.syncError, isNotNull);
+    expect(liveState.syncError, contains('Sync failed'));
+    expect(liveState.isBackendAvailable, isFalse);
+    expect(liveState.backendErrorMessage, contains('Offline'));
+  });
+
   test('syncNow records syncError and resets isSyncing when sync fails',
       () async {
     await state.initLocal();