Error Handling in Riverpod: Best Practices

final userProvider = FutureProvider<User>((ref) async {
  try {
    return await userRepository.fetchUser();
  } catch (error) {
    throw CustomException('Failed to fetch user data: $error');
  }
});

final weatherProvider = StateNotifierProvider<WeatherNotifier, AsyncValue<WeatherData>>((ref) {
  return WeatherNotifier();
});

class WeatherNotifier extends StateNotifier<AsyncValue<WeatherData>> {
  WeatherNotifier() : super(const AsyncValue.loading()) {
    _fetchWeather();
  }

  Future<void> _fetchWeather() async {
    state = const AsyncValue.loading();
    try {
      final weather = await weatherRepository.fetch();
      state = AsyncValue.data(weather);
    } catch (error, stackTrace) {
      state = AsyncValue.error(error, stackTrace);
    }
  }
}

sealed class AppError {
  final String message;
  const AppError(this.message);
}

class NetworkError extends AppError {
  const NetworkError(super.message);
}

class ValidationError extends AppError {
  const ValidationError(super.message);
}

final configProvider = FutureProvider<Config>((ref) async {
  try {
    return await loadConfig();
  } catch (e) {
    // Fallback to default configuration
    return Config.defaults();
  }
});

extension RetryOperation\<T\> on Future\<T\> {
  Future\<T\> withRetry({int maxAttempts = 3}) async {
    int attempts = 0;
    while (true) {
      try {
        attempts++;
        return await this;
      } catch (e) {
        if (attempts >= maxAttempts) rethrow;
        await Future.delayed(Duration(seconds: attempts));
      }
    }
  }
}

Consumer(
  builder: (context, ref, child) {
    return ref.watch(userProvider).when(
      data: (user) => UserProfile(user: user),
      loading: () => const LoadingIndicator(),
      error: (error, stack) => ErrorView(
        message: error.toString(),
        onRetry: () => ref.refresh(userProvider),
      ),
    );
  },
);