Skip to content

5. Las funciones HTTP de TypeScript

Aquí presentamos dos formas de hacer solicitudes HTTP en TypeScript: la función [fetch], nativa en Node desde la versión 18, y la biblioteca de terceros [axios]. Los scripts de este capítulo se encuentran en la carpeta [http] del proyecto.

Image

5.1. Elección de las herramientas HTTP

En 2019, fetch aún no había sido implementada por node.js, y el documento original recomendaba el paquete node-fetch . Desde Node 18 (2022), [fetch] es una función global nativa, estandarizada por el estándar WHATWG Fetch, y ya no es necesario importarla.

[axios] sigue siendo, sin embargo, una biblioteca interesante: compatible tanto con node.js como con los navegadores, ofrece una API algo más rica (interceptores, serialización JSON automática, manejo de errores estandarizado). Presentamos ambas, con el mismo ejemplo, para mostrar que el enfoque de programación es similar.

5.2. El servidor de cálculo de impuestos

Este capítulo, al igual que los siguientes, hace referencia al servidor NestJS instalado anteriormente. La arquitectura de pruebas es la siguiente:

 

En [A-B], el código JavaScript ejecutado por [node.js] enviará solicitudes a la aplicación web [C] a través de [1]. La aplicación web devolverá respuestas jSON (4). El código JavaScript del lado del cliente puede organizarse en capas [UI, business, dao] (UI: interfaz de usuario). Lo haremos más adelante. Para ejecutar los scripts siguientes, su servidor NestJS debe estar en ejecución.

5.3. script [fetch-01]

Este script usa [fetch] para inicializar una sesión JSON con el servidor de cálculo de impuestos:

'use strict';

// [actualización 2026] en 2019, había que instalar el paquete [node-fetch] para tener
// la función [fetch] en el lado de node. Desde Node 18 (2022), [fetch] es una función
// global nativa, estandarizada por el "WHATWG Fetch standard": ya no hace falta importarla.
// importaciones
import qs from 'qs';
import { sprintf } from 'sprintf-js';
import moment from 'moment';


// URL base del servidor de cálculo del impuesto
const baseUrl: string = 'http://localhost:3000/main.php?';
// inicio de sesión
async function initSession(): Promise<any> {
  // [actualización 2026] el [fetch] nativo no conoce la opción [timeout].
  // para limitar el tiempo de espera, se le da un [signal] producido por
  // [AbortSignal.timeout(ms)] (disponible desde Node 17.3): pasado este plazo,
  // la solicitud se cancela automáticamente y [fetch] lanza un error.
  const options: RequestInit = {
    method: "GET",
    signal: AbortSignal.timeout(2000)
  };
  // ejecución de la solicitud HTTP [get /main.php?action=init-session&type=json]
  let fetchStart: moment.Moment | undefined;
  try {
    // solicitud asíncrona - [fetch] devuelve una promesa
    fetchStart = moment(Date.now());
    const response = await fetch(baseUrl + qs.stringify({
      action: 'init-session',
      type: 'json'
    }), options);
    // [response] es la respuesta HTTP completa del servidor (encabezados HTTP + la respuesta propiamente dicha)
    // we display this response to see its structure
    console.log(sprintf("fetch response formatted as json,=%j, %s", response, time(fetchStart)));
    console.log("fetch response in javascript=", response);
    // podemos acceder a los encabezados HTTP
    console.log("response headers=", response.headers);
    // si la respuesta es de tipo application / json, la respuesta json del servidor se obtiene con la función asíncrona [response.json()]
    // en este caso el código que llama obtiene un objeto [Promise]
    // [await] permite obtener la respuesta [json] del servidor en lugar de su promesa
    const jsonStart = moment(Date.now());
    const object = await response.json();
    console.log(sprintf("json response=%j, type=%s, %s", object, typeof (object), time(jsonStart)));
    return object;
    // si la respuesta es de tipo text / plain, la respuesta de texto del servidor se obtiene con [response.text()]
    // en este caso el código que llama obtiene un objeto [Promise]
    // [await] permite obtener la respuesta [text] del servidor en lugar de su promesa
    // const text = await response.text();
    // console.log("text response=", text);
    // return text;
  } catch (error: any) {
    // estamos aquí porque el servidor envió un código de error [404 Not Found, ...] con un cuerpo vacío - se muestra el error para ver su estructura
    // o porque el cliente [fetch] lanzó una excepción (red inaccesible, ...)
    // se muestra la estructura del error
    console.log(sprintf("fetch error in json=%j, %s", error, time(fetchStart)));
    console.log("fetch error in javascript=", typeof (error), error);
    // se lanza el msg de error recibido
    throw error.message;
  }
}

// la función principal ejecuta la función asíncrona [initSession]
async function main(): Promise<void> {
  try {
    console.log("HTTP request to the server in progress ---------------------------------------------");
    const response = await initSession();
    console.log("success ---------------------------------------------");
    console.log("response=", response, typeof (response))
  } catch (error) {
    console.log("error ---------------------------------------------");
    console.log("error=", error, typeof (error));
  }
}

// test
main();

// utilidad que muestra la hora y la duración
function time(start?: moment.Moment): string {
  // hora del momento actual
  const now = moment(Date.now());
  // formateo de la hora
  let result = "time=" + now.format("HH:mm:ss:SSS");
  // ¿se debe calcular una duración?
  if (start) {
    const duration = now.valueOf() - start.valueOf();
    const milliseconds = duration % 1000;
    const seconds = Math.floor(duration / 1000);
    // formateo de hora + duración
    result = result + sprintf(", duration= %s second(s) and %s milliseconds", seconds, milliseconds);
  }
  // result
  return result;
}
  • líneas 3–5: [actualización 2026] : comentario que señala que fetch ahora es nativa, a diferencia de 2019;
  • línea 13: esta línea es importante. Especifica el encabezado de la URL que consultará el script, que se completará con los parámetros que correspondan. Aquí usamos la configuración definida en la sección “Instalación de un servidor NestJS”;
  • línea 22: AbortSignal.timeout(2000) : reemplaza la opción timeout de node-fetch (que no existe en el fetch nativo): si la solicitud tarda más de 2 segundos, se cancela automáticamente;
  • línea 29: fetch(URL, options) : la sintaxis sigue siendo la del fetch estándar: una URL y un objeto de opciones (método, señal de cancelación, etc.);
  • líneas 30–31: se inicia una sesión jSON;
  • línea 36: se muestra toda la respuesta del servidor;
  • línea 38: se muestran los encabezados de la respuesta;
  • línea 43: await response.json() : extrae el cuerpo JSON de la respuesta; esta es a su vez una operación asíncrona (la respuesta puede ser un flujo que aún se está recibiendo);
  • línea 52: fetch solo lanza una excepción si la solicitud HTTP falló (red inaccesible, tiempo de espera agotado, etc.). Si se recibe una respuesta, incluso con un código de error (400, 500, etc.), fetch no lanza una excepción: la respuesta está disponible normalmente, en la línea 38.
npx tsx http/fetch-01.ts

Resultado de la ejecución:

