如何构建Node.js+mongodb.js项目结构？重构时全局db变量处理困惑

Hey there! Let's break down how to split your MongoDB functions into separate files without relying on that global db variable—this will make your code more modular and easier to maintain. Here are two solid approaches you can use:

1. Dependency Injection (Recommended) #

This is the cleanest approach because it avoids global state entirely. Instead of relying on a global db, you pass the connected database instance directly to your individual data modules.

Step 1: Refactor your database connection file #

First, update database.js to export a function that returns the connected db instance instead of using a global variable:

// database.js
const { MongoClient } = require('mongodb');

async function connectToDatabase() {
  const client = await MongoClient.connect(process.env.MONGODB_URI);
  // Return the specific database instance you need
  return client.db(process.env.DATABASE_NAME);
}

module.exports = connectToDatabase;

Step 2: Create modular data functions #

For each collection (like users), create a dedicated file that exports a factory function accepting the db instance. This function will return your collection-specific methods:

// database/user.js
// Factory function that takes the db instance and returns user-related methods
function createUserDB(db) {
  return {
    async getUserById(userId) {
      return db.collection('users').findOne({ _id: userId });
    },
    async createUser(userData) {
      const result = await db.collection('users').insertOne(userData);
      return result.insertedId;
    },
    // Add more user methods here
  };
}

module.exports = createUserDB;

Step 3: Initialize modules in your API layer #

In api.js, first establish the database connection, then initialize your data modules with the db instance, and use them in your routes:

// api.js
const express = require('express');
const connectToDatabase = require('./database');
const createUserDB = require('./database/user');

const app = express();

async function startServer() {
  // Wait for the database connection to complete
  const db = await connectToDatabase();
  
  // Initialize your data modules with the connected db
  const userDB = createUserDB(db);

  // Define routes using the modular methods
  app.get('/users/:id', async (req, res) => {
    try {
      const user = await userDB.getUserById(req.params.id);
      res.json(user || { message: 'User not found' });
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  });

  app.post('/users', async (req, res) => {
    try {
      const userId = await userDB.createUser(req.body);
      res.status(201).json({ userId });
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  });

  app.listen(3000, () => {
    console.log('Server running on port 3000');
  });
}

// Start the server (wrap in async to handle db connection promises)
startServer();

2. Centralized Module Container #

If you prefer a more centralized setup (similar to your original global approach but cleaner), you can create a root database module that initializes the connection and injects db into all sub-modules.

Step 1: Create a root database index file #

// database/index.js
const { MongoClient } = require('mongodb');
const createUserDB = require('./user');

// Hold the db instance internally (not global to the whole app)
let db;

// Initialize the connection and set up sub-modules
async function initDatabase() {
  const client = await MongoClient.connect(process.env.MONGODB_URI);
  db = client.db(process.env.DATABASE_NAME);

  // Export initialized sub-modules once db is ready
  module.exports.userDB = createUserDB(db);
}

// Export the init function and placeholder for sub-modules
module.exports = { initDatabase };

Step 2: Use the container in your API #

// api.js
const express = require('express');
const dbContainer = require('./database');

const app = express();

async function startServer() {
  // Initialize the database and sub-modules
  await dbContainer.initDatabase();
  const { userDB } = dbContainer;

  // Routes are the same as the dependency injection example
  app.get('/users/:id', async (req, res) => {
    try {
      const user = await userDB.getUserById(req.params.id);
      res.json(user || { message: 'User not found' });
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  });

  app.listen(3000, () => {
    console.log('Server running on port 3000');
  });
}

startServer();

Why Avoid Global db? #

Global variables introduce hidden dependencies—your data functions rely on a variable that could be uninitialized or modified elsewhere, leading to hard-to-debug errors. Both approaches above eliminate this risk:

• Dependency injection makes dependencies explicit and simplifies testing (you can easily mock the db instance for unit tests).
• The centralized container keeps the db instance encapsulated, so it's only accessible to your controlled sub-modules.

内容的提问来源于stack exchange，提问作者blub