¿Cómo pueden venir las peticiones?

Para no tener que andar bajando y subiendo el server se puede instalar una librería que se llama nodemon, la cual detecta cambios en el file system del proyecto y hace el reload del proyecto automáticamente.
Para instalar nodemon ejecutar

npm i -g nodemon

Luego de tener instalado nodemon, hay que realizar un cambio en el package.json agregando lo siguiente en el apartado de scripts

    "server":"nodemon server.js",

Luego para levantar el server en vez de

node server.js

ejecutamos lo siguiente

npm run server

Este “server” coincide con la key que hemos agregado en el package.json en el apartado “scripts”

En el 2021 ya no es necesario usar router de express para crear rutas, ya esto viene por defecto en el elemento app. Lo puedes usar asi:

app.get("/", (req, res) => {
	res.send("Hola, mundo)
} 

Por si a alguien se le escapa el detalle, cuando dice “vamos a matar el servidor” lo hace con las teclas “Ctrl + C”

Insomnia me gusto mucho por que soporta graphQl, cosa que postman apenas lo tiene en beta

También podemos usar Postman o desde la terminal con curl

curl http://localhost:3000 // Petición GET
curl -X 'POST' http://localhost:3000 -d {} // Petición POST

Yo utilizo Postman para probar los endpoints de mi app. Lo recomiendo.

Para los que se perdieron en como manejar insomnio, aquí hay un link que explica como abrir los proyectos, realmente me perdí en esta parte porque el profesor no explico como abrir el proyecto.
Link: https://support.insomnia.rest/article/11-getting-started
Gracias!!

Les aconsejo instalar nodemon ya que reinicia de forma automatica cuando detecta cambios en nuestros archivos y así no debemos volver a ejecutar el comando “node server.js” cada vez que hagamos un cambio y unicamente seria “nodemon server.js”.

Recomiendo la extensión Node Snippets para VSCode

const express =  require('express');
const router = express.Router();

var app = express();
app.use(router);

/*
app.use('/', function(req, resp){
    resp.send("hola");
});
*/

router.get("/", function(req, res){
    res.send("peticion de get");
  });

router.post("/", function(req, res){
    res.send("peticion de post");
  });

router.patch("/",function(req, res){
    res.send("peticion de patch");
  });

router.delete("/",function(req, res){
    res.send("peticion de delete");
  });

app.listen(3000);
console.log(" la aplication esta escuchando en el port http://localhost::3000");

Hola, Que ventaja da usar express.Router()??
router.get(’/’ (req, res)=> res.send(‘Hola desde get’))
sobre
app.get(’/’ (req, res)=> res.send(‘Hola desde get’))
Saludos!!

Apuntes de la clase:

Hay un curso de Postman aquí mismo. Pero si tienen un entono de desarrollo en VSCode, y no quieren estar cambiando de ventana, les recomiendo Thuder Client.

Igualmente, también se debió explicar qué es el parámetro “/”. Pésimo todo, no pueden dar por sentado de que el estudiante sabe estas cosas.

en ves de insonia yo uso Postman y la verdad es muy similar y me gusta mas

me gusta mas postman

Yo utilizo, para hacer las peticiones, una extensión en Visual Studio Code llamada RESTClient.

Nombre: REST Client
ID: humao.rest-client
Descripción: REST Client for Visual Studio Code
Versión: 0.24.5
Editor: Huachao Mao
Vínculo de VS Marketplace: https://marketplace.visualstudio.com/items?itemName=humao.rest-client

Para crear una petición GET o POST, es tan sencillo como crear un archivo con extensión .http, después declarar la dirección de la API en una variable que estaremos utilizando a lo largo del archivo:

### API VARIABLE
@api = http://localhost:3000

Los “###” se utilizan para indicar un comentario.

Posteriormente hacemos las peticiones:

### GET
GET {{api}}/mensaje

### POST
POST {{api}}/mensaje

El resultado es como el siguiente:

Team postman :3

He tenido un problema al utilizar el código que viene en este vídeo:

const express = require("express");
const router = express.Router();

let port = 3000;

router.get("/", function (request, response) {
  response.send("Hola desde GET");
});

router.post("/", function (request, response) {
  response.send("Hola desde POST");
});

app.listen(port);
console.log(`La aplicacion esta escuchando en http://localhost:${port}`);

De esta manera mi daba el error al mandar una petición GET
Cannot GET /
y al mandar una petición POST
Cannot POST/

Así que investigando me encontré con la siguiente página:
https://expressjs.com/es/guide/routing.html

Al perecer ahora se hace de las peticiones se hacen de la siguiente manera:

const express = require("express");

let app = express();
let port = 3000;

// GET method route
app.get('/', function (request, response) {
  response.send('GET request to the homepage');
});

// POST method route
app.post('/', function (request, response) {
  response.send('POST request to the homepage');
});

app.listen(port);
console.log(`La aplicacion esta escuchando en http://localhost:${port}`);

Con esto mi error se ha solucionado

Que herramienta considerarían mejor, Insomnia o Postman?

Enlace de descarga Insomnia Windows 👍👍👍

fue super facil , me encanta

si quieren no estar parando y arrancando el sistema todo el tiempo, instalar npm install -g nodemon para que se guarde automáticamente

Yo utilizo normalmente Postman es una muy buena herramienta de igual forma probaré Insomnia a ver que tal me va.

llames donde llames o llames como llames

Pregunta de examen:
¿Cómo le indicamos a nuestra app que use el router?

Plus:
Para poder trabajar con EcmaScript 6+ y poder ver los cambios tienes que modificar tu package.json

{
  "name": "backendnode",
  "version": "1.0.0",
  "description": "Un chat como telegram",
  "main": "server.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "server": "nodemon server.js"
  },
  "author": "Max Diaz <[email protected]>",
  "license": "MIT",
  "dependencies": {
    "express": "^4.17.1"
  }
}

Luego en la consola escribes npm run serve y listo, a programar sin tener que volver a escribir node server.js

Me paso que deteniendo el servidor oprimí CTROL+Z y lo que hace es que suspende el servidor y lo deja en segundo plano. Si les llega a pasar deben escribir el comando “fg” y ahí sí oprimir CTROL+C.

Para los que no les gusta insomnia pueden utilizar postman para mí es mucho mejor.

también podrías usar postman en lugar de insomnia que a mi parecer es mejor

const express = require("express");
const router = express.Router();

var app = express();

app.use(router);

router
  .get("/", function(req, res) {
    res.send("Traer");
  })

  .post("/", function(req, res) {
    res.send("Enviar");
  })
  .patch("/", (req, res) => {
    res.send("Cambiar");
  })
  .delete("/", (req, res) => {
    res.send("Borrar");
  });

app.listen(3002);

console.log("La aplicacion esta escuchando en el puerto http://localhost:3002");

Pueden usar Postman en vez de Insomnia, cuestión de gustos. 😃

¿Cómo gestionar diferentes tipos de peticiones en nuestro servidor?

Una vez que tenemos nuestro servidor configurado, es importante entender cómo gestionar diferentes tipos de peticiones, como obtener datos, enviar información, actualizar o eliminar datos. Para ello, utilizaremos el método Router() de express.

// Creamos una instancia del enrutador
const router = express.Router()

// Agregamos el enrutador a nuestra aplicación express
app.use(router)

// Ahora podemos especificar qué tipo de petición deseamos manejar, en este caso usamos "get"
router.get('/', (req, res) => {
  res.send('¡Hola! Esta es una respuesta por defecto del servidor.')
})

Al agregar el enrutador a nuestra aplicación con app.use(), podemos definir rutas específicas para diferentes tipos de peticiones HTTP, como GET, POST, PUT o DELETE. En el ejemplo anterior, utilizamos router.get() para definir una ruta de tipo GET en la ruta principal ("/") de nuestro servidor.

Cuando realizamos una petición GET a esa ruta, el servidor responderá con el mensaje especificado. Sin embargo, si intentamos realizar cualquier otro tipo de petición, como POST o DELETE, el servidor responderá con el mensaje “Cannot <MétodoDePeticion>”, lo cual nos indica que ese tipo de petición no está permitida en esa ruta.

Esta configuración nos permite manejar adecuadamente los diferentes tipos de peticiones que pueden ser realizadas desde nuestras rutas. Podemos agregar más rutas y utilizar diferentes métodos para cada una de ellas, según las necesidades de nuestra aplicación.

Como alguien había dado el aporte en el curso de Express, si desean evitarse instalar PostMan o Insomnia para las request básicas, pueden utilizar la extension de VsCode ThunderClient

También pueden usar un paquete en Visual Studio Code, llamado REST Client, e integrar desde ahí sus peticiones fácilmente, sin un usar postman o insomnia

si no quieren descargar insomnia o postman, Visual studio code tiene una extension que se llama Thunder Ciient, con la que podemos hacer las peticiones.

Ya no es necesario usar aplicaciones, desde el mismo vs lo puedes hacer con la extension “Thunder Client” ! Es superior postman y a otras herramientas para realizar ejercicios de éste estilo

con una extensión de VSC llamda thunder client es más cómodo hacerlo ( en vez de insomnia)

Hay una extensión en vscode llamada Thunder Client, asi no tienen que descargar otra aplicación aparte para hacer peticiones

por que se añade el router a express, si ya viene el Router dentro de express ?

const express = require(“express”)
const router = express.Router() // nos permite seperar cabezeras o por metodos o por URL y separar nuestras peticiones al maximo.

let app = express()

app.use(router)

router.get("/message", function (req, res) {
res.send(“Lista de mensajes”)
})

router.post("/message", function (req, res) {
res.send(“mensaje añadido”)
})

router.delete("/message", function (req, res) {
res.send(“mensaje Eliminado”)
})

// app.use("/", function (req, res) {
// res.send(“Hola Mundo”)
// })

app.listen(3000)
console.log(“la aplicacion esta escuchando en http//localhost:3000”)

Este profesor explica demaciado bien

Buenisima la clase !!!

Mis aporte de como es que yo organice mi código.

En este archivo tengo todo lo que necesita express para poder ejecutar el servidor en la dirección y el puerto que se establece.

const express = require('express');
const router = require('./router/index');
const PORT = process.env.PORT || 3000;
const app = express();

app.use('/api',router);

app.listen(PORT, () => {
  console.info(`La aplicación esta escuchando peticiones`);

});

Creo una carpeta 📂 router con un archivo llamado 📄 index,js, donde lo que hago es requerir el modulo de express y en especifico router y me creo las rutas que necesita mi servidor luego lo exporto mi variable router y asi puedo usarlo en mi archivo server.js

const express = require("express");
const router = express.Router();
router.get('/message', (req, res) => {
  res.json({
    "method": "GET", 
    "Uso": "Se usa para listar datos, del servidor",
    "ejemplo": "Lista de Mensajes! 👀"
  })
})
router.post('/message', (req, res) => {
  res.json({
    "method": "POST", 
    "Uso": "Se usa para insertar datos, al servidor",
    "ejemplo": "Mensaje Agregado! 👍"
  })
})
router.put('/message', (req, res) => {
  res.json({
    "method": "PUT", 
    "Uso": "Se usa para remplazar datos, al servidor",
    "ejemplo": "Mensaje editado! 👌"
  })
})
router.delete('/message', (req, res) => {
  res.json({
    "method": "DELETE", 
    "Uso": "Se usa para eliminar datos, al servidor",
    "ejemplo": "Mensaje Eliminado! 🤷‍♂️"
  })
})

module.exports = router;

Veo y entiendo que Insomnia es similar a Postman para hacer este tipo de peticiones HTTP. Si quiere aprender más dejo el curso: https://platzi.com/clases/postman/

Para los que deseen instalar Insomia in ubuntu solo ejecuten el siguiente comando:

sudo snap install insomnia

Interesante

Yo utilizo ARC (Advanced REST Client) para hacer el seguimiento a las peticiones

excelente clase, llevo ya algunos meses usando node-express y nunca había usado router.

Esta chido el cliente RES

Ohhh se esta poniendo bueno esto.
Me encanta NodeJs❤
Me agrada insomnia .

Insomnia buena herramienta para ser usada en linux 😃

Excelente clase !

https://itnext.io/postman-vs-insomnia-comparing-the-api-testing-tools-4f12099275c1

como mata el servidor para volver a arrancarlo? es una combinacion de teclas?

This is my code

const express = require('express');
const router = express.Router();

var app =  express();

app.use(router);

app.get('/', (req, res) => {
    res.send('Que ondas Soy tu primer petición con GET');
});
app.post('/', (req, res) => {
    res.send('Que ondas Soy tu primer petición con POST');
});
app.listen(3000);
console.log('La aplicación esta escuchando en pueto:3000');

//en consola se debe instalar el paquete de express con el siguiente comando
//npm i express
//una vez instalado debemos asignar a una constante el paquete instalado
const express = require("express");
var app = express();
//añadiremos router de express para poder utilizar los metodos http y controlar los mensajes a entregar en nuestras peticiones
const router = express.Router();

// app.use("/", function(req, res) {
//     res.send("Hola soy un server con express");
// });

//ahora indicamos que nuestra app utilizara las rutas entregadas por express
app.use(router);
//de esta forma podemos invocar los distintos metodos http con express
router.get("/mensaje", (req, res) => {
    res.send("Hola este metodo es get para listar los mensajes");
});
router.post("/mensaje", (req, res) => {
    res.send("hola este metodo invocado es post, gracias por añadir un mensaje");
});

app.listen(3002);
console.log("la aplicacion esta escuchando en http://localhost:3002");

Me siento hacker xdxd

Insomnia es similar a posman?

const express = require('express');
const router = express.Router();

var app = express();

app.use(router);

router.get('/message', function(req, res){
    res.send('Hola desde get, Lista de mensajes');
})

router.post('/message', function(req, res){
    res.send('Hola desde post, mensaje añadido');
})

router.delete('/message', function(req, res){
    res.send('Hola desde delete, eliminar mensaje');
})

router.put('/message', function(req, res){
    res.send('Hola desde put, editar mensaje');
})

router.patch('/message', function(req, res){
    res.send('Hola desde patch, cambiar precio del mensaje');
})

router.options('/message', function(req, res){
    res.send('Hola desde options');
})

app.listen(3000);
console.log('La aplicación esta escuchando en http://localhost:3000')```

muy interesante,

const express = require('express');
//nos permite trabajar y gestionar nuestras peticiones
const router = express.Router();
const PUERTO = 3000;

var app = express();
//aqui añadinos router a la aplicacion de express
app.use(router);

router.get('/message', (req, res) => {
    res.send('Lista de mensajes');
});

router.post('/message', (req, res) => {
    res.send('Mensaje añadido');
});

// app.use('/', (req, res) => {
//     res.send('Hola');
// })

app.listen(PUERTO);
console.log(`La aplicacion esta escucando en http://localhost:${PUERTO}`);

entonces express sirve para administrar lo que el servidor devuelve?

![Por si tienen problemas con el puerto en linux pueden hacer esto para cerrar el puerto y que deje de dar problemas](

otro opción seria utilizar postman

Para gestionar el tipo de peticiones que realizamos a nuestro servidor utilizaremos el router de express.

Nos va a permitir separar cabeceras ó por métodos ó por url

De esta manera lo que debemos hacer es cambiar el código para gestionar cada una de las rutas que vamos a crear con el método http que le indiquemos.

const express = require("express");
const router = express.Router();

var app = express();

app.use(router);

router.get("/", function (req, res) {
  res.send("listando objetos");
});

router.post("/", function (req, res) {
    res.send("creando objeto");
  });

  router.delete("/", function (req, res) {
    res.send("borrando objeto");
  });

app.listen(3000);
console.log("La aplicación esta escuchando en http://localhost:3000");

Facinante cuestion we :v

Se debió explicar qué son los parámetros req y res. Si sí lo hicieron y yo no lo vi, por favor indíquenlo.

En postman, no me deja usar el Agent del Cloud. Asi que tuve que descargalo para desktop por que no me dejaba acceder al localhost desde el browser… Solo desde el desktop 😦

https://www.postman.com

Postman es otra buena herramienta para hacer peticiones http cuando desarrollas una API, es muy bueno como alternativa a Insomnia.

Recomiendo que usen Postman, es como Insomnia pero mucho más potente y tiene una interfaz muy similar

Práctica: