Skip to content

5. As funções HTTP do TypeScript

Apresentamos aqui duas formas de fazer requisições HTTP em TypeScript: a função [fetch], nativa no Node desde a versão 18, e a biblioteca de terceiros [axios]. Os scripts deste capítulo estão na pasta [http] do projeto.

Image

5.1. Escolha das ferramentas HTTP

Em 2019, fetch ainda não havia sido implementada pelo node.js, e o documento original recomendava o pacote node-fetch . Desde o Node 18 (2022), [fetch] é uma função global nativa, padronizada pelo padrão WHATWG Fetch — não precisa mais ser importada.

[axios] continua sendo, no entanto, uma biblioteca interessante: compatível tanto com o node.js quanto com navegadores, oferece uma API um pouco mais rica (interceptors, serialização JSON automática, tratamento de erros padronizado). Apresentamos ambas, usando o mesmo exemplo, para mostrar que a abordagem de codificação é semelhante.

5.2. O servidor de cálculo de imposto

Este capítulo, como os seguintes, refere-se ao servidor NestJS instalado anteriormente. A arquitetura de teste é a seguinte:

 

Em [A-B], o código JavaScript executado pelo [node.js] enviará requisições à aplicação web [C] por meio de [1]. A aplicação web devolverá respostas jSON (4). O código JavaScript do lado do cliente pode ser organizado em camadas [UI, business, dao] (UI: User Interface). Faremos isso mais adiante. Para executar os scripts a seguir, o seu servidor NestJS deve estar em execução.

5.3. script [fetch-01]

Este script usa [fetch] para inicializar uma sessão JSON com o servidor de cálculo de imposto:

'use strict';

// [atualização 2026] em 2019, era preciso instalar o pacote [node-fetch] para ter
// a função [fetch] no lado do node. Desde o Node 18 (2022), [fetch] é uma função
// global nativa, padronizada pelo "WHATWG Fetch standard": não é mais necessário importá-la.
// importações
import qs from 'qs';
import { sprintf } from 'sprintf-js';
import moment from 'moment';


// URL base do servidor de cálculo do imposto
const baseUrl: string = 'http://localhost:3000/main.php?';
// inicialização da sessão
async function initSession(): Promise<any> {
  // [atualização 2026] o [fetch] nativo não conhece a opção [timeout].
  // para limitar o tempo de espera, passamos a ele um [signal] produzido por
  // [AbortSignal.timeout(ms)] (disponível desde o Node 17.3): após esse prazo,
  // a requisição é cancelada automaticamente e o [fetch] lança um erro.
  const options: RequestInit = {
    method: "GET",
    signal: AbortSignal.timeout(2000)
  };
  // execução da requisição HTTP [get /main.php?action=init-session&type=json]
  let fetchStart: moment.Moment | undefined;
  try {
    // requisição assíncrona - [fetch] retorna uma promise
    fetchStart = moment(Date.now());
    const response = await fetch(baseUrl + qs.stringify({
      action: 'init-session',
      type: 'json'
    }), options);
    // [response] é a resposta HTTP inteira do servidor (cabeçalhos HTTP + a própria resposta)
    // exibimos essa resposta para ver sua estrutura
    console.log(sprintf("fetch response formatted as json,=%j, %s", response, time(fetchStart)));
    console.log("fetch response in javascript=", response);
    // podemos acessar os cabeçalhos HTTP
    console.log("response headers=", response.headers);
    // se a resposta for do tipo application / json, a resposta json do servidor é obtida com a função assíncrona [response.json()]
    // nesse caso o código chamador recebe um objeto [Promise]
    // [await] permite obter a resposta [json] do servidor em vez de sua promise
    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;
    // se a resposta for do tipo text / plain, a resposta de texto do servidor é obtida com [response.text()]
    // nesse caso o código chamador recebe um objeto [Promise]
    // [await] permite obter a resposta [text] do servidor em vez de sua promise
    // const text = await response.text();
    // console.log("text response=", text);
    // return text;
  } catch (error: any) {
    // estamos aqui porque o servidor enviou um código de erro [404 Not Found, ...] com corpo vazio - exibimos o erro para ver sua estrutura
    // ou porque o cliente [fetch] lançou uma exceção (rede inacessível, ...)
    // exibimos a estrutura do erro
    console.log(sprintf("fetch error in json=%j, %s", error, time(fetchStart)));
    console.log("fetch error in javascript=", typeof (error), error);
    // lançamos a mensagem de erro recebida
    throw error.message;
  }
}

// a função principal executa a função assí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();

