According to the information provided (https://next-auth.js.org/providers/credentials#example)

async authorize(credentials, req) {
  // Implement your custom logic here to retrieve user data based on the credentials
  const user = { id: 1, name: 'John Doe', email: '<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="acb8b7afb9aae4bbbdb988b5bfb3cbacbb">[email protected]</a>' }

  if (user) {
    // Any object returned will be stored in the JWT's `user` property
    return user
  } else {
    // Return null or false to reject the credentials
    return null
    // You can also trigger an Error or specify a URL for rejection:
    // throw new Error('error message') // Redirect to error page
    // throw '/path/to/redirect'        // Redirect to a URL
  }
}

Ensure that you are returning either a user object or null from the authorize callback.

shanewwarren's initial answer is accurate, but allow me to provide a more detailed explanation:

To tackle this issue, we can utilize the axios library.

 async authorize(credentials, req) {
        return axios
          .post(`${process.env.NEXT_PUBLIC_STRAPI_API}/auth/login`, {
            identifier: credentials.identifier,
            password: credentials.password,
          })
          .then((response) => {
            return response.data;
          })
          .catch((error) => {
            console.log(error.response);
            throw new Error(error.response.data.message);
          }) || null;
      },

Consider including a try/catch block within the async function authorize(credentials) {} to handle errors more effectively. In my experience, adding some logging statements was instrumental in troubleshooting an issue that ultimately required switching to a different Node.js version.

I encountered the same error, but found a solution that worked:

export const authOptions = {
  secret: process.env.SECRET,
  adapter: MongoDBAdapter(clientPromise),
  providers: [
    GoogleProvider({
      clientId: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    }),
    CredentialsProvider({
      name: 'Credentials',
      id: 'credentials',
      credentials: {
        username: { label: "Email", type: "email", placeholder: "<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="5b2f3e282f1b3e233a362b373e75383436">[email protected]</a>" },
        password: { label: "Password", type: "password" },
      },
      async authorize(credentials, req) {
        // const user1 = { id: 1, name: 'J Smith', email: '<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="600a130d091408200518010d100c054e030f0d">[email protected]</a>' }
        const email = credentials?.email;
        const password = credentials?.password;

        mongoose.connect(process.env.MONGO_URL);
        const user = await User.findOne({email});
        const passwordOk = user && bcrypt.compareSync(password, user.password);
        // if (user1) {
        //   return user1;
        // }
        if (passwordOk) {
          return user;
        }

        return null
      }
    })
  ],
  session: {
    strategy: 'jwt'
  },
  secret: process.env.SECRET,
  // callbacks: {
  //   async jwt(token, user) {
  //     if (user) {
  //       console.log(user, "user jwt");
  //       token.id = user.id;
  //       token.name = user.name;
  //     }
  //     console.log(token,"token jwt");
  //     return token;
  //   },
  // },
  // callbacks: {
  //   async session(session, token) {
  //     // if you need to add more info in session
  //     console.log(token,"token session");
  //     session.user.id = token.id;
  //     session.user.name = token.name;
  //     console.log(session,"session");
  //     return session;
  //   },
  // },
};
const handler = NextAuth(authOptions);

export { handler as GET, handler as POST }

Login:

"use client";
import { signIn } from "next-auth/react";
import Image from "next/image";
import { useState } from "react";

export default function LoginPage() {
  const [email, setEmail] = useState("");
  const [password, setPassword] = useState("");
  const [loginInProgress, setLoginInProgress] = useState(false);

  async function handleFormSubmit(ev) {
    ev.preventDefault();
    setLoginInProgress(true);

    await signIn("credentials", { email, password, callbackUrl: "/" });

    setLoginInProgress(false);
  }
  return (
    <section className="mt-8">
      <h3 className="text-center text-primary font-extrabold text-4xl mb-4">
        Login
      </h3>
      <form className="max-w-xs mx-auto" onSubmit={handleFormSubmit}>
        <input type="email" name="email" placeholder="email" value={email}
               disabled={loginInProgress}
               onChange={ev => setEmail(ev.target.value)} />
        <input type="password" name="password" placeholder="password" value={password}
               disabled={loginInProgress}
               onChange={ev => setPassword(ev.target.value)}/>
        <button disabled={loginInProgress} type="submit">Login</button>
      </form>
    <hr className="mt-6"/>
      <div className="max-w-xs mx-auto">
        <div className="my-4 text-center text-gray-500">
          login with provider
        </div>
        <button
          type="button"
          onClick={() => signIn("google", { callbackUrl: "/" })}
          className="flex gap-4 justify-center"
        >
          <Image src={"/google.png"} alt={""} width={24} height={24} />
          Login with google
        </button>
      </div>
    </section>
  );
}

Dealing with a similar issue, I encountered some challenges.

To resolve it, I included a `try/catch` block in my fetch request and utilized a console.log() statement within the catch block to track errors effectively.

In my case, the root cause of the problem stemmed from a

self-signed certificate

To address this issue, I implemented NODE_TLS_REJECT_UNAUTHORIZED=0 in my .env.local file, efficiently resolving the error.

import type { NextAuthConfig } from "next-auth";
import Credentials from "next-auth/providers/credentials";
import axios from "axios";

export default {
  providers: [
    Credentials({
      credentials: {
        email: {},
        password: {},
      },
      authorize: async (credentials) => {
        let userInfo = null;

        userInfo = await axios.post("https://fakejson.com/auth/login", {
          email: credentials.email,
          password: credentials.password,
        });

        if (userInfo) {
          return userInfo.data;
        }

        return null;
      },
    }),
  ],
} meets requirements of NextAuthConfig;