NEXTAUTH_URL is redirecting to a different uri than my github app callback URL

[nicolasguasca1]

Hello guys, Thank you for opening this space for discussions. I have the following situation. Steps to reproduce:

Set a .env.local file with the following value: NEXTAUTH_URL="http://subdomain.localhost:3000/".
Set a callback url on a Github app with this value: "http://subdomain.localhost:3000/".
Create a middleware function to deal with the rewriting of the subdomain like this:

import type { NextRequest } from "next/server";
import { request } from "http";

export default function middleware(req: NextRequest) {
  const newReq = req.nextUrl.clone();
  const regex = new RegExp(
    `*********\.vercel\.app`
  );

  const pathname = req.nextUrl.pathname.toString();

  const hostname = req.headers.get("host");

  if (!hostname)
    return new Response(null, {
      status: 400,
      statusText: "No hostname found in request headers"
    });

  const currentHost =
    process.env.VERCEL_ENV === `production` ||
    process.env.VERCEL_ENV === `preview`
      ? 
        hostname
          .replace(`${process.env.VERCEL_URL}`, "")
          .replace(`${process.env.NEXT_PUBLIC_VERCEL_URL}`, "")
      : hostname.replace(`.localhost:3000`, "");

  if (pathname.startsWith(`/_sites`))
    return new Response(null, {
      status: 404
    });

  if (
    !pathname.includes(".") &&
    !pathname.startsWith("/api")
  ) {
    if (currentHost === "subdomain") {
      if (
        pathname === "/login" &&
        (req.cookies["next-auth.session-token"] ||
          req.cookies["__Secure-next-auth.session-token"])
      ) {
        newReq.pathname = "/";
        return NextResponse.redirect(newReq.toString());
      }

      newReq.pathname = `/subdomain${pathname}`;
      console.log(newReq.toString()); // ==>>>>>This logs: http://localhost:3000/subdomain/login
      return NextResponse.rewrite(newReq.toString());
    }

    newReq.pathname = `${pathname}`;
    return NextResponse.rewrite(newReq.toString());
  }
}

Also, here is my [...nextauth].ts

import GitHubProvider from "next-auth/providers/github";
import { PrismaAdapter } from "@next-auth/prisma-adapter";
import prisma from "@/lib/prisma";

import type { NextAuthOptions } from "next-auth";

if (!process.env.GITHUB_ID || !process.env.GITHUB_SECRET)
  throw new Error("Failed to initialize Github authentication");

export const authOptions = {
  providers: [
    GitHubProvider({
      clientId: process.env.GITHUB_ID,
      clientSecret: process.env.GITHUB_SECRET,
      profile(profile) {
        return {
          id: profile.id.toString(),
          name: profile.name || profile.login,
          gh_username: profile.login,
          email: profile.email,
          image: profile.avatar_url
        };
      }
    })
  ],
  secret: process.env.SECRET,
  pages: {
    signIn: `/login`,
    verifyRequest: `/login`,
    error: "/login" // Error code passed in query string as ?error=
  },
  adapter: PrismaAdapter(prisma),
  callbacks: {
    session: ({ session, user }) => ({
      ...session,
      user: {
        ...session.user,
        id: user.id,
        username: user.username
      }
    })
  }
} as NextAuthOptions;

export default NextAuth(authOptions);

Expected behaviour:

The next app uses the session token to redirect back to / or ask for the credentials and then go to /.
Actual behaviour: nextauth warns that the redirect uri doesn't match the one specified in the callback url of the github app (which are actually the same).
Any help would be realy appreciated folks!