Tu primera experiencia con Node.js

1

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

2

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

3

¿Qué es Node.js?

4

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

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

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

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

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

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

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

31

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

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

Regálate acceso ilimitado a todos los cursos por 1 año a precio especial de Navidad 🎄

Antes: $199

Currency
$149/año
regístrate

termina en:

16D
15H
12M
49S

Middlewares populares en Express.js

37/48

Lectura

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

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 34

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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());
...
}

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"
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} ✅`);
});```

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)

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

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

Pregunta

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

Alguien logró implementar Express Debug?

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

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

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, () => {
  console.log(`Listening http://localhost:${config.port}`);
});

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

✌

Gracias por la información es muy buena

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

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

y

debugExpress(app,{})

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

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

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, () => {
    console.log(`Corriendo en http://localhost:${config.port}`);
});

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.

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;

Mi solucion implementando cors:

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

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

// Implementacion de cors
app.use(cors());
app.use(express.json());

// Routes
moviesApi(app);

// Catch 404
app.use(notFoundHandler);

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

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

// app.get('/', function(req, res) {
//     res.send('Hello world');
// });

// app.get('/json', function(req, res) {
//     res.json({ hello: 'wolrd'});
// });

// app.get('/bisiesto/:year', function(req, res) {
//     let { year } = req.params;
//     ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) ?
//     res.send(`El ${year} es bisiesto`)
//     : res.send(`El ${year} no es bisiesto.`);
// })
const express = require('express');
const app = express();

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

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

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

Implementación de debug- express

npm install express-debug --save-dev

or

npm i express-debug -D

…

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

app.use(express.json());

debugExpress(app, {});

  // config slash middleware
  app.enable('strict routing');

  const router = express.Router({
    caseSensitive: app.get('case sensitive route'),
    strict: app.get('strict routing')
  });
  app.use('/api/movies', router);
  // Middleware slash
  app.use(slash());
  // Instance service
  const movieService = new MoviesService();```

Reto 😄

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

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

...

// morgan
app.use(morgan(config.dev ? 'dev' : 'common'));

...

Que buena información, ahora tocará aprender mas de cada uno.

Passport es la que más me interesa, dado que manejar usuarios con strings no creo que sea muy seguro. Ya quiero llegar al curso de esta herramienta: Curso de Autenticación con Passport.js

Muy buena información y muy útil, muchas gracias!!

Buenísima info, gracias!

Excelente listado de middlewares

validationHandler

const boom = require('@hapi/boom');
const joi = require('@hapi/joi');

function validate(data, schema) {
    const { error } = joi.object(schema).validate(data);
    return error;
}

function validationHandler(schema, check = "body") {
    return function (req, res, next) {
        const error = validate(req[check], schema);
        error ? next(boom.badRequest(error)) : next();
    }
}

module.exports = validationHandler;

Reto

const express = require('express');
const app = express();
const cors = require('cors');
const helmet = require('helmet');
const { config } = require('./config/index');
const moviesApi = require('./routes/movies.js');

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

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

// routes
moviesApi(app);

// Catch 404
app.use(notFoundHandler);

//Middleware
app.use(logErrors);
app.use(wrapErrors);
app.use(errorHandler);

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

Lectura muy interesante y servibles. Gracias!!

Gracias!