I don't receive accessToken from jwt({token, user, account})

[DarkOrbitWeaver]

Question 💬

I want to verify the request so the user cannot edit request to post as another user.

/api/posts/newpost.js API code:

import mongoose from "mongoose";
import { getCsrfToken, getSession } from "next-auth/react";

const postSchema = new mongoose.Schema({
    authorId: {type: String, required: true},
    description: String,
    media: Array,     
});

let post;
try {
    post = mongoose.model("Post");
} catch (error) {
    post = mongoose.model("Post", postSchema);
}


export default async function newpost(req, res){
    if(req.method === "POST"){
        const session = await getSession({ req });
        const csrfToken = await getCsrfToken({ req });
        //csrftoken as headerscsrftoken
        const {csrftoken: headersCsrfToken} = req.headers;

        //if headers not contain csrf token or headers csrf token doesn't match cookies csrf token
        if(!headersCsrfToken || headersCsrfToken !== csrfToken){
            return res.status(403).json({message: "Unauthorized request"});
        }
       //I want to verify user here, is getSession enough to submit changes securely?


        //connect to db
        const client = await mongoose.connect(process.env.DB_URI);


        


        client.connection.close();
        res.status(201).json({message: "recived your request"});
    }else{
        res.status(403).json({message: "Method not allowed!"})
    }
}

/api/auth/[...next-auth].js code:

import NextAuth from "next-auth";
import CredentialsProvider from "next-auth/providers/credentials";
import mongoose from "mongoose";
import { compare } from "bcrypt";
import { User } from "../auth/signup"

export default NextAuth({
    secret: process.env.NEXT_AUTH_SECRET,
    session: {
        strategy: "jwt",
        maxAge: 30 * 24 * 60 * 60,
        updateAge: 24 * 60 * 60,
    },
    jwt: {
      encryption: true,
      secret: process.env.NEXT_AUTH_JWT_SECRET
    },
    providers: [
        
        CredentialsProvider({
            async authorize(credentials){
                //connect to database
                const client = await mongoose.connect(process.env.DB_URI);
                //search for user using email or username
                const result = await User.findOne({$or: [{email: credentials.username}, {username: credentials.username}]});
                //if not found
                if(!result){
                    client.connection.close();
                    throw new Error("Incorrect username or password.");
                }
                const checkPassword = await compare(credentials.password, result.password);
                //of password doesn't match
                if(!checkPassword){
                    client.connection.close();
                    throw new Error("Incorrect username or password.")
                }
                
                client.connection.close();

                if(!result.emailVerified.verified){
                    client.connection.close();
                    throw new Error("Please verify your email adress.") 
                }

                return {
                   uid: result._id
                };
            }
        }),
    ], 
   callbacks: {
      async jwt({token, user, account}) {

        account && (token.accessToken = account?.access_token)
        user && (token.user = user)        
        return token;
      },
      async session({session, token}) {
        session.user = token.user;
        session.accessToken = token.accessToken;
        console.log(session);
        return session;
      }
   }

});

-also if someone could answer my question, please.
https://stackoverflow.com/questions/70172881/i-want-to-implement-a-sessions-management-system-using-next-auth

How to reproduce ☕️

//console.log(session);
{
user: { uid: '61a53559b7a09ec93f45f6ad' },
expires: '2021-12-30T21:18:18.182Z',
accessToken: undefined
}

Contributing 🙌🏽

Yes, I am willing to help answer this question in a PR