运行节点server.js会导致以下错误：Route.post()需要一个回调函数，但在Route处得到一个[object Undefined]。<computed>

Question

就像标题所说，我正在制作一个用于多个项目的样板。语法方面的一切看起来都很好，在我试图解决问题的过程中，我没有找到解决我的问题的任何解决方案，即使存在类似的问题。每当我输入 node Server.js 时，我都会得到：

Node.js v20.11.0
PS C:\Users\Edward Akande\mern-boilerplate\backend> node Server.js
C:\Users\Edward Akande\mern-boilerplate\backend\node_modules\express\lib\router\route.js:216
        throw new Error(msg);
        ^

Error: Route.post() requires a callback function but got a [object Undefined]
    at Route.<computed> [as post] (C:\Users\Edward Akande\mern-boilerplate\backend\node_modules\express\lib\router\route.js:216:15)
    at proto.<computed> [as post] (C:\Users\Edward Akande\mern-boilerplate\backend\node_modules\express\lib\router\index.js:521:19)
    at Object.<anonymous> (C:\Users\Edward Akande\mern-boilerplate\backend\routes\auth.js:10:8)
    at Module._compile (node:internal/modules/cjs/loader:1376:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1435:10)
    at Module.load (node:internal/modules/cjs/loader:1207:32)
    at Module._load (node:internal/modules/cjs/loader:1023:12)
    at Module.require (node:internal/modules/cjs/loader:1235:19)
    at require (node:internal/modules/helpers:176:18)
    at Object.<anonymous> (C:\Users\Edward Akande\mern-boilerplate\backend\Server.js:15:22)

我期望服务器启动并且 mongo db 连接，但实际发生的是上面提到的错误。这是相关的代码，我感觉它非常简单，但我已经盯着它看了几天了。

// server.js

const express = require('express');
const connectDB = require('./config/db.js');

const app = express();

// Connect to MongoDB
connectDB();

// Middleware
app.use(express.json()); // Parse JSON bodies

// Routes
app.use('/api/auth', require('./routes/auth'));

// Define port
const PORT = process.env.PORT || 5000;

// Start server
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

module.exports=app;

//auth.js
const express = require('express');
const router = express.Router();
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const User = require('../models/user.js');
const { registerValidation } = require('../middleware/validation.js');
const { validationResult } = require('express-validator');
//Register Route
router.post('/register', registerValidation, async (req, res) => {
  // Validate request body
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }

  const { email, password } = req.body;

  try {
    // Check if user already exists
    let user = await User.findOne({ email });
    if (user) {
      return res.status(400).json({ msg: 'User already exists' });
    }

    // Create new user
    user = new User({
      email,
      password
    });

    // Hash password
    const salt = await bcrypt.genSalt(10);
    user.password = await bcrypt.hash(password, salt);

    // Save user to database
    await user.save();

    // Generate JWT token
    const payload = {
      user: {
        id: user.id
      }
    };

    jwt.sign(
      payload,
      process.env.JWT_SECRET,
      { expiresIn: '1d' },
      (err, token) => {
        if (err) throw err;
        res.json({ token });
      }
    );
  } catch (err) {
    console.error(err.message);
    res.status(500).send('Server Error');
  }
});

//Email Verification Route
router.get('/verify/:token', async (req, res) => {
    const token = req.params.token;
  
    try {
      // Verify token
      const decoded = jwt.verify(token, process.env.JWT_SECRET);
  
      // Update user's verified status
      await User.findByIdAndUpdate(decoded.user.id, { verified: true });
  
      res.json({ msg: 'Email verified successfully' });
    } catch (err) {
      console.error(err.message);
      res.status(500).send('Server Error');
    }
  });

// Login Route
router.post('/login', async (req, res) => {
    const { email, password } = req.body;
  
    try {
      // Check if user exists
      let user = await User.findOne({ email });
      if (!user) {
        return res.status(400).json({ msg: 'Invalid Credentials' });
      }
  
      // Check if password matches
      const isMatch = await bcrypt.compare(password, user.password);
      if (!isMatch) {
        return res.status(400).json({ msg: 'Invalid Credentials' });
      }
  
      // Check if user is verified
      if (!user.verified) {
        return res.status(400).json({ msg: 'Please verify your email' });
      }
  
      // Generate JWT token
      const payload = {
        user: {
          id: user.id
        }
      };
  
      jwt.sign(
        payload,
        process.env.JWT_SECRET,
        { expiresIn: '1d' },
        (err, token) => {
          if (err) throw err;
          res.json({ token });
        }
      );
    } catch (err) {
      console.error(err.message);
      res.status(500).send('Server Error');
    }
  });

