Please help me with this refresh token issue

[ryannovarypradana]

I've encountered an issue where the refresh token operation is initially successful, but after several attempts, it fails to fully update. Subsequently, all attempts to refresh fail continuously. Is there any suggestion to ensure the refresh token process always succeeds, regardless of how many times it's attempted? my next auth version : 4.24.4 and next 13.4.10
this my code

 import type { NextAuthOptions } from 'next-auth';
import CredentialsProvider from 'next-auth/providers/credentials';
import AuthService from '@/app/service/authService';
import axios, { AxiosRequestConfig } from 'axios';

let isRefreshing = false;
let refreshPromise: Promise<any> | null = null;

export async function refreshAccessToken(token: any) {
  console.log('refresh token in process');
  // console.log('access token: ' + token.tokenAccess);
  // console.log('refresh token: ' + token.refreshToken);

  if (isRefreshing) {
    console.log('Refresh token is currently running, skip refresh');
    return refreshPromise;
  }

  console.log('Processing the refresh token');

  const baseUrl = process.env.REACT_APP_API_URL;
  try {
    const url = baseUrl + '/token-refresh';
    const tokenAccess = token.tokenAccess;
    console.log('Token sent for refresh:', tokenAccess);

    const config: AxiosRequestConfig = {
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${tokenAccess}`,
      },
    };

    isRefreshing = true; // Set flag to true to prevent double refresh token

    // Start the refresh process and save to refreshPromise so other requests can wait
    refreshPromise = axios.get(url, config)
      .then((res) => {
        if (res.status === 200) {
          // console.log('Successfully got a new token:', res.data.new_token.token);

          // Reset flag after refresh is complete
          isRefreshing = false;
          refreshPromise = null;

          // Return the new token
          return {
            ...token,
            tokenAccess: res.data.new_token.token,
            expires_in: Date.now() + 22120 * 1000, // Update token expiration time
            refreshToken: res.data.new_token.token ?? token.refreshToken, // Use new refresh token if available
          };
        } else {
          console.log('Failed to get new token:', res.status, res.data);
          throw new Error('Failed to refresh token');
        }
      })
      .catch((error) => {
        console.error('Error refreshing token:');
        // console.error('Error refreshing token:', error.response ? error.response.data : error.message);

        isRefreshing = false; // Reset flag when error occurs
        refreshPromise = null;

        // Return token with error
        return {
          ...token,
          error: 'RefreshAccessTokenError',
        };
      })

    return refreshPromise;
  } catch (error: any) {
    console.error('Failed to get new token, catch error:', error.message);

    isRefreshing = false;
    refreshPromise = null;

    return {
      ...token,
      error: "RefreshAccessTokenError",
    };
  }
}

export const authOptions: NextAuthOptions = {
  session: {
    strategy: "jwt",
    // maxAge: 120,
  },
  jwt: {
    secret: process.env.NEXTAUTH_SECRET,
  },
  providers: [
    CredentialsProvider({
      name: "Credentials",
      credentials: {
        email: { label: "Email / Phone Number", type: "email" },
        password: { label: "Password", type: "password" },
      },
      async authorize(credentials) {
        const payload = {
          user: {
            email_phone: credentials!.email,
            password: credentials!.password
          }
        }
        const res = await AuthService.handleLogin(payload);
        if (res.status === 200) {
          const user = {
            id: res.data.data.user_id,
            role: res.data.data.user_type,
            tokenAccess: res.data.data.access_token,
            // expires_in: res.data.data.expires_in,
            expires_in: Date.now() + 120 * 1000, // hardcoded for access token to be 2 minutes for now
            dataUser: res.data.data.user,
          }
          console.log('this is user', user)
          return user;
        } else {
          return null
        }
      }
    })
  ],
  callbacks: {
    async jwt({ token, account, user, trigger, session }: any) {

      // This will be for updating profile
      if (trigger === 'update') {
        token.dataUser = session.user.dataUser;
      }

      if (account && user) {
        if (account?.provider === 'credentials') {
          token.id = user.id;
          token.role = user.role;
          token.tokenAccess = user.tokenAccess;
          token.expires_in = user.expires_in;
          token.dataUser = user.dataUser;
          token.refreshToken = user.tokenAccess;
        }
      }
      console.log('this is current token', token.tokenAccess)
      console.log(token.expires_in)
      console.log('this is current time', Date.now())
      const bufferTime = 60 * 1000; // 60 seconds

      // Check if token is about to expire (less than bufferTime)
      if (Date.now() < token.expires_in) {
        console.log('token')
        return token; // Token is still valid, no need to refresh


      }



      if (token.error === "RefreshAccessTokenError") {
        console.log("Token refresh already failed, not trying again.");
        return token;
      }

      console.log('Token before update:', token.tokenAccess);
      const refreshedToken = await refreshAccessToken(token);
      console.log('Token after update on refresh token:', refreshedToken.tokenAccess);
      console.log('Token after update on token:', token.tokenAccess);
      if (refreshedToken.error) {
        // If refresh fails, mark token with error to not try again
        token.error = refreshedToken.error;
      }

      // return refreshAccessToken(token);
      return refreshedToken;
    },

    async session({ session, token }: any) {

      if (token) {
        // session.user.dataUser = token.dataUser;
        // session.user.role = token.role;
        // session.accessToken = token.tokenAccess;
        // session.error = token.error;

        if ("dataUser" in token) {
          session.user.dataUser = token.dataUser;

        }
        if ("role" in token) {
          session.user.role = token.role;
        }
        if ("tokenAccess" in token) {
          session.user.name = token.tokenAccess; // access token is stored in the name variable in session data
        }
        if ("expires_in" in token) {
          session.user.expires_in = token.expires_in;
        }
        if (token) {
          session.accessToken = token.tokenAccess as string}
      }
      session.error = token.error
      return session
    }
  },
  pages: {
    signIn: "/login",
  },
}

and this my middleware

import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'
import withAuth from './middlewares/withAuth';


export async function mainMiddleware(req: NextRequest) {

  const res = NextResponse.next();
  return res;
}
export default withAuth(mainMiddleware, [
  "/admin",
  "/cart",
  "/checkout",
  "/checkout/payment/[number]",
  "/loyalty",
  "/settings",
]);

import { getToken } from "next-auth/jwt";
import { NextFetchEvent, NextMiddleware, NextRequest, NextResponse } from "next/server";

export default function withAuth(
  middleware: NextMiddleware, requireAuth: string[] = []) {
  return async (req: NextRequest, next: NextFetchEvent) => {
    const pathname = req.nextUrl.pathname;
    if (requireAuth.includes(pathname) || pathname.startsWith('/admin') || pathname === '/login' || requireAuth.some(route => pathname.startsWith(route))) {
      const token = await getToken({
        req, secret: process.env.NEXTAUTH_SECRET
      });
      if (!token) {
        if (pathname === '/login') {
          return middleware(req, next);
        }
        const url = new URL('/login', req.url);
        return NextResponse.redirect(url);

      }
      else {
        if (pathname === '/login') {
          const url = new URL('/', req.url);
          return NextResponse.redirect(url);
        }
        if (pathname.startsWith('/admin') && token.role !== 'YWRtaW4=') {
          const url = new URL('/', req.url);
          return NextResponse.redirect(url);
        }
      }

    } else {
      return middleware(req, next);
    }
    return middleware(req, next)
  }
}

Are there any recommendations to ensure that the refresh token process works as expected every time? I'm looking for solutions that guarantee success in refreshing tokens, no matter how many attempts are made. I've been stuck on this refresh token issue for two weeks now. Any advice or solutions would be greatly appreciated