307 Status Code(Temporary Redirect)

[epenflow]

Facing an issue 307 Status Code (Temporary Redirect) when sign in and tries to redirect to /settings, however upon refreshing the browser page the issue suddenly disappears and status code changes from 307 to 200.

///routes.ts
export const DEFAULT_LOGIN_REDIRECT_URL = '/settings';
export const PUBLIC_ROUTES = ['/', '/auth/new-verification'];
export const AUTH_ROUTES = [
	'/auth/login',
	'/auth/register',
	'/auth/error',
	'/auth/reset',
	'/auth/new-password',
];
export const API_AUTH_PREFIX = '/api/auth';

///midleware.ts
import authConfig from '@/auth.config';
import {
    API_AUTH_PREFIX,
    AUTH_ROUTES,
    DEFAULT_LOGIN_REDIRECT_URL,
    PUBLIC_ROUTES,
} from '@/routes';
import NextAuth from 'next-auth';
import { NextResponse } from 'next/server';

const { auth } = NextAuth(authConfig);
export default auth((request): any => {
    const { nextUrl } = request;
    let isLoggedIn = !!request.auth;

    const isApiAuthRoute = nextUrl.pathname.startsWith(API_AUTH_PREFIX);
    const isPublicRoute = PUBLIC_ROUTES.includes(nextUrl.pathname);
    const isAuthRoute = AUTH_ROUTES.includes(nextUrl.pathname);

    if (isApiAuthRoute) {
        return null;
    }
    console.log(isLoggedIn);
    if (isAuthRoute) {
        if (isLoggedIn) {
            return NextResponse.redirect(
                new URL(DEFAULT_LOGIN_REDIRECT_URL, nextUrl),
            );
        }
        return null;
    }
    if (!isLoggedIn) {
        return NextResponse.redirect(new URL('/auth/login', nextUrl));
    }
    return null;
});
export const config = {
    matcher: ['/((?!.+\\.[\\w]+$|_next).*)', '/', '/(api|trcp)(.*)'],
};

///auth.ts
import { db } from '@/lib/db';
import NextAuth from 'next-auth';
import { PrismaAdapter } from '@auth/prisma-adapter';
import authConfig from '@/auth.config';
import { getUserById } from '@/data/user';
export const { handlers, auth, signIn, signOut } = NextAuth({
    pages: {
        signIn: '/auth/login',
    },
    events: {
        async linkAccount({ user }) {
            await db.user.update({
                where: {
                    id: user.id,
                },
                data: {
                    emailVerified: new Date(),
                },
            });
        },
    },
    callbacks: {
        async signIn({ user, account }) {
            if (account?.provider !== 'credentials') return true;
            const existingUser = await getUserById(user.id);
            if (!existingUser?.email) return false;
            return true;
        },
        async jwt({ token }) {
            return token;
        },
    },
    adapter: PrismaAdapter(db),
    session: { strategy: 'jwt' },
    ...authConfig,
    secret: process.env.AUTH_SECRET,
});

///
auth.config.ts
import { getUserByEmail } from '@/data/user';
import { LoginSchema } from '@/schema';
import { NextAuthConfig } from 'next-auth';
import Credentials from 'next-auth/providers/credentials';
import bcrypt from 'bcryptjs';
export default {
    providers: [
        Credentials({
            async authorize(credentials, request) {
                const validatedFields = await LoginSchema.safeParse(
                    credentials,
                );
                if (validatedFields.success) {
                    const { email, password } = validatedFields.data;
                    const user = await getUserByEmail(email);
                    if (!user || !user.password) return null;
                    const passwordMatch = await bcrypt.compare(
                        password,
                        user.password,
                    );
                    if (user && passwordMatch) return user;
                }
                return null;
            },
        }),
    ],
} satisfies NextAuthConfig;

///login.ts
'use server';
import * as z from 'zod';
import { LoginSchema } from '@/schema';
import { getUserByEmail } from '@/data/user';
import { signIn } from '@/auth';
import { AuthError } from 'next-auth';
import { DEFAULT_LOGIN_REDIRECT_URL } from '@/routes';

type ReturnLogin = {
    error?: string;
    success?: string;
};
export async function login(values: z.infer<typeof LoginSchema>) {
    const validatedFields = await LoginSchema.safeParseAsync(values);

    if (!validatedFields.success) {
        return { error: 'Something went wrong!' };
    }
    const { email, password } = validatedFields.data;
    const existingUser = await getUserByEmail(email);
    if (!existingUser || !existingUser?.email) {
        return { error: 'Email does not exist!' };
    }
    try {
        await signIn('credentials', {
            email,
            password,
            redirectTo: DEFAULT_LOGIN_REDIRECT_URL,
            redirect: true,
        });
    } catch (error) {
        if (error instanceof AuthError) {
            switch (error.type) {
                case 'CredentialsSignin':
                    return { error: 'Invalid Credentials!' };
                case 'CallbackRouteError':
                    return { error: error.cause?.err?.message };
                default:
                    return { error: 'Something went wrong!' };
            }
        }
    }
    return { success: 'Login success' };
}


`