No tienes acceso a esta clase

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

Convierte tus certificados en títulos universitarios en USA

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

19 Días
9 Hrs
49 Min
51 Seg

Fetch

13/26
Recursos

Aportes 92

Preguntas 45

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

💾 𝗖𝗹𝗮𝘀𝗲 #𝟭𝟭: 𝗙𝗲𝘁𝗰𝗵𝟭𝟭/𝟮𝟭 💾
.
Por medio de Fetch se puede realizar peticiones HTTP asíncronas de JavaScript (JS) con promesas. La API Fetch proporciona una interfaz JS más cómoda para acceder y manipular; fetch() es un método global.
.
🛠️ Para poder usar fetch, primero tenemos que instalarlo:
.

  • Ir a la terminal e instalar fetch con: npm i node-fetch
  • Para poder compilar desde VSC, debemos registrar el modulo en package.json, abrimos el archivo y al final se agrega:
"type": "module"
  • Importante agregar una coma (,) a la llave que cierra a “dependencies”.
  • En la ruta src/promise crear el archivo challenge.js
  • En el archivo challenge.js inicialmente se debe importar lo que acabamos de instalar, agregando el código: import fetch from 'node-fetch';
  • Dado que la API es una constante, nunca va a cambiar, por convección se coloca en letras mayúsculas: const API = 'https://api.escuelajs.co/api/v1';
  • Ahora se crea la lógica con fetch, then y catch:
import fetch from 'node-fetch';
const API = 'https://api.escuelajs.co/api/v1';

//función que va a recibir como argumento la url que queremos llamar y esto retornará el llamado de fecth: una promesa
function fetchData(urlApi){
    return fetch(urlApi);
};
//el llamado
fetchData(`${API}/products`)
    .then(response => response.json())
    .then(products => {
        console.log(products);
    })
    .then(() => {
        console.log('hola');
    }) //se pueden anidar múltiples .then
    .catch(error => console.log(error));
  • Para correrlo dentro de la consola de VSC, se selecciona el código, se da click derecho y se le da a Run Code. En la salida (OUTPUT) si no arroja error, sale una lista larga de elementos del llamado a la API.
    .

Continuando con la clase, para compilar el segundo ejemplo debemos comentar fetchData() para evitar problemas de compilación.
.
🖊️ ¿Cómo comentar en JavaScript?
.
En JS se comenta cada línea con doble slash // o se puede comentar todo un párrafo iniciando con slash + asterisco /* y finalizar con asterisco + slash */
.
Pero para ahorrar tiempo se puede usar los shortcuts de VSC, se pueden ver y editar en File>Preferences>Keyboard Shortcuts o pulsando las teclas Ctrl + K Ctrl + S:
.

  • Para comentar con shortcut, seleccionar el texto que se quiere comentar y presionar las teclas Ctrl + K luego las sueltas y presionas las teclas Ctrl + C
  • Para quitar los comentarios con shortcut, seleccionas el texto comentado, presionar las teclas Ctrl + K luego las sueltas y presionas las teclas Ctrl + U
    .

✏️ El código del segundo ejemplo queda:

fetchData(`${API}/products`)
    .then(response => response.json()) //se hace la conversión a un objeto json
    .then(products => {
        console.log(products);
        return fetchData(`${API}/products/${products[0].id}`) // solo se quiere mostrar el primer elemento de la primera solicitud
    })
    .then(response => response.json()) //se vuelve traer la data
    .then(product => {
        console.log(products.title);
        return fetchData(`${API}/categories/${product.category.id}`) //se quiere mostrar la categoria de un producto en particular
    })
    .then(response => response.json())
    .then(category => {
        console.log(category.name);
    })
    .catch(err => console.log(err)) //detectar un error
    .finally(() => console.log('Finally')); //es opcional para mostrar que se terminó la solicitud

.

  • Al correrlo con Run Code, la salida muestra una lista larga con la última palabra impresa Finally.

Desde la versión 18 de Node.js se puede utilizar fetch de manera nativa.

Me pareció más fácil usar las promises que las callbacks, pero la pregunta es cuando uso uno y cuando uso el otro. 🤔

⭐ Fetch:

Nos permite realizar peticiones HTTP asíncronas utilizando promesas y de forma que el código sea un poco más sencillo y menos verboso.

Básicamente llamamos a Fetch y le pasamos como parámetro la URL de la petición.

const request = fetch(API);

Fetch devolvera una promesa, la cual le podremos aplicar los métodos then y catch

fetch(API)
	.then(res => res.json())
	.then(data => console.log(data))
	.catch(err => console.log(err));

Se pueden anidar multiples then para hacer lógicas consecuentes.

Todo es color de rosa cunado comprendes todo maldita sea😄!!

.

Aunque tengo una duda,

  • Como podria usar este tipo de conocimiento en mi proyecto?
  • Osea para que sirve todo esto?
  • En que lo uso, por ejemplo en mi web page que lo hara ver mas chido?

En las notas de un compañero del curso pasado comentó sobre una librería llamada axios que nos ayudaba a hacer las peticiones de una manera más sencilla me anime a intentarlo a hacer el codigo con esa librería y el resultado fue este se redujo mucho el codigo :

import axios from 'axios';

const API = 'https://api.escuelajs.co/api/v1';

axios.get(`${API}/products`)
  .then((products) => {
    console.log(products.data[0]);
    return axios.get(`${API}/products/${products.data[0].id}`);
  })
  .then((product) => {
    console.log(product.data.title);
    console.log(product.data.price);
    return axios.get(`${API}/categories/${product.data.category.id}`);
  })
  .then((category) => console.log(category.data.name))
  .catch((err) => console.error(err));

por si a alguien le interesa solo utiliza npm i axios y listo ya lo puedes utilizar aquí dejo documentacion
recuerden que antes de correr tenemos que caminar para utilizar estos frameworks y saber que esta pasando tenemos que estudiar muy bien las bases para dominar estas ayudas.

Aqui les traigo una forma de escribir la funcion fetchData para no tener que escribir en cada peticion la conversion a formato json

import fetch from "node-fetch";

const API = 'https://api.escuelajs.co/api/v1';

//función que va a recibir como argumento la url que queremos llamar y esto retornará el llamado de fecth: una promesa
function fetchData(urlApi){
    return fetch(urlApi).then(response => response.json());
};

fetchData(`${API}/products`)
    .then(products =>{
        console.log(products[0]);
        return fetchData(`${API}/products/${products[0].id}`)
    })
    .then(product=>{
        console.info(product.title)
        return fetchData(`${API}/categories/${product?.category?.id}`)
    })
    .then(category=>{
        console.info(category.name)
    })
    .catch(err=>{ console.error(err)})

