En este post te mostraré una envoltura de la función fetch para encerrar las peticiones básicas que se hacen con los verbos GET, POST, PUT y DELETE.

De este modo nos ahorramos repetir código y aprendemos un poco sobre la reutilización del mismo.

Al final tendremos una librería que nos permitirá hacer peticiones HTTP como cualquier otra usando AJAX.

He usado esta librería y evitado usar Axios o proveedores de terceros. El primer uso es en mi sistema de ventas, aunque también lo he usado en el sistema escolar que hice recientemente.

Sobre fetch

Como sabemos la función fetch de JavaScript es el remplazo oficial de XMLHttpRequest así que podemos usarla para peticiones AJAX sin problemas.

Nota: aunque es el remplazo, no está disponible en navegadores antiguos.

La envoltura

Vamos a crear un objeto que tendrá funciones con los 4 verbos HTTP más populares:

const HTTP = {
    "post": (ruta, datos) => {
      // Magia aquí
    },
    "put": (ruta, datos) => {
      // Magia aquí
    },
    "get": (ruta) => {
      // Magia aquí
    },
    "delete": (ruta)=> {
      // Magia aquí
    }
};

Si no entiendes la sintaxis de => mira por favor lo que son las funciones flecha en JavaScript.

Con esto, podremos invocar a algo como:

HTTP.get("/usuarios")
.then(usuarios => {
  // Aquí hacer algo con usuarios
});

La ruta base

Para hacer las peticiones tomando en cuenta una ruta base podemos definir la constante de la ruta del servidor, dentro de nuestra envoltura.

Así, en lugar de hacer una petición a “localhost/app/usuarios” podríamos hacer simplemente a “/usuarios”. Así que:

const RUTA_SERVIDOR = "./webapi";

Método post

Comencemos viendo el primer método post. Recibe la ruta relativa y los datos que se enviarán. La función se encargará de establecer los encabezados, enviar el cuerpo, etcétera.

Queda así:

"post": (ruta, datos) =>
  fetch(RUTA_SERVIDOR + ruta, {
      credentials: 'include',
      method: "POST",
      body: JSON.stringify(datos)
  })
      .then(r => r.json())

Vemos algunas cosas interesantes. Está regresando una promesa para que podamos esperarla desde donde sea llamada.

Además, se utiliza JSON en JavaScript para enviar y recibir los datos. Por un lado al incluir el body y por otro al recibir la respuesta.

La opción credentials es para que las cookies sean enviadas y si tenemos una sesión todo funcione perfecto.

Finalmente, la ruta del servidor está siendo usada, pues se usa para concatenar con la ruta relativa.

Para invocarla hacemos lo siguiente (por ejemplo):

HTTP.post("/usuario", {
  nombre: "Luis",
  web: "parzibyte.me",
})
.then(respuesta => {
  // Aquí hacer algo con la respuesta
});

Con esto nos ahorramos un montón de código.

Los otros métodos

Una vez que he explicado el método post los otros métodos son similares, solo cambia el method y en algunos casos no lleva body.

Poniendo todo junto

El código completo queda así:

/*
    Programado por Luis Cabrera Benito 
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
    
    Blog:       https://parzibyte.me/blog
    Ayuda:      https://parzibyte.me/blog/contrataciones-ayuda/
    Contacto:   https://parzibyte.me/blog/contacto/
*/
const RUTA_SERVIDOR = "./webapi";
const HTTP = {
    "post": (ruta, datos) =>
        fetch(RUTA_SERVIDOR + ruta, {
            credentials: 'include',
            method: "POST",
            body: JSON.stringify(datos)
        })
            .then(r => r.json())
    ,
    "put": (ruta, datos) =>
        fetch(RUTA_SERVIDOR + ruta, {
            credentials: 'include',
            method: "PUT",
            body: JSON.stringify(datos)
        })
            .then(r => r.json())
    ,
    "get": (ruta) =>
        fetch(RUTA_SERVIDOR + ruta, {
            credentials: 'include',
        })
            .then(r => r.json())
    ,
    "delete": (ruta) =>
        fetch(RUTA_SERVIDOR + ruta, {
            credentials: 'include',
            method: "DELETE",
        })
            .then(r => r.json())
};

Modo de uso

Puedes incluirlo en una etiqueta script o usarlo con import. Yo lo uso mayormente con Vue y webpack así que hago un:

export const HTTP{/*...*/}

Y luego lo importo con:

import {HTTP} from "./http";

En donde ./http se refiere al archivo http.js que tengo dentro del mismo directorio.

Para usarla es:

HTTP.método(argumentos...)

Por ejemplo:

HTTP.get("/docentes").then(d => console.log(d));

Nota: si no usas webpack o no entiendes, simplemente incluye el archivo en una etiqueta script.

Nota 2: no olvides definir la constante de tu servidor.

Conclusión

Este código funciona, y lo hace bien. Puedes adecuarlo a tus necesidades y crear tu propia envoltura. De nuevo lo digo, no pretendo remplazar una librería, solo mostrar cómo podemos crear nuestras funciones.

Te invito a ver más ejemplos sobre JavaScript o más artículos que he escrito sobre JS.