NextAuth: Redirect Back to Original URL After Login

const onSubmit = async (data: { clientId: string; secret: string }) => {
 setError("");

 const result = await signIn("credentials", {
 clientId: data.clientId,
 secret: data.secret,
 redirect: false,
 });

 if (result?.error) {
 setError("Invalid credentials. Please try again.");
 return;
 }

 if (result?.ok) {
 router.push("/reconciliation");
 }
};

export { default } from "next-auth/middleware"
import { NextResponse, NextRequest } from "next/server";
import { getToken } from "next-auth/jwt";
import { hasRole } from "@/app/utils/roleUtils";

export async function proxy(req: NextRequest) {
 console.log("🚀 Middleware Triggered 🚀");
 const token = await getToken({ req, secret: process.env.NEXTAUTH_SECRET });
 console.log("🌍 URL :", req.nextUrl.pathname);
 console.log("🔑 Token founded");

 if (!token) {
 console.log("No token found, redirecting to login page");
 return NextResponse.redirect(new URL("/", req.url));
 }

 // Get the current path
 const path = req.nextUrl.pathname;

 // Get user roles from token (array of roles)
 const userRoles = token.roles as string[] || [];
 
 console.log("User roles:", userRoles);

 // Check if user has the required SYS_FINANCE role
 if (!hasRole(userRoles, "SYS_FINANCE")) {
 console.log("Access denied: User does not have SYS_FINANCE role");
 return NextResponse.redirect(new URL("/unauthorized", req.url));
 }

 return NextResponse.next();
}

export const config = {
 matcher: ["/reconciliation/:path*, /detail/:path*", "/account/:path*", "/unauthorized/:path*"],
};

import CredentialsProvider from "next-auth/providers/credentials";
import {NextAuthOptions} from "next-auth";
import {JWT} from "next-auth/jwt";

export const authOptions : NextAuthOptions = {
 providers: [
 CredentialsProvider({
 name: "Credentials",
 credentials: {
 clientId: {label: "clientId", type: "text"},
 secret: {label: "secret", type: "password"},
 },
 async authorize(credentials, _req): Promise<any> {
 console.log('api url : '+process.env.NEXT_PUBLIC_API_BASE_URL);
 console.log('callback url : '+process.env.NEXTAUTH_CALLBACK_URL);
 console.log('front url : '+process.env.NEXTAUTH_URL);
 try {
 const res = await fetch(`${process.env.NEXT_PUBLIC_AUTH_API_BASE_URL}/api/v1/authentication/token/admin`, {
 method: "POST",
 headers: {"Content-Type": "application/json"},
 body: JSON.stringify({
 clientId: credentials?.clientId,
 secret: credentials?.secret,
 }),
 });

 if (!res.ok) {
 const errorData = await res.json();
 console.log(`❌ Login failed: ${res.status} - ${errorData.message}`);
 throw new Error(`Login failed: ${res.status} - ${errorData.message}`);
 }

 const data = await res.json();
 return {
 clientId: data.clientId,
 token: data.token,
 };
 } catch (error) {
 console.error("❌ Error in authentication:", error);
 throw new Error(error.message || "Unknown authentication error");
 }
 },
 }),
 ],
 session: {strategy: "jwt", maxAge: 15 * 60},
 callbacks: {
 async jwt({token, user}: { token: JWT, user: any }) {
 if (user) {
 (token as any).id = user.id;
 (token as any).token = user.token;
 (token as any).clientId = user.clientId;

 const decodedAccessToken = JSON.parse(Buffer.from(user.token.split(".")[1], "base64").toString())
 console.debug("decodedAccessToken :" + Buffer.from(user.token.split(".")[1], "base64"));
 
 // Store all roles as an array
 if (decodedAccessToken.roles && Array.isArray(decodedAccessToken.roles)) {
 (token as any).roles = decodedAccessToken.roles.map((role: any) => role.authority);
 } else if (decodedAccessToken.roles) {
 (token as any).roles = [decodedAccessToken.roles.authority];
 } else {
 (token as any).roles = [];
 }
 
 if (decodedAccessToken) {
 (token as any).accessTokenExpires = decodedAccessToken["exp"] * 1000
 }

 if ((token as any).accessTokenExpires && (Date.now() > Number((token as any).accessTokenExpires))) {
 console.log("token expired");
 return null
 }
 }
 return token;
 },
 async session({session, token}: { session:any,token: JWT }) {
 console.log("session :" + (token as any).clientId);

 if (!token) {
 return null;
 }
 session.user.token = (token as any).token;
 session.user.clientId = (token as any).clientId;
 session.user.roles = (token as any).roles; // Array of all roles
 return session;
 },
 },
 pages: {
 signIn: "/",
 error: "?error=true",

 },
 secret: process.env.NEXTAUTH_SECRET,
};