From 076c5912519e3ad28b7497dc1efbdb4cbc61bfdb Mon Sep 17 00:00:00 2001
From: bponders12-cell <bponders12@gmail.com>
Date: Tue, 1 Sep 2026 16:57:28 -0400
Subject: [PATCH] Reconnect pending cloud sync after authentication changes

---
 lib/services/sync/sync_providers.dart | 85 +++++++++------------------
 1 file changed, 27 insertions(+), 58 deletions(-)

diff --git a/lib/services/sync/sync_providers.dart b/lib/services/sync/sync_providers.dart
index 588ac42..079576d 100644
--- a/lib/services/sync/sync_providers.dart
+++ b/lib/services/sync/sync_providers.dart
@@ -9,74 +9,43 @@ import 'github_sync_provider.dart';
 import 'r2_upload_service.dart';
 import 'sync_bundle_worker.dart';
 import 'sync_manager.dart';
-import 'sync_models.dart';
 import 'sync_outbox.dart';
 
-/// Provider for the Cloudflare R2 Upload Service
-final r2UploadServiceProvider = Provider<R2UploadService>((ref) {
-  return R2UploadService();
-});
+final r2UploadServiceProvider = Provider<R2UploadService>((ref) => R2UploadService());
+final syncBundleWorkerProvider = Provider<SyncBundleWorker>((ref) => SyncBundleWorker(ref.watch(databaseProvider)));
+final syncOutboxProvider = Provider<SyncOutbox>((ref) => SyncOutbox(ref.watch(sharedPreferencesProvider)));
 
-/// Provider for the background bundle generation worker
-final syncBundleWorkerProvider = Provider<SyncBundleWorker>((ref) {
-  final db = ref.watch(databaseProvider);
-  return SyncBundleWorker(db);
-});
+final firebaseSyncProvider = Provider<FirebaseSyncProvider>((ref) => FirebaseSyncProvider(
+      db: ref.watch(databaseProvider),
+      authService: ref.watch(authServiceProvider),
+      bundleWorker: ref.watch(syncBundleWorkerProvider),
+      r2UploadService: ref.watch(r2UploadServiceProvider),
+    ));
 
-/// Provider for the local SyncOutbox backed by SharedPreferences
-final syncOutboxProvider = Provider<SyncOutbox>((ref) {
-  final prefs = ref.watch(sharedPreferencesProvider);
-  return SyncOutbox(prefs);
-});
+final githubSyncProvider = Provider<GitHubSyncProvider>((ref) => GitHubSyncProvider(
+      service: ref.watch(githubSyncServiceProvider),
+      auth: ref.watch(githubAuthServiceProvider),
+    ));
 
-/// Provider for the Firebase + Cloudflare R2 Cloud Sync Provider
-final firebaseSyncProvider = Provider<FirebaseSyncProvider>((ref) {
-  final db = ref.watch(databaseProvider);
-  final authService = ref.watch(authServiceProvider);
-  final bundleWorker = ref.watch(syncBundleWorkerProvider);
-  final r2Service = ref.watch(r2UploadServiceProvider);
-  return FirebaseSyncProvider(
-    db: db,
-    authService: authService,
-    r2UploadService: r2Service,
-    bundleWorker: bundleWorker,
-  );
-});
-
-/// Provider for the GitHub Sync Provider wrapper
-final githubSyncProvider = Provider<GitHubSyncProvider>((ref) {
-  final service = ref.watch(githubSyncServiceProvider);
-  final auth = ref.watch(githubAuthServiceProvider);
-  return GitHubSyncProvider(service: service, auth: auth);
-});
-
-/// Primary ChangeNotifierProvider for the SyncManager
 final syncManagerProvider = ChangeNotifierProvider<SyncManager>((ref) {
-  final outbox = ref.watch(syncOutboxProvider);
-  final firebaseProvider = ref.watch(firebaseSyncProvider);
-  final gitHubProvider = ref.watch(githubSyncProvider);
-
   final manager = SyncManager(
-    outbox,
-    initialProviders: [firebaseProvider, gitHubProvider],
+    ref.watch(syncOutboxProvider),
+    initialProviders: [ref.watch(firebaseSyncProvider), ref.watch(githubSyncProvider)],
     defaultProviderId: 'firebase',
   );
 
+  // A successful Firebase/Google/Email sign-in must automatically release
+  // rides that were durably parked in AUTH_REQUIRED. Sign-out does not delete
+  // or cancel them; they remain local/pending until another authenticated session.
+  ref.listen<AuthState>(authNotifierProvider, (previous, next) {
+    if (next.isAuthenticated && previous?.isAuthenticated != true) {
+      manager.retryAuthRequired();
+    }
+  });
+  ref.onDispose(manager.dispose);
   return manager;
 });
 
-/// Reactive snapshot of the overall synchronization state
-final syncStateProvider = Provider<SyncManagerState>((ref) {
-  final manager = ref.watch(syncManagerProvider);
-  return manager.currentState;
-});
-
-/// Reactive count of currently pending synchronization items
-final pendingSyncCountProvider = Provider<int>((ref) {
-  return ref.watch(syncStateProvider).pendingCount;
-});
-
-/// Reactive boolean indicating if background synchronization is actively running
-final isSyncProcessingProvider = Provider<bool>((ref) {
-  return ref.watch(syncStateProvider).isProcessing;
-});
+final syncStateProvider = Provider<SyncManagerState>((ref) => ref.watch(syncManagerProvider).currentState);
+final pendingSyncCountProvider = Provider<int>((ref) => ref.watch(syncStateProvider).pendingCount);
+final isSyncProcessingProvider = Provider<bool>((ref) => ref.watch(syncStateProvider).isProcessing);