model.findone() no longer accepts a callback

더이상 저 문법을 지원하지 않는다고 해서 이것저것 코드 수정해 봤는데...
비밀번호가 일치해도 일치한다는 메세지가 포스트맨에 나오지 않고
에러도 뜨고 있습니다
[에러 메세지]
cb(null, isMatch);

^

TypeError: cb is not a function

at C:\Users\wwww\Documents\boiler-plate\models\User.js:69:5

index.js와 user.js를 첨부합니다 혹시 해결방법을 알 수 있을까요?

// http://localhost:5000/
const express = require("express");
const app = express();
const port = 5000;
const bodyParser = require("body-parser");
const cookieParser = require("cookie-parser");
const config = require("./config/key");

const { User } = require("./models/User");

app.use(bodyParser.urlencoded({ extended: true }));

app.use(bodyParser.json());
app.use(cookieParser());

const mongoose = require("mongoose");

mongoose
  .connect(config.mongoURI)
  .then(() => console.log("MongoDB Connected..."))
  .catch((err) => console.log(err));

app.get("/", (req, res) => {
  res.send("Hello World!~~안녕 새해복");
});

app.post("/register", async (req, res) => {
  try {
    const user = new User(req.body);

    await user.save();

    return res.status(200).json({
      success: true,
    });
  } catch (err) {
    return res.json({
      success: false,
      err: err.message,
    });
  }
});

app.post("/api/users/login", async (req, res) => {
  try {
    // 요청된 이메일을 데이터베이스에서 찾기
    const user = await User.findOne({ email: req.body.email });

    if (!user) {
      return res.json({
        loginSuccess: false,
        message: "제공된 이메일에 해당하는 유저가 없습니다.",
      });
    }

    const isMatch = await user.comparePassword(req.body.password);

    if (!isMatch) {
      return res.json({
        loginSuccess: false,
        message: "비밀번호가 틀렸습니다.",
      });
    }

    // 비밀번호가 일치하면 토큰 생성
    const userWithToken = await user.generateToken();

    // 토큰 저장
    res
      .cookie("x_auth", userWithToken.token)
      .status(200)
      .json({ loginSuccess: true, userId: userWithToken._id });
  } catch (err) {
    return res.status(400).send(err);
  }
});

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`);
});

const mongoose = require("mongoose"); // 몽구스 모듈을 가져와 몽고DB와 연결
const bcrypt = require("bcrypt");
const saltRounds = 10;
const jwt = require("jsonwebtoken");

// 몽구스를 이용해 스키마 생성(필드들 작성)
const userSchema = mongoose.Schema({
  name: {
    type: String,
    maxlength: 50,
  },
  email: {
    type: String,
    trim: true,
    unique: true,
  },
  password: {
    type: String,
    minlength: 5,
    maxlength: 100,
  },
  lastname: {
    type: String,
    maxlength: 50,
  },
  role: {
    type: Number,
    default: 0,
  },
  image: String,
  token: {
    type: String,
  },
  tokenExp: {
    type: Number,
  },
});

userSchema.pre("save", function (next) {
  var user = this;
  if (user.isModified("password")) {
    bcrypt.genSalt(saltRounds, function (err, salt) {
      if (err) return next(err);
      bcrypt.hash(user.password, salt, function (err, hash) {
        if (err) return next(err);
        user.password = hash;
        next();
      });
    });
  } else {
    next();
  }
});

// comparePassword
userSchema.methods.comparePassword = function (PlainPassword, cb) {
  bcrypt.compare(PlainPassword, this.password, function (err, isMatch) {
    if (err) return cb(err);
    cb(null, isMatch);
  });
};

userSchema.methods.generateToken = function () {
  var user = this;

  return new Promise((resolve, reject) => {
    var token = jwt.sign(user._id.toHexString(), "secretToken");
    user.token = token;
    user
      .save()
      .then((user) => resolve(user))
      .catch((err) => reject(err));
  });
};

const User = mongoose.model("User", userSchema);

module.exports = { User };