Why does bcrypt always return false?

I've been trying to figure out why bcrypt always return false. I've pretty much tried everything and it's pretty much the same results. I've also tried using third party websites to check if the hash and plain password matches but it also returns false. I'm thinking there's an issue with what I HATCHED but I can't seem to figure it out. Stack: Express, mongoose, mongodb atlas api calls

login = (req, res, next) => {
let userData = req.body;
User.findOne({
  email: userData.email
},function(error,user){
  if(error){
    console.log(error)
  } else {
    if(!user){
      res.status(401).send('email not found')
    } else if(user){
      bcrypt.compare(userData.password, user.password).then(function(resp) {
        if(resp === false){
          res.status(401).send('Invalid password')
        } else {
          let payload = {
            subject: user._id
          }
          let token = jwt.sign(payload,"secretKey")
          res.status(200).send({user,token})
        }});

    }
  }

})
   }

    register = async (req, res) => {
let userData = req.body;
User.find({
  email: userData.email
},function(err,result){
 if(err){
    console.log(err)
 } else if(under._.isEmpty(result)){
   bcrypt.genSalt(saltRounds, function(err, salt) {
        bcrypt.hash(userData.password, salt, function(err, hash) {
          userData.password = hash;
          let user = new User(userData)
          user.save((error,registerUser)=>{
            if(error){
              console.log(error)
            } else {
              let payload = {
                subject: registerUser._id
              }
              let token = jwt.sign(payload,"secretKey")
              res.status(200).send({registerUser,token})
            }
          })
        });
    })
 } else {
   res.status(401).send('Email is already in use')
   }
})
 };      

My schema

     import mongoose from 'mongoose';
        import {
        saveUser,
      toAuthJSON,
  validatePassword,
} from '../helpers/model.helpers';
import { generateAccessToken } from '../helpers/auth.helpers';

const { Schema } = mongoose;

const userSchema = new Schema({
  firstName: {
    type: String,
    required: [true, 'first name is required'],
  },
  lastName: {
    type: String,
    required: [true, 'last name is required'],
  },
  phoneNumber: {
    type: String,
    required: [true, 'Phone number is required'],
    min: [10, 'A phone number can have at-least 10 digits'],
    max: [13, 'Please enter a valid phone number, this is too long'],
  },
  email: {
    type: String,
    required: [true, 'An Email is required'],
  },
  password: {
    type: String,
    required: [true, 'A password is required'],
  },
  profileImage: {
    type: String,
    required: false,
  },
  title: {
    type: String,
    required: false,
  },
  companyName: {
    type: String,
    required: [false, 'Company name is required'],
  },
     companyAddress: {
       type: String,
       required: false,
        },
       companyPhoneNumber: {
        type: String,
       required: [false, 'Company phone number is required'],
       },
       companyLogo: {
       type: String,
       required: false,
       },
       },{
       versionKey: false
       });

       userSchema.pre('save', saveUser);

       userSchema.methods.validatePassword = validatePassword;
       userSchema.methods.generateAccessToken = generateAccessToken;
      userSchema.methods.toAuthJSON = toAuthJSON;

      export default mongoose.model('User', userSchema);

my helper

import bcrypt from 'bcrypt';

export async function saveUser(next) {
  const SALT_WORK_FACTOR = 10;
  if (!this.isModified('password')) return next();
  try {
    const salt = await bcrypt.genSalt(SALT_WORK_FACTOR);
    this.password = await bcrypt.hash(this.password, salt);

    return next();
  } catch (error) {
    return next(error);
  }
}

export function validatePassword(password) {
  return bcrypt.compare(password, this.password);
}

export function toAuthJSON() {
  const profile = this.toJSON();
  delete profile.password;
  // eslint-disable-next-line no-underscore-dangle
  delete profile.__v;
  return {
    profile,
    token: this.generateAccessToken(this.id),
  };
}