hey so i wanna pass some data from adapterSession to normal session callback but i simply cant because it removes the additional data i pass how can i fix this

[achiragaming]

import NextAuth, { AuthOptions } from "next-auth";

import { PrismaAdapter } from "@auth/prisma-adapter";

import { db } from "@/lib/db";
import authConfig from "@/auth.config";
import { createUserImageByUrl, getAccountByProvider, getLoginAttemptByData, getSessionByToken, getUserByEmail, getUserById } from "@/utils/user";
import { getTwoFactorConfirmationByUserId } from "@/utils/two-factor-confirmation";

import { Adapter, AdapterAccount, AdapterSession, AdapterUser } from "next-auth/adapters";
import { headers } from "next/headers";
import { PrismaClient, User } from "@prisma/client";
import { link } from "fs";
import { getLocationByIp } from "./utils/location";
import { generateToken } from "./lib/tokens";
import { login } from "./actions/auth/login";
import { currentSession } from "./utils/auth";

const customPrismaAdapter = (db: PrismaClient): Adapter => {
const adapter = PrismaAdapter(db) as Adapter;
return {
...adapter,
async updateUser(user: any) {
const existingUser = await getUserByEmail(user.email);
if (!existingUser) throw new Error("User not found");

  const updatedUser = await db.user.update({
    where: { id: existingUser.id },
    data: {
      name: user.name,
      email: user.email,
      emailVerified: user.emailVerified,
    }
  }
  )

  return updatedUser;

},
async createUser(user: any) {
  const existingUser = await getUserByEmail(user.email);
  if (existingUser) {
    return existingUser;
  }
  const newUser = await db.user.create({
    data: {
      id: user.id,
      name: user.name,
      email: user.email,
      emailVerified: user.emailVerified,
    }
  }
  )

  return newUser;
},
async createSession({ sessionToken, userId, expires }) {

  const geoData = await getLocationByIp(headers().get('x-user-ip') as string)
  if (!geoData) throw new Error("no geo data found");
  const { ip, location } = {
    ip: geoData.ip,
    location: `${geoData.city}-${geoData.country}`,
  };
  const user = await getUserById(userId)
  if (!user) throw new Error("User not found");

  let loginAttempt = await getLoginAttemptByData(user.id, location, ip)
  if (!loginAttempt) {
    const loginAttemptToken = await generateToken("loginAttempt", "token")
    loginAttempt = await db.loginAttempt.create({
      data: {
        location: location,
        ip: ip,
        userId: user.id,
        token: loginAttemptToken,
      }
    })
  }
  if (!loginAttempt) throw new Error("Login attempt not found");

  const session = await db.session.create({
    data: {
      sessionToken,
      userId,
      expires,
      loginAttemptId: loginAttempt.id
    }
  })
  if (!session) throw new Error("Session not found");
  return {
    sessionId: session.id,
    sessionToken: session.sessionToken,
    userId: session.userId,
    expires: session.expires
  };
},
async getSessionAndUser(sessionToken: string): Promise<{ session: AdapterSession; user: AdapterUser } | null> {
  const session = await getSessionByToken(sessionToken);
  if (!session) return null;
  const user = await getUserById(session.userId);
  if (!user) return null;

  return {
    session: {
      sessionToken: session.sessionToken,
      userId: session.userId,
      expires: session.expires,
      sessionId: session.id
    },
    user: { ...user },
  };
}, async getUserByAccount({ providerAccountId, provider }) {
  const account = await getAccountByProvider(provider, providerAccountId)
  if (!account) return null
  const user = await getUserById(account.userId)
  if (!user) return null
  return user

},
async deleteSession(sessionToken: string) {
  await db.session.delete({
    where: { sessionToken: sessionToken },
  })

},
async updateSession(session: any) {
  const updatedSession = await db.session.update({
    where: { sessionToken: session.sessionToken },
    data: {
      expires: session.expires,
    }
  })
  if (!updatedSession) throw new Error("Session not found");
  return { sessionToken: updatedSession.sessionToken, sessionId: updatedSession.id, expires: updatedSession.expires, userId: updatedSession.userId };
},
async getUser(id) {
  const user = await getUserById(id)
  return user
},
async getUserByEmail(email) {
  const user = await getUserByEmail(email)
  return user
},

}
}
export const authOptions: AuthOptions = {
pages: {
signIn: "/auth/login",
error: "/auth/error",
},

secret: process.env.APP_SECRET,
events: {

async linkAccount({ user, profile }) {
  await db.user.update({
    where: { id: user.id },
    data: { emailVerified: new Date() },
  });
  if (profile.image) {
    await createUserImageByUrl(user.id, {
      url: profile.image,
      private: false,
    });
  }

},

},
callbacks: {
async signIn({ user, account, profile, }) {
const session = await currentSession();
console.log("Sign in Occured ", session);

  if (account?.provider === "credentials") {

    const existingUser = user

    // Prevent sign in without email verification
    if (!existingUser?.emailVerified) return false;

    if (existingUser.isTwoFactorEnabled) {
      const twoFactorConfirmation = await getTwoFactorConfirmationByUserId(
        existingUser.id
      );

      if (!twoFactorConfirmation) return false;

      // Delete two factor confirmation for next sign in
      await db.twoFactorConfirmation.delete({
        where: { id: twoFactorConfirmation.id },
      });
    }
  }
  return true;
},


async session({ session, user, token }) {
  if (user) {
    session.user.id = user.id
    session.user.name = user.name
    session.user.email = user.email
    session.sessionId = session.sessionId
  }
  session.sessionId // =<< this is undefined 
  return session
},

},

adapter: customPrismaAdapter(db),
session: { strategy: "database" },
...authConfig,
};

// export const {
// handlers: { GET, POST },
// auth,
// signIn,
// signOut,
// update,
// } = authOptions;