Para el que todavía no lo sepa, para comentar todo lo seleccionado en VSC, solo tienes que seleccionar lo que quieres comentar, y luego pulsar CTRL+K, seguido de CTRL+C, espero les sirva, saludos!

Quiero darle la duda al profesor en cuanto a su forma de llevar el curso, para muchos de seguro es mucho más fácil de entender y obviamente no es solo quedarse con este curso, pero creo que sería mucho más fácil para a quellos que se nos dificulta, que hiciera un ejemplo real, es decir, tiene una web x ( y que podamos verla) y va a traer de la API x productos y la va a mostrar en dicha web pero que sea visible lo que está trayendo. Monse si me explico! Llevo todo el curso tratando de entender y me cuesta.
import fetch from "node-fetch";
const API = 'https://api.escuelajs.co/api/v1';

function fetchData(urlApi){
    return fetch(urlApi);
};

/*fetchData (`${API}/products`)
    .then(response => response.json())
    .then(products => {
        console.log(products);
    })
    .catch(error => console.log(error))*/

fetchData(`${API}/products`)
    .then(response => response.json())
    .then(products=> {
        console.log(products);
        return fetchData (`${API}/products/${products[0].id}`)
    })
    .then(response => response.json())
    .then(product => {
        console.log(product.title)
        return fetchData (`${API}/categories/${product.category.id}`)
    })
    .then(response => response.json())
    .then(category => {
        console.log(category.name);
    })
    .catch(err => console.log(err))
    .finally (()=> console.log('Finally'))

Si no estas muy familiarizado con arrow function ve el primer then

fetchData(`${API}/products`)
  .then(function (response) {
    console.log("ejemplo de más validaciones");
    return response.json(); // regresa el primer llamado
  })
  .then((products) => {
    //console.log(products);
    return fetchData(`${API}/products/${products[0].id}`); // se lanza el fetch para solicitar solo un producto
  })
  .then((response) => response.json()) //respuesta del segundo llamado
  .then((product) => {
    console.log(product); //trae el poducto
    return fetchData(`${API}/categoriess/${product.category.id}`); // se lanza el fetch para obtene el id de la categoria del unico producto
  })
  .then((response) => response.json()) // respuesta del tercer llamado
  .then((category) => {
    console.log(category); //trae la categoria
    console.log(category.name); // imprime la categoria del producto
  })
  .catch((error) => console.error("Error " + error)) // si existe error
  .finally(() => console.log("Finally")); // finally

Vengo haciendo toda la ruta sin ningún problema y este curso deja mucho que desear. No explica la mitad de los conceptos que utiliza. Muy mal…

Recuerden que para ahorrarse el paso del package.json, pueden simplemente renombrar el archivo como Challenge.mjs

de esa forma la m transformará el archivo js en módulo.

Hasta el minuto 6 estaba totalmente perdido. Podría haber arrancado diciendo que fetch ya es una promesa por defecto, y así poder ir siguiendo mejor el video.

Les dejo el link de la API, lo escribí mal dos veces

import fetch from 'node-fetch';
const API = 'https://api.escuelajs.co/api/v1';

En lugar de añadir tu módulo a tu package.json, puedes simplemente cambiar el formato de tu archivo .js por .msj y ya el intérprete de JavaScript lo tratará como un módulo.

Colbal Hell

🔥 ¿Cómo usar esto en nuestros proyectos?

Te dejo mis apuntes y el tutorial que estuve viendo.


Terminos que usaremos

En JavaScript, los términos “fetch”, “async-await” y “try-catch” tienen relación con el manejo de solicitudes y respuestas a través de la red, mientras que el archivo JSON es un formato de datos comúnmente utilizado para el intercambio de información a través de la red.

  1. “fetch”: es un método nativo de JavaScript que permite realizar solicitudes HTTP asincrónicas (AJAX) a servidores web y recibir respuestas en formato JSON, texto, blob, entre otros. El método “fetch” devuelve una promesa que puede ser resuelta para obtener la respuesta del servidor.

  2. “async-await”: es una sintaxis para manejar promesas en JavaScript. Permite que las funciones asincrónicas se escriban de una manera más sencilla y legible, sin tener que encadenar múltiples callbacks. La palabra clave “async” se utiliza para definir una función asincrónica, mientras que “await” se usa para esperar a que una promesa se resuelva antes de continuar con la ejecución.

  3. “try-catch”: es un bloque de código utilizado para manejar errores en JavaScript. El bloque “try” contiene el código que se ejecutará y el bloque “catch” se ejecuta si hay alguna excepción lanzada en el bloque “try”. El bloque “catch” permite manejar el error y tomar medidas para corregirlo o recuperarse de él.

  4. Archivo JSON: es un formato de datos utilizado para el intercambio de información a través de la red. La sintaxis de JSON es similar a la sintaxis de los objetos JavaScript, lo que lo hace fácil de leer y escribir. Los archivos JSON se utilizan comúnmente para enviar y recibir datos entre servidores y clientes web en aplicaciones basadas en AJAX. En JavaScript, los archivos JSON se pueden leer y manipular utilizando el método “fetch” para obtener los datos del servidor y los métodos “JSON.parse” y “JSON.stringify” para analizar y convertir los datos a objetos JavaScript.

Rick and Morty

Creamos un archivo index.html con esta estructura:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Rick and Morty</title>
  </head>
  <body>
    <div id="characters"></div>
    <script src="./main.js"></script>
  </body>
</html>

Agregamos este código para ver las imágenes y nombres en la web. Usaremos una API de Rick and Morty:

/* 
🔥 No Hace falta usar import fetch...
import fetch from "node-fetch"; 
*/
const API = 'https://rickandmortyapi.com/api/character';
let characters = document.querySelector('#characters');

fetch(API)
	.then(response => response.json())
	.then(data => {
		console.log(data.results)

		data.results.map((item) => {
			const content = document.createElement("div");
			content.innerHTML =
				`
			<h4>${item.name}</h4>
			<img src="${item.image}">
			`;
			characters.append(content)
		})
	});

🔥 No Hace falta usar import fetch, ni instalar el módulo desde consola.

NASA

Para hacer uso de la API de la NASA, debemos registrarnos y luego entramos a APOD.

https://api.nasa.gov/planetary/apod
PNmL8OBHZyiJFCAeRyGdL5qxemQSmOCGln
🔥 Referencia no real👉https://api.nasa.gov/planetary/apod?api_key=PNmL8OBHZyiJFCAeRyGdL5qxemQSmOCGln

index.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>NASA</title>
  </head>
  <body>
    <div id="infoNasa"></div>
    <script src="./main.js"></script>
  </body>