// utilitário que exibe a hora e a duração
function time(start?: moment.Moment): string {
  // hora do momento atual
  const now = moment(Date.now());
  // formatação da hora
  let result = "time=" + now.format("HH:mm:ss:SSS");
  // deve-se calcular uma duração?
  if (start) {
    const duration = now.valueOf() - start.valueOf();
    const milliseconds = duration % 1000;
    const seconds = Math.floor(duration / 1000);
    // formatação da hora + duração
    result = result + sprintf(", duration= %s second(s) and %s milliseconds", seconds, milliseconds);
  }
  // result
  return result;
}
  • linhas 3–5: [2026 update] — comentário observando que fetch agora é nativa, ao contrário de 2019;
  • linha 13: esta linha é importante. Ela especifica o cabeçalho da URL que o script consultará. Ele será complementado por eventuais parâmetros. Aqui, usamos a configuração definida na seção “Instalação de um servidor NestJS”;
  • linha 22: AbortSignal.timeout(2000) — substitui a opção timeout do node-fetch (que não existe na fetch nativa): se a requisição demorar mais de 2 segundos, ela é cancelada automaticamente;
  • linha 29: fetch(URL, options) — a sintaxe continua a da fetch padrão: uma URL e um objeto de opções (método, sinal de cancelamento etc.);
  • linhas 30–31: uma sessão jSON é iniciada;
  • linha 36: toda a resposta do servidor é exibida;
  • linha 38: os cabeçalhos da resposta são exibidos;
  • linha 43: await response.json() — extrai o corpo JSON da resposta; trata-se, por si só, de uma operação assíncrona (a resposta pode ser um fluxo ainda em recepção);
  • linha 52: fetch só lança uma exceção se a requisição HTTP falhou (rede inacessível, timeout etc.). Se uma resposta é recebida, mesmo com um código de erro (400, 500 etc.), fetch não lança exceção: a resposta fica normalmente disponível, linha 38.
npx tsx http/fetch-01.ts

Resultado da execução:

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
  • Linhas 3–22: toda a resposta do servidor;
  • linha 4: o código de status 200 significa que o servidor conseguiu processar a URL solicitada. Isso é mostrado na linha 21. Já usamos essa URL com o cliente Postman;
  • linhas 23–32: os cabeçalhos da resposta. Eles fornecem informações sobre a resposta que segue. Por exemplo, na linha 29, o servidor indica que esta resposta tem 84 caracteres;
  • linha 28: o servidor enviou um cookie de sessão. Isso permite que um cliente mantenha no servidor um espaço de memória chamado sessão. Ele é gerenciado pelo servidor web. Depois de receber esse cookie de sessão — que é, na verdade, o identificador do cliente junto ao servidor —, o cliente deve reenviá-lo a cada nova requisição. Observe o formato desse cookie de sessão. Vamos recuperá-lo em breve em um cliente TypeScript.
  • linha 33: a resposta jSON do servidor;

5.4. script [fetch-02]

Este script reutiliza fetch-01 removendo todos os detalhes de demonstração desnecessários para o uso cotidiano:

'use strict';

// [atualização 2026] [fetch] agora é uma função global nativa do node
// (desde o Node 18): não é mais preciso importar o pacote [node-fetch] como em 2019.
// importações
import qs from 'qs';

// URL base do servidor de cálculo do imposto
const baseUrl: string = 'http://localhost:3000/main.php?';
// inicialização da sessão
async function initSession(): Promise<any> {
  // opções da requisição HTTP [get /main.php?action=init-session&type=json]
  // [AbortSignal.timeout(ms)] substitui a opção [timeout], que não existe no fetch nativo
  const options: RequestInit = {
    method: "GET",
    signal: AbortSignal.timeout(2000)
  };
  // execução da requisição HTTP [get /main.php?action=init-session&type=json]
  const response = await fetch(baseUrl + qs.stringify({
    action: 'init-session',
    type: 'json'
  }), options);
  // resultado recebido em JSON
  return await response.json();
}

// a função principal executa a função assí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);
  }
}

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

Resultado da execução:

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]

Mesmo exemplo, com [axios]:

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

// configuração padrão do axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';

// inicialização da sessão
async function initSession(axios: AxiosInstance): Promise<any> {
  // opções da requisição HTTP [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [atualização TypeScript] axios.request() aceita, no que diz respeito à tipagem, apenas um
    // argumento de configuração: a URL deve, portanto, estar em [options.url]
    // em vez de ser um 1º parâmetro separado de request()
    url: 'main.php',
    method: "GET",
    // parâmetros da URL
    params: {
      action: 'init-session',
      type: 'x'
    }
  };
  // execução da requisição HTTP [get /main.php?action=init-session&type=json]
  try {
    // requisição assíncrona
    const response = await axios.request(options);
    // response é a resposta HTTP completa do servidor (cabeçalhos HTTP + a própria resposta)
    // exibimos essa resposta para ver sua estrutura
    // console.log("axios response=", response);
    // a resposta do servidor está em [response.data]
    return response.data;
  } catch (error: any) {
    // chegamos aqui porque o servidor enviou um código de erro [404 Not Found, 500 Internal Server Error, ...]
    // o parâmetro [error] é uma instância de exceção - pode assumir várias formas
    // exibimos o erro para ver sua estrutura
    // console.log("axios error=", typeof (error), error);
    if (error.response) {
      // o servidor sinalizou um erro no status HTTP, mas também enviou uma resposta
      // que se encontra então em [error.response.data]
      // sabemos que o servidor envia respostas JSON com a estrutura {action, status, response}
      // e que, em caso de erro, a msg de erro está em [response]
      return error.response.data;
    } else {
      // lançamos o erro
      throw error;
    }
  }
}

// a função principal executa a função assí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);
  }
}

// teste
main();
  • A requisição à URL é construída a partir das informações das linhas 6, 15, 19 e 20;
  • linha 26: axios.request(options) — ao contrário de fetch, a URL e as opções são reunidas em um único objeto de configuração (linha 11);
  • linha 37: error.response — se o servidor respondeu (mesmo com um código de erro), o Axios coloca essa resposta em error.response, acessível no bloco catch — ao contrário de fetch, o Axios sempre lança uma exceção quando o código de status não indica sucesso (2xx);
  • linha 31: a resposta bem-sucedida está em response.data — o axios extrai o JSON automaticamente; não é preciso um await response.json() separado como com fetch.
npx tsx http/axios-01.ts

Resultado da execução:

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. script [axios-03] — autenticação

Este script encadeia duas requisições: init-session, seguida de authenticate-user em **[POST], com um corpo codificado pela biblioteca **[qs] :

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

// configuração do axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';


// inicialização da sessão
async function initSession(axios: AxiosInstance): Promise<any> {
  // opções da requisição HTTP [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [atualização TypeScript] URL incluída em [options.url] (o axios.request() tipado aceita apenas um argumento)
    url: 'main.php',
    method: "GET",
    // parâmetros da URL
    params: {
      action: 'init-session',
      type: 'json'
    }
  };
  try {
    // execução da requisição HTTP [get /main.php?action=init-session&type=json]
    const response = await axios.request(options);
    // a resposta do servidor está em [response.data]
    return response.data;
  } catch (error: any) {
    // resposta do servidor
    if (error.response) {
      // a resposta JSON está em [error.response.data]
      return error.response.data;
    } else {
      // relançamos o erro
      throw error;
    }
  }
}

async function authenticateUser(axios: AxiosInstance, user: string, password: string): Promise<any> {
  // opções da requisição HTTP [post /main.php?action=authenticate-user]
  const options: AxiosRequestConfig = {
    // [atualização TypeScript] URL incluída em [options.url]
    url: 'main.php',
    method: "POST",
    headers: {
      'Content-type': 'application/x-www-form-urlencoded',
    },
    // corpo do POST
    data: qs.stringify({
      user: user,
      password: password
    }),
    // parâmetros da URL
    params: {
      action: 'authenticate-user'
    }
  };
  try {
    // execução da requisição HTTP [post /main.php?action=authenticate-user]
    const response = await axios.request(options);
    // a resposta do servidor está em [response.data]
    return response.data;
  } catch (error: any) {
    // resposta do servidor
    if (error.response) {
      // a resposta JSON está em [error.response.data]
      return error.response.data;
    } else {
      // relançamos o erro
      throw error;
    }
  }
}

// a função principal executa as funções assíncronas uma a uma
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);
  }
}

// teste
main();
  • linhas 42–53: A requisição POST envia seus parâmetros (user, password), codificados como application/x-www-form-urlencoded, por meio de qs.stringify(...) em options.data;
  • linhas 55–57: a URL ([post /main.php?action=authenticate-user]) também tem um parâmetro;
  • as duas funções são executadas sequencialmente em main (com await uma após a outra) (linhas 81, 86): a segunda só faz sentido se a primeira tiver tido sucesso, pois depende do cookie de sessão definido por init-session.
npx tsx http/axios-03.ts

