javascript - Mongoose 模式无法读取未定义的属性 'password'

Question

我正在按照教程尝试 Passport 本地身份验证。一切看起来都很好，但是当我使用 Postman 发出请求时出现此错误:

[nodemon] 1.18.11
[nodemon] to restart at any time, enter `rs`
[nodemon] watching: *.*
[nodemon] starting `node server.js`
body-parser deprecated bodyParser: use individual json/urlencoded middlewares server.js:17:10
(node:6336) DeprecationWarning: current URL string parser is deprecated, and will be removed in a future version. To use the new parser, pass option { useNewUrlParser: true } to MongoClient.connect.
Started listening on PORT: 8080
events.js:167
      throw er; // Unhandled 'error' event
      ^

    TypeError: Cannot read property 'password' of undefined
        at model.userSchema.methods.validPassword.password [as validPassword] (F:\Web Projects\LocalAuth\userModel.js:20:50)
        at F:\Web Projects\LocalAuth\passport.js:34:21
        at F:\Web Projects\LT1Kqob5UDEML61gCyjnAcfMXgkdP3wGcgGdBcFel.js:4672:16
        at F:\Web Projects\LT1Kqob5UDEML61gCyjnAcfMXgkdP3wGcgGdBcFry.js:4184:12
        at process.nextTick (F:\Web Projects\LT1Kqob5UDEML61gCyjnAcfMXgkdP3wGcgGdBcFry.js:2741:28)
        at process._tickCallback (internal/process/next_tick.js:61:11)
    Emitted 'error' event at:
        at F:\Web Projects\LT1Kqob5UDEML61gCyjnAcfMXgkdP3wGcgGdBcFel.js:4674:13
        at F:\Web Projects\LT1Kqob5UDEML61gCyjnAcfMXgkdP3wGcgGdBcFry.js:4184:12
        at process.nextTick (F:\Web Projects\LT1Kqob5UDEML61gCyjnAcfMXgkdP3wGcgGdBcFry.js:2741:28)
        at process._tickCallback (internal/process/next_tick.js:61:11)
    [nodemon] app crashed - waiting for file changes before starting...

这是我的用户架构:

const mongoose = require('mongoose');
const bcrypt = require('bcrypt-nodejs');
const Config = require ('./config');


mongoose.connect (Config.dbUrl);

let userSchema = new mongoose.Schema({
  local : {
    email: String,
    password: String,
  },
});

userSchema.methods.generateHash = password => {
  return bcrypt.hashSync(password, bcrypt.genSaltSync(8), null);
};

userSchema.methods.validPassword = password => {
  return bcrypt.compareSync(password, this.local.password);
};

module.exports = mongoose.model('User', userSchema);

这是我的 server.js 文件:

const express = require ('express');
const session = require ('express-session');
const mongoose = require ('mongoose');
const bodyParser = require ('body-parser');
const cookieParser = require ('cookie-parser');
const morgan = require ('morgan');
const flash = require ('connect-flash');
const passport = require ('passport');

const PassHandler = require('./passport');

const app = express ();
const port = process.env.PORT || 8080;


app.use (morgan ('dev'));
app.use (bodyParser ({extended: false}));
app.use (cookieParser ());

app.use (
  session ({secret: 'borkar.amol', saveUninitialized: true, resave: true})
);

//Initialize Passport.js
app.use (passport.initialize ());
app.use (passport.session ());
app.use (flash ());

//Global Vars for flash messages
app.use((req, res, next) => {
  res.locals.successMessage = req.flash('successMessage');
  res.locals.errorMessage = req.flash('errorMessage');
  res.locals.error = req.flash('error');
  next();
});

PassHandler(passport);

//Middleware to check if the user is logged in.
const isLoggedIn = (req, res, next) => {
  if(req.isAuthenticated()) {
    return next();
  }

  res.status(400).json({ message: 'You are not authenticated to acces this route.' });
}

app.get('/', (req, res) => {
  res.json({ message: 'Local Auth API v0.1.0'});
});

app.post('/signup', passport.authenticate('local-signup', {
  successRedirect: '/user',
  failureRedirect: '/signup',
  failureFlash: true,
}));

app.post('/login', passport.authenticate('local-login', {
  successRedirect: '/user',
  failureRedirect: '/',
  failureFlash: true,
}));

app.get('/user', isLoggedIn, (req, res) => {
  res.json({ user: req.user, message: "User is logged in."});
});

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