</html>

main.js

let infoNasa = document.querySelector("#infoNasa");
const API = 'https://api.nasa.gov/planetary/apod?api_key=PNmL8OBHZyiJFCAeRyGdL5qxemQSmOCGlni';

const fetchNasa = async () => {
	try {
		const response = await fetch(API);
		const data = await response.json();
		console.log(data);

		const spaceInfo = document.createElement('div');
		spaceInfo.innerHTML = `
		<img src="${data.url}"/>
		<h4>${data.title}</h4>
		<p>${data.explanation}</p>		
		`;

		infoNasa.append(spaceInfo);
	} catch (err) {
		console.log(err);
	}
};

fetchNasa();

Star Wars

🔥 Debes crear un archivo data.json y agregar datos que puedes obtener con los enlaces del párrafo siguiente.

Revisa swapi.dev, puedes obtener más datos desde la Api Root, aunque esto no tiene imágenes, por eso decidí usar esto starwars-api. Aquí están los datos que agregué Characters

index.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Star Wars</title>
  </head>
  <body>
	<div id="star-wars"></div>
    <script src="./main.js"></script>
  </body>
</html>

main.js

let starwars = document.querySelector('#star-wars');

fetch('./data.json')
	.then(response => response.json())
	.then(data => {
		console.log(data)
		data.map(item => {
			const content = document.createElement('div');
			content.innerHTML = `
				<h4>${item.name}</h4>
				<img src="${item.image}" width="50%" height="50%">
			`;

			starwars.append(content);
		})
	});

🔥 Como utilizar fetch, async-await, try-catch + archivo json

Por cierto, cuando Oscar dice “se ve un poco Reburujado” se refiere a que se ve confuso, no muy claro, revuelto.

Es algo que se usa mucho en la región donde vivo en Mexico, busque y es Oscar originario muy cerca de aquí, en Torreon. ahora tiene sentido jaja!

Me ha gustado mucho, no terminaba de entender fetch y ahora lo tengo muy claro.

13/26 Curso de Asincronismo: Fetch

En JavaScript, “fetch” es una función que se utiliza para realizar solicitudes de red (por ejemplo, solicitudes HTTP) desde un navegador web o desde un entorno de ejecución de JavaScript, como Node.js. Fetch se utiliza para recuperar datos de recursos externos, como archivos JSON, imágenes, API web, y más.


¿Cómo se utiliza “fetch” en JavaScript?



Para hacer una solicitud utilizando “fetch”, debes proporcionar la URL del recurso al que deseas acceder. La función “fetch” devuelve una promesa que resuelve en una respuesta HTTP. Puedes usar métodos encadenados en la promesa para procesar la respuesta.

Aquí hay un ejemplo básico de cómo hacer una solicitud GET con “fetch”:

fetch('https://api.example.com/data')
  .then(response => {
    if (!response.ok) {
      throw new Error('Error de red');
    }
    return response.json(); // Convierte la respuesta a JSON
  })
  .then(data => {
    console.log(data); // Hacer algo con los datos obtenidos
  })
  .catch(error => {
    console.error('Error:', error);
  });


¿Por qué se utiliza “fetch” en JavaScript?


  1. Acceso a datos remotos: Fetch se utiliza para obtener datos de recursos remotos, como API web, archivos JSON, imágenes, etc. Esto permite a las aplicaciones web interactuar con servicios en línea y recuperar información en tiempo real.

  2. Actualizaciones dinámicas: Fetch es esencial para crear aplicaciones web dinámicas que pueden actualizar su contenido sin necesidad de recargar la página completa. Puedes usar “fetch” para cargar datos adicionales a medida que los usuarios interactúan con tu aplicación.

  3. Integración con APIs: Muchas aplicaciones web modernas utilizan APIs para obtener datos y funcionalidades de terceros. Fetch facilita la comunicación con estas APIs al enviar solicitudes HTTP y recibir respuestas JSON u otros formatos de datos.

  4. Manipulación de datos asincrónicos: Fetch opera de manera asincrónica, lo que significa que no bloquea la ejecución de otras partes de tu código. Esto es crucial para garantizar una experiencia de usuario fluida en aplicaciones web.


En resumen, “fetch” es una herramienta esencial en JavaScript para realizar solicitudes de red y acceder a recursos externos, lo que permite a las aplicaciones web interactuar con servicios en línea y proporcionar una experiencia de usuario más dinámica y enriquecedora.

Espero sea de utilidad. 👨‍💻

Yo no entiendo nada

//mi manera de hacerlo
fetchData(`${API}/products`)
  .then((response) => response.json())
  .then((response) => {
    console.log(response);
    return fetchData(`${API}/products`)
      .then((response) => response.json())
      .then((response) => response[0].title)
      .then((response) => {
        console.log(response);
        return fetchData(`${API}/products`)
          .then((response) => response.json())
          .then((response) => response[0].category.name)
          .then((response) => console.log(response))
          .catch((error) => console.error(error))
          .finally(() => console.log("Peticion finalizada"));
      });
  });

Ahora que hay una version 3 de node-fetch
https://www.npmjs.com/package/node-fetch
el import debe ser como

const fetch = require('node-fetch');

https://www.netlify.com/blog/how-to-make-a-fetch-request-using-node-fetch-v3/

tal vez no sea un experto y me cueste mucho aprender esta temática pero me di cuenta al instante lo del doble console.log xD

aqui les aporto el comando de descaga de node-fetch

npm install node-fetch
import fetch from "node-fetch";
const API = 'https://api.escuelajs.co/api/v1';


function fetchData (urlApi){
  return fetch(urlApi);
}

// fecthData(`${API}/products`)
//   .then(response=>response.json())
//   .then(products =>{
//     console.log(products);
//   })
//   .then(console.log('hola'))
//   .catch(err => console.log(err))

fetchData(`${API}/products`)
  .then(response=>response.json())
  .then(products =>{
    console.log(products)
    return fetchData(`${API}/products/${products[0].id}`)
  })
  .then(response=>response.json())
  .then(product => {
    console.log(product.title)
    return fetchData(`${API}/categories/${product.category.id}`)
  })
  .then(response=>response.json())
  .then(category =>{
    console.log(category.name)
  })
  .catch(err => console.log(err))
  .finally(() => console.log('finally'))

FETCH

Ahora que sabemos que son las promesas, vamos a utilizar nuestra API con ellas.
Para eso utilizaremos fetch, al mismo hay que instalarlo desde nuestra terminal de la siguiente manera:

npm i node-fetch

