Express：路由不是在异步函数中创建的

Question

这是创建测试路由的 api.js 模块：

'use strict';

module.exports = function (app) {
  
  console.log("before route creation");
  app.get("/api/test", (req, res) => {
    res.send("it worked");
  });
  console.log("routes created");
};

在 server.js 文件中，我将此模块导入为apiRoutes。然后，我在异步函数中调用它。

const databaseConnection = async (apiRoutes, app) => {
  try {
    await mongoose.connect(`mongodb+srv://replitUser:${process.env.DB_PW}@issuetracker.pbbm6.mongodb.net/myFirstDatabase?retryWrites=true&w=majority`);
    console.log("db connection successful");

    //Routing for API 
    console.log("apiRoutes called");
    apiRoutes(app);  

  } catch (err) {
    console.log("an err occurred", err);
  }
}
databaseConnection(apiRoutes, app);
// apiRoutes(app);

字符串"before route creation" 和"routes created" 被记录到控制台。但是，尽管没有发生错误，但该路由似乎不起作用。

如果我在异步函数之外调用apiRoutes，就像这里：

const databaseConnection = async (apiRoutes, app) => {
  try {
    await mongoose.connect(`mongodb+srv://replitUser:${process.env.DB_PW}@issuetracker.pbbm6.mongodb.net/myFirstDatabase?retryWrites=true&w=majority`);
    console.log("db connection successful");

    //Routing for API 
    // console.log("apiRoutes called");
    // apiRoutes(app);  

  } catch (err) {
    console.log("an err occurred", err);
  }
}
databaseConnection(apiRoutes, app);
apiRoutes(app);

...它将成功创建测试路线。

我尝试直接在 async 函数内部而不是在新模块中创建路由，它什么也没改变，仍然没有创建路由。

const databaseConnection = async (apiRoutes, app) => {
  try {
    await mongoose.connect(`mongodb+srv://replitUser:${process.env.DB_PW}@issuetracker.pbbm6.mongodb.net/myFirstDatabase?retryWrites=true&w=majority`);
    console.log("db connection successful");

    //Routing for API 
    // console.log("apiRoutes called");
    // apiRoutes(app);  
    app.get("/api/test", (req, res) => {
      res.send("it worked");
    });
  } catch (err) {
    console.log("an err occurred", err);
  }
}
databaseConnection(apiRoutes, app);

为什么我不能在异步函数中创建路由？

Here is a link to the project on replit - Feel free to fork

Answer 1

我知道这不是您问题的直接答案。

但问题是你不能正确地构造你的代码。

所以在下面你可以看到应用程序结构具有单独的数据库和应用程序模块，应用程序在数据库连接后开始侦听。

server.js

const http = require('http');

const db = require('./db');
const app = require('./app');

const server = http.createServer(app);
const PORT = process.env.PORT || 8000;

(async () => {
  await db.connect();
  console.log('connected to db');

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

db.js

const mongoose = require('mongoose');

const UserSchema = require('./schemas/User');
mongoose.model('User', UserSchema);

module.exports = {
  connect: function() {
    const dsn = `mongodb+srv://replitUser:${process.env.DB_PW}@issuetracker.pbbm6.mongodb.net/myFirstDatabase?retryWrites=true&w=majority`;
    return mongoose.connect(dsn);
  },
  model: function(name) {
    return mongoose.model(name);
  },
};

app.js

const express = require('express');
const app = express();

const routes = require('./routes');
app.use(routes);

module.exports = app;

路由/index.js

const express = require('express');
const router = express.Router();

const users = require('./users');
router.use('/api/users', users);

module.exports = router;

路由/users.js

const express = require('express');
const router = express.Router();

const db = require('../db');
const User = db.model('User');

router.get('/', async (req, res) => {
  const users = await User.find({}).lean();
  res.status(200).send({users});
});

router.get('/:id', async (req, res) => {
  const user = await User.findById(req.params.id).lean();
  if (!user) {
    return res.status(404).end();
  }
  res.status(200).send(user);
});

module.exports = router;

架构/User.js

const mongoose = require('mongoose');
const {Schema} = mongoose;

const UserSchema = new Schema({
  username: Schema.Types.String,
  password: Schema.Types.String,
  name: Schema.Types.String,
});

module.exports = UserSchema;

Answer 2

起初，我认为使用express.Router() 很容易解决。 这就是它的样子：

创建路由器并将其挂载到/api路径：

const router = express.Router();
app.use("/api", router);

然后，使用router.get() 而不是app.get() 创建路由。

const databaseConnection = async (router) => {
  try {
    await mongoose.connect(`mongodb+srv://replitUser:${process.env.DB_PW}@issuetracker.pbbm6.mongodb.net/myFirstDatabase?retryWrites=true&w=majority`);
    console.log("db connection successful");

    //Routing for API 
    router.get("/test", (req, res) => {
      res.send("it worked");
    });
  } catch (err) {
    console.log("an err occurred", err);
  }
}
databaseConnection(router);

Here is a link to the complete version of this

但正如用户@num8er 提到的，这种结构是不好的做法，没有必要。

我不明白有连接数据库后不需要创建路由。 Mongoose 允许您在连接数据库之前使用模型，因为 mongoose 在内部缓冲这些数据库调用。服务器只需要在数据库连接后监听即可。

所以现在我已经实现了@num8er 的想法并更新了项目！

我有一个db.js 模块，它导出一个返回承诺的connect 函数：

const mongoose = require("mongoose");

module.exports = {
  connect: function() {
    const dsn = `mongodb+srv://replitUser:${process.env.DB_PW}@cluster0.m31tz.mongodb.net/myFirstDatabase?retryWrites=true&w=majority`;
    return mongoose.connect(dsn);
  },
}

在server.js 文件中，我只通过执行api.js 模块来创建路由：

const apiRoutes = require("./routes/api.js");
const router = express.Router();
app.use("/", router);
apiRoutes(router);

然后我连接到数据库后开始监听：

(async () => {
  const db = require("./db");
  try {
    await db.connect();
    console.log("connected to db");
  } catch (err) {
    console.log("an error occurred while connecting to db", err);
  }

  //Start our server and tests!
  const listener = app.listen(process.env.PORT || 3000, function () {
    console.log("Your app is listening on port " + listener.address().port);
    if (process.env.NODE_ENV === "test") {
      console.log("Running Tests...");
      setTimeout(function () {
        try {
          runner.run();
        } catch (e) {
          console.log("Tests are not valid:");
          console.error(e);
        }
      }, 5000);
    }
  });
})();

Here is a link to the complete fixed project on replit

注意：replit 上的 chai 测试存在问题，as explained here。但是，如果您下载文件并在本地运行服务器，则一切正常。