Middlewares populares en Express.js

Clase 37 de 48 • Curso de Backend con Node.js 2019

Contenido del curso

Tu primera experiencia con Node.js

Manejo y uso de Streams con Node.js

Uso de utilidades de Node.js

Crea tu primer proyecto en Express.js

Aprende a crear un API con REST

Cómo conectarse con librerías externas en Express.js

Conoce como funcionan los Middleware en Express.js

Implementa tests en Node.js

Despliega tu primera aplicación en Express.js

Conclusiones

48
¿Qué aprendiste en este curso?
00:43 min

Tomar examen

A continuación te compartiré una lista de los middlewares más populares en Express.

Body parser

Analiza los cuerpos de las solicitudes entrantes en un middleware antes que los manejadores de ruta disponibles bajo la propiedad req.body. http://expressjs.com/en/resources/middleware/body-parser.html

CORS

Middleware para habilitar CORS (Cross-origin resource sharing) en nuestras rutas o aplicación. http://expressjs.com/en/resources/middleware/cors.html

Morgan

Un logger de solicitudes HTTP para Node.js. http://expressjs.com/en/resources/middleware/morgan.html

Helmet

Helmet nos ayuda a proteger nuestras aplicaciones Express configurando varios encabezados HTTP. ¡No es a prueba de balas de plata, pero puede ayudar! https://github.com/helmetjs/helmet

Express Debug

Nos permite hacer debugging de nuestras aplicaciones en Express mediante el uso de un toolbar en la pagina cuando las estamos desarrollando. https://github.com/devoidfury/express-debug

Express Slash

Este middleware nos permite evitar preocuparnos por escribir las rutas con o sin slash al final de ellas. https://github.com/ericf/express-slash

Passport

Passport es un middleware que nos permite establecer diferentes estrategias de autenticación a nuestras aplicaciones. https://github.com/jaredhanson/passport

Puedes encontrar más middlewares populares en el siguiente enlace: http://expressjs.com/en/resources/middleware.html

Comentarios

Alejandro González Reyes

student•

Yo implementé el middleware de slash

const express = require('express');
const slash = require('express-slash');
const MoviesServices = require('../services/movies');

// habilitar rutas estructas
app.enable('strict routing');

function moviesApi(app) {
  // Crear el router con algunas opciones para establecer el modo estricto de ruta
  const router = express.Router({
    caseSensitive: app.get('case sensitive routing'),
    strict: app.get('strict routing')
  });

  app.use('/api/movies', router);
  // añadir el middleware de slash
  app.use(slash());
...
}

Diego Felipe García Cortés

student•

Implementación de morgan para el manejo de logs tipo access.log

npm i morgan

Para poder tener rotación del archivo de log usamos:

npm i rotating-file-stream

en nuestro index.js agregamos lo siguiente:

const morgan = require('morgan');
const path = require('path');
const rfs = require('rotating-file-stream');
...
// create a rotating write stream
const accessLogStream = rfs.createStream('access.log', {
    interval: '1d', // rotate daily
    path: path.join(__dirname, 'log')
})

//Logger
app.use(morgan('combined', { stream: accessLogStream }))
...

Esto nos genera un archivo en la carpeta ./log/access.log con la siguiente salida de ejemplo:

::1 - - [17/Jan/2020:22:38:13 +0000] "GET /api/asdsd HTTP/1.1" 404 60 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36"
::1 - - [17/Jan/2020:22:38:30 +0000] "PUT /api/users/098 HTTP/1.1" 200 44 "-" "PostmanRuntime/7.19.0"

Mauricio Fernando Bautista López

student•

Wow muchas gracias

Pedro Roberto Capriles Morales

student•

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const cors = require('cors');
const morgan = require('morgan');
const helmet = require('helmet');
const { config } = require('./config');
const moviesApi = require('./src/routes/movies');
const { logErrors, errorHandler, wrapErrors } = require('./src/middleware/errorHandler');
const notFoundHandler = require('./src/middleware/notFoundHandler');