Ahora que ya lo instalamos, podemos utilizarlo en nuestro código.
El primer paso seria importarlo (Si quieren saber mas sobre importar/exportar pueden revisar el curso de Ecmascript 6+)

import fetch from "node-fetch";

Recordemos que para importar un modulo debemos estar en “type”: “module”, lo cual esta predeterminado en los navegadores, pero no en nuestro editor de código. Así que deberemos agregar la siguiente linea en nuestro archivo package.json

"type": "module"

Ahora, volviendo a nuestro archivo challenge.js declararemos una constante que será la url de nuestra API, en este caso estaremos usando la API de la Platzi fake store.

const API = "https://api.escuelajs.co/api/v1";

Perfecto, ya hemos importado fetch y declarado la constante con la url inicial de la API.
Ahora, crearemos la función fetchData (Puedes revisar la clase 8 de este curso si te olvidaste de que se trataba), el objetivo es el mismo, pero esta vez lo haremos con promesas:

function fetchData(urlAPI){
    return fetch(urlAPI);
}

Ya tenemos la función creada! ahora es cuestión de llamarla, en este caso la llamaremos para pedirle que nos de un listado de todos los productos, el nombre de un producto, y su categoría.

fetchData(`${API}/products`)
.then(response => response.json())
.then(products => {
    console.log(products);
    return fetchData(`${API}/products/${products[1].id}`)
     })
.then(response => response.json())
.then(product => {
    console.log(product.title);
    return fetchData(`${API}/categories/${product.category.id}`)
})
.then(response=> response.json())
.then(category=> {
    console.log(category.name);
})

Por ultimo, es fundamental no olvidar utilizar el metodo .catch() por si llega a ocurrir en error.

.catch(error => {
    console.log(error);
})```


No se si el profesor metio de aposta el console.log doble hahahaha pero si cai encuenta.

Buena la clase, hay que practicar y escribir bastante para entender 😃

import fetch from "node-fetch"; //previamente en consola sudo npm i node-fetch
const API = 'https://api.escuelajs.co/api/v1';

function fetchData(urlApi) {
    return fetch(urlApi);
};
//no es necesario new Promise porque fetch por defecto ya es una promesa
/* fetchData(`${API}/products`)
    .then(response => response.json())//convierte la respuesta a un objeto .json
    .then(products => {
        console.log(products);//muestra los productos
    })
    .then(() => {
        console.log('Hola');//se pueden aniddar todos los then necesarios
    })
    .catch(error => console.log(error));//manejo de errores */
//para que el código funcione en VSCode es necesario agregar en package.json ,"type": "module", esto no es necesario en el navegador

fetchData(`${API}/products`)
    .then(response => response.json())
    .then(products => {
        console.log(products)
        return fetchData(`${API}/products/${products[0].id}`)
    })
    .then(response => response.json())
    .then(product => {
        console.log(product.title)
        return fetchData(`${API}/categories/${product.category.id}`)
    })
    .then(response => response.json())
    .then(category => {
        console.log(category.name);
    })
    .catch(err => console.log(err))
    .finally(() => console.log('Finally'));

//de esta manera se obtienen los datos del API con promise, evitando los callbacks hell

me pareció un ejercicio interesante para practicar el concepto de promesa utilizar el fetchData de la case anterior y convertirlo en una función que retorna una promesa.
NOTA: si vas a utilizar el siguiente script y agregaron en el package.json el “type”: “module”, debemos quitarlo.

const XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest;
const API = 'https://api.escuelajs.co/api/v1';

function fetchData(urlApi){
    return new Promise(function (resolve, reject){
        let xhttp = new XMLHttpRequest();
        xhttp.open('GET', urlApi, true);
        xhttp.onreadystatechange = function (event){
            if(xhttp.readyState === 4){
                if(xhttp.status === 200){
                    resolve(xhttp.responseText);
                } else {
                    const error = new Error('Error' + urlApi);
                    reject(error);
                }
            }
        }
        xhttp.send();
    });
}

fetchData(`${API}/products`)
.then(response => JSON.parse(response))
.then(products => {
    console.log(products[0]);
    return fetchData(`${API}/products/${products[0].id}`);
})
.then(response => JSON.parse(response))
.then(product => {
    console.log(product.title);
    return fetchData(`${API}/categories/${product.category.id}`);
})
.then(response => JSON.parse(response))
.then(category => {
    console.log(category.name);
})

Aqui esta como yo tengo guardada la informacion de la clase y lo que se realizo

<code> 
//Fetch: Nos permite realizar peticiones HTTP asíncronas utilizando promesas y de forma que el código sea un poco más sencillo y menos verboso.
//Hay que instalar en la terminal -> npm i node-fetch

import fetch from "node-fetch";
const API = 'https://api.escuelajs.co/api/v1';

function fetchData(urlApi) {
    return fetch(urlApi);
};

/*fetchData(`${API}/products`)
    .then(response => response.json())
    .then(products => {console.log(products);})
    .then(() => {console.log('Hello');})
    .catch(error => console.log(error))*/

fetchData(`${API}/products`)
    .then(response => response.json())
    .then(products => {console.log(products); return fetchData(`${API}/products/${products[50].id}`);})
    .then(response => response.json())
    .then(product => {console.log(product.title); return fetchData(`${API}/categories/${product.category.id}`);})
    .then(response => response.json())
    .then(category => {console.log(category.name);})
    .catch(error => console.log(error))
    .finally(() => console.log('Finally'))

```js const api = "https://api.escuelajs.co/api/v1"; async function fetchData(url) { return await fetch(url); } function getAll(endpoint) { return fetchData(`${api}/${endpoint}`) .then((response) => response.json()) .then((data) => console.log(data)) .catch((error) => console.log(error)); } function getById(endpoint, id) { return fetchData(`${api}/${endpoint}/${id}`) .then((response) => response.json()) .then((data) => console.log(data)) .catch((error) => console.log(error)); } const products = getAll("products"); const product = getById("products", 150); ```
![](https://static.platzi.com/media/user_upload/image-6360fdf7-13d0-4ac0-b832-6a79f33302cd.jpg)
No se si estare en lo correcto pero los returns no estan mostrando nada, no tiene sentido entrar a sub productos o a sus indices, si no los vas a mostrar. El ejemplo esta mal planteado el primer ejemplo deberia ser algo asi para: console.log(products\[0].id) Si realmente queria mostrarnos eso, solo nos mostro todo los productos. Con este profesor que prefiere hablar mucho y que explicar poco, tengo que pasar a sus cursos son las expectativas bajas.
Para los que tienen problema con la API o les da error que no encuentra nada les dejo la de fakestore de platzi: <https://fakeapi.platzi.com/>
![](https://static.platzi.com/media/user_upload/code-cb5183a3-1f01-400b-aa96-5e8207238fe2.jpg)
![](https://static.platzi.com/media/user_upload/image-d8fe9273-c60a-4626-9743-26c5dab256cb.jpg)
me sale este error :(
![](https://static.platzi.com/media/user_upload/image-aa2c4a3d-c6be-4e0e-bf4a-0a9de2b91846.jpg)
```js fetchData(`${API}/products`) // Llama a la función fetchData con la URL de productos como argumento .then(response => response.json()) // Convierte la respuesta a formato JSON .then(products => { // Ejecuta esta función cuando la respuesta se convierte en JSON, pasando los productos como argumento console.log(products) // Imprime los productos en la consola return fetchData(`${API}/products/${products[0].id}`) // Retorna una llamada a fetchData con la URL del primer producto como argumento }) .then(response => response.json()) // Convierte la respuesta del primer producto a formato JSON .then(product => { // Ejecuta esta función cuando la respuesta del primer producto se convierte en JSON, pasando el producto como argumento console.log(product.title); // Imprime el título del producto en la consola return fetchData(`${API}/categories/${product.category.id}`) // Retorna una llamada a fetchData con la URL de la categoría del producto como argumento }) .then(response => response.json()) // Convierte la respuesta de la categoría a formato JSON .then(category => { // Ejecuta esta función cuando la respuesta de la categoría se convierte en JSON, pasando la categoría como argumento console.log(category.name); // Imprime el nombre de la categoría en la consola }) .catch(err => console.log(err)) // Captura cualquier error que ocurra durante las promesas anteriores y lo imprime en la consola .finally(() => console.log('Finally')); // Ejecuta esta función después de que todas las promesas anteriores se completen o fallen, imprimiendo 'Finally' en la consola ```