这是我正在使用的 Passport 策略:

  passport.use (
    'local-login',
    new LocalStrategy (
      {
        usernameField: 'email',
        passwordField: 'password',
        passReqToCallback: true,
      },
      function (req, email, password, done) {
        User.findOne ({'local.email': email}, function (err, user) {
          if (err) return done (err);

          if (!user)
            return done (
              null,
              {message: 'User not found.'},
              req.flash ('errorMessage', 'No user found.')
            );
          if (!user.validPassword (password))
            return done (
              null,
              {message: 'Invalid email or password.'},
              req.flash ('errorMessage', 'Oops! Wrong password.')
            );

          // all is well, return successful user
          return done (null, user);
        });
      }
    )
  );

说实话，我不知道出了什么问题。请帮忙。

**更新:**注册路线和注册策略运行良好。只有 /login 路由出现问题。

Answer 1

我遇到了同样的问题。我通过将 validatePassword 方法从用户模式移至 Passport 策略来解决我的问题。密码似乎没有传递到 UserSchema 中的 validatePassword 方法。这是我的 UserSchema.js

    // Pulling in required dependencies
const mongoose = require('mongoose');
const bcrypt   = require('bcrypt-nodejs');
const Schema = mongoose.Schema;

//Creat UserSchema
const UserSchema = new Schema({
    local: {
        email: String,
        password: String
    },
    role: {
        type: String,
        default: 'user',
    },
    books_downloaded: {
        booksId: {
            type: Array,
            required: false,
        },
    },
    books_needed: {
        type: Object,
        default: null,
    },
    created_at: {
        type: Date,
        default: Date.now,
    },
});

// methods=====================================================
// generating a hash
UserSchema.methods.generateHash = (password) => {
    return bcrypt.hashSync(password, bcrypt.genSaltSync(8), null);
}

// expose User model to the app
module.exports = mongoose.model('User', UserSchema);

这是我的 Passport 策略

// load all the things we need
const LocalStrategy = require('passport-local').Strategy;
const bcrypt   = require('bcrypt-nodejs');

//load up the user model
const User = require('../models/User');

// expose this function to our app
module.exports = passport => {
    /**
     * passport session setup =======================
     * required for persistent login sessions
     * serialize and unserialize users out of session
     */
    //serialize the user for the session
    passport.serializeUser((user, done) => {
        done(null, user.id);
    });

    //deserialize the user
    passport.deserializeUser((id, done) => {
        User.findById(id, (err, user) => {
            done(err, user);
        });
    });

    /**
     * LOCAL SIGNUP
     * using named strategies
     */
    // local signup
    passport.use(
        'local-signup',
        new LocalStrategy(
            {
                usernameField: 'email',
                passwordField: 'password',
                passReqToCallback: true,
            },
            (req, email, password, done) => {
                process.nextTick(() => {

                    // find a user whose email is the same as the forms email
                    User.findOne({ 'local.email': email }, (err, user) => {
                        if (err) return done(err);
                        // check to see if theres already a user with that email
                        if (user) {
                            return done(null, false, req.flash('signupMessage', 'That email is already taken.'));
                        } else {
                            // if there is no user with that email
                            // create the user
                            var newUser = new User();

                            // set the user's local credentials
                            newUser.local.email = email;
                            newUser.local.password = newUser.generateHash(password);

                            // save the user
                            newUser.save(err => {
                                if (err) throw err;
                                return done(null, newUser);
                            });
                        }
                    });
                });
            }
        )
    );

    // =========================================================================
    // LOCAL LOGIN =============================================================
    passport.use(
        'local-login',
        new LocalStrategy(
            {
                usernameField: 'email',
                passwordField: 'password',
                passReqToCallback: true,
            },
            (req, email, password, done) => {

                // checking to see if the user trying to login already exists
                User.findOne({ 'local.email': email }, function(err, user) {
                    // if there are any errors, return the error before anything else
                    if (err) return done(err);

                    // if no user is found, return the message
                    if (!user) return done(null, false, req.flash('loginMessage', 'No 
                     user found.'));

                    // if the user is found but the password is wrong
                        let correctPassword = 
                  bcrypt.compareSync(password,user.local.password);

                    if (!correctPassword)
                        return done(null, false, req.flash('loginMessage', 'Oops! 
                  Wrong password.'));

                    // If all is well, return successful user
                    return done(null, user);
                });
            }
        )
    );
};