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?

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:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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!