Algo que no terminaba de entender era el método .json() y exactamente que retornaba, luego de revisar la documentación entendí que retorna una promesa! Es por esto que podemos usar otro .then() con dicho valor, espero esto pueda aclarar la duda si alguien también la tuvo

Por si alguien no entiende, como yo, por qué en los .then en donde se utiliza el método .json() no se retorna algo, lo que realmente pasa es que sí se retorna algo solo que no se utiliza la palabra return gracias a la sintaxis simplificada de las funciones flecha, implícitamente en esta sintaxis de una sola línea de código se esta indicando que el resultado obtenido se retorne. Espero a alguien le ayude.
Okay, este curso si que me apaga el cerebro, y eso que ya he aprendido algo de APIs y Node... de momento continuaré la ruta y probablemente aprenda a profundidad estos temas en su momento

¿Que ofrece Fetch?

Fetch ofrece una definición genérica de los objetos Request y Response (y otras cosas relacionadas con las solicitudes de red). Esto permitirá su uso donde sea necesario en un futuro, ya sea para operadores de servicios, API caché y otras cosas similares que manipulen o modifiquen las solicitudes y respuestas, o cualquier otro tipo de caso de uso que pudiera requerirle la generación de sus propias respuestas mediante programación.

Una vez aprendemos a realizar peticiones HTTP mediante XHR nos damos cuenta que es un mecanismo muy interesante y útil, y que nos abre un mundo de posibilidades trabajando con Javascript. Sin embargo, con el tiempo nos vamos dando cuenta también, que la forma de trabajar con objetos XMLHttpRequest, aunque es muy potente requiere mucho trabajo que hace que el código no sea tan legible y práctico como quizás debería.

Entonces es cuando surge fetch, un sistema más moderno, basado en promesas de Javascript, para realizar peticiones HTTP asíncronas de una forma más legible y cómoda.

Peticiones HTTP con fetch

Fetch es el nombre de una nueva API para Javascript con la cuál podemos realizar peticiones HTTP asíncronas utilizando promesas y de forma que el código sea un poco más sencillo y menos verbose. La forma de realizar una petición es muy sencilla, básicamente se trata de llamar a fetch y pasarle por parámetro la URL de la petición a realizar:

const promise = fetch("/robots.txt");

promise.then(function(response) {
  /* ... */
});

El fetch() devolverá una  que será aceptada cuando reciba una respuesta y sólo será rechazada si hay un fallo de red o si por alguna razón no se pudo completar la petición.

