JWT token never gets updated on production build

[pszafer]

Hi,
My site is using only Google Sign In / Next-Auth with Apollo Client.
In dev run everything works well, but in production build (on Vercel) JWT token is never updated, so after first hour (JWT token from Google is valid for 1 hour) user have to refresh page to get it working.
I see several similar bugs, but I'm not sure if those are the same as mine, so I decided to ask here.

This is my code:

import NextAuth from 'next-auth';
import Providers from 'next-auth/providers';

const GOOGLE_AUTHORIZATION_URL =
  'https://accounts.google.com/o/oauth2/v2/auth?' +
  new URLSearchParams({
    prompt: 'consent',
    access_type: 'offline',
    response_type: 'code',
  });

async function refreshAccessToken(token) {
  try {
    const url =
      'https://oauth2.googleapis.com/token?' +
      new URLSearchParams({
        client_id: process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID,
        client_secret: process.env.GOOGLE_SECRET,
        grant_type: 'refresh_token',
        refresh_token: token.refreshToken,
      });

    const response = await fetch(url, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
      },
      method: 'POST',
    });

    const refreshedTokens = await response.json();
    if (!response.ok) {
      throw refreshedTokens;
    }
    return {
      ...token,
      accessToken: refreshedTokens.access_token,
      accessTokenExpires: Date.now() + refreshedTokens.expires_in * 1000,
      idToken: refreshedTokens.id_token,
      error: null,
      refreshToken: refreshedTokens.refresh_token ?? token.refreshToken, // Fall back to old refresh token
    };
  } catch (error) {
    console.log(error);

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

export default NextAuth({
  providers: [
    Providers.Google({
      clientId: process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_SECRET,
      authorizationUrl: GOOGLE_AUTHORIZATION_URL,
    }),
  ],
  callbacks: {
    async signIn(user, account, profile) {
      if (
        account.provider === 'google' &&
        profile.verified_email === true &&
        profile.email.endsWith('process.env.NEXT_PUBLIC_DOMAIN')
      ) {
        const { accessToken, idToken, provider } = account;
        user.accessToken = accessToken;
        user.idToken = idToken;
        user.provider = provider;
        return true;
      } else {
        return false;
      }
    },
    async jwt(token, user, account) {
      // Initial sign in
      console.log('JWT accessed');
      if (account && user) {
        return {
          accessToken: account.accessToken,
          accessTokenExpires: Date.now() + account.expires_in * 1000,
          refreshToken: account.refresh_token,
          idToken: account.id_token,
          error: null,
          user,
        };
      }
      if (Date.now() < token.accessTokenExpires) {
        return token;
      }
      return refreshAccessToken(token);
    },
    async session(session, token) {
      if (token) {
        session.user = token.user;
        session.accessToken = token.accessToken;
        session.idToken = token.idToken;
        session.error = token.error;
      }
      return session;
    },
  },
});

in apollo wraper:

import { useApollo } from 'lib/withApollo';
import { useSession } from 'next-auth/client';

const ApolloWrapper = ({ children }) => {
  const [googleUser] = useSession();
  const { idToken } = googleUser;
  const apolloClient = useApollo(idToken);
  return <ApolloProvider client={apolloClient}>{children}</ApolloProvider>;
};

Is there something wrong with my implementation or is this known bug?