Node未定义路由时的动态路由实现方案咨询

Hey there! Great job setting up your initial RESTful routes for /users — that's a solid start. To handle undefined routes while keeping your existing routes working as expected, you'll want to use a catch-all route middleware that runs after all your defined routes. Here's how to do it:

First, keep your existing routes exactly as they are — these will be matched first since Express processes routes in the order they're defined:

app.route('/users')
  .get(dbController.collect)
  .post(dbController.insert);
app.route('/users/:userId')
  .get(dbController.read)
  .put(dbController.update)
  .delete(dbController.delete);

Next, add a catch-all route after all your existing routes. This ensures that only requests that don't match any of your defined routes will hit this handler. You can tailor this to mirror your dynamic route logic with two flexible options:

Option 1: Handle specific HTTP methods separately #

If you want to replicate the exact pattern of your /users routes (collection-level GET/POST, resource-level GET/PUT/DELETE) for any undefined path, set up catch-all handlers for each method:

// Catch-all GET requests (matches any path not already defined)
app.get('*', (req, res) => {
  const pathSegments = req.path.split('/').filter(segment => segment);
  
  if (pathSegments.length === 1) {
    // Mirror collection-level GET logic (like /users -> collect)
    res.status(200).json({ message: `Fetching all items from ${pathSegments[0]} collection` });
    // Replace with: dbController.collect(req, res) (or a generic collection handler)
  } else if (pathSegments.length === 2) {
    // Mirror resource-level GET logic (like /users/:userId -> read)
    const resourceType = pathSegments[0];
    const resourceId = pathSegments[1];
    res.status(200).json({ message: `Fetching ${resourceType} with ID: ${resourceId}` });
    // Replace with: dbController.read(req, res) (pass resourceId via req.params if needed)
  } else {
    res.status(404).json({ error: 'Resource not found' });
  }
});

// Catch-all POST requests (collection-level inserts)
app.post('*', (req, res) => {
  const pathSegments = req.path.split('/').filter(segment => segment);
  if (pathSegments.length === 1) {
    res.status(201).json({ message: `Created new item in ${pathSegments[0]} collection` });
    // Replace with: dbController.insert(req, res)
  } else {
    res.status(404).json({ error: 'Invalid path for POST requests' });
  }
});

// Repeat for PUT and DELETE if needed
app.put('*', (req, res) => {
  const pathSegments = req.path.split('/').filter(segment => segment);
  if (pathSegments.length === 2) {
    const resourceType = pathSegments[0];
    const resourceId = pathSegments[1];
    res.status(200).json({ message: `Updated ${resourceType} with ID: ${resourceId}` });
    // Replace with: dbController.update(req, res)
  } else {
    res.status(404).json({ error: 'Invalid path for PUT requests' });
  }
});

app.delete('*', (req, res) => {
  const pathSegments = req.path.split('/').filter(segment => segment);
  if (pathSegments.length === 2) {
    const resourceType = pathSegments[0];
    const resourceId = pathSegments[1];
    res.status(200).json({ message: `Deleted ${resourceType} with ID: ${resourceId}` });
    // Replace with: dbController.delete(req, res)
  } else {
    res.status(404).json({ error: 'Invalid path for DELETE requests' });
  }
});

Option 2: Single catch-all handler for all methods #

For a more consolidated approach, use app.all('*', ...) to handle every HTTP method in one place. This is great if you want to reuse logic across methods:

// Generic handler that mirrors your existing controller pattern
const genericRouteHandler = (req, res) => {
  const { method } = req;
  const pathSegments = req.path.split('/').filter(segment => segment);

  switch (method) {
    case 'GET':
      if (pathSegments.length === 1) {
        res.json({ data: `All items from ${pathSegments[0]} collection` });
        // dbController.collect(req, res)
      } else if (pathSegments.length === 2) {
        res.json({ data: `Item ${pathSegments[1]} from ${pathSegments[0]} collection` });
        // dbController.read(req, res)
      } else {
        res.status(404).json({ error: 'Resource not found' });
      }
      break;
    case 'POST':
      if (pathSegments.length === 1) {
        res.status(201).json({ message: `Created new item in ${pathSegments[0]} collection` });
        // dbController.insert(req, res)
      } else {
        res.status(404).json({ error: 'POST requests only allowed at collection level' });
      }
      break;
    case 'PUT':
    case 'DELETE':
      if (pathSegments.length === 2) {
        const action = method === 'PUT' ? 'Updated' : 'Deleted';
        res.json({ message: `${action} ${pathSegments[0]} with ID: ${pathSegments[1]}` });
        // method === 'PUT' ? dbController.update(req, res) : dbController.delete(req, res)
      } else {
        res.status(404).json({ error: `${method} requests only allowed at resource level` });
      }
      break;
    default:
      res.status(405).json({ error: `Method ${method} is not supported` });
  }
};

// Add the catch-all route AFTER all your defined routes
app.all('*', genericRouteHandler);

Critical Reminders: #

• Order is everything! Never place catch-all routes before your specific routes (like /users). Express matches routes top-to-bottom, so a catch-all first would override all your existing routes.
• Integrate your database logic: Replace the placeholder responses with calls to your dbController methods (or create generic versions of them) to connect this to your database.
• Add error handling: Don’t forget to wrap database calls in try/catch blocks to handle errors gracefully and return appropriate HTTP status codes.

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