fix: serialize token refresh across Dio instances

Author: jjoonleo

lib/core/dio/app_dio.dart

@@ -6,23 +6,24 @@ import 'package:on_time_front/core/dio/interceptors/logger_interceptor.dart';
 import 'package:on_time_front/core/dio/interceptors/token_interceptor.dart';
 import 'package:on_time_front/core/dio/transformers/logging_transformer.dart';
 
-@Injectable(as: Dio)
+@LazySingleton(as: Dio)
 class AppDio with DioMixin implements Dio {
   AppDio() {
     httpClientAdapter = getAdapter();
     transformer = LoggingTransformer(inner: BackgroundTransformer());
     options = BaseOptions(
-        contentType: Headers.jsonContentType,
-        baseUrl: EnvironmentVariable.restApiUrl,
-        connectTimeout: const Duration(milliseconds: 30000),
-        receiveTimeout: const Duration(milliseconds: 30000),
-        sendTimeout: const Duration(milliseconds: 30000),
-        receiveDataWhenStatusError: true,
-        followRedirects: false,
-        headers: {
-          "Accept": "application/json",
-          "Authorization": EnvironmentVariable.restAuthToken
-        });
+      contentType: Headers.jsonContentType,
+      baseUrl: EnvironmentVariable.restApiUrl,
+      connectTimeout: const Duration(milliseconds: 30000),
+      receiveTimeout: const Duration(milliseconds: 30000),
+      sendTimeout: const Duration(milliseconds: 30000),
+      receiveDataWhenStatusError: true,
+      followRedirects: false,
+      headers: {
+        "Accept": "application/json",
+        "Authorization": EnvironmentVariable.restAuthToken,
+      },
+    );
 
     interceptors.addAll([TokenInterceptor(this), LoggerInterceptor()]);
   }

lib/core/dio/interceptors/token_interceptor.dart

@@ -12,21 +12,14 @@ class TokenInterceptor implements InterceptorsWrapper {
   static const _tokenUnavailableMessage =
       'Authentication token is unavailable for a protected request';
 
+  static bool _isRefreshing = false;
+  static final _requestsNeedRetry = <_RequestNeedingRetry>[];
+
   final Dio dio;
   TokenInterceptor(this.dio);
   final TokenLocalDataSource tokenLocalDataSource = getIt
       .get<TokenLocalDataSource>();
 
-  // when accessToken is expired & having multiple requests call
-  // this variable to lock others request to make sure only trigger call refresh token 01 times
-  // to prevent duplicate refresh call
-  bool _isRefreshing = false;
-
-  // when having multiple requests call at the same time, you need to store them in a list
-  // then loop this list to retry every request later, after call refresh token success
-  final _requestsNeedRetry =
-      <({RequestOptions options, ErrorInterceptorHandler handler})>[];
-
   @override
   void onRequest(
     RequestOptions options,
@@ -58,7 +51,13 @@ class TokenInterceptor implements InterceptorsWrapper {
     if (_shouldRefreshToken(err)) {
       final response = err.response;
       // if hasn't not refreshing yet, let's start it
-      _requestsNeedRetry.add((options: err.requestOptions, handler: handler));
+      _requestsNeedRetry.add(
+        _RequestNeedingRetry(
+          dio: dio,
+          options: err.requestOptions,
+          handler: handler,
+        ),
+      );
 
       if (!_isRefreshing) {
         _isRefreshing = true;
@@ -163,16 +162,14 @@ class TokenInterceptor implements InterceptorsWrapper {
     }
   }
 
-  Future<void> _retryRequests(
-    List<({RequestOptions options, ErrorInterceptorHandler handler})> requests,
-  ) async {
+  Future<void> _retryRequests(List<_RequestNeedingRetry> requests) async {
     await Future.wait(
       requests.map((requestNeedRetry) async {
         final options = requestNeedRetry.options;
         options.extra[_retryAfterRefreshKey] = true;
 
         try {
-          final response = await dio.fetch(options);
+          final response = await requestNeedRetry.dio.fetch(options);
           requestNeedRetry.handler.resolve(response);
         } on DioException catch (error) {
           requestNeedRetry.handler.reject(error);
@@ -198,3 +195,15 @@ class TokenInterceptor implements InterceptorsWrapper {
     handler.next(response);
   }
 }
+
+class _RequestNeedingRetry {
+  const _RequestNeedingRetry({
+    required this.dio,
+    required this.options,
+    required this.handler,
+  });
+
+  final Dio dio;
+  final RequestOptions options;
+  final ErrorInterceptorHandler handler;
+}

test/core/dio/interceptors/token_interceptor_test.dart

@@ -29,13 +29,7 @@ void main() {
     getIt.registerSingleton<UserRepository>(userRepository);
 
     adapter = _TokenRefreshAdapter();
-    dio = Dio(
-      BaseOptions(
-        baseUrl: 'https://example.com',
-        receiveDataWhenStatusError: true,
-      ),
-    )..httpClientAdapter = adapter;
-    dio.interceptors.add(TokenInterceptor(dio));
+    dio = _dioWithTokenInterceptor(adapter);
   });
 
   tearDown(() async {
@@ -89,6 +83,33 @@ void main() {
     );
   });
 
+  test('shares refresh coordination across interceptor instances', () async {
+    final refreshCompleter = Completer<void>();
+    adapter = _TokenRefreshAdapter(refreshCompleter: refreshCompleter);
+    final firstDio = _dioWithTokenInterceptor(adapter);
+    final secondDio = _dioWithTokenInterceptor(adapter);
+
+    final firstRequest = firstDio.get<String>('/protected/one');
+    await _flushMicrotasks();
+    final secondRequest = secondDio.get<String>('/protected/two');
+    await _flushMicrotasks();
+
+    expect(adapter.refreshRequests, 1);
+    refreshCompleter.complete();
+
+    final responses = await Future.wait([firstRequest, secondRequest]);
+
+    expect(responses.map((response) => response.statusCode), everyElement(200));
+    expect(adapter.refreshRequests, 1);
+    expect(tokenLocalDataSource.storeTokensCallCount, 1);
+    expect(
+      adapter.protectedAuthorizationHeaders.where(
+        (header) => header == 'Bearer new-access-token',
+      ),
+      hasLength(2),
+    );
+  });
+
   test('rejects original request when retry after refresh fails', () async {
     adapter = _TokenRefreshAdapter(retryStatusCode: 500);
     dio.httpClientAdapter = adapter;
@@ -178,6 +199,17 @@ void main() {
   );
 }
 
+Dio _dioWithTokenInterceptor(HttpClientAdapter adapter) {
+  final dio = Dio(
+    BaseOptions(
+      baseUrl: 'https://example.com',
+      receiveDataWhenStatusError: true,
+    ),
+  )..httpClientAdapter = adapter;
+  dio.interceptors.add(TokenInterceptor(dio));
+  return dio;
+}
+
 Future<void> _flushMicrotasks() async {
   for (var i = 0; i < 5; i++) {
     await Future<void>.delayed(Duration.zero);

test/presentation/home/components/month_calendar_test.dart

@@ -15,7 +15,8 @@ void main() {
     tester,
   ) async {
     DateTime? selected;
-    final targetDate = DateTime.now().add(const Duration(days: 2));
+    final now = DateTime.now();
+    final targetDate = DateTime(now.year, now.month, 15);
 
     await tester.pumpWidget(
       _TestApp(