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.

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.
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();
|
Resultado da execução:
| 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.
Resultado da execução:
| 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.
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;
5.7. Script [axios-04] — gerenciamento do cookie de sessão
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:
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).
Resultado da execução:
| --- 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);