Resultado da execução:

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]' ]
}
  • Linhas 10–14: A ação [authenticate-user] falhou. O motivo é o seguinte:
    • A ação [init-session] não enviou o cookie de sessão ao servidor. Esse é o identificador do cliente junto ao servidor. Como não enviou esse identificador, o cliente é desconhecido para o servidor. Em sua resposta, o servidor incluiu um cookie de sessão. Isso diz ao cliente: “Aqui está o seu identificador para as suas próximas requisições”;
    • mas a ação [authenticate-user] também não enviou o cookie de sessão ao servidor. Isso ocorre porque [init-session] não se deu ao trabalho de armazená-lo. O servidor, portanto, não reconhece o cliente e não sabe que ele iniciou anteriormente uma sessão jSON, e informa isso ao cliente;

A solução para esse problema é gerenciar o cookie de sessão enviado pelo servidor:

  • A primeiríssima requisição feita ao servidor deve armazenar o cookie de sessão enviado por ele;
  • as requisições seguintes devem recuperar esse cookie de sessão e enviá-lo ao servidor para se autenticar;

O código é o mesmo de antes, mas acrescenta uma função, [getRemoteData], para gerenciar o cookie de sessão:

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

// configuração do axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';

// cookie de sessão
const sessionCookieName: string = "connect.sid";
let sessionCookie: string = '';

// inicialização da sessão
async function initSession(axios: AxiosInstance): Promise<any> {
  // opções da requisição HTTP [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [atualização TypeScript] URL incluída em [options.url]
    url: 'main.php',
    method: "GET",
    // parâmetros da URL
    params: {
      action: 'init-session',
      type: 'json'
    }
  };
  // execução da requisição HTTP
  return await getRemoteData(axios, options);
}

async function authenticateUser(axios: AxiosInstance, user: string, password: string): Promise<any> {
  // opções da requisição HTTP [post /main.php?action=authenticate-user]
  const options: AxiosRequestConfig = {
    // [atualização TypeScript] URL incluída em [options.url]
    url: 'main.php',
    method: "POST",
    headers: {
      'Content-type': 'application/x-www-form-urlencoded',
    },
    // corpo do POST
    data: qs.stringify({
      user: user,
      password: password
    }),
    // parâmetros da URL
    params: {
      action: 'authenticate-user'
    }
  };
  // execução da requisição HTTP
  return await getRemoteData(axios, options);
}

async function getRemoteData(axios: AxiosInstance, options: AxiosRequestConfig): Promise<any> {
  // para o cookie de sessão
  if (!options.headers) {
    options.headers = {} as any;
  }
  (options.headers as any).Cookie = sessionCookie;
  // execução da requisição HTTP
  let response: AxiosResponse;
  try {
    // requisição assíncrona
    response = await axios.request(options);
  } catch (error: any) {
    // o parâmetro [error] é uma instância de exceção - pode assumir várias formas
    if (error.response) {
      // a resposta do servidor está em [error.response]
      response = error.response;
    } else {
      // relançamos o erro
      throw error;
    }
  }
  // response is the whole HTTP response of the server (HTTP headers + the response itself)
  // recuperamos o cookie de sessão, se existir
  const setCookie = response.headers['set-cookie'];
  if (setCookie) {
    // setCookie é um array
    // procuramos o cookie de sessão nesse array
    let found = false;
    let i = 0;
    while (!found && i < setCookie.length) {
      // procuramos o cookie de sessão
      const results = RegExp('^(' + sessionCookieName + '.+?);').exec(setCookie[i]);
      if (results) {
        // armazenamos o cookie de sessão
        // eslint-disable-next-line require-atomic-updates
        sessionCookie = results[1];
        // encontrado
        found = true;
      } else {
        // próximo elemento
        i++;
      }
    }
  }
  // a resposta do servidor está em [response.data]
  return response.data;
}