// Forgot password route
router.post('/forgot-password', async (req, res) => {
    const { email } = req.body;
  
    try {
      // Check if user exists
      const user = await User.findOne({ email });
      if (!user) {
        return res.status(400).json({ msg: 'User not found' });
      }
  
      // Generate verification code
      const verificationCode = Math.floor(100000 + Math.random() * 900000);
  
      // Implement logic to send verification code to user's email using SendGrid
  
      res.json({ msg: 'Verification code sent to your email' });
    } catch (err) {
      console.error(err.message);
      res.status(500).send('Server Error');
    }
  });
  
// Verify Code route
router.post('/verify-code', async (req, res) => {
    const { email, verificationCode } = req.body;
  
    try {
      // Check if user exists
      const user = await User.findOne({ email });
      if (!user) {
        return res.status(400).json({ msg: 'User not found' });
      }
  
      // Check if verification code matches
      if (user.verificationCode !== verificationCode) {
        return res.status(400).json({ msg: 'Invalid verification code' });
      }
  
      // If verification code matches, update user's verified status
      user.verified = true;
      // Clear verification code after successful verification
      user.verificationCode = null;
      await user.save();
  
      res.json({ msg: 'Verification code verified' });
    } catch (err) {
      console.error(err.message);
      res.status(500).send('Server Error');
    }
  });
  
  //Rest Password route
  router.post('/reset-password', async (req, res) => {
    const { email, newPassword } = req.body;
  
    try {
      // Check if user exists
      const user = await User.findOne({ email });
      if (!user) {
        return res.status(400).json({ msg: 'User not found' });
      }
  
      // Hash new password
      const salt = await bcrypt.genSalt(10);
      user.password = await bcrypt.hash(newPassword, salt);
  
      // Save new password to database
      await user.save();
  
      res.json({ msg: 'Password reset successful' });
    } catch (err) {
      console.error(err.message);
      res.status(500).send('Server Error');
    }
  });
  
  

module.exports = router;

//validation.js
const jwt = require('jsonwebtoken');
const User = require('../models/user.js');


module.exports = async function (req, res, next) {
  // Get token from header
  const token = req.header('x-auth-token');

  // Check if token exists
  if (!token) {
    return res.status(401).json({ msg: 'No token, authorization denied' });
  }

  try {
    // Verify token
    const decoded = jwt.verify(token, process.env.JWT_SECRET);

    // Find user by id
    const user = await User.findById(decoded.user.id);

    // Check if user exists
    if (!user) {
      return res.status(401).json({ msg: 'Token is not valid' });
    }

    req.user = user;
    next();
  } catch (err) {
    console.error(err.message);
    res.status(500).json({ msg: 'Server Error' });
  }
};

// db.js

const mongoose = require('mongoose');
require('dotenv').config();

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      useCreateIndex: true,
      useFindAndModify: false,
    });
    console.log('MongoDB Connected');
  } catch (error) {
    console.error('Error connecting to MongoDB:', error.message);
    process.exit(1); // Exit process with failure
  }
};

module.exports = connectDB;

//user.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  accountType: { type: String, enum: ['Admin', 'Paid', 'Free'], default: 'Free' },
  verified: { type: Boolean, default: false }
});

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

module.exports = User;

//Package.json
{
  "name": "backend",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "Percy",
  "license": "ISC",
  "dependencies": {
    "@sendgrid/mail": "^8.1.3",
    "bcryptjs": "^2.4.3",
    "cors": "^2.8.5",
    "dotenv": "^16.4.5",
    "express": "^4.19.2",
    "express-validator": "^7.0.1",
    "jsonwebtoken": "^9.0.2",
    "mongoose": "^8.3.1",
    "nodemailer": "^6.9.13",
    "nodemon": "^3.1.0",
    "sendgrid": "^5.2.3"
  }
}

Answer 1

auth.js 文件中的 registerValidation 导入出现错误。它应该在不使用解构的情况下导入，因为它是使用 module.exports 导出的。

你应该改变：

const { registerValidation } = require('../middleware/validation.js');

致：

const registerValidation = require('../middleware/validation.js');