El modo más habitual de manejar las promesas es utilizando [.then()](https://lenguajejs.com/javascript/asincronia/promesas/), aunque también se puede utilizar async/await. Esto se suele reescribir de la siguiente forma, que queda mucho más simple y evitamos constantes o variables temporales de un solo uso:

fetch("/robots.txt")
  .then(function(response) {
    /** Código que procesa la respuesta **/
  });

Al método .then() se le pasa una función callback donde su parámetro response es el objeto de respuesta de la petición que hemos realizado. En su interior realizaremos la lógica que queramos hacer con la respuesta a nuestra petición.

Opciones de fetch()

A la función fetch(), al margen de la url a la que hacemos petición, se le puede pasar un segundo parámetro de opciones de forma opcional, un  con opciones de la petición HTTP:

const options = {
  method: "GET"
};

fetch("/robots.txt", options)
  .then(response => response.text())
  .then(data => {
    /** Procesar los datos **/
  });

Un poco más adelante, veremos como trabajar con la respuesta response, pero vamos a centrarnos ahora en el parámetro opcional options de la petición HTTP. En este objeto podemos definir varios detalles:

Campo Descripción
method Método HTTP de la petición. Por defecto, GET. Otras opciones: HEAD, POST, etc…
headers Cabeceras HTTP. Por defecto, {}.
body Cuerpo de la petición HTTP. Puede ser de varios tipos: String, FormData, Blob, etc…
credentials Modo de credenciales. Por defecto, omit. Otras opciones: same-origin e include.

Lo primero, y más habitual, suele ser indicar el método HTTP a realizar en la petición. Por defecto, se realizará un GET, pero podemos cambiarlos a HEADPOSTPUT o cualquier otro tipo de método. En segundo lugar, podemos indicar objetos para enviar en el body de la petición, así como modificar las cabeceras en el campo headers:

const options = {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify(jsonData)
};

En este ejemplo, estamos enviando una petición POST, indicando en la cabecera que se envía contenido JSON y en el cuerpo de los datos, enviando el objeto jsonData, codificado como texto mediante stringify().

Por último, el campo credentials permite modificar el modo en el que se realiza la petición. Por defecto, el valor omit hace que no se incluyan credenciales en la petición, pero es posible indicar los valores same-origin, que incluye las credenciales si estamos sobre el mismo dominio, o include que incluye las credenciales incluso en peticiones a otros dominios.

yo estoy haciendo el curso con typescript porque bueno estoy aprendiedno el lenguaje aprobvechando. No me creeran cuando les digo que aparentemente typescript trae el metodo fetch instalado por lo que al importar node-fetch siempre me daba error, estuve como 30 minutos con ese problema

si

excelente clase

Ahora entiendo por qué los datos que consumo de la API no son los mismos del profe, porque seguramente ya varios estudiantes hicieron post a la API y agregaron productos algo extraños, y en algunos casos no le pusieron ni nombre al producto ni a la categoría.

Por si alguien le pasa, estuve intentando hacer el llamado pero obtuve un error y al parecer es por que npm detecta que la api no tiene un certificado de confianza entonces no hace el llamado.

Este es el error:
![](

Lo solucione quitando la ‘s’ de en ‘http’ y funciono perfecto:

url original: 'https://api.escuelajs.co/'
url modificada: 'http ://api.escuelajs.co/'

Nota: no se si les pase lo que me pasó a mi, pero quise seguir practicando con los callbacks y no podia porque me salía un error de que require no esta definido en un modulo ES, hay dos soluciones a esto, eliminar en json “type”: “module”, o renombrar la extensión .js a .cjs

Si también te pareció compleja la estructura de fetchData y sus then(), en el siguiente código comenté cada línea para hacerla más amena.

//callback hell con fetch
fetchData(`${API}/products`) //trae todos los productos
.then(response => response.json()) //como viene en array hay que convertirlo a json


.then(products => {
    return fetchData(`${API}/products/${products[0].id}`) //selecciona el primero que se agregue al array
})
.then(response => response.json()) //como viene en array hay que convertirlo a json


.then(product => { 
    console.log(product.title); 
    return fetchData(`${API}/categories/${product.category.id}`) //trae la categoria del producto
})
.then(response => response.json()) //como viene en array se debe convertir a json


.then(category => {
    console.log(category.name); //imprime la categoria
})
.catch(error => console.log(error))
.finally( () => console.log('done'))

Trayendo datos de usuarios por diversión.

const API = "https://api.escuelajs.co/api/v1";
const mainElement = document.querySelector("main");


function fecthData(urlAPI) {
  return fetch(urlAPI);
};

fecthData(`${API}/users`)
.then(response => response.json())
.then(users => {
  let output="";
  users.forEach(element => {
    output += `<div>${element.name} ${element.email}</div>`
  });
  mainElement.innerHTML = output;
})
.then(() => {
  console.log("ola");
})
.catch((err => {
  console.log(err);
}));

Código de la clase:

import fetch from 'node-fetch'
const API = 'https://api.escuelajs.co/api/v1'

function fetchData(urlApi){
  return fetch(urlApi)
}


fetchData(`${API}/products`)
.then(response => response.json())
.then(products => {
  return fetchData(`${API}/products/${products[0].id}`)
})
.then(response => response.json())
.then(product => {
  return fetchData(`${API}/categories/${product.category.id}`)
})
.then(response => response.json())
.then(category => console.log(category.name))

me perdí con tanto .then xd

13/26 Fetch

Imagina que quieres obtener información de un libro de una biblioteca. Para hacerlo, tienes que ir a la biblioteca, hacer una solicitud al bibliotecario y esperar a que te entregue el libro. Una vez que tienes el libro, puedes leer la información que contiene.

En la programación, fetch es una función que te permite hacer solicitudes de información a través de internet. Puede usarla para obtener datos de una API, como obtener información de un libro de una biblioteca en línea.

fetch('https://api.example.com/books/1')
  .then(response => response.json())
  .then(data => {
    console.log(data);
    // Hacer algo con los datos obtenidos
  })
  .catch(error => {
    console.error('Error:', error);
    // Manejar el error
  });

Se usa fetch para hacer una solicitud a una URL que representa un endpoint de una API que devuelve información sobre un libro.

Luego encadenamos los métodos .then() para manejar la respuesta de la solicitud. El método .json() convierte la respuesta en un objeto JavaScript legilble, y luego podemos acceder a los datos en el bloque de código dentro del segundo .then(). En este caso, simplemente los imprimimos en la consola.

Si ocurre algún error durante la solicitud, utilizamos el método .catch() para manejarlo y mostrar un mensaje de error en la consola.

me cae gordo el profe

para comentar las lineas de codigo
CTRL + K y luego CTRL + C

Me genera error la ultima linea de .finally

.finally(() => console.log('Finally'));
^

SyntaxError: Unexpected token '.'

al fin me sale a la primera jaja

me parece que va un poco acelerado, sumaria mucho el aprendizaje si explicara por linea o diera ejemplos.

Por si alguien tiene este error

Error [ERR_MODULE_NOT_FOUND]: Cannot find package 'note-fetch' imported from

Apareció en mi máquina con Linux. Según la documentación es porque el paquete node-fetch se actualizó y ahora se importa de una forma diferente. Para solucionarlo pueden descargar la versión anterior.

npm install node-fetch@2 

SI eres como yo y tienes la inquietud de que eso se puede hacer en una linea, si asi es. asumo que lo hacen de manera didactica pero enreda porque da a entender lo contrario.

import fetch from 'node-fetch';
const API = 'https://api.escuelajs.co/api/v1';

function fetchData(urlAPI){
    return fetch(urlAPI);
};

fetchData(`${API}/products`)
    .then(response => response.json())
    .then(products => {
        console.log(products[0])
        console.log(products[0].title)
        console.log(products[0].category.name);
        return fetchData(`${API}/products/${products[0].id}`)
    })
    .catch(error => console.log(error))
    .finally(() => console.log('Se ha termidado de ejecutar el script'));
//1-vamos a traer a node-ferch
import fetch from "node-fetch";
//2-llamaremos a la APi
const API = 'https://api.escuelajs.co/api/v1'
//3-aremos una funcion que resibira la url de la api que nos retornara el llamado de fetch que es una promesa esto nos ayudara a crear elementos con el llamado del primer recurso productos el segundo un solo producto y la categoria  
function fetchData(urlApi){
    return fetch (urlApi);
};
//ahora aremos el llamado de la api 
// fetch(`${API}/products`)
// //utilizaremos then pra saber que nos va arrojar la funcion 
//     .then(response => response.json())//json nos va a transformar los datos que nos arroja la funcion en un objeto json
//     //creamos otro then para crear los productos  
//     .then(products=>{
//         console.log(products);
//     })//si se nos presenta un erro nosotros queremos que se nos muestre y esto lo hacemos con carch
//     .catch(error=>console.log(error));
    //con esto hemos creado el llamado fetch funciona como promesa 
    //si corremos el codigo nos va arrojar un error para solucionarlo tenemos que agregar un tyoe en el archivo package.json 
    //ya despues de aber arreglado el problema y de corre el code vamos nos mostrara multiples objetos 


    //ahora crearemos la logica para hacer varios llamados con fetch y que se consecuente
fetchData(`${API}/products`)//primera solicitud 
    //transformar datos a objeto json 
    .then(response=>response.json( ))//con esto ya tenemos los productos 
    .then(products=>{
        console.log(products.title)
        return fetchData(`${API}/products/${products[0].id}`) //ahora llamaremos a la segunda peticion que es un producto en particular que en este caso es le primero 
    })
    .then(response=>response.json())//ahora la informacion que resibamos del producto lo tranformaremos en un objeto json 
    .then(product=>{
        //y ahora si nos mostrara un producto y nada mas pero en este caso lo que queremos mostrar es la categoria 
        console.log(console.log(product.title))
        return fetchData(`${API}/categories/${product.category.id}`)
    })
    .then(response=>response.json())
    .then(category=>{
        console.log(category.name);
    })//ahora nos dara la respuesta de la acterior solicitud de un objeto en dado caso 
    .catch(err =>console.log(err))
    .finally(()=>console.log('Finally'));

Les dejo la API por acá

const API = "https://api.escuelajs.co/api/v1";

Si les sale este error

import fetch from 'node-fetch';
       ^^^^^

SyntaxError: Unexpected identifier

Yo lo solucioné actualizando mi version de nodejs

muy buena explicación, le entendi facilmente sobre Fetch, “traer datos de un API”, me costaba entenderle igual que el post “agregar datos al api”

Si quedaron con ganas de ver lo que explicado por el profe en la creacion de un sitio web, les recomiendo vean este video en el que el profe Carlos consume la API de Rick y Morty en 10min y presenta los datos de manera genial.

Me estaba constando enteder fetch, ahora tengo mas claro como usarlo, vamos que si se puede, no se den por vencidos

Chicos, a mi me salio un error al ejecutar el codigo con la extencion de visual de run code:

internal/process/esm_loader.js:74
    internalBinding('errors').triggerUncaughtException(
                              ^

Error [ERR_UNSUPPORTED_ESM_URL_SCHEME]: Only file and data URLs are supported by the default ESM loader. Received protocol 'node:'
    at Loader.defaultResolve [as _resolve] (internal/modules/esm/resolve.js:782:11)
    at Loader.resolve (internal/modules/esm/loader.js:85:40)
    at Loader.getModuleJob (internal/modules/esm/loader.js:229:28)
    at ModuleWrap.<anonymous> (internal/modules/esm/module_job.js:51:40)
    at link (internal/modules/esm/module_job.js:50:36) {
  code: 'ERR_UNSUPPORTED_ESM_URL_SCHEME'
}

El cual investigue y el error era la versión de NODE que tenia instalada, así que pase de estar en la versión 14.15.4 a la 16.14.0.

Luego de eso si me dejo correr el codigo.

me da este error

[Running] node "/home/ivancholuna/Projects/AsincronismoJS/asincronismo/src/promises/tempCodeRunnerFile.js"
/home/ivancholuna/Projects/AsincronismoJS/asincronismo/src/promises/tempCodeRunnerFile.js:1
import fetch from 'node-fetch';
       ^^^^^

SyntaxError: Unexpected identifier
    at Module._compile (internal/modules/cjs/loader.js:723:23)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:789:10)
    at Module.load (internal/modules/cjs/loader.js:653:32)
    at tryModuleLoad (internal/modules/cjs/loader.js:593:12)
    at Function.Module._load (internal/modules/cjs/loader.js:585:3)
    at Function.Module.runMain (internal/modules/cjs/loader.js:831:12)
    at startup (internal/bootstrap/node.js:283:19)
    at bootstrapNodeJSCore (internal/bootstrap/node.js:623:3)

No me habia quedado a gusto. me hubiera gustado que explique desde 0 como funciona “FETCH” que dentro muy dentro utiliza el objeto XMLHttpRequest entonces aplique lo de la clase de callbacks con las promises!

PD: no esta mal. solo es mi curiosidad!!

let API = 'https://rickandmortyapi.com/api'

function fetchData(apiURL){
    return new Promise((resolve,reject)=>{
        let xhr = new XMLHttpRequest()
        xhr.addEventListener('readystatechange',(e)=>{
            if(xhr.readyState === 4){
                if(xhr.status === 200){
                    resolve(JSON.parse(xhr.responseText))
                }else{
                    let error = new Error('HUBO UN ERROR')
                    reject(error)
                }
            }
        })
        xhr.open('GET',apiURL)
        xhr.send()
    })
}

fetchData(`${API}/character`)
.then(data1 =>{
    console.log('Todos los personajes son: ')
    console.table(data1.results)
    return fetchData(`${API}/character/${data1.results[0].id}`)
})
.then(data2 => {
    console.log(`Pero elejiste el personaje: ${data2.name}`)
    return fetchData(`${API}/location/${data2.id}`)
})
.then(data3 => {
    console.log(`Y el personaje reside en: ${data3.name}`)
})

Mi aporte para el error de modulos:
Otra forma practica para resolver y poder ver por consola lo que trae la consulta es en la extensión del archivo _chalenge.js _agregarle la m de la siguiente forma: challenge.mjs.
Así ejecuta nuevamente y ya pueden ver por consola el resultado 😊

Bastante bueno, aunque me hubiera quedado al nivel de listar todos todos los productos y luego responder a un evento de usuario para acceder al detalle de ese en especial.

bendito seas fetch :v

Si les regresa undefined al ejecutar challenge.js en node, es necesario agregar un return al momento de transformar nuestra respuesta a un archivo json

    .then(response => {
        return response.json();
    })

De esta manera es posible correr el archivo challenge.js

Muy excelente curso, mejoro demasiado a la anterior version

a partir de la version de la version numero 18 de node.js se puede utilizar fetch de forma nativa de esta manera ya no se debe instlar la dependencia de fetch no hacer el import inicial.
el codigo quedaria de la siguiente manera:

const API = 'https://api.escuelajs.co/api/v1';

function fetchData(urlApi){
 return fetch(urlApi)
}
fetchData(`${API}/products`)
 .then(response => response.json())
 .then(products =>{
  console.log(products);
 })
 .catch(error => console.error(error));

Hola, yo lo resolví de otra forma también usando promesas pero usando una lógica más similar a la que usamos en el challenge anterior con callbacks

fetchData(`${API}/products`)
  .then(response => response.json())
  .then(products => {
    fetchData(`${API}/products/${products[0].id}`)
    .then(response => response.json())
    .then(product => {
        fetchData(`${API}/categories/${product?.category?.id}`)
        .then(response => response.json())
        .then(category => {
            console.log(products[0]);
            console.log(product.title);
            console.log(category.name);
          })
          .catch(error => console.error(error))
      })
      .catch(error => console.error(error))
  })
  .catch(error => console.error(error))
  .finally(() => console.log('Finally'))

Hay algo muy interesante, y es que cuando importamos node-fetch, no es necesario utilizar el ASYNC para invocar el await. Alguien sabe por qué?

Por aquí les dejo lo que he hecho antes de ver el video, leyendo previamente: esto.

const option = { // Request option
    method: 'GET',
    headers: {
      "Content-Type": "application/json"
    },
    credentials: 'omit',
  };
  
  const API = 'https://api.escuelajs.co/api/v1';
  
  const savedData = []; // To save the first products, the title of the products and the name of the category
  
  // Functio to verify status of request
  function requestOk(response) {
    if(!response.ok) {
      throw new Error(response.status)
    }
    
    return response.json();
  }
  
  // The first method
  
  const firstMethod = fetch(`${API}/products`, option)
      .then((response1) => { // Validation of the call to products
        return requestOk(response1);	
  })
      .then((response2) => { // Request the first product by the Id
        const firstProduct = response2[0];
        const firstProductId = firstProduct.id;
      
        return fetch(`${API}/products/${firstProductId}`, option);
  })
      .then((response3) => { // Validation of the call to the first products
        return requestOk(response3);
  })
      .then((response4) => { // Request the category by the Id
        savedData.push(response4); // Save the first product
        savedData.push(response4.title); // Save the title of the first product
    
        const category = response4.category;
        const categoryId = category.id;
          
        return fetch(`${API}/categories/${categoryId}`);
  })
      .then((response5) => { // Validation of the call to the category
            return requestOk(response5);
  })
      .then((response6) => {
          savedData.push(response6.name);
    
        // Show the colected data
        savedData.forEach((v, i, a) => {
        console.log(v);
        });
  })
      .catch((error) => {
        console.error(error);
  }); 
  
  // Second method
  const secondMethod = fetch(`${API}/products`, option)
      .then((response1) => { // Validation of the call to products
        return requestOk(response1);
  })
      .then((response2) => { // Request the first product by the Id
        const firstProduct = response2[0];
        const firstProductId = firstProduct.id;
      
        fetch(`${API}/products/${firstProductId}`, option)
        .then((response3) => { // Validation of the call to the first products
            return requestOk(response3);
      })
        .then((response4) => { // Request the category by the Id
        const category = response4.category;
        const categoryId = category.id;
  
        fetch(`${API}/categories/${categoryId}`)
        .then((response5) => { // Validation of the call to the category
          return requestOk(response5);
        })
        .then((response6) => {
            console.log(firstProduct);
          console.log(firstProduct.title);
          console.log(response6.name);
        })
        .catch((error) => {
          console.error(error);
        })
      })
      .catch((error) => {
        console.error(error);
      })
    })
      .catch((error) => {
        console.error(error);
  });

según tengo entendido también se puede resolver el problema de los módulos con solo añadir una M a la extensión del archivo, quedaría así

challenge.mjs

y así nos ahorramos en ir hasta el package.json y poner type module etc.

Resumiendo un poco el codigo sin estar realizando mucho el reponse.json() lo ise de esta forma.

import fetch from "node-fetch";

const API = 'https://api.escuelajs.co/api/v1';

function fetchData(url) {
    return fetch(url).then(response => response.json());
}

const onError = (error) => console.log(error);

fetchData(`${API}/products`)
    .then(products => {
        let product = products[0];
        console.log(product);
        return fetchData(`${API}/products/${product.id}`);
    })
    .then(product => {
        console.log(`Producto: ${product.title}`);
        return fetchData(`${API}/categories/${product?.category?.id}`);
    })
    .then(category => {
        console.log(`Categoria: ${category.name}`);
    })
    .catch(onError).finally('Finally');

excelente explicacion

Hola, esto es lo que logre hace usando la API de pokemon.
Que les parace?
Que le podria mejorar a este tipo de llamado?

import fetch from "node-fetch";
const API = 'https://pokeapi.co/api/v2'

let fetchData = (urlApi)=>{
    return fetch(urlApi)
};
//This is the first API calling to fetch a pokemon list
 fetchData(`${API}/pokemon`)
.then( response => response.json() )
.then(data => {
    const pokemon = data.results[0]
    console.log(`Name: ${pokemon.name}`)
    //This is a new addition to the url using the information we fetched from the API 
   return fetchData(`${API}/pokemon/${pokemon.name}`)
    .then(response => response.json() )
    .then(data2 => {
       const abilities = data2.abilities
       //here we accede to the object information and extract the ability information
       const ability = abilities[1]
       console.log(`Ability name: ${ability.ability.name}`)
       const abilityAPI = ability.ability.url
       //here we fetch the url to access the abilities description
        return fetchData(abilityAPI)
        .then(response => response.json())
        //here we finally get the ability information and description we want
        .then(description => {
            const effect = description.effect_entries[1].effect
            console.log(`Effect name: ${effect}`)
        })
    })
})



import fetch from 'node-fetch';
const API = 'https://api.escuelajs.co/api/v1';

function fetchData(urlApi){
    return fetch(urlApi);
}

fetchData(`${API}/products`)
    .then(response => response.json())
    .then(products => {
        console.log(products)
        return fetchData(`${API}/products/${products[0].id}`)
    })
    .then(response => response.json())
    .then(products => {
        console.log(products.title)
        return fetchData(`${API}/categories/${products.category.id}`)
    })
    .then(response => response.json())
    .then(category => {
        console.log(category.name);
    })
    .catch(err => console.log(err))
    .finally(() => console.log('Finally'));

Para practicar lo aprendido, lo hice también de esta otra forma:

Me gusta como quedó, je je, se ve bonito ✨.
·
Dejaré también por aquí el código que escribí para ello:

import fetch from "node-fetch";
const API = "https://api.escuelajs.co/api/v1";

fetch(`${API}/products`)
	.then(response => response.json())
	.then(products => {
		const product = products[0];
		console.group("Product Obtained:");
			console.log(`·) Title: ${product.title}`);
			console.log(`·) Category: ${product.category.name}`);
			console.group("·) Full Object:");
				console.log(product);
			console.groupEnd();
		console.groupEnd();
	})
	.catch(error => console.log(`There was an error: ${error}`))
	.finally(() => console.log(`All done!`));