400 Bad Request in NodeJs Application

Question

When ever I submit a from to login in or get registered I get 400 bad request. But in register route the user get registered but it also gives bad request. When we go to login route same as register route I get BAD REQUEST. 0

I am using the following dependencies:

express session passport passport-local passport-local-mongoose

Is there something wrong with the implementation of the passport-local-mongoose or its passport side or serialize or deserialize the user. Can anybody help me with this problem I am stuck on this for three days. Here is some code.

//-----------------------//Require---------------------
const express = require("express");
const app = express();
const bodyParser = require("body-parser");
const ejs = require("ejs");
const session = require("express-session");
const passport = require("passport");
const LocalStrategy= require("passport-local").Strategy;
const passportLocalMongoose = require("passport-local-mongoose");
const mongoose = require("mongoose");
//-----------------------//App.use---------------------

app.use(express.static("public"));
app.set("view engine", "ejs");
app.use(bodyParser.urlencoded({extended: true}));
app.use(session({
    secret: 'keyboard cat',
    resave: false,
    saveUninitialized: true
}));
//-----------------------//Passport---------------------
app.use(passport.initialize());
app.use(passport.session());

//-----------------------//Mongoose---------------------
mongoose.connect('mongodb://localhost/Twitter', {useNewUrlParser: true, useUnifiedTopology: true});
mongoose.set('useCreateIndex', true);
const tweetschema = new mongoose.Schema({
    username: String,
    password: String,
    tweets: String
});
//-----------------------//Schema Plgin---------------------
tweetschema.plugin(passportLocalMongoose);


//-----------------------//New Model---------------------

const Tweet = new mongoose.model("Tweet", tweetschema);

//-----------------------//Local Strategy-------------------
passport.use(new LocalStrategy(Tweet.authenticate()));

//-----------------------//Seralize Passport---------------------
passport.serializeUser(Tweet.serializeUser());
passport.deserializeUser(Tweet.deserializeUser());
//-----------------------//Get Routes---------------------

app.get("/" ,(req, res)=>{
    Tweet.find({}, function(err, founItems){
        res.render("home", {founItems:founItems});
    });
});

app.get("/tweets", (req, res)=>{
    if(req.isAuthenticated()){
    res.render("Tweets");

    }else{
        res.redirect("/login");
    }
});
//-----------------------//Post Routes---------------------

app.post("/login", (req, res)=>{
    
    
    const user = new Tweet({
        username: req.body.email,
        password: req.body.password
    });
    
    req.logIn(user, (err)=>{
        if(err){
            res.send(err);
        }
        passport.authenticate("local")(req, res, ()=>{
            console.log("Successfull.");
        })
    })
});

app.post("/reg", (req, res)=>{
    Tweet.register({username: req.body.email}, req.body.password, (err, user)=>{
        if(err){
            console.log(err);
            res.redirect("/reg");
        }else{
            if(user){
                passport.authenticate("local")(req, res, ()=>{
                    res.redirect("/tweets");
                    console.log("Successfully Regsitered The User!");
                })
            }
        }
    })

})

Answer 1

You redirect user to /login route, but you don't have get request for this.

If you have it but not uploaded try this in Seralize Passport

passport.serializeUser(function (user, done) {
  done(null, user.id);
});

passport.deserializeUser(function (id, done) {
  User.findById(id, function (err, user) {
    done(err, user);
  });
});

What about this:

app.post("/login", (req, res) => {
  const email = req.body.email;
  User.findOne({ username: email }, function (err, u) {
    if (err) {
      console.log(err);
    } else {
      if (u) {
        u.authenticate(req.body.password, (err, model, info) => {
          if (info) {
            res.send("Wrong email or password!");
          }
          if (err) {
            console.log(err);
          } else if (model) {
            req.login(u, (err) => {
              if (err) {
                console.log(err);
              } else {
                passport.authenticate("local");
                req.session.save((error) => {
                  if (err) {
                    console.log(err);
                  } else {
                    res.redirect("/");
                  }
                });
              }
            });
          }
        });
      } else {
        res.send("Wrong email or password!");
      }
    }
  });
});

So you first search user in the database with email: User.findOne({ username: email }, function (err, u){} I suggest to make username unique username: { type: String, unique: true} in tweetSchema. After that you check for err. If u exists, you authenticate it with password. According to passport-local-mongoose- u.authenticate(password, (err, model, info)=>{}) has two arguments: password and callback function. In callback we check for info which is "an instance of AuthenticationError describing the reason the password failed, else undefined." After that we check for err and it is "null unless the hashing algorithm throws an error." And finally, we check for model that is "the model getting authenticated if authentication was successful otherwise false."

So, model is authenticated. After that we must use the user with req.login(u,(err)). Check for errors and if everything is alright, we authenticate user locally passport.authenticate("local");. If you want to save session, write:

req.session.save((error) => {
                      if (err) {
                        console.log(err);
                      } else {
                        res.redirect("/");
                      }
                    });

That's all.

For registration :

app.post("/register", (req, res) => {
  const email = req.body.email;
  const password = req.body.password
  User.find({ email: email }, function (err, docs) {
    if (docs.length === 0) {
      User.register(
        {
          username: email,
        },
        password,
        function (err, user) {
          if (err) {
            console.log(err);
          } else {
            req.login(user, (err) => {
              if (err) {
                console.log(err);
              } else {
                passport.authenticate("local");
                req.session.save((error) => {
                  if (err) {
                    console.log(err);
                  } else {
                    res.redirect("/");
                  }
                });
              }
            });
          }
        }
      );
    } else {
      res.send("The accout already exists!");
    }
  });
});