app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(cors());
app.use(morgan('tiny'));
app.use(helmet());

moviesApi(app);
app.use(notFoundHandler);

// Errors managment middleware
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

app.listen(config.port, () => {
  console.log(`Listening http://localhost:${config.port} ✅`);
});```

Paolo Donato Torregrosa Navarro

student•

Implementación de helmet:

1: Instalar helmet

npm i helmet --save

2: Requerirlo dentro de index.js

const helmet = require('helmet');

3: Usarlo dentro de los midlewares antes de las rutas de la aplicación

app.use(helmet());
//Here is moviesApi(app);

Listo, protegidos al establecer multiples encabezados http dentro de la aplicación. (Se pueden habilitar y desabilitar funciones de helmet individualmente llamándolas o no independientemente)

Luis Enrique Sauceda Herrera

student•

Hola, te recomiendo esta configuración :)

    app.use(helmet.contentSecurityPolicy({
        directives: {
            defaultSrc: ["'self"],
            styleSrc: ["'self'", 'maxcdn.bootstrapcdn.com']
        }
    }));

Bcanon@diamante.com.gt

student•

Configurar un handler

const morgan = require('morgan');
const { config } = require('../../config');

function morganHandler() {
    if (config.dev) {
        return morgan('dev');
    }
    return morgan('tiny');
}



module.exports = morganHandler;

Para luego configurar express con el middleware de morgan.

app.use(morganHandler());

Juan David González Rodríguez

student•

Morgan es increíble para saber que tipo de request se esta lanzando ... en consola

// Express
const express = require('express');
const app = express();
// Midlewares
const bodyParser = require('body-parser');
const morgan = require('morgan');
const {
  logErrors,
  errorHandler,
  wrapErrors,
} = require('./utils/middleware/errorHandlers');
const notFoundHandler = require('./utils/middleware/notFoundHandler');
// Config
const config = require('./config');
// Router
const router = require('./network/router');

//

// Midlewares
app.use(morgan('dev'));
app.use(express.json());
app.use(bodyParser.json());

// Router
router(app);
// Route Catch 404
app.use(notFoundHandler);

// Error Midlewares
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

// Listen
app.listen(config.port, () => {
  console.log(`The server is listening in ${config.host}:${config.port}`);
});

Hector Romero

student•

Pregunta

A partir de la versiones 4.x.x de express el uso de Body parser se cambia por express.json(), no es así?

Félix Andersson

student•

Alguien logró implementar Express Debug?

Freddy Barrios

student•

Si, Aunque dio algún problema, ya que tiene que estar debajo del middleware para la conversión a JSON

Félix Andersson

student•

Yo lo puse debajo de los middlewares de rutas y ahí no tira error pero igual no veo el panel de debug, como se hace? entro al 127.0.0.1/api/movies y nada, sale el json de siempre

Nicolas Saporiti

student•

Body Parser para la ruta específica post createMovie validando json

const express = require('express');
const MoviesService = require('../services/movies');
const bodyParser = require('body-parser');

const {
  movieIdSchema,
  createMovieSchema,
  updateMovieSchema,
} = require('../utils/schemas/movies');

const validationHandler = require('../utils/middleware/validationHandler');

const jsonParser = bodyParser.json();

function moviesApi(app) {
  const router = express.Router();
  app.use('/api/movies', router);

  const moviesService = new MoviesService();

  router.get('/', async function (req, res, next) {
    const { tags } = req.query;

    try {
      const movies = await moviesService.getMovies({ tags });
      res.status(200).json({
        data: movies,
        message: 'movies listed',
      });
    } catch (err) {
      next(err);
    }
  });

  router.get(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const movies = await moviesService.getMovie({ movieId });

        res.status(200).json({
          data: movies,
          message: 'movie retrieved',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.post('/', jsonParser, validationHandler(createMovieSchema), async function (
    req,
    res,
    next
  ) {
    const { body: movie } = req;
    try {
      const createdMovieId = await moviesService.createMovie({ movie });

      res.status(201).json({
        data: createdMovieId,
        message: 'movie created',
      });
    } catch (err) {
      next(err);
    }
  });

  router.put(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    validationHandler(updateMovieSchema),
    async function (req, res, next) {
      const { movieId } = req.params;
      const { body: movie } = req;

      try {
        const updatedMovieId = await moviesService.updateMovie({
          movieId,
          movie,
        });

        res.status(200).json({
          data: updatedMovieId,
          message: 'movie updated',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.delete(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const deletedMovieId = await moviesService.deleteMovie({ movieId });

        res.status(200).json({
          data: deletedMovieId,
          message: 'movie deleted',
        });
      } catch (err) {
        next(err);
      }
    }
  );
}

module.exports = moviesApi;```