HTTP request to the server in progress ---------------------------------------------
fetch response formatted as json,={}, time=12:36:31:319, duration= 0 second(s) and 93 milliseconds
fetch response in javascript= Response {
  status: 200,
  statusText: 'OK',
  headers: Headers {
      date: 'Sun, 06 Sep 2026 10:36:31 GMT',
      server: 'Apache/2.4.66 (Win64) OpenSSL/3.0.18 PHP/8.3.30',
      'x-powered-by': 'PHP/8.3.30',
      'cache-control': 'max-age=0, private, must-revalidate, no-cache, private',
      'set-cookie': 'PHPSESSID=9u1rb9euj0m6f18efm7b5m952t; path=/',
      'content-length': '84',
      connection: 'close',
      'content-type': 'application/json'
  },
  body: ReadableStream { locked: false, state: 'readable', supportsBYOB: true },
  bodyUsed: false,
  ok: true,
  redirected: false,
  type: 'basic',
  url: 'http://localhost/main.php?action=init-session&type=json'
}
response headers= Headers {
  date: 'Sun, 06 Sep 2026 10:36:31 GMT',
  server: 'Apache/2.4.66 (Win64) OpenSSL/3.0.18 PHP/8.3.30',
  'x-powered-by': 'PHP/8.3.30',
  'cache-control': 'max-age=0, private, must-revalidate, no-cache, private',
  'set-cookie': 'PHPSESSID=9u1rb9euj0m6f18efm7b5m952t; path=/',
  'content-length': '84',
  connection: 'close',
  'content-type': 'application/json'
}
json response={"action":"init-session","status":700,"response":"session started with type [json]"}, type=object, time=12:36:31:323, duration= 0 second(s) and 2 milliseconds
success ---------------------------------------------
response= {
  action: 'init-session',
  status: 700,
  response: 'session started with type [json]'
} object
  • Líneas 3–22: toda la respuesta del servidor;
  • línea 4: el código de estado 200 significa que el servidor pudo procesar la URL solicitada. Esto se muestra en la línea 21. Ya hemos usado esta URL con el cliente Postman;
  • líneas 23–32: los encabezados de la respuesta. Proporcionan información sobre la respuesta que sigue. Por ejemplo, en la línea 29, el servidor indica que esta respuesta tiene 84 caracteres;
  • línea 28: el servidor envió una cookie de sesión. Esto permite que un cliente mantenga un espacio de memoria en el servidor llamado sesión. Lo administra el servidor web. Después de recibir esta cookie de sesión, que es en realidad el identificador del cliente ante el servidor, el cliente debe reenviarla con cada nueva solicitud. Observe el formato de esta cookie de sesión. Pronto la recuperaremos en un cliente TypeScript.
  • línea 33: la respuesta jSON del servidor;

5.4. script [fetch-02]

Este script reutiliza fetch-01 eliminando todos los detalles de demostración que no son necesarios para el uso cotidiano:

'use strict';

// [actualización 2026] [fetch] es ahora una función global nativa de node
// (desde Node 18): ya no hace falta importar el paquete [node-fetch] como en 2019.
// importaciones
import qs from 'qs';

// URL base del servidor de cálculo del impuesto
const baseUrl: string = 'http://localhost:3000/main.php?';
// inicio de sesión
async function initSession(): Promise<any> {
  // opciones de la solicitud HTTP [get /main.php?action=init-session&type=json]
  // [AbortSignal.timeout(ms)] reemplaza la opción [timeout], que no existe en fetch nativo
  const options: RequestInit = {
    method: "GET",
    signal: AbortSignal.timeout(2000)
  };
  // ejecución de la solicitud HTTP [get /main.php?action=init-session&type=json]
  const response = await fetch(baseUrl + qs.stringify({
    action: 'init-session',
    type: 'json'
  }), options);
  // resultado recibido en jSON
  return await response.json();
}

// la función principal ejecuta la función asíncrona [initSession]
async function main(): Promise<void> {
  try {
    console.log("HTTP request to the server in progress ---------------------------------------------");
    const response = await initSession();
    console.log("success ---------------------------------------------");
    console.log("response=", response)
  } catch (error: any) {
    console.log("error ---------------------------------------------");
    console.log("error=", error.message);
  }
}

// prueba
main();
npx tsx http/fetch-02.ts

Resultado de la ejecución:

1
2
3
4
5
6
7
HTTP request to the server in progress ---------------------------------------------
success ---------------------------------------------
response= {
  action: 'init-session',
  status: 700,
  response: 'session started with type [json]'
}

5.5. script [axios-01]

El mismo ejemplo, con [axios]:

'use strict';
import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';

// configuración por defecto de axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';

// inicio de sesión
async function initSession(axios: AxiosInstance): Promise<any> {
  // opciones de la solicitud HTTP [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [actualización de TypeScript] axios.request() acepta, en lo que respecta al tipado, un solo
    // argumento de configuración: por lo tanto la URL debe estar en [options.url]
    // y no como 1.er parámetro separado de request()
    url: 'main.php',
    method: "GET",
    // parámetros de la URL
    params: {
      action: 'init-session',
      type: 'x'
    }
  };
  // ejecución de la solicitud HTTP [get /main.php?action=init-session&type=json]
  try {
    // solicitud asíncrona
    const response = await axios.request(options);
    // response es la respuesta HTTP completa del servidor (encabezados HTTP + la respuesta propiamente dicha)
    // mostramos esta respuesta para ver su estructura
    // console.log("axios response=", response);
    // la respuesta del servidor está en [response.data]
    return response.data;
  } catch (error: any) {
    // estamos aquí porque el servidor envió un código de error [404 Not Found, 500 Internal Server Error, ...]
    // el parámetro [error] es una instancia de excepción - puede adoptar diversas formas
    // la mostramos para ver su estructura
    // console.log("axios error=", typeof (error), error);
    if (error.response) {
      // el servidor señaló un error en el estado HTTP pero también envió una respuesta
      // que se encuentra entonces en [error.response.data]
      // sabemos que el servidor envía respuestas jSON con la estructura {action, status, response}
      // y que en caso de error, el mensaje de error está en [response]
      return error.response.data;
    } else {
      // lanzamos el error
      throw error;
    }
  }
}

