Refresh Access Token is being called immediately after it's refreshed and the jwt function returns a stale token.

[shubhamsWEB]

import NextAuth from "next-auth";
import CredentialsProvider from "next-auth/providers/credentials";

function parseJwt(token) {
    return JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
}
async function refreshAccessToken(token) {
    console.log("🚀 Refreshing access token", token);
    try {
      const response = await fetch(`${process.env.NEXT_PUBLIC_ASTRO_API_URL}/astro/v2/astrologer/tokens/refresh/${token?.astro_id}`, {
        method: 'POST',
        body: JSON.stringify({
          data: {
            token: token.refreshToken,
            device_info: {
              astro_id: token.astro_id,
              device_id: token?.details?.device_id,
              platform: "web",
              device_type: 'web'
            }
          }
        }),
        headers: {
          "Authorization": `Bearer ${token.refreshToken}`,
          "Content-Type": "application/json"
        }
      });
  
      const tokens = await response.json();
      console.log("🚀 ~ refreshAccessToken ~ tokens:", tokens);
  
      if (!response.ok || !tokens?.data?.tokens) {
        throw new Error('Failed to refresh token');
      }
  const decodedToken = parseJwt(tokens?.data?.tokens?.session);
      return {
        astro_id: tokens?.data?.details?.astro_id,
        details: tokens?.data?.details,
        accessToken: tokens?.data?.tokens?.session || token.accessToken,
        refreshToken: tokens?.data?.tokens?.refresh || token.refreshToken, // Fall back to old refresh token if not returned
        accessTokenExpires: decodedToken?.about_to_expiry * 1000, // Update expiration
      };
    } catch (error) {
      console.log(error);
  
      return {
        ...token,
        error: "RefreshAccessTokenError",
      };
    }
  }
  

export const authOptions = {
  providers: [
    CredentialsProvider({
                    name:"credentials",
                    credentials: {
                        country_code: {},
                        mobile: {},
                        otp: {},
                        type: {},
                        device_id: {},
                        token:{}
                    },
                    async authorize(credentials) {
                        if (!credentials?.otp || !credentials?.mobile) return null;
        
                        try {
                            const res = await fetch(`${process.env.NEXT_PUBLIC_ASTRO_API_URL}/astro/v2/astrologer/login/${credentials?.device_id}`, {
                                method: 'POST',
                                body: JSON.stringify({
                                    data: {
                                        "country_code": credentials?.country_code,
                                        "mobile": credentials?.mobile,
                                        "otp": credentials?.otp,
                                        "type": "otp"
                                    }
                                }),
                                headers: {
                                    'Content-Type': 'application/json',
                                    'Authorization': `Bearer ${credentials?.token}`
                                }
                            });
        
                            if (!res.ok) {
                                return null;
                            }
        
                            const data = await res.json();
        
                            if (data?.data?.status !== 'success') {
                                return null;
                            }
        
                            const { tokens, details } = data?.data;
        
                            return {
                                astro_id: details?.astro_id,
                                accessToken: tokens?.session,
                                refreshToken: tokens?.refresh,
                                details: details
                            };
                        } catch (e) {
                            console.error(e);
                            return null;
                        }
                    },
                })
  ],
  callbacks: {
    async jwt({ token, account, user }: { token: any; account: any; user: any }) {
        console.log(`In jwt callback - Token is ${JSON.stringify(token)}`);
      
        // If it's a new sign-in, update the token
        if (account && user) {
          console.log(`In jwt callback - User is ${JSON.stringify(user)}`);
          console.log(`In jwt callback - account is ${JSON.stringify(account)}`);
          return {
            ...token,
            accessToken: user.accessToken,
            refreshToken: user.refreshToken,
            astro_id: user.astro_id,
            details: user.details,
          };
        }
      
        // Parse the current access token to check expiration
        const decodedToken = parseJwt(token.accessToken);
        token.accessTokenExpires = decodedToken?.about_to_expiry * 1000;
      
        // If the token is still valid, return the current token
        if (Date.now() < token.accessTokenExpires) {
          console.log("**** Returning current token ******");
          return token;
        }
      
        // If the token has expired, refresh it
        const newtokens = await refreshAccessToken(token); // Await the token refresh
        token = {
            ...token,
            accessToken: newtokens.accessToken,
            refreshToken: newtokens.refreshToken,
            accessTokenExpires: newtokens.accessTokenExpires,
            astro_id: newtokens.astro_id,
            details: newtokens.details,
          };
        
          console.log("**** Returning new token ******", token);
          return token;
      },
    async session({ session, token }) {
        console.log("🚀 ~ session ~ token:", token);
        if(token) {
            session.user.astro_id = token.astro_id;
            session.user.details = token.details;
            session.user.accessToken = token.accessToken;
            session.user.refreshToken = token.refreshToken;
            session.user.accessTokenExpires = token.accessTokenExpires;
        }
        return session;
    },
  },

  secret: process.env.NEXTAUTH_SECRET,
//   pages: {
//     signIn: "/auth/signin", // Custom sign-in page
//   },
};
const handler = NextAuth(authOptions);

// Support both GET and POST methods
export { handler as GET, handler as POST };

Any help is verygreateful.