[next-auth][error][CLIENT_FETCH_ERROR] "\nhttps://next-auth.js.org/errors#client_fetch_error" "Failed to execute 'json' on 'Response': Unexpected end of JSON input" {}

//options.ts
import type {NextAuthOptions} from "next-auth";
import CredentialsProvider from "next-auth/providers/credentials";

import prisma from "@/lib/prisma";
import bcrypt from "bcryptjs";

export const options: NextAuthOptions = {
    providers: [CredentialsProvider({
        name: "Credentials", credentials: {
            username: {
                label: "Username", type: "text", placeholder: "username"
            }, password: {
                label: "Password", type: "password", placeholder: "password"
            }
        }, async authorize(credentials) {
            if (!credentials?.username || !credentials?.password) {
                return null;
            }

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

            if (!user) {
                console.error("Utente non trovato");
                return null;
            }

            const isPasswordValid = await bcrypt.compare(credentials?.password, user.password);
            if (!isPasswordValid) {
                console.error("Password errata");
                return null;
            }

            return {id: user.id.toString(), name: user.username};
        }
    })], pages: {
        signIn: "/auth/login",
        signOut: "/auth/login",
    }, session: {
        strategy: "jwt",
    }, secret: process.env.NEXTAUTH_SECRET,
};

//route.ts
import NextAuth from "next-auth";
import {options} from "./options";

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

//middleware.ts
import type { NextRequest } from "next/server";
import { NextResponse } from "next/server";
import { getToken } from "next-auth/jwt";

export async function middleware(request: NextRequest) {
    const token = await getToken({ req: request });
    const { pathname } = request.nextUrl;

    // Redirect unauthenticated users to login page
    if (!token && pathname !== "/auth/login") {
        return NextResponse.redirect(new URL("/auth/login", request.url));
    }

    // Redirect authenticated users to dashboard if they try to access login page
    if (token && pathname === "/auth/login") {
        return NextResponse.redirect(new URL("/dashboard", request.url));
    }

    return NextResponse.next();
}

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

//scheme.prisma
model User {
  id        String   @id @default(auto()) @map("_id") @db.ObjectId
  username  String   @unique
  password  String
  createdAt DateTime @default(now())

  @@map("webapp_users")
}

//logout button
Button
            className="mb-4"
            onClick={() => signOut()}
        >
            Log out
        </Button>

//restricted.ts
import {getServerSession} from "next-auth/next"
import {options} from "@/app/api/auth/[...nextauth]/options"
import {NextApiRequest, NextApiResponse} from 'next'

export default async function restrictedHandler(req: NextApiRequest, res: NextApiResponse) {
    const session = await getServerSession(req, res, options)

    if (session) {
        res.send({
            content: "This is protected content. You can access this content because you are signed in.",
        })
    } else {
        res.send({
            error: "You must be signed in to view the protected content on this page.",
        })
    }
}

, pages: {
        signIn: "/auth/login", signOut: "/auth/login",
    }, session: {
        strategy: "jwt",
    }, secret: process.env.NEXTAUTH_SECRET,

[next-auth][error][CLIENT_FETCH_ERROR] "\nhttps://next-auth.js.org/errors#client_fetch_error" "Failed to execute 'json' on 'Response': Unexpected end of JSON input" {}

import { AppProps } from 'next/app';
import { SessionProvider } from 'next-auth/react';
import '@/app/globals.css';

function BloxStakes({ Component, pageProps }: AppProps) {
    return (
        <SessionProvider session={pageProps.session}>
            <Component {...pageProps} />
        </SessionProvider>
    );
}

export default BloxStakes;

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