Supongamos que quiero tener puntos finales REST que se vean más o menos así:

/user/
/user/user_id 

/user/user_id/items/
/user/user_id/items/item_id

CRUDO en cada uno si tiene sentido. Por ejemplo, / user POST crea un nuevo usuario, GET obtiene todos los usuarios. / user / user_id GET obtiene solo ese usuario.

Los elementos son específicos del usuario, por lo que los coloco en user_id , que es un usuario en particular.

Ahora, para hacer que el enrutamiento Express sea modular, hice algunas instancias de enrutador. Hay un enrutador para el usuario y un enrutador para el artículo.

var userRouter = require('express').Router();
userRouter.route('/')
  .get(function() {})
  .post(function() {})
userRouter.route('/:user_id')
  .get(function() {})

var itemRouter = require('express').Router();
itemRouter.route('/')
  .get(function() {})
  .post(function() {})
itemRouter.route('/:item_id')
  .get(function() {})

app.use('/users', userRouter);

// Now how to add the next router?
// app.use('/users/', itemRouter);

URL a itemes descendientes de la jerarquía de URL de user. Ahora, ¿cómo obtengo URL con /userslo que sea para userRouter pero la ruta más específica de /user/*user_id*/items/itemRouter? Y también, me gustaría que user_id también sea accesible para itemRouter, si es posible.

Puede anidar enrutadores al conectarlos como middleware en otro enrutador, con o sin ellos params.

Debe pasar {mergeParams: true}al enrutador secundario si desea acceder al paramsenrutador principal.

mergeParamsse introdujo en Express4.5.0 (5 de julio de 2014)

En este ejemplo, el itemRouterse adjunta a userRouterla /:userId/itemsruta

Esto dará como resultado las siguientes rutas posibles:

GET /user-> hello user
GET /user/5-> hello user 5
GET /user/5/items-> hello items from user 5
GET /user/5/items/6->hello item 6 from user 5

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

var userRouter = express.Router();
// you need to set mergeParams: true on the router,
// if you want to access params from the parent router
var itemRouter = express.Router({mergeParams: true});

// you can nest routers by attaching them as middleware:
userRouter.use('/:userId/items', itemRouter);

userRouter.route('/')
    .get(function (req, res) {
        res.status(200)
            .send('hello users');
    });

userRouter.route('/:userId')
    .get(function (req, res) {
        res.status(200)
            .send('hello user ' + req.params.userId);
    });

itemRouter.route('/')
    .get(function (req, res) {
        res.status(200)
            .send('hello items from user ' + req.params.userId);
    });

itemRouter.route('/:itemId')
    .get(function (req, res) {
        res.status(200)
            .send('hello item ' + req.params.itemId + ' from user ' + req.params.userId);
    });

app.use('/user', userRouter);

app.listen(3003);

rutas anidadas manejables ...

Quería un ejemplo específico de hacer rutas anidadas de una manera muy manejable en express 4 y este fue el principal resultado de búsqueda para "rutas anidadas en express". Aquí hay una API que tendría muchas rutas que deberían dividirse, por ejemplo.

./index.js:

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

// anything beginning with "/api" will go into this
app.use('/api', require('./routes/api'));

app.listen(3000);

./routes/api/index.js:

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

// split up route handling
router.use('/products', require('./products'));
router.use('/categories', require('./categories'));
// etc.

module.exports = router;

./routes/api/products.js:

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

// api/products
router.get('/', function(req, res) {
  res.json({ products: [] });
});

// api/products/:id
router.get('/:id', function(req, res) {
  res.json({ id: req.params.id });
});

module.exports = router;

Ejemplo de anidamiento en estructura de carpetas

Noté algunos comentarios sobre "estructura de carpetas de anidación". Está implícito en esto, sin embargo, no es obvio, así que agregué la sección a continuación. Aquí hay un ejemplo específico de una estructura de carpetas anidadas para rutas .

index.js
/api
  index.js
  /admin
    index.js
    /users
      index.js
      list.js
    /permissions
      index.js
      list.js

Este es más un ejemplo general de cómo funciona el nodo. Si usa "index.js" en carpetas de forma similar a cómo funciona "index.html" en las páginas web para un directorio predeterminado, será fácil escalar su organización en función de la recursividad sin cambiar sus puntos de entrada al código. "index.js" es el documento predeterminado al que se accede cuando se requiere require en un directorio.

contenido de index.js

const express = require('express');
const router = express.Router();
router.use('/api', require('./api'));
module.exports = router;

contenido de /api/index.js

const express = require('express');
const router = express.Router();
router.use('/admin', require('./admin'));
module.exports = router;

contenido de /api/admin/index.js

const express = require('express');
const router = express.Router();
router.use('/users', require('./users'));
router.use('/permissions', require('./permissions'));
module.exports = router;

contenido de /api/admin/users/index.js

const express = require('express');
const router = express.Router();
router.get('/', require('./list'));
module.exports = router;

Posiblemente hay algunos problemas SECOS aquí, pero se presta bien para encapsular las preocupaciones.

Para su información, recientemente me metí en actionhero y he encontrado que tiene todas las funciones con enchufes y tareas, más como un verdadero marco todo en uno que cambia el paradigma REST en su cabeza. Probablemente deberías echarle un vistazo antes de desnudarte con express.

var userRouter = require('express').Router();
var itemRouter = require('express').Router({ mergeParams: true }); 

userRouter.route('/')
  .get(function(req, res) {})
  .post(function(req, res) {})
userRouter.route('/:user_id')
  .get(function() {})

itemRouter.route('/')
  .get(function(req, res) {})
  .post(function(req, res) {})
itemRouter.route('/:item_id')
  .get(function(req, res) {
    return res.send(req.params);
  });

app.use('/user/', userRouter);
app.use('/user/:user_id/item', itemRouter);

La clave para la segunda parte de su pregunta es el uso de la opción mergeParams

var itemRouter = require('express').Router({ mergeParams: true }); 

De /user/jordan/item/catrecibo una respuesta:

{"user_id":"jordan","item_id":"cat"}

Usando la solución @Jason Sebring y adaptándome para Typecript.

server.ts

import Routes from './api/routes';
app.use('/api/', Routes);

/api/routes/index.ts

import { Router } from 'express';
import HomeRoutes from './home';

const router = Router();

router.use('/', HomeRoutes);
// add other routes...

export default router;

/api/routes/home.ts

import { Request, Response, Router } from 'express';

const router = Router();

router.get('/', (req: Request, res: Response) => {
  res.json({
    message: 'Welcome to API',
  });
});

export default router;

try to add  { mergeParams: true } look to simple example  which it middlware use it in controller file getUser at the same for  postUser
    const userRouter = require("express").Router({ mergeParams: true });
    export default ()=>{
    userRouter
      .route("/")
      .get(getUser)
      .post(postUser);
    userRouter.route("/:user_id").get(function () {});
    
    
    }

Solo necesita un enrutador y úselo así:

router.get('/users');
router.get('/users/:user_id');

router.get('/users/:user_id/items');
router.get('/users/:user_id/items/:item_id');

app.use('api/v1', router);