javascript - how - node js install express windows

Descanse con el enrutador anidado Express.js

Question

Supongamos que quiero tener puntos finales REST que se parecen más o menos a esto:

/user/
/user/user_id 

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

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

Los elementos son específicos del usuario, así que los puse en user_id , que es un usuario particular.

Ahora, para hacer el enrutamiento Express modular, realicé algunas instancias de enrutadores. 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);

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

Answer 1

rutas anidables manejables ...

Quería un ejemplo específico de hacer rutas anidadas de una manera muy manejable en Express 4 y este fue el resultado de búsqueda superior 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 anidación en la estructura de carpetas

Observé algunos comentarios sobre "estructura de carpetas anidadas". Está implícito en esto, sin embargo, no es obvio, así que agregué la siguiente sección. Aquí hay un ejemplo específico de una estructura de carpetas anidadas para las 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 base a la recursión sin cambiar los puntos de entrada al código. "index.js" es el documento predeterminado al que se accede cuando se utiliza require en un directorio.

contenidos 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;

Hay algunos problemas DRY aquí posiblemente, pero se presta bien a la encapsulación de las preocupaciones.

FYI, hace poco me metí en Actionhero y descubrí que tenía todas las funciones con zócalos y tareas, más como un verdadero marco todo-en-uno moviendo el paradigma de REST en su cabeza. Probablemente deberías echarle un vistazo antes de ir desnudo con el expreso.

Answer 2

Puede anidar enrutadores adjuntándolos como middleware en otro enrutador, con o sin params .

Debe pasar {mergeParams: true} al enrutador secundario si desea acceder a los params desde el enrutador principal.

mergeParams se introdujo en Express 4.5.0 (5 de julio de 2014)

En este ejemplo, el itemRouter se adjunta al userRouter en la ruta /:userId/items

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);

Answer 3

Solo necesita un enrutador y lo usa 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);

Answer 4

Utilizando la solución de @Jason Sebring y adaptándome a Typescript.

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;

Answer 5

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 de la segunda parte de su pregunta es el uso de la opción mergeParams

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

Desde /user/jordan/item/cat recibo una respuesta:

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