Jesús Miguel Quinto Teran

student•

Implementación de CORS (Cross-origin resource sharing)

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

const { config } = require('./config/index');
const moviesApi = require('./routes/movies');
const { logError, wrraperError, errorHandler } = require('./utils/middleware/errorsHandler');
const notFoundHandler = require('./utils/middleware/notFoundHandler');

// Permitir solicitudes cruzadas
app.use(cors())

// Body parser
app.use(express.json());

// Routes
moviesApi(app);

// NotFound
app.use(notFoundHandler);

// Middleware Error
app.use(logError);
app.use(wrraperError);
app.use(errorHandler);


app.listen(config.port, () => {
    console.log(`Listening http://localhost:${config.port}`);
});

Rodrigo Esgueva Ordóñez

student•

BodyParser, Cors & Morgan

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

const morgan = require('morgan');
const cors = require('cors');
const bodyParser = require('body-parser');

const { config } = require('./config/index');
const moviesAPI = require('./routes/movies');
const notFoundHandler = require('./utils/middleware/notFoundHandler');
const {
  logErrors,
  wrapErrors,
  errorHandler
} = require('./utils/middleware/errorHandler');

//Cors
app.use(cors());

//Body Parser
app.use(bodyParser.json());

//Morgan Http Logger
app.use(morgan('tiny'));

//Routes API
moviesAPI(app);

//Catch 404
app.use(notFoundHandler);

//Errors Middlewares
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

//Server
app.listen(config.port, () =&gt; {
  console.log(`Listening http://localhost:${config.port}`);
});

Luis Enrique Sauceda Herrera

student•

Te recomiendo la siguiente configuración de morgan para que así puedas ver algunos datos extra que se le hacen a tu servidor como: verbo(GET, PUT, etc..), ruta, statusCode, tiempo en ms que tardó.

const morgan = require('morgan');

//Other code

app.use(morga('dev'));

Adonys Santos Jiménez

student•

Aquí está mi solución del reto:

Yo agrege CORS y Helmet

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

const { config } = require('./config');
const moviesApi = require('./routes/movies.js');

const {
  logErrors,
  wrapErrors,
  errorHandler,
} = require('./utils/middleware/errorHandlers');

const notFoundHandler = require('./utils/middleware/notFoundHandler.js');

// body parser
app.use(express.json());
app.use(cors());
app.use(helmet());

moviesApi(app);

// catch 404
app.use(notFoundHandler);

// errors middleware
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

app.listen(config.port, () => {
  const url = `https://localhost:${config.port}`;
  console.info(`Server is running on ${url}`);
});

Naldo Duran

student•

✌

john fredy quimbaya orozco

student•

Gracias por la información es muy buena

Oswaldo Trejo

student•

Implementé express-debug por curiosidad y es muy sencillo. Solo con dos lineas en el Index

const debugExpress = require('express-debug');

debugExpress(app,{})

Wilmar Yoan Malaver Malaver

student•

que bueno que dejaron documentación en este curso bien intentare hacer el ejercico.

Juan David González Rodríguez

