I configure nextauth with Keycloak provider I redirected to this page api/auth/error if I left tab open for a while.

[ArslanAkhtar]

Hi, I am new with nextauth. I have configure keylcloak with nextauth it is working fine except when I left site open for a while in other tab it redirected to api/auth/error page and does not show any specific errors It just give redirect option to redirect on site. I have written auto redirect script on the following url api/auth/error I have created error.tsx

`import { NextApiResponse, NextApiRequest } from 'next';

export default function handler(req: NextApiRequest, res: NextApiResponse) {
res.writeHead(307, { Location: '/' });
res.end();
}
`

Then found this is not the write way because it didnt give any error if the keycloak went down.

This is my authOptions file

`import { getServerSession, type NextAuthOptions } from 'next-auth';
import KeycloakProvider from 'next-auth/providers/keycloak';
import { env } from '@env';
import { TokenSet } from 'next-auth/core/types';
import { JWT } from 'next-auth/jwt';
import axios from 'axios';

async function refreshAccessToken(token: JWT) {
try {
const response = await fetch(${env.KEYCLOAK_ISSUER}/protocol/openid-connect/token, {
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: new URLSearchParams({
client_id: env.KEYCLOAK_CLIENT_ID,
client_secret: env.KEYCLOAK_CLIENT_SECRET,
grant_type: 'refresh_token',
refresh_token: token.refresh_token ?? ''
}),
method: 'POST'
});

    const tokens: TokenSet & { expires_in: number } = await response.json();

    if (!response.ok) throw tokens;

    return {
        access_token: tokens.access_token,
        expires_at: Math.floor(Date.now() / 1000 + (tokens.expires_in ?? 0)),
        refresh_token: tokens.refresh_token ?? token.refresh_token,
        roles: token.roles,
        username: token.username,
        preferred_username: token.preferred_username,
        email: token.email,
        sub: token.sub
    };
} catch (error) {
    return { ...token, error: 'RefreshAccessTokenError' as const };
}

}
export const authOptions: NextAuthOptions = {
session: {
strategy: 'jwt'
},
secret: env.NEXTAUTH_SECRET,
callbacks: {
function

    async jwt(args) {
        const { token, account, profile } = args;
        if (account) {
            return {
                access_token: account.access_token,
                expires_at: account.expires_at,
                id_token: account.id_token,
                refresh_token: account.refresh_token,
                sub: account.providerAccountId ?? profile?.sub,
                roles: profile?.roles,
                username: profile?.name,
                preferred_username: profile?.preferred_username,
                email: profile?.email
            };
        }


        const now = Math.floor(Date.now() / 1000);
        if (token.expires_at && now < token.expires_at) {
            return token;
        }

        return refreshAccessToken(token);
    },
    async session(args) {
        const { session, token } = args;

        return {
            ...session,
            user: {
                ...session.user,
                id: token.sub,
                name: token.username,
                email: token.email,
                roles: token.roles,
                username: token.preferred_username
            },
            access_token: token.access_token,
            refresh_token: token.refresh_token,
            expires_at: token.expires_at,
            error: token.error
        };
    }
},
providers: [
    // see: https://next-auth.js.org/providers/keycloak
    KeycloakProvider({
        id: 'keycloak',
        name: 'keycloak',
        clientId: env.KEYCLOAK_CLIENT_ID,
        clientSecret: env.KEYCLOAK_CLIENT_SECRET,
        issuer: env.KEYCLOAK_ISSUER,
        profile(profile) {
            return {
                id: profile.sub,
                name: profile.name,
                preferred_username: profile.preferred_username,
                email: profile.email,
                image: profile.picture,
                roles: profile.roles
            };
        },
        authorization: { params: { scope: 'openid email profile offline_access' } }
    })
],
events: {
    signOut: async (args) => {
        const { token } = args;
        const params = new URLSearchParams();

        params.append('id_token_hint', token.id_token || '');
        await axios.get(`${env.KEYCLOAK_ISSUER}/protocol/openid-connect/logout?${params.toString()}`);
    }
}

};
export async function getServerAuthSession(req: any, res: any) {
return await getServerSession(req, res, authOptions);
}

declare module 'next-auth/core/types' {
interface Session {
access_token?: string;
refresh_token?: string;
expires_at?: number;
user: DefaultSession['user'] & { id?: string; roles?: string[]; username?: string; email?: string };
error?: 'RefreshAccessTokenError';
}
}

declare module 'next-auth' {
interface Profile {
roles?: string[];
preferred_username?: string;
}
}

declare module 'next-auth/jwt' {
interface JWT {
id_token?: string;
preferred_username?: string;
username?: string;
access_token?: string;
refresh_token?: string;
roles?: string[];
expires_at?: number;
sub?: string;
error?: 'RefreshAccessTokenError';
}
}`