NextAuth is redirecting to http://localhost:3000/api/auth/signin?error=OAuthCallback page after authorizing Zoom account

[rishipatel2005]

I have set up the zoom connect option in my website so that I can add zoom meeting functionality to my next.js website. I already have the sign in with Google option to authenticate the user, and once the user is authenticated I give them the option to connect their zoom account. But when I write the code in NextAuth to add the zoom authentication option it works fine, zoom asks for permission but once I give the permission and authenticate it, NextAuth redirects me to doamin.com instead of the account page.

My /api/[...nextauth] code:

import NextAuth from "next-auth/next";
import { authOptions } from "@/lib/authentication";

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

/lib/authentication:

import { Account, User as AuthUser } from "next-auth";

import GoogleProvider from "next-auth/providers/google";
import CredentialsProvider from "next-auth/providers/credentials";
import Zoom from "next-auth/providers/zoom";

import bcrypt from "bcryptjs";
import User from "@/models/user";
import connectMongoDB from "@/lib/mongoose";

interface User {
    id: string;
    name: string;
    email: string;
    username: string;
    image: string;
    provider: string;
    role: string;
    categories: string[];
}

declare module "next-auth" {
    interface Session {
        user: User;
    }
}

export const authOptions: any = {
    providers: [
        CredentialsProvider({
            id: "credentials",
            name: "Credentials",
            credentials: {
                email: { label: "Email", type: "text" },
                password: { label: "Password", type: "password" },
            },
            async authorize(credentials: any) {
                await connectMongoDB();
                try {
                    const user = await User.findOne({ email: credentials.email });
                    if (user) {
                        const isPasswordCorrect = await bcrypt.compare(credentials.password, user.password);
                        if (isPasswordCorrect) {
                            return user;
                        }
                    }
                } catch (err: any) {
                    throw new Error(err);
                }
            },
        }),
        GoogleProvider({
            clientId: process.env.GOOGLE_CLIENT_ID ?? "",
            clientSecret: process.env.GOOGLE_CLIENT_SECRET ?? "",
            authorization: {
                params: {
                    prompt: "consent",
                    access_type: "offline",
                    response_type: "code",
                },
            },
        }),
        Zoom({
            clientId: process.env.ZOOM_CLIENT_ID ?? "",
            clientSecret: process.env.ZOOM_CLIENT_SECRET ?? "",
        }),
    ],
    callbacks: {
        async signIn({ user, account }: { user: AuthUser; account: Account }) {
            if (account?.provider == "credentials") {
                return true;
            }
            if (account?.provider == "google") {
                await connectMongoDB();

                try {
                    const existingUser = await User.findOne({ email: user.email }); 

                    // If user does not exist, create a new user
                    if (!existingUser) {
                        const generatedUsername = user.email!.split("@")[0].slice(0, 16);

                        const newUser = new User({
                            name: user.name,
                            email: user.email,
                            username: generatedUsername,
                            image: user.image,
                            provider: "google",
                        });

                        await newUser.save(); 
                        return true;
                    }

                    return true;
                } catch (err) {
                    console.log("Error saving user", err);
                    return false;
                }
            }

            if (account?.provider == "zoom") return true;
        },

        async jwt({ token, trigger, user, session, account }: { token: any; trigger: any; user: any; session: any; account: any }) {
            if ((trigger === "signIn" || trigger === "signUp") && user) {
                const userData = await User.findOne({ email: user.email });
                console.log(userData);
                token.id = userData._id;
                token.name = userData.name;
                token.email = userData.email;
                token.username = userData.username;
                if (userData.image) token.image = `${userData.image}?${new Date().getTime()}`;
                token.provider = userData.provider;
                token.role = userData.role;
                token.categories = userData.categories;
                console.log(token);
            }

            if (trigger === "update") {
                return { ...token, ...session.user };
            }

            return token;
        },

        async session({ session, token }: { session: any; token: any }) {
            if (session.user) {
                session.user.id = token.id;
                session.user.name = token.name;
                session.user.email = token.email;
                session.user.username = token.username;
                session.user.image = token.image;
                session.user.provider = token.provider;
                session.user.role = token.role;
                session.user.categories = token.categories;
                session.zoomAccessToken = token.zoomAccessToken;
                session.zoomRefreshToken = token.zoomRefreshToken;
            }

            return session;
        },
    },
};

Button code in Next.js (with NextUI):
<Button onPress={() => signIn("zoom")}>Connect Zoom</Button>