student•

Challenge complete:

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const morgan = require('morgan');
const helmet = require('helmet');

const {
  logErrors,
  errorHandler,
  wrapErrors,
} = require('./utils/middleware/errorHandlers');
const notFoundHandler = require('./utils/middleware/notFoundHandler');
const { config } = require('./config');
const moviesApi = require('./routes/movies');

// Middlewares
app.use(express.json());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(morgan('dev'));
app.use(helmet());

// Routes
moviesApi(app);
// Catch 404
app.use(notFoundHandler);

// Errores middlewares
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

// Server listening
app.listen(config.port, () => {
  console.log(`Listening http://localhost:${config.port}`);
});

Carlos Enrique Ramírez Flores

student•

body parse y cords

/*
video 14 https://platzi.com/clases/1646-backend-nodejs/22026-creando-tu-primer-servidor-con-expressjs/
para llegar ha este punto se tuvo que instalar y configurar las siguientes dependencias

Instalar: express y dotenv

Dependencias de desarrollo
 npm i -D nodemon  eslint eslint-config-prettier eslint-plugin-prettier prettier

 instalar 
 npx mrm lint-staged
*/
const express = require('express');
const app = express();

const cors = require('cors');
const bodyParser = require('body-parser');

const { config } = require('./config/index');
const moviesApi = require('./routes/movies')

const { logErrors, wrapErrors, errorHandler } = require('./utils/middleware/errorHandlers');
const notFoundHandler = require('./utils/middleware/notFoundHandler');


//app.use(express.json());
app.use(cors());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false }));

moviesApi(app);

// para manejar el error 404
app.use(notFoundHandler);
//menejadores de errores
//middleware siempre van al final de las rutas
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

app.listen(config.port, () =&gt; {
    console.log(`Corriendo en http://localhost:${config.port}`);
});

Héctor Hugo Sandoval Marcelo

student•

Están geniales, yo me quedé con dos: morgan: para un mejor log de las solicitudes. helmet: para tener una buena configuración en los Headers.

Rodrigo Martinez

student•

Implementacion de CORS para asegurarse de que el CRUD de la app se haga de las rutas que el admin define en las variables de entorno (.env)

const config = require('../config/index');
const express = require('express');
const MoviesService = require('../services/movies');
const cors = require('cors');

const corsOptions = {
  origin: `http://${config.cors}:${config.port}`,
};

const {
  movieIdSchema,
  createMovieSchema,
  updateMovieSchema,
} = require('../utils/schemas/movies');

const validationHandler = require('../utils/middleware/validationHandler');

