Merge pull request #398 from DevKor-github/feat/implement-issue-390

[codex] Harden token refresh retry handling

Author: jjoonleo

lib/core/dio/interceptors/token_interceptor.dart

@@ -2,9 +2,13 @@ import 'package:dio/dio.dart';
 import 'package:flutter/material.dart';
 import 'package:on_time_front/data/data_sources/token_local_data_source.dart';
 import 'package:on_time_front/core/di/di_setup.dart';
+import 'package:on_time_front/domain/entities/token_entity.dart';
 import 'package:on_time_front/domain/repositories/user_repository.dart';
 
 class TokenInterceptor implements InterceptorsWrapper {
+  static const _refreshTokenPath = '/refresh-token';
+  static const _retryAfterRefreshKey = 'tokenInterceptor.retryAfterRefresh';
+
   final Dio dio;
   TokenInterceptor(this.dio);
   final TokenLocalDataSource tokenLocalDataSource =
@@ -35,96 +39,94 @@ class TokenInterceptor implements InterceptorsWrapper {
 
   @override
   void onError(DioException err, ErrorInterceptorHandler handler) async {
-    final response = err.response;
-    if (response != null &&
-        // status code for unauthorized usually 401
-        response.statusCode == 401 &&
-        // refresh token call maybe fail by it self
-        // eg: when refreshToken also is expired -> can't get new accessToken
-        // usually server also return 401 unauthorized for this case
-        // need to exlude it to prevent loop infinite call
-        response.requestOptions.path != "/refresh-token") {
+    if (_shouldRefreshToken(err)) {
+      final response = err.response;
       // if hasn't not refreshing yet, let's start it
+      _requestsNeedRetry.add((options: err.requestOptions, handler: handler));
+
       if (!_isRefreshing) {
         _isRefreshing = true;
 
-        // add request (requestOptions and handler) to queue and wait to retry later
-        _requestsNeedRetry
-            .add((options: response.requestOptions, handler: handler));
-
         // call api refresh token
         final isRefreshSuccess = await _refreshToken();
 
-        if (isRefreshSuccess) {
-          // refresh success, loop requests need retry
-          for (var requestNeedRetry in _requestsNeedRetry) {
-            // don't need set new accessToken to header here, because these retry
-            // will go through onRequest callback above (where new accessToken will be set to header)
-
-            // won't use await because this loop will take longer -> maybe throw: Unhandled Exception: Concurrent modification during iteration
-            // because method _requestsNeedRetry.add() is called at the same time
-            // final response = await dio.fetch(requestNeedRetry.options);
-            // requestNeedRetry.handler.resolve(response);
-
-            dio.fetch(requestNeedRetry.options).then((response) {
-              requestNeedRetry.handler.resolve(response);
-            }).catchError((_) {});
-          }
-
-          _requestsNeedRetry.clear();
-          _isRefreshing = false;
-        } else {
-          for (final requestNeedRetry in _requestsNeedRetry) {
-            requestNeedRetry.handler.reject(
-              DioException(
-                requestOptions: requestNeedRetry.options,
-                response: response,
-                type: err.type,
-                error: err.error,
-                message: err.message,
-              ),
-            );
-          }
-          _requestsNeedRetry.clear();
-          // Force a local logout when the refresh token is rejected. The full
-          // sign-out use case may make authenticated cleanup calls, which can
-          // deadlock while the interceptor is already refreshing.
-          try {
-            await getIt.get<UserRepository>().signOut();
-          } catch (_) {
-            await tokenLocalDataSource.deleteToken();
+        try {
+          if (isRefreshSuccess) {
+            while (_requestsNeedRetry.isNotEmpty) {
+              final requestsNeedRetry = List.of(_requestsNeedRetry);
+              _requestsNeedRetry.clear();
+              await _retryRequests(requestsNeedRetry);
+            }
+          } else {
+            for (final requestNeedRetry in _requestsNeedRetry) {
+              requestNeedRetry.handler.reject(
+                DioException(
+                  requestOptions: requestNeedRetry.options,
+                  response: response,
+                  type: err.type,
+                  error: err.error,
+                  message: err.message,
+                ),
+              );
+            }
+            _requestsNeedRetry.clear();
+            // Force a local logout when the refresh token is rejected. The full
+            // sign-out use case may make authenticated cleanup calls, which can
+            // deadlock while the interceptor is already refreshing.
+            await _signOutLocally();
           }
+        } finally {
           _isRefreshing = false;
         }
-      } else {
-        // if refresh flow is processing, add this request to queue and wait to retry later
-        _requestsNeedRetry
-            .add((options: response.requestOptions, handler: handler));
       }
     } else {
       // ignore other error is not unauthorized
       return handler.next(err);
     }
   }
 
+  bool _shouldRefreshToken(DioException err) {
+    final response = err.response;
+    if (response?.statusCode != 401) {
+      return false;
+    }
+
+    final requestOptions = err.requestOptions;
+    return requestOptions.path != _refreshTokenPath &&
+        requestOptions.extra[_retryAfterRefreshKey] != true;
+  }
+
   Future<bool> _refreshToken() async {
     try {
       final tokenEntity = await tokenLocalDataSource.getToken();
       final refreshToken = tokenEntity.refreshToken;
 
       final res = await dio.get(
-        '/refresh-token',
+        _refreshTokenPath,
         options: Options(
+          extra: {
+            _retryAfterRefreshKey: true,
+          },
           headers: {
             'Authorization-refresh': 'Bearer $refreshToken',
           },
         ),
       );
       if (res.statusCode == 200) {
         debugPrint("token refreshing success");
-        final authToken = res.headers['authorization']![0];
-        // save new access + refresh token to your local storage for using later
-        await tokenLocalDataSource.storeAuthToken(authToken);
+        final accessToken = res.headers.value('authorization');
+        final refreshedRefreshToken =
+            res.headers.value('authorization-refresh');
+        if (accessToken == null || refreshedRefreshToken == null) {
+          throw StateError(
+              'Refresh response must include authorization and authorization-refresh headers');
+        }
+        await tokenLocalDataSource.storeTokens(
+          TokenEntity(
+            accessToken: accessToken,
+            refreshToken: refreshedRefreshToken,
+          ),
+        );
         return true;
       } else {
         debugPrint("refresh token fail ${res.statusMessage ?? res.toString()}");
@@ -136,6 +138,39 @@ class TokenInterceptor implements InterceptorsWrapper {
     }
   }
 
+  Future<void> _retryRequests(
+    List<({RequestOptions options, ErrorInterceptorHandler handler})> requests,
+  ) async {
+    await Future.wait(
+      requests.map((requestNeedRetry) async {
+        final options = requestNeedRetry.options;
+        options.extra[_retryAfterRefreshKey] = true;
+
+        try {
+          final response = await dio.fetch(options);
+          requestNeedRetry.handler.resolve(response);
+        } on DioException catch (error) {
+          requestNeedRetry.handler.reject(error);
+        } catch (error) {
+          requestNeedRetry.handler.reject(
+            DioException(
+              requestOptions: options,
+              error: error,
+            ),
+          );
+        }
+      }),
+    );
+  }
+
+  Future<void> _signOutLocally() async {
+    try {
+      await getIt.get<UserRepository>().signOut();
+    } catch (_) {
+      await tokenLocalDataSource.deleteToken();
+    }
+  }
+
   @override
   void onResponse(Response response, ResponseInterceptorHandler handler) {
     handler.next(response);