// la función principal ejecuta la función asíncrona [initSession]
async function main(): Promise<void> {
  try {
    console.log("HTTP request to the server in progress ---------------------------------------------");
    const response = await initSession(axios);
    console.log("success ---------------------------------------------");
    console.log("response=", response, typeof (response))
  } catch (error: any) {
    console.log("error ---------------------------------------------");
    console.log("error=", error.message);
  }
}

// prueba
main();
  • La consulta de la URL se construye a partir de la información de las líneas 6, 15, 19 y 20;
  • línea 26: axios.request(options) : a diferencia de fetch, la URL y las opciones se agrupan en un único objeto de configuración (línea 11);
  • línea 37: error.response : si el servidor respondió (incluso con un código de error), Axios coloca esta respuesta en error.response, accesible en el bloque catch ; a diferencia de fetch, Axios siempre lanza una excepción cuando el código de estado no indica éxito (2xx);
  • línea 31: la respuesta exitosa está en response.data : axios extrae automáticamente el JSON; no hace falta un await response.json() aparte, como con fetch.
npx tsx http/axios-01.ts

Resultado de la ejecución:

1
2
3
4
5
6
7
HTTP request to the server in progress ---------------------------------------------
success ---------------------------------------------
response= {
  action: 'init-session',
  status: 700,
  response: 'session started with type [json]'
} object

5.6. [axios-03] script: autenticación

Este script encadena dos solicitudes: init-session, seguida de authenticate-user mediante **[POST], con un cuerpo codificado por la biblioteca **[qs] :

'use strict';
import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
import qs from 'qs'

// configuración de axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';


// inicio de sesión
async function initSession(axios: AxiosInstance): Promise<any> {
  // opciones de la solicitud HTTP [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [actualización de TypeScript] URL incluida en [options.url] (el axios.request() tipado acepta un solo argumento)
    url: 'main.php',
    method: "GET",
    // parámetros de la URL
    params: {
      action: 'init-session',
      type: 'json'
    }
  };
  try {
    // ejecución de la solicitud HTTP [get /main.php?action=init-session&type=json]
    const response = await axios.request(options);
    // la respuesta del servidor está en [response.data]
    return response.data;
  } catch (error: any) {
    // respuesta del servidor
    if (error.response) {
      // la respuesta jSON está en [error.response.data]
      return error.response.data;
    } else {
      // volvemos a lanzar el error
      throw error;
    }
  }
}

async function authenticateUser(axios: AxiosInstance, user: string, password: string): Promise<any> {
  // opciones de la solicitud HTTP [post /main.php?action=authenticate-user]
  const options: AxiosRequestConfig = {
    // [actualización de TypeScript] URL incluida en [options.url]
    url: 'main.php',
    method: "POST",
    headers: {
      'Content-type': 'application/x-www-form-urlencoded',
    },
    // cuerpo del POST
    data: qs.stringify({
      user: user,
      password: password
    }),
    // parámetros de la URL
    params: {
      action: 'authenticate-user'
    }
  };
  try {
    // ejecución de la solicitud HTTP [post /main.php?action=authenticate-user]
    const response = await axios.request(options);
    // la respuesta del servidor está en [response.data]
    return response.data;
  } catch (error: any) {
    // respuesta del servidor
    if (error.response) {
      // la respuesta jSON está en [error.response.data]
      return error.response.data;
    } else {
      // volvemos a lanzar el error
      throw error;
    }
  }
}