function moviesApi(app) {
  const router = express.Router();
  app.use('/api/movies', cors(corsOptions), router);

  const moviesService = new MoviesService();

  router.get('/', async function (req, res, next) {
    const { tags } = req.query;

    try {
      const movies = await moviesService.getMovies({ tags });

      res.status(200).json({
        data: movies,
        message: 'movies listed',
      });
    } catch (err) {
      next(err);
    }
  });

  router.get(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const movies = await moviesService.getMovie({ movieId });

        res.status(200).json({
          data: movies,
          message: 'movie retrieved',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.post('/', validationHandler(createMovieSchema), async function (
    req,
    res,
    next
  ) {
    const { body: movie } = req;
    try {
      const createdMovieId = await moviesService.createMovie({ movie });

      res.status(201).json({
        data: createdMovieId,
        message: 'movie created',
      });
    } catch (err) {
      next(err);
    }
  });

  router.put(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    validationHandler(updateMovieSchema),
    async function (req, res, next) {
      const { movieId } = req.params;
      const { body: movie } = req;

      try {
        const updatedMovieId = await moviesService.updateMovie({
          movieId,
          movie,
        });

        res.status(200).json({
          data: updatedMovieId,
          message: 'movie updated',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.delete(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const deletedMovieId = await moviesService.deleteMovie({ movieId });

        res.status(200).json({
          data: deletedMovieId,
          message: 'movie deleted',
        });
      } catch (err) {
        next(err);
      }
    }
  );
}

module.exports = moviesApi;

const express = require('express');
const slash = require('express-slash');
const MoviesServices = require('../services/movies');

// habilitar rutas estructas
app.enable('strict routing');

function moviesApi(app) {
  // Crear el router con algunas opciones para establecer el modo estricto de ruta
  const router = express.Router({
    caseSensitive: app.get('case sensitive routing'),
    strict: app.get('strict routing')
  });

  app.use('/api/movies', router);
  // añadir el middleware de slash
  app.use(slash());
...
}

const morgan = require('morgan');
const path = require('path');
const rfs = require('rotating-file-stream');
...
// create a rotating write stream
const accessLogStream = rfs.createStream('access.log', {
    interval: '1d', // rotate daily
    path: path.join(__dirname, 'log')
})

//Logger
app.use(morgan('combined', { stream: accessLogStream }))
...

::1 - - [17/Jan/2020:22:38:13 +0000] "GET /api/asdsd HTTP/1.1" 404 60 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36"
::1 - - [17/Jan/2020:22:38:30 +0000] "PUT /api/users/098 HTTP/1.1" 200 44 "-" "PostmanRuntime/7.19.0"

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const cors = require('cors');
const morgan = require('morgan');
const helmet = require('helmet');
const { config } = require('./config');
const moviesApi = require('./src/routes/movies');
const { logErrors, errorHandler, wrapErrors } = require('./src/middleware/errorHandler');
const notFoundHandler = require('./src/middleware/notFoundHandler');


app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(cors());
app.use(morgan('tiny'));
app.use(helmet());

moviesApi(app);
app.use(notFoundHandler);

// Errors managment middleware
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

app.listen(config.port, () => {
  console.log(`Listening http://localhost:${config.port} ✅`);
});```

const morgan = require('morgan');
const { config } = require('../../config');

function morganHandler() {
    if (config.dev) {
        return morgan('dev');
    }
    return morgan('tiny');
}



module.exports = morganHandler;

// Express
const express = require('express');
const app = express();
// Midlewares
const bodyParser = require('body-parser');
const morgan = require('morgan');
const {
  logErrors,
  errorHandler,
  wrapErrors,
} = require('./utils/middleware/errorHandlers');
const notFoundHandler = require('./utils/middleware/notFoundHandler');
// Config
const config = require('./config');
// Router
const router = require('./network/router');

//

// Midlewares
app.use(morgan('dev'));
app.use(express.json());
app.use(bodyParser.json());

// Router
router(app);
// Route Catch 404
app.use(notFoundHandler);

// Error Midlewares
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

// Listen
app.listen(config.port, () => {
  console.log(`The server is listening in ${config.host}:${config.port}`);
});

const express = require('express');
const MoviesService = require('../services/movies');
const bodyParser = require('body-parser');

const {
  movieIdSchema,
  createMovieSchema,
  updateMovieSchema,
} = require('../utils/schemas/movies');

const validationHandler = require('../utils/middleware/validationHandler');

const jsonParser = bodyParser.json();

function moviesApi(app) {
  const router = express.Router();
  app.use('/api/movies', router);

  const moviesService = new MoviesService();

  router.get('/', async function (req, res, next) {
    const { tags } = req.query;

    try {
      const movies = await moviesService.getMovies({ tags });
      res.status(200).json({
        data: movies,
        message: 'movies listed',
      });
    } catch (err) {
      next(err);
    }
  });

  router.get(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const movies = await moviesService.getMovie({ movieId });

        res.status(200).json({
          data: movies,
          message: 'movie retrieved',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.post('/', jsonParser, validationHandler(createMovieSchema), async function (
    req,
    res,
    next
  ) {
    const { body: movie } = req;
    try {
      const createdMovieId = await moviesService.createMovie({ movie });

      res.status(201).json({
        data: createdMovieId,
        message: 'movie created',
      });
    } catch (err) {
      next(err);
    }
  });

  router.put(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    validationHandler(updateMovieSchema),
    async function (req, res, next) {
      const { movieId } = req.params;
      const { body: movie } = req;

      try {
        const updatedMovieId = await moviesService.updateMovie({
          movieId,
          movie,
        });

        res.status(200).json({
          data: updatedMovieId,
          message: 'movie updated',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.delete(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const deletedMovieId = await moviesService.deleteMovie({ movieId });

        res.status(200).json({
          data: deletedMovieId,
          message: 'movie deleted',
        });
      } catch (err) {
        next(err);
      }
    }
  );
}

module.exports = moviesApi;```

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

const { config } = require('./config/index');
const moviesApi = require('./routes/movies');
const { logError, wrraperError, errorHandler } = require('./utils/middleware/errorsHandler');
const notFoundHandler = require('./utils/middleware/notFoundHandler');

// Permitir solicitudes cruzadas
app.use(cors())

// Body parser
app.use(express.json());

// Routes
moviesApi(app);

// NotFound
app.use(notFoundHandler);

// Middleware Error
app.use(logError);
app.use(wrraperError);
app.use(errorHandler);


app.listen(config.port, () => {
    console.log(`Listening http://localhost:${config.port}`);
});

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

const morgan = require('morgan');
const cors = require('cors');
const bodyParser = require('body-parser');

const { config } = require('./config/index');
const moviesAPI = require('./routes/movies');
const notFoundHandler = require('./utils/middleware/notFoundHandler');
const {
  logErrors,
  wrapErrors,
  errorHandler
} = require('./utils/middleware/errorHandler');

//Cors
app.use(cors());

//Body Parser
app.use(bodyParser.json());

//Morgan Http Logger
app.use(morgan('tiny'));

//Routes API
moviesAPI(app);

//Catch 404
app.use(notFoundHandler);

//Errors Middlewares
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

//Server
app.listen(config.port, () =&gt; {
  console.log(`Listening http://localhost:${config.port}`);
});

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

const { config } = require('./config');
const moviesApi = require('./routes/movies.js');

const {
  logErrors,
  wrapErrors,
  errorHandler,
} = require('./utils/middleware/errorHandlers');

const notFoundHandler = require('./utils/middleware/notFoundHandler.js');

// body parser
app.use(express.json());
app.use(cors());
app.use(helmet());

moviesApi(app);

// catch 404
app.use(notFoundHandler);

// errors middleware
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

app.listen(config.port, () => {
  const url = `https://localhost:${config.port}`;
  console.info(`Server is running on ${url}`);
});

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const morgan = require('morgan');
const helmet = require('helmet');

const {
  logErrors,
  errorHandler,
  wrapErrors,
} = require('./utils/middleware/errorHandlers');
const notFoundHandler = require('./utils/middleware/notFoundHandler');
const { config } = require('./config');
const moviesApi = require('./routes/movies');

// Middlewares
app.use(express.json());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(morgan('dev'));
app.use(helmet());

// Routes
moviesApi(app);
// Catch 404
app.use(notFoundHandler);

// Errores middlewares
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

// Server listening
app.listen(config.port, () => {
  console.log(`Listening http://localhost:${config.port}`);
});

/*
video 14 https://platzi.com/clases/1646-backend-nodejs/22026-creando-tu-primer-servidor-con-expressjs/
para llegar ha este punto se tuvo que instalar y configurar las siguientes dependencias

Instalar: express y dotenv

Dependencias de desarrollo
 npm i -D nodemon  eslint eslint-config-prettier eslint-plugin-prettier prettier

 instalar 
 npx mrm lint-staged
*/
const express = require('express');
const app = express();

const cors = require('cors');
const bodyParser = require('body-parser');

const { config } = require('./config/index');
const moviesApi = require('./routes/movies')

const { logErrors, wrapErrors, errorHandler } = require('./utils/middleware/errorHandlers');
const notFoundHandler = require('./utils/middleware/notFoundHandler');


//app.use(express.json());
app.use(cors());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false }));

moviesApi(app);

// para manejar el error 404
app.use(notFoundHandler);
//menejadores de errores
//middleware siempre van al final de las rutas
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

app.listen(config.port, () =&gt; {
    console.log(`Corriendo en http://localhost:${config.port}`);
});

const config = require('../config/index');
const express = require('express');
const MoviesService = require('../services/movies');
const cors = require('cors');

const corsOptions = {
  origin: `http://${config.cors}:${config.port}`,
};

const {
  movieIdSchema,
  createMovieSchema,
  updateMovieSchema,
} = require('../utils/schemas/movies');

const validationHandler = require('../utils/middleware/validationHandler');

function moviesApi(app) {
  const router = express.Router();
  app.use('/api/movies', cors(corsOptions), router);

  const moviesService = new MoviesService();

  router.get('/', async function (req, res, next) {
    const { tags } = req.query;

    try {
      const movies = await moviesService.getMovies({ tags });

      res.status(200).json({
        data: movies,
        message: 'movies listed',
      });
    } catch (err) {
      next(err);
    }
  });

  router.get(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const movies = await moviesService.getMovie({ movieId });

        res.status(200).json({
          data: movies,
          message: 'movie retrieved',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.post('/', validationHandler(createMovieSchema), async function (
    req,
    res,
    next
  ) {
    const { body: movie } = req;
    try {
      const createdMovieId = await moviesService.createMovie({ movie });

      res.status(201).json({
        data: createdMovieId,
        message: 'movie created',
      });
    } catch (err) {
      next(err);
    }
  });

  router.put(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    validationHandler(updateMovieSchema),
    async function (req, res, next) {
      const { movieId } = req.params;
      const { body: movie } = req;

      try {
        const updatedMovieId = await moviesService.updateMovie({
          movieId,
          movie,
        });

        res.status(200).json({
          data: updatedMovieId,
          message: 'movie updated',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.delete(
    '/:movieId',
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async function (req, res, next) {
      const { movieId } = req.params;

      try {
        const deletedMovieId = await moviesService.deleteMovie({ movieId });

        res.status(200).json({
          data: deletedMovieId,
          message: 'movie deleted',
        });
      } catch (err) {
        next(err);
      }
    }
  );
}

module.exports = moviesApi;

Middlewares populares en Express.js

Tu primera experiencia con Node.js

¿Dónde aprender backend con Node.js actualizado?

Todo lo que aprenderás sobre backend con Node.js

¿Qué es Node.js?

¿Qué es Node.js y para qué sirve?

Diferencias entre Node.js y JavaScript

Resumen: Diferencias Nodejs y Javascript

Instalación de Node.js

Arquitectura orientada a eventos

Node.js para la web

Manejo y uso de Streams con Node.js

Introducción a streams

Readable y Writable streams

Duplex y Transforms streams

Uso de utilidades de Node.js

Sistema operativo y sistema de archivos

Administrar directorios y archivos

Consola, utilidades y debugging

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

¿Qué es Express.js y para qué sirve?

Creando tu primer servidor con Express.js

Request y Response Objects

Aprende a crear un API con REST

Anatomía de una API Restful

Estructura de una película con Moockaru

Implementando un CRUD en Express.js

Métodos idempotentes del CRUD

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

Creación de una BD en MongoAtlas

Conexión a MongoAtlas una instancia de MongoDB

Conexión con Robot3T y MongoDB Compass a una BD

Implementación de las acciones de MongoDB

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

¿Qué es un middleware? Capa de manejo de errores usando un middleware

Manejo de errores asíncronos y síncronos en Express

Capa de validación de datos usando un middleware

¿Qué es Joi y Boom?

Implementando Boom

Implementando Joi

Probar la validación de nuestros endpoints