The code for my API route where i want to get the session role, I am only getting the name and email:

export async function GET(req, res) {
    try {
        const session = await getServerSession({ req, res });

        if (!session) {
            return new NextResponse(
                JSON.stringify({
                    error: 'Unauthorized',
                }),
                {
                    status: 401,
                }
            );
        }

        if (session.user.role !== 'ADMIN') {
            return new NextResponse(
                JSON.stringify({
                    error: 'Permission Denied',
                }),
                {
                    status: 403,
                }
            );
        }

        const users = await prisma.user.findMany({
            where: {
                role: "USER"
            }
        });

        if (users.length === 0) {
            return new NextResponse(
                JSON.stringify({
                    error: 'Not Found',
                }),
                {
                    status: 404,
                }
            );
        }

        return NextResponse.json(users);

    } catch (error) {
        return new NextResponse(
            JSON.stringify({
                error: 'Internal Server Error',
                details: error.message,
            }),
            {
                status: 500,
            }
        );
    }
}

The code for the ..nextauth:

export const authOptions = {
    session: {
        strategy: 'jwt',
    },
    providers: [
        CredentialsProvider({
            name: 'Sign in',
            credentials: {
                email: {
                    type: 'email',
                },
                password: {
                    type: 'password',
                },
            },
            async authorize(credentials) {
                if (!credentials?.email || !credentials.password) {
                    return null;
                }

                const user = await prisma.user.findUnique({
                    where: {
                        email: credentials.email,
                    }
                });

                if (!user) {
                    throw new Error('Invalid e-mail or password');

                }

                const isPasswordValid = await compare(credentials.password, user.password);

                if (!isPasswordValid) {
                    throw new Error('Invalid e-mail or password');
                }

                return {
                    name: user.name,
                    phoneNumber: user.phoneNumber,
                    email: user.email,
                    role: user.role,
                };
            },
        }),
    ],

    pages: {
        signIn: '/',
    },

    callbacks: {
        session: async ({ session, token }) => {
            console.log('Session Callback', { session, token });
            return {
                ...session,
                user: {
                    ...session.user,
                    id: token.id,
                    name: token.name,
                    email: token.email,
                    phoneNumber: token.phoneNumber,
                    role: token.role,
                },
            };
        },
        jwt: async ({ token, user }) => {
            console.log('JWT Callback', { token, user });
            if (user) {
                const u = user;
                return {
                    ...token,
                    id: u.id,
                    name: u.name,
                    email: u.email,
                    phoneNumber: u.phoneNumber,
                    role: u.role,
                };
            }
            return token;
        },
    },
};

const handler = NextAuth(authOptions);
export { handler as GET, handler as POST };