// la función principal ejecuta una por una las funciones asíncronas
async function main(): Promise<void> {
  try {
    // init-session
    console.log("init-session action in progress ---------------------------------------------");
    const response1 = await initSession(axios);
    console.log("success ---------------------------------------------");
    console.log("response=", response1);
    // authenticate-user
    console.log("authenticate-user action in progress ---------------------------------------------");
    const response2 = await authenticateUser(axios, 'admin', 'admin');
    console.log("success ---------------------------------------------");
    console.log("response=", response2)
  } catch (error) {
    console.log("error ---------------------------------------------");
    console.log("error=", error);
  }
}

// prueba
main();
  • líneas 42–53: la solicitud POST envía sus parámetros (user, password), codificados como application/x-www-form-urlencoded, mediante qs.stringify(...) en options.data;
  • líneas 55–57: la URL ([post /main.php?action=authenticate-user]) también tiene un parámetro;
  • ambas funciones se ejecutan secuencialmente en main (con await una tras otra) (líneas 81, 86): la segunda solo tiene sentido si la primera tuvo éxito, ya que depende de la cookie de sesión establecida por init-session.
npx tsx http/axios-03.ts

Resultado de la ejecución:

init-session action in progress ---------------------------------------------
success ---------------------------------------------
response= {
  action: 'init-session',
  status: 700,
  response: 'session started with type [json]'
}
authenticate-user action in progress ---------------------------------------------
success ---------------------------------------------
response= {
  action: 'authenticate-user',
  status: 103,
  response: [ 'no session in progress. Start with action [init-session]' ]
}
  • Líneas 10–14: la acción [authenticate-user] falló. El motivo es el siguiente:
    • La acción [init-session] no envió la cookie de sesión al servidor. Este es el identificador del cliente ante el servidor. Como no envió este identificador, el servidor no conoce al cliente. En su respuesta, el servidor incluyó una cookie de sesión. Con ello le dice al cliente: “Este es tu identificador para tus próximas solicitudes”;
    • pero la acción [authenticate-user] tampoco envió la cookie de sesión al servidor. Esto se debe a que [init-session] no se tomó el tiempo de almacenarla. Por lo tanto, el servidor no reconoce al cliente y no sabe que previamente inició una sesión jSON, y se lo informa al cliente;

La solución a este problema es administrar la cookie de sesión enviada por el servidor:

  • La primera solicitud hecha al servidor debe almacenar la cookie de sesión enviada por este;
  • las solicitudes posteriores deben recuperar esta cookie de sesión y enviarla al servidor para autenticarse;

El código es el mismo que el anterior, pero agrega una función, [getRemoteData], para administrar la cookie de sesión:

'use strict';
import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import qs from 'qs'

// configuración de axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';

// cookie de sesión
const sessionCookieName: string = "connect.sid";
let sessionCookie: string = '';

// inicio de sesión
async function initSession(axios: AxiosInstance): Promise<any> {
  // opciones de la solicitud HTTP [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [actualización de TypeScript] URL incluida en [options.url]
    url: 'main.php',
    method: "GET",
    // parámetros de la URL
    params: {
      action: 'init-session',
      type: 'json'
    }
  };
  // ejecución de la solicitud HTTP
  return await getRemoteData(axios, options);
}

async function authenticateUser(axios: AxiosInstance, user: string, password: string): Promise<any> {
  // opciones de la solicitud HTTP [post /main.php?action=authenticate-user]
  const options: AxiosRequestConfig = {
    // [actualización de TypeScript] URL incluida en [options.url]
    url: 'main.php',
    method: "POST",
    headers: {
      'Content-type': 'application/x-www-form-urlencoded',
    },
    // cuerpo del POST
    data: qs.stringify({
      user: user,
      password: password
    }),
    // parámetros de la URL
    params: {
      action: 'authenticate-user'
    }
  };
  // ejecución de la solicitud HTTP
  return await getRemoteData(axios, options);
}