// a função principal executa as funções assíncronas uma a uma
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 fatora initSession e authenticateUser em torno de uma função comum, [getRemoteData], que trata explicitamente o cookie de sessão (aqui connect.sid, veja a linha 10) — o que é essencial, pois o servidor associa a autenticação e as simulações a uma sessão HTTP:

  • linha 10: o nome do cookie de sessão procurado. Ele depende do servidor web usado. O servidor NestJS usado neste curso usa um cookie de sessão chamado [connect.sid];
  • linha 53: a função [getRemoteData] cuida do envio das requisições e do recebimento da resposta do servidor. Ela também gerencia o cookie de sessão. Recebe dois parâmetros:
    • o objeto [AxiosInstance], que cuida da mecânica geral das requisições HTTP do Axios. Esse objeto e outros são obtidos pela importação da linha 2;
    • o objeto [AxiosRequestConfig], que define as opções de uma requisição específica;
  • Linhas 54–58: [options.headers] define o cabeçalho da requisição HTTP que será enviada ao servidor. Se existir um cookie de sessão, ele deve ser incluído nesse cabeçalho. A linha 58 realiza essa tarefa. Ao término da primeira requisição, [getRemoteData] armazenará esse cookie na variável global definida na linha 11. Durante a primeira requisição, seu valor será uma string vazia. Nas requisições seguintes, será a cadeia de caracteres do cookie de sessão enviado pelo servidor em resposta à primeira requisição.
  • Linha 63: a requisição HTTP é executada;
  • linha 76: verifica-se no cabeçalho da resposta se há uma linha “set-cookie”. Essa linha só está presente se a requisição anterior do cliente não incluía uma linha “Cookie” em seus cabeçalhos. Quando o servidor recebe uma requisição HTTP do cliente que inclui a linha ‘Cookie’, ele deixa de enviar o cookie de sessão, pois sabe que o cliente já o possui. Cabe ao cliente reenviá-lo a cada nova requisição. É o que acontece na linha 58;
  • linha 77: se o servidor enviou o cabeçalho [Set-Cookie], seu conteúdo deve ser recuperado. Esse cabeçalho pode conter vários cookies na forma [cookie_name=value]. As linhas 77–95 serão executadas apenas uma vez durante a execução do script. Como mencionado, o servidor não envia o cookie de sessão em resposta a requisições que foram autenticadas com esse mesmo cookie de sessão;
  • linha 84: procuramos explicitamente o cookie cujo nome foi armazenado na linha 10;
  • linha 88: se ele for encontrado, é armazenado na variável global definida na linha 11;

Esse mecanismo garante que:

  • o cookie de sessão seja recuperado da resposta à primeira requisição HTTP;
  • ele seja então enviado sistematicamente ao servidor a cada nova requisição, permitindo que o servidor reconheça o seu cliente;

O código é executado:

npx tsx http/axios-04.ts

Resultado da execução:

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] — cancelamento de requisições

[NEW since 2019] Este script ilustra dois usos do mecanismo de cancelamento de requisições fetch, disponível nativamente desde o Node 18:

'use strict';
// ========================================================================
// [NOVO desde 2019] fetch nativo + cancelamento de uma requisição HTTP
// ========================================================================

// [fetch] é global desde o Node 18: não é preciso o pacote [node-fetch]
// usado em 2019 em fetch-01.js/fetch-02.js (veja os comentários [atualização 2026]
// adicionados nesses dois arquivos)

// URL base do servidor de cálculo do imposto (veja http/README.md)
// como em axios-01.js, este script supõe que o servidor PHP do curso esteja em execução
// localmente: sem ele, as requisições falham com "fetch failed", o que é normal
const baseUrl: string = 'http://localhost:3000/main.php';

// exemplo 1: requisição com um tempo máximo graças 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', {
      // após 2 segundos, a requisição é cancelada automaticamente
      signal: AbortSignal.timeout(2000)
    });
    const data = await response.json();
    console.log("response =", data);
  } catch (error: any) {
    // se o prazo for excedido,
    // [error.name] é "TimeoutError" ou "AbortError", conforme o caso
    console.log("error.name =", error.name, ", message =", error.message);
  }
}

// exemplo 2: cancelamento manual de uma requisição, por exemplo porque
// o usuário mudou de ideia (ex.: ele digita de novo em um campo de busca)
async function manuallyCancellableRequest(): Promise<void> {
  console.log("--- manually cancelled request ---");
  const controller = new AbortController();

  // programamos um cancelamento "de negócio" após 500 ms
  // (em uma aplicação real, seria, por exemplo, um clique em um botão "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 automaticamente a requisição se ela exceder o tempo limite especificado — um padrão já visto no script fetch-01;
  • [AbortController]: permite o cancelamento manual, acionado por qualquer evento da aplicação (aqui, um setTimeout que simula, por exemplo, o clique em um botão “Cancel” ou um novo texto digitado em um campo de busca que invalida a requisição anterior).
npx tsx http/fetch-03.ts

Resultado da execução:

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
  • Linhas 2–6: A primeira requisição foi concluída normalmente;
  • linhas 8–9: a segunda requisição foi cancelada devido ao tempo limite muito curto (10 ms) definido para a requisição (linha 43 do código);