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?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Métodos idempotentes del CRUD

23/48
Recursos

Aportes 35

Preguntas 5

Ordenar por:

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

Así se vería el método del año bisiesto en una ruta

const express = require('express');

function yearApi(app) {
  const router = express.Router();
  app.use('/', router);
  app.use(express.urlencoded({ extended: false }));
  app.use(express.json());

  router.get('/year/:year', (req, res, next) => {
    try {
      const { year } = req.params;
      const isFourDivisible = !(year % 4);
      const isHundredDivisible = !(year % 100);
      const isFourHundredDivisible = !(year % 400);

      if (isFourDivisible && !isHundredDivisible || isFourHundredDivisible) {
        res.send(`El año ${year} es bisiesto`);
      } else {
        res.send(`El año ${year} no es bisiesto`);
      }
    } catch (error) {
      next(error);

    }
  });

}

module.exports = yearApi;

En mi caso me ha gustado más trabajar con Insomnia en lugar de Postman, y me ha servido también para crear variables de entorno y la interfaz se me hace amigable.

Gran clase!

http://gitignore.io/

La razon por la que creo que usamos PUT en lugar de PATCH es porque a la hora de actualizar las peliculas vamos a volver a enviar toooda la informacion de la pelicula. O al menos eso parece

Alguien me puede decir por que el API retorna una movie cuando solo hacemos un query cualquiera con abc?

¿Por qué si en clases anteriores el instructor dijo que no es muy recomendable utilizar el verbo PUT, aquí lo esta utilizando?😏

Hizo falta la coleccion de postman con los métodos ??

Porque se carga el mock con una promise?

Revisando cada uno de los métodos realizados en el ejercicio, concretamente post, put y delete, veo que siempre devuelve el mismo valor y que no cambia ni modifica ningún registro falso. Seguramente ello se deba a que son datos de prueba, falsos.

A lo que voy es que siempre la aplicación devolvía los mismos datos. Si se consultaba un id diferente siempre devolvía el mismo dato.

No me queda claro por qué ocurre eso.

npx license mit > LICENSE && npx gitignore node && git init

Excelente recurso el de gitignore, yo por lo general solía ignorar node_modules.
Lo importante sigue siendo ahorrar tiempo de configuración y destinarlo al desarrollo y pruebas

Que genial esta página de gitignore!!

Con las colecciones de Postman y todas sus herramientas al final podemos publicar una documentación muy buena para la API que estemos construyendo.

Ya quiero empezar con los datos reales!!!

This is my code!

interesante!

complicado pero genial!!

Very good recomendation to push the first commit.

muy importante lo del gitignore pero nunca lo habia aplicado así cada dia se aprende algo nuevo 😃

si quieren manejar postman como un profesional, les recomiendo el El curso de postman dado por nuestro profesor Eduardo Álvarez.

Esta es mi implementación del reto anterior
muy interesante como verificar cuando llega un numero en un string con isNaN()😅

const express = require('express');

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

  router.get('/:year', (req, res) => {
    const { year } = req.params;
    if (isNaN(year)) {
      res.status(406).send('year must be a number');
    } else {
      year % 4 === 0
        ? res.status(200).send(`${year} is a leap-year`)
        : res.status(200).send(`${year} is not a leap-year`);
    }
  });
}

module.exports = yearApi;

Otra forma de generar el gitignore seria usando:

npx gitignore node

También funciona para crear el archivo de licencia:

npx license MIT

impresionante tanto estudio para backend, pensé que era mas fácil.

Uso de GitIgnore.io

No me sabía la página de gitignore, interesante!

Si deseo realizar un insert de dos documentos relacionados, se inserta el primero y cuando inserta el segundo si hay un error en este como deshagoel insert anterior como un rollback. actualmente trate con transacciones, pero no lo realiza

empleadoCtrl.createEmpleado = async(req,res) => {
    const session = await mongoose.startSession();
    session.startTransaction();
    try {
        const {tipo_sangre, num_seguro_social, cambio_sucursal, usuario,password, nombre, paterno, materno} = req.body;
        console.log(req.body);

        //Guardamos Persona
        const newPersona = new Persona({
            nombre,
            paterno,
            materno,
        });

        //Guardamos Empleado
        const newEmpleado = new Empleado({
           num_seguro_social,
           tipo_sangre,
           cambio_sucursal,
           usuario,
           password,
           persona:newPersona._id
        });

            await newPersona.save();
            await newEmpleado.save();

        await session.commitTransaction();
        await session.endSession();

        res.json("Guardado");
    }
    catch (err) {
        session.abortTransaction();
        session.endSession();
        res.status(400).json({
            error: err
        });
    }

};

no entiendo porque en el metodo post llama al id del moviesmock[0]

const createMovieId = await Promise.resolve(moviesMock[0].id)

Listo

Cuando leí acerca de postman, nunca imaginé que se volvería una herramienta fundamental en mi trabajo.
No conocía que se podían guardar las consultas.

Bien dicho gigachad!!!

De casualidad alguien a podido configurar postman con WSL2(“Windows system for linux”)

Tunder client, es una extensión de vscode que puedes usar en vez de Postman.

Dejo el código de la clase por si lo requiere:

const express = require('express');

const { moviesMock } = require('../utils/mocks/movies')

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

    router.get("/", async function(req, res, next) {
        try {
            const movies = await Promise.resolve(moviesMock);

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

    router.get("/:movieId", async function(req, res, next) {
        try {
            const movies = await Promise.resolve(moviesMock[0]);

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

    router.post("/", async function(req, res, next) {
        try {
            const createdMovieId = await Promise.resolve(moviesMock[0].id);

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

    router.put("/:movieId", async function(req, res, next) {
        try {
            const updatedMovieId = await Promise.resolve(moviesMock[0].id);

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

    router.delete("/:movieId", async function(req, res, next) {
        try {
            const deletedMovieId = await Promise.resolve(moviesMock[0].id);

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

module.exports = moviesApi;