async function getRemoteData(axios: AxiosInstance, options: AxiosRequestConfig): Promise<any> {
  // para la cookie de sesión
  if (!options.headers) {
    options.headers = {} as any;
  }
  (options.headers as any).Cookie = sessionCookie;
  // ejecución de la solicitud HTTP
  let response: AxiosResponse;
  try {
    // solicitud asíncrona
    response = await axios.request(options);
  } catch (error: any) {
    // el parámetro [error] es una instancia de excepción - puede adoptar diversas formas
    if (error.response) {
      // la respuesta del servidor está en [error.response]
      response = error.response;
    } else {
      // volvemos a lanzar el error
      throw error;
    }
  }
  // response es la respuesta HTTP completa del servidor (encabezados HTTP + la respuesta propiamente dicha)
  // recuperamos la cookie de sesión si existe
  const setCookie = response.headers['set-cookie'];
  if (setCookie) {
    // setCookie es un arreglo
    // buscamos la cookie de sesión en este arreglo
    let found = false;
    let i = 0;
    while (!found && i < setCookie.length) {
      // buscamos la cookie de sesión
      const results = RegExp('^(' + sessionCookieName + '.+?);').exec(setCookie[i]);
      if (results) {
        // almacenamos la cookie de sesión
        // eslint-disable-next-line require-atomic-updates
        sessionCookie = results[1];
        // encontrada
        found = true;
      } else {
        // siguiente elemento
        i++;
      }
    }
  }
  // la respuesta del servidor está en [response.data]
  return response.data;
}


// la función principal ejecuta una por una las funciones asíncronas
async function main(): Promise<void> {
  try {
    // init-session
    console.log("init-session action in progress ----------------");
    const response1 = await initSession(axios);
    console.log("success --------------------------");
    console.log("response=", response1);
    // authenticate-user
    console.log("authenticate-user action in progress ---------");
    const response2 = await authenticateUser(axios, 'admin', 'admin');
    console.log("success -------------------");
    console.log("response=", response2)
  } catch (error: any) {
    console.log("error ------------------");
    console.log("error=", error.message);
  }
}

// test
main();

Este script factoriza initSession y authenticateUser en torno a una función común, [getRemoteData], que administra explícitamente la cookie de sesión (aquí connect.sid, véase la línea 10), lo cual es esencial porque el servidor asocia la autenticación y las simulaciones a una sesión HTTP:

  • línea 10: el nombre de la cookie de sesión que se busca. Depende del servidor web utilizado. El servidor NestJS usado en este curso emplea una cookie de sesión llamada [connect.sid];
  • línea 53: la función [getRemoteData] se encarga de enviar las solicitudes y recibir la respuesta del servidor. También administra la cookie de sesión. Recibe dos parámetros:
    • el objeto [AxiosInstance], que gestiona la mecánica general de las solicitudes HTTP de Axios. Este objeto y otros se obtienen mediante la importación de la línea 2;
    • el objeto [AxiosRequestConfig], que define las opciones de una solicitud específica;
  • Líneas 54–58: [options.headers] establece el encabezado de la solicitud HTTP que se enviará al servidor. Si existe una cookie de sesión, debe incluirse en este encabezado. La línea 58 realiza esta tarea. Al terminar la primera solicitud, [getRemoteData] almacenará esta cookie en la variable global definida en la línea 11. Durante la primera solicitud, su valor será una cadena vacía. En las solicitudes posteriores, será la cadena de caracteres de la cookie de sesión enviada por el servidor en respuesta a la primera solicitud.
  • Línea 63: se ejecuta la solicitud HTTP;
  • línea 76: se examina el encabezado de la respuesta para ver si hay una línea “set-cookie”. Esta línea está presente solo si la solicitud anterior del cliente no incluía una línea “Cookie” en sus encabezados. Cuando el servidor recibe una solicitud HTTP del cliente que incluye la línea ‘Cookie’, ya no envía la cookie de sesión porque sabe que el cliente ya la tiene. Corresponde al cliente reenviarla con cada nueva solicitud. Esto es lo que ocurre en la línea 58;
  • línea 77: si el servidor envió el encabezado [Set-Cookie], debe recuperarse su contenido. Este encabezado puede contener varias cookies con la forma [cookie_name=value]. Las líneas 77–95 se ejecutarán una sola vez durante la ejecución del script. Como se mencionó, el servidor no envía la cookie de sesión en respuesta a las solicitudes que se han autenticado con esa misma cookie de sesión;
  • línea 84: se busca explícitamente la cookie cuyo nombre se almacenó en la línea 10;
  • línea 88: si se encuentra, se almacena en la variable global definida en la línea 11;

Este mecanismo garantiza que:

  • la cookie de sesión se recupere de la respuesta a la primera solicitud HTTP;
  • luego se envíe sistemáticamente al servidor con cada nueva solicitud, lo que permite que el servidor reconozca a su cliente;

El código se ejecuta:

npx tsx http/axios-04.ts

Resultado de la ejecución:

init-session action in progress ----------------
success --------------------------
response= {
  action: 'init-session',
  status: 700,
  response: 'session started with type [json]'
}
authenticate-user action in progress ---------
success -------------------
response= {
  action: 'authenticate-user',
  status: 200,
  response: 'Authentication successful [admin, admin]'
}

5.8. script [fetch-03]: cancelación de solicitudes

[NUEVO desde 2019] Este script ilustra dos usos del mecanismo de cancelación de solicitudes fetch, disponible de forma nativa desde Node 18:

'use strict';
// ========================================================================
// [NUEVO desde 2019] fetch nativo + cancelación de una solicitud HTTP
// ========================================================================

// [fetch] es global desde Node 18: no hace falta el paquete [node-fetch]
// usado en 2019 en fetch-01.js/fetch-02.js (vea los comentarios [actualización 2026]
// agregados en estos dos archivos)

// URL base del servidor de cálculo del impuesto (vea http/README.md)
// como con axios-01.js, este script supone que el servidor PHP del curso se está ejecutando
// localmente: sin él, las solicitudes fallan con "fetch failed", lo cual es normal
const baseUrl: string = 'http://localhost:3000/main.php';

// ejemplo 1: solicitud con un plazo máximo gracias a AbortSignal.timeout()
async function requestWithMaximumDelay(): Promise<void> {
  console.log("--- request with AbortSignal.timeout ---");
  try {
    const response = await fetch(baseUrl + '?action=init-session&type=json', {
      // pasados 2 segundos, la solicitud se cancela automáticamente
      signal: AbortSignal.timeout(2000)
    });
    const data = await response.json();
    console.log("response =", data);
  } catch (error: any) {
    // si se supera el plazo,
    // [error.name] es "TimeoutError" o "AbortError" según el caso
    console.log("error.name =", error.name, ", message =", error.message);
  }
}

// ejemplo 2: cancelación manual de una solicitud, por ejemplo porque
// el usuario cambió de opinión (p. ej.: vuelve a escribir en un campo de búsqueda)
async function manuallyCancellableRequest(): Promise<void> {
  console.log("--- manually cancelled request ---");
  const controller = new AbortController();

  // programamos una cancelación "de negocio" a los 500 ms
  // (en una aplicación real, esto sería por ejemplo un clic en un botón "cancelar")
  setTimeout(() => {
    console.log("manual cancellation triggered");
    controller.abort();
  }, 10);

  try {
    const response = await fetch(baseUrl + '?action=init-session&type=json', {
      signal: controller.signal
    });
    const data = await response.json();
    console.log("response =", data);
  } catch (error: any) {
    console.log("error.name =", error.name, ", message =", error.message);
  }
}

async function main(): Promise<void> {
  await requestWithMaximumDelay();
  await manuallyCancellableRequest();
}

main();
  • [AbortSignal.timeout(ms)]: cancela automáticamente la solicitud si excede el tiempo de espera especificado; es un patrón que ya vimos en el script fetch-01;
  • [AbortController]: permite la cancelación manual, activada por cualquier evento de la aplicación (aquí, un setTimeout que simula, por ejemplo, un clic en un botón “Cancelar” o un nuevo texto ingresado en un campo de búsqueda que invalida la solicitud anterior).
npx tsx http/fetch-03.ts

Resultado de la ejecución:

1
2
3
4
5
6
7
8
9
--- request with AbortSignal.timeout ---
response = {
  action: 'init-session',
  status: 700,
  response: 'session started with type [json]'
}
--- manually cancelled request ---
manual cancellation triggered
error.name = AbortError , message = This operation was aborted
  • Líneas 2–6: la primera solicitud se completó con normalidad;
  • líneas 8–9: la segunda solicitud se canceló debido al tiempo de espera muy corto (10 ms) fijado para la solicitud (línea 43 del código);