fetch & HTTP Clients

import { createServer } from 'node:http';
import { once } from 'node:events';

// A tiny Bookshelf API used by the client examples. Port 0 = the OS picks a free port.
export async function startServer() {
  let flaky = 0;
  const server = createServer(async (req, res) => {
    const url = new URL(req.url, 'http://localhost');
    if (url.pathname === '/books' && req.method === 'GET') {
      res.setHeader('content-type', 'application/json');
      res.end(JSON.stringify([{ id: 1, title: 'Dune' }, { id: 2, title: 'Emma' }]));
    } else if (url.pathname === '/books' && req.method === 'POST') {
      let body = '';
      for await (const chunk of req) body += chunk;
      res.writeHead(201, { 'content-type': 'application/json' });
      res.end(JSON.stringify({ id: 3, ...JSON.parse(body) }));
    } else if (url.pathname === '/missing') {
      res.writeHead(404, { 'content-type': 'application/json' });
      res.end(JSON.stringify({ error: 'not found' }));
    } else if (url.pathname === '/slow') {
      setTimeout(() => res.end('finally'), 2000).unref();
    } else if (url.pathname === '/flaky') {
      // Fails twice with 503 + Retry-After, then succeeds.
      if (flaky++ < 2) {
        res.writeHead(503, { 'retry-after': '1' });
        res.end('try later');
      } else {
        res.end('ok after ' + flaky + ' attempts');
      }
    } else if (url.pathname === '/lines') {
      res.setHeader('content-type', 'application/x-ndjson');
      for (let i = 1; i <= 5; i++) res.write(JSON.stringify({ n: i }) + '\n');
      res.end();
    } else if (url.pathname === '/old') {
      res.writeHead(301, { location: '/books' }).end();
    } else if (url.pathname === '/echo') {
      let length = 0;
      for await (const chunk of req) length += chunk.length;
      res.setHeader('content-type', 'application/json');
      res.end(JSON.stringify({ type: req.headers['content-type']?.split(';')[0], length }));
    } else if (url.pathname === '/work') {
      await new Promise((r) => setTimeout(r, 50));
      res.end('done');
    } else {
      res.writeHead(404).end();
    }
  });
  server.listen(0, '127.0.0.1');
  await once(server, 'listening');
  return { base: `http://127.0.0.1:${server.address().port}`, server, close: () => server.close() };
}

import { createServer } from 'node:http';
import { once } from 'node:events';
import { startServer } from './server.js';

const { base, close } = await startServer();

const res = await fetch(`${base}/books`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);          // fetch does NOT reject on 4xx/5xx
console.log(res.status, res.headers.get('content-type'), await res.json());

const created = await fetch(`${base}/books`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ title: 'Ulysses' }),
});
console.log(created.status, await created.json());

const missing = await fetch(`${base}/missing`);
console.log('a 404 is a normal response:', missing.status, missing.ok, await missing.json());

// A network failure rejects with TypeError; the real reason is in err.cause
const probe = createServer().listen(0, '127.0.0.1');          // find a free port, then free it again
await once(probe, 'listening');
const { port } = probe.address();
probe.close();
await once(probe, 'close');
try {
  await fetch(`http://127.0.0.1:${port}/`);
} catch (err) {
  console.log(err.name, '-', err.message, '| cause:', err.cause.code);
}
try { await fetch('/books'); } catch (err) { console.log(err.name, '-', err.message, '|', err.cause.code); }

console.log('bundled undici', process.versions.undici, 'on Node.js', process.version);
close();

200 application/json [ { id: 1, title: 'Dune' }, { id: 2, title: 'Emma' } ]
201 { id: 3, title: 'Ulysses' }
a 404 is a normal response: 404 false { error: 'not found' }
TypeError - fetch failed | cause: ECONNREFUSED
TypeError - Failed to parse URL from /books | ERR_INVALID_URL
bundled undici 8.10.2 on Node.js v26.10.0

import { startServer } from './server.js';

const { base, close } = await startServer();

// URLSearchParams -> application/x-www-form-urlencoded, set automatically
const form = await fetch(`${base}/echo`, { method: 'POST', body: new URLSearchParams({ q: 'dune', page: '1' }) });
console.log(await form.json());

// FormData with a Blob -> multipart/form-data with a generated boundary
const data = new FormData();
data.set('title', 'Dune');
data.set('cover', new Blob(['fake image bytes'], { type: 'image/png' }), 'cover.png');
console.log(await (await fetch(`${base}/echo`, { method: 'POST', body: data })).json());

// A string body is sent as text/plain;charset=UTF-8
console.log(await (await fetch(`${base}/echo`, { method: 'POST', body: 'hello' })).json());

// A body can be read once; clone() before reading when you need it twice
const res = await fetch(`${base}/books`);
const copy = res.clone();
console.log((await res.json()).length, (await copy.text()).length);
console.log(await res.json().catch((e) => `${e.name}: ${e.message}`));

// Redirects are followed unless you say otherwise
const followed = await fetch(`${base}/old`);
console.log('follow:', followed.status, followed.redirected, new URL(followed.url).pathname);
const manual = await fetch(`${base}/old`, { redirect: 'manual' });
console.log('manual:', manual.status, manual.headers.get('location'));
await fetch(`${base}/old`, { redirect: 'error' }).catch((e) => console.log('error: ', e.name, '-', e.cause.message));
close();

{ type: 'application/x-www-form-urlencoded', length: 13 }
{ type: 'multipart/form-data', length: 277 }
{ type: 'text/plain', length: 5 }
2 49
TypeError: Body is unusable: Body has already been read
follow: 200 true /books
manual: 301 /books
error:  TypeError - unexpected redirect

import { startServer } from './server.js';

const { base, close } = await startServer();

// A deadline for the whole exchange, including reading the body
try {
  const res = await fetch(`${base}/slow`, { signal: AbortSignal.timeout(300) });
  console.log(await res.text());
} catch (err) {
  console.log(err.name, '-', err.message);       // TimeoutError
}

// A deadline plus a cancel button that the caller controls
const user = new AbortController();
setTimeout(() => user.abort(), 100);
try {
  await fetch(`${base}/slow`, { signal: AbortSignal.any([user.signal, AbortSignal.timeout(5000)]) });
} catch (err) {
  console.log(err.name, '-', err.message);       // AbortError: the user's signal fired first
}
close();

TimeoutError - The operation was aborted due to timeout
AbortError - This operation was aborted

import { startServer } from './server.js';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { createWriteStream } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const { base, close } = await startServer();

// Read an NDJSON response line by line, as the bytes arrive
const res = await fetch(`${base}/lines`);
const lines = res.body.pipeThrough(new TextDecoderStream());
let pending = '';
for await (const text of lines) {
  pending += text;
  const parts = pending.split('\n');
  pending = parts.pop();                       // keep an incomplete last line
  for (const line of parts) console.log(JSON.parse(line));
}

// Save a response straight to disk with backpressure
const dest = join(tmpdir(), 'books.json');
const res2 = await fetch(`${base}/books`);
await pipeline(Readable.fromWeb(res2.body), createWriteStream(dest));
console.log('saved', dest);

// Stream a request body from an async generator (needs duplex: 'half')
async function* chunks() {
  yield '{"title":';
  yield '"Streamed"}';
}
const up = await fetch(`${base}/books`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: Readable.from(chunks()),
  duplex: 'half',
});
console.log(up.status, await up.json());

// Not reading the body: cancel it so the connection can be reused
const unread = await fetch(`${base}/books`);
console.log('status only:', unread.status);
await unread.body.cancel();
close();

{ n: 1 }
{ n: 2 }
{ n: 3 }
{ n: 4 }
{ n: 5 }
saved <tmpdir>/books.json
201 { id: 3, title: 'Streamed' }
status only: 200

import { setTimeout as sleep } from 'node:timers/promises';

const RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
const IDEMPOTENT = new Set(['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE']);

// Retry-After is either delta-seconds or an HTTP-date.
export function retryAfterMs(value, now = Date.now()) {
  if (!value) return null;
  if (/^\d+$/.test(value)) return Number(value) * 1000;
  const at = Date.parse(value);
  return Number.isNaN(at) ? null : Math.max(0, at - now);
}

export async function fetchWithRetry(url, init = {}, { retries = 3, baseMs = 200, capMs = 10_000 } = {}) {
  const method = (init.method ?? 'GET').toUpperCase();
  const canRetry = IDEMPOTENT.has(method);               // never blindly retry POST
  for (let attempt = 0; ; attempt++) {
    let res;
    try {
      res = await fetch(url, init);
    } catch (err) {
      if (init.signal?.aborted || !canRetry || attempt >= retries) throw err;
      await sleep(Math.random() * Math.min(capMs, baseMs * 2 ** attempt), undefined, { signal: init.signal });
      continue;                                           // network error: back off and retry
    }
    if (!RETRYABLE_STATUS.has(res.status) || !canRetry || attempt >= retries) return res;
    const hinted = retryAfterMs(res.headers.get('retry-after'));
    const backoff = Math.random() * Math.min(capMs, baseMs * 2 ** attempt);   // "full jitter"
    await res.body?.cancel();                             // release the connection before waiting
    await sleep(Math.min(capMs, hinted ?? backoff), undefined, { signal: init.signal });
  }
}

import { startServer } from './server.js';
import { fetchWithRetry, retryAfterMs } from './retry.js';

const { base, close } = await startServer();

const t0 = Date.now();
const res = await fetchWithRetry(`${base}/flaky`, { signal: AbortSignal.timeout(10_000) });
console.log(res.status, await res.text(), `after ${Math.round((Date.now() - t0) / 100) / 10}s`);

console.log(retryAfterMs('120'), retryAfterMs(new Date(Date.now() + 5000).toUTCString()) > 3000, retryAfterMs('soon'));
close();

200 ok after 3 attempts after 2s
120000 true null

// Run fn over items with at most `limit` calls in flight; results keep input order.
export async function mapLimit(items, limit, fn) {
  const results = new Array(items.length);
  const entries = items.entries();                        // one shared iterator
  async function worker() {
    for (const [i, item] of entries) results[i] = await fn(item, i);
  }
  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
  return results;
}

import { startServer } from './server.js';
import { mapLimit } from './mapLimit.js';

const { base, close } = await startServer();

let inFlight = 0;
let peak = 0;
const ids = Array.from({ length: 20 }, (_, i) => i);
const out = await mapLimit(ids, 4, async (i) => {
  inFlight++;
  peak = Math.max(peak, inFlight);
  const res = await fetch(`${base}/work`);
  const text = await res.text();                      // always consume the body
  inFlight--;
  return `${i}:${text}`;
});
console.log(out.length, out[0], out.at(-1), '| peak in flight =', peak);
close();

20 0:done 19:done | peak in flight = 4

import http from 'node:http';
import { once } from 'node:events';

// Minimal promise wrapper around http.request(): resolves with { status, headers, body }.
export async function request(url, { method = 'GET', headers, body, agent, signal, timeout } = {}) {
  const req = http.request(url, { method, headers, agent, signal, timeout });
  req.on('timeout', () => req.destroy(new Error(`socket idle for ${timeout} ms`)));
  req.end(body);
  const [res] = await once(req, 'response');            // 'error' rejects once() automatically
  const chunks = [];
  for await (const chunk of res) chunks.push(chunk);     // IncomingMessage is a Readable
  return { status: res.statusCode, headers: res.headers, body: Buffer.concat(chunks).toString() };
}

import http from 'node:http';
import { startServer } from './server.js';
import { request } from './httpclient.js';
const { base, server, close } = await startServer();
let sockets = 0;
server.on('connection', () => sockets++);

const r = await request(`${base}/books`, { headers: { accept: 'application/json' } });
console.log(r.status, r.headers['content-type'], JSON.parse(r.body).length, 'books');
console.log('globalAgent keepAlive:', http.globalAgent.keepAlive, '| maxSockets:', http.globalAgent.maxSockets);
http.globalAgent.destroy();                              // forget the pooled socket for a clean count

async function sequential(label, agent) {
  sockets = 0;
  for (let i = 0; i < 5; i++) await request(`${base}/books`, { agent });
  console.log(label.padEnd(26), 'TCP connections for 5 requests:', sockets);
}
await sequential('default (globalAgent)', undefined);
await sequential('new Agent()', new http.Agent());
await sequential('agent: false', false);
const pooled = new http.Agent({ keepAlive: true, maxSockets: 2 });
await sequential('new Agent({ keepAlive })', pooled);
pooled.destroy();

// maxSockets bounds concurrent connections per origin; the rest wait in agent.requests
const limited = new http.Agent({ keepAlive: true, maxSockets: 2 });
sockets = 0;
await Promise.all(Array.from({ length: 8 }, () => request(`${base}/work`, { agent: limited })));
console.log('8 concurrent, maxSockets 2 -> connections opened:', sockets);

try { await request(`${base}/slow`, { timeout: 200 }); } catch (e) { console.log(e.message); }
try { await request(`${base}/slow`, { signal: AbortSignal.timeout(200) }); } catch (e) { console.log(e.name); }

limited.destroy();
http.globalAgent.destroy();
close();

200 application/json 2 books
globalAgent keepAlive: true | maxSockets: Infinity
default (globalAgent)      TCP connections for 5 requests: 1
new Agent()                TCP connections for 5 requests: 5
agent: false               TCP connections for 5 requests: 5
new Agent({ keepAlive })   TCP connections for 5 requests: 1
8 concurrent, maxSockets 2 -> connections opened: 2
socket idle for 200 ms
AbortError

import { Agent, fetch as undiciFetch, request } from 'undici';
import { startServer } from './server.js';
const { base, server, close } = await startServer();
let sockets = 0;
server.on('connection', () => sockets++);

async function burst(label, doFetch, init) {
  sockets = 0;
  await Promise.all(Array.from({ length: 16 }, () => doFetch(`${base}/work`, init).then((r) => r.text())));
  console.log(label.padEnd(40), 'connections opened:', sockets);
}
await burst('global fetch, defaults', fetch);

// Use the SAME package for the dispatcher and for fetch: the Agent must match the fetch implementation
const dispatcher = new Agent({ connections: 4, connect: { timeout: 2000 } });
await burst('undici fetch + Agent({ connections: 4 })', undiciFetch, { dispatcher });

const { statusCode, headers, body } = await request(`${base}/books`, { dispatcher });
console.log(statusCode, headers['content-type'], (await body.json()).length, 'books');
await dispatcher.close();
close();

global fetch, defaults                   connections opened: 16
undici fetch + Agent({ connections: 4 }) connections opened: 4
200 application/json 2 books

import http from 'node:http';
import net from 'node:net';
import { once } from 'node:events';

// A tiny forward proxy for experiments. It handles plain HTTP forwarding and CONNECT tunnels,
// and maps every host name to 127.0.0.1 so that invented names such as books.internal.test work.
export async function startProxy() {
  const proxy = http.createServer((req, res) => {
    console.log('[proxy]', req.method, req.url);                // absolute-form target: GET http://host:port/path
    const target = new URL(req.url);
    const upstream = http.request(
      { host: '127.0.0.1', port: target.port, path: target.pathname + target.search, method: req.method, headers: req.headers },
      (up) => { res.writeHead(up.statusCode, up.headers); up.pipe(res); },
    );
    req.pipe(upstream);
  });
  proxy.on('connect', (req, client, head) => {
    console.log('[proxy] CONNECT', req.url);                    // used for tunnels, e.g. HTTPS through a proxy
    const upstream = net.connect(Number(req.url.split(':')[1]), '127.0.0.1', () => {
      client.write('HTTP/1.1 200 Connection Established\r\n\r\n');
      upstream.write(head);
      upstream.pipe(client);
      client.pipe(upstream);
    });
    upstream.on('error', () => client.destroy());
    client.on('error', () => upstream.destroy());
  });
  proxy.listen(0, '127.0.0.1');
  await once(proxy, 'listening');
  return { url: `http://127.0.0.1:${proxy.address().port}`, close: () => proxy.close() };
}

// run-proxy.mjs
import { startProxy } from './proxy.js';

const proxy = await startProxy();
console.log(proxy.url);       // the first line is the proxy URL; the process keeps running

import http from 'node:http';
import { startServer } from './server.js';
import { request } from './httpclient.js';

const { base, close } = await startServer();
const fake = `http://books.internal.test:${new URL(base).port}/books`;   // resolvable only through the proxy
console.log('NODE_USE_ENV_PROXY =', process.env.NODE_USE_ENV_PROXY, '| HTTP_PROXY =', process.env.HTTP_PROXY);

for (const [label, call] of [
  ['fetch', async () => (await fetch(fake)).status],
  ['http.get', async () => (await request(fake)).status],
]) {
  try { console.log(label.padEnd(9), '->', await call()); }
  catch (e) { console.log(label.padEnd(9), '-> failed:', e.cause?.code ?? e.code ?? e.message); }
}
http.globalAgent.destroy();
close();

node run-proxy.mjs &                       # prints http://127.0.0.1:<port>
export HTTP_PROXY=http://127.0.0.1:<port>

node e09-proxy.mjs                         # proxy variables are ignored: ENOTFOUND
NODE_USE_ENV_PROXY=1 node e09-proxy.mjs    # both requests go through the proxy
NO_PROXY=books.internal.test node --use-env-proxy e09-proxy.mjs   # bypassed again: ENOTFOUND

NODE_USE_ENV_PROXY = undefined | HTTP_PROXY = http://127.0.0.1:<port>
fetch     -> failed: ENOTFOUND
http.get  -> failed: ENOTFOUND
NODE_USE_ENV_PROXY = 1 | HTTP_PROXY = http://127.0.0.1:<port>
fetch     -> 200
http.get  -> 200
NODE_USE_ENV_PROXY = undefined | HTTP_PROXY = http://127.0.0.1:<port>
fetch     -> failed: ENOTFOUND
http.get  -> failed: ENOTFOUND

import http from 'node:http';
import { startServer } from './server.js';

const { base, close } = await startServer();
const fake = `http://books.internal.test:${new URL(base).port}/books`;
const proxyUrl = process.env.PROXY_URL;                   // set by the shell for this experiment

// 1. One request through a specific proxy: an agent with proxyEnv (v22.21.0 / v24.5.0 and later)
const agent = new http.Agent({ proxyEnv: { HTTP_PROXY: proxyUrl } });
const status = await new Promise((resolve, reject) =>
  http.get(fake, { agent }, (res) => { res.resume(); resolve(res.statusCode); }).on('error', reject));
console.log('http.get with proxyEnv agent ->', status);
agent.destroy();

// 2. Switch proxy support on for the whole process at runtime (v24.14.0 / v25.4.0 and later)
if (typeof http.setGlobalProxyFromEnv === 'function') {
  const restore = http.setGlobalProxyFromEnv({ http_proxy: proxyUrl });
  console.log('fetch after setGlobalProxyFromEnv ->', (await fetch(fake)).status);
  restore();                                               // back to direct connections
  await fetch(fake).catch((e) => console.log('after restore() ->', e.cause.code));
} else {
  console.log('http.setGlobalProxyFromEnv is not available on', process.version);
}
http.globalAgent.destroy();
close();

http.get with proxyEnv agent -> 200
fetch after setGlobalProxyFromEnv -> 200
after restore() -> ENOTFOUND

mkdir -p certs && cd certs
openssl req -x509 -newkey rsa:2048 -nodes -keyout ca.key -out ca.pem -days 30 -subj "/CN=Bookshelf Test CA"
openssl req -newkey rsa:2048 -nodes -keyout server.key -out server.csr -subj "/CN=localhost"
printf "subjectAltName=DNS:localhost,IP:127.0.0.1\n" > san.ext
openssl x509 -req -in server.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out server.pem -days 30 -extfile san.ext
cd ..

import https from 'node:https';
import { readFileSync } from 'node:fs';
import { once } from 'node:events';

// HTTPS server whose certificate was issued by a private CA (certs/ca.pem)
export async function startTlsServer() {
  const server = https.createServer(
    { key: readFileSync('certs/server.key'), cert: readFileSync('certs/server.pem') },
    (req, res) => res.end('secure hello'),
  );
  server.listen(0, '127.0.0.1');
  await once(server, 'listening');
  return { url: `https://localhost:${server.address().port}/`, close: () => server.close() };
}

import https from 'node:https';
import tls from 'node:tls';
import { readFileSync } from 'node:fs';
import { Agent, fetch as undiciFetch } from 'undici';
import { startTlsServer } from './tlsserver.js';

const { url, close } = await startTlsServer();
const ca = readFileSync('certs/ca.pem', 'utf8');
const get = (opts) => new Promise((resolve, reject) =>
  https.get(url, opts, (res) => { res.resume(); resolve(res.statusCode); }).on('error', reject));

console.log('NODE_EXTRA_CA_CERTS =', process.env.NODE_EXTRA_CA_CERTS);
try { console.log('fetch    ->', (await fetch(url)).status); }
catch (e) { console.log('fetch    -> failed:', e.cause.code, '-', e.cause.message); }
try { console.log('https.get ->', await get({})); }
catch (e) { console.log('https.get -> failed:', e.code); }

// Per-request trust: https.request() takes a ca option (it REPLACES the default roots)
if (!process.env.NODE_EXTRA_CA_CERTS) {
  console.log('https.get with ca ->', await get({ ca }));
  // The same idea for fetch: a dispatcher whose TLS options carry the CA
  const dispatcher = new Agent({ connect: { ca } });
  console.log('undici fetch with ca ->', (await undiciFetch(url, { dispatcher })).status);
  await dispatcher.close();
  // Process-wide: add the CA to the default list (v22.19.0 / v24.5.0 and later)
  tls.setDefaultCACertificates([...tls.getCACertificates('default'), ca]);
  console.log('fetch after setDefaultCACertificates ->', (await fetch(url)).status);
}
https.globalAgent.destroy();
close();

node e11-tls.mjs
NODE_EXTRA_CA_CERTS=certs/ca.pem node e11-tls.mjs

NODE_EXTRA_CA_CERTS = undefined
fetch    -> failed: UNABLE_TO_VERIFY_LEAF_SIGNATURE - unable to verify the first certificate; if the root CA is installed locally, try running Node.js with --use-system-ca
https.get -> failed: UNABLE_TO_VERIFY_LEAF_SIGNATURE
https.get with ca -> 200
undici fetch with ca -> 200
fetch after setDefaultCACertificates -> 200
NODE_EXTRA_CA_CERTS = certs/ca.pem
fetch    -> 200
https.get -> 200

export class HttpError extends Error {
  constructor(res, body) {
    super(`HTTP ${res.status} ${res.statusText} for ${res.url}`);
    this.name = 'HttpError';
    this.status = res.status;
    this.body = body;                 // parsed JSON or text, like axios's error.response.data
    this.headers = res.headers;
  }
}

// A small axios.create() replacement: base URL, default headers, query params,
// JSON in/out, a per-request timeout and throwing on non-2xx statuses.
export function createClient({ baseUrl, headers = {}, timeoutMs = 10_000 } = {}) {
  const root = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
  async function send(method, path, { params, json, signal, headers: extra } = {}) {
    const url = new URL(path.replace(/^\//, ''), root);            // 'books', not '/books': a leading slash resets the path
    for (const [k, v] of Object.entries(params ?? {})) url.searchParams.set(k, String(v));
    const res = await fetch(url, {
      method,
      headers: { accept: 'application/json', ...(json !== undefined && { 'content-type': 'application/json' }), ...headers, ...extra },
      body: json === undefined ? undefined : JSON.stringify(json),
      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs),
    });
    const text = await res.text();
    const data = text && res.headers.get('content-type')?.includes('json') ? JSON.parse(text) : text;
    if (!res.ok) throw new HttpError(res, data);                   // axios rejects here; fetch does not
    return { status: res.status, headers: res.headers, data };
  }
  return {
    get: (path, opts) => send('GET', path, opts),
    post: (path, json, opts) => send('POST', path, { ...opts, json }),
    put: (path, json, opts) => send('PUT', path, { ...opts, json }),
    delete: (path, opts) => send('DELETE', path, opts),
  };
}

import axios from 'axios';
import { startServer } from './server.js';
import { createClient } from './client.js';
const { base, close } = await startServer();

const http = axios.create({ baseURL: base, timeout: 300 });
const mine = createClient({ baseUrl: base, timeoutMs: 300 });

// Success: both give { status, data }
const a = await http.get('/books', { params: { q: 'x' } });
const f = await mine.get('/books', { params: { q: 'x' } });
console.log('axios :', a.status, a.data.length, '| fetch client:', f.status, f.data.length);

// POST JSON
console.log('axios :', (await http.post('/books', { title: 'A' })).data);
console.log('fetch :', (await mine.post('/books', { title: 'A' })).data);

// 404
try { await http.get('/missing'); } catch (e) { console.log('axios 404 :', e.name, e.code, e.response.status, e.response.data); }
try { await mine.get('/missing'); } catch (e) { console.log('fetch 404 :', e.name, e.status, e.body); }

// Timeout
try { await http.get('/slow'); } catch (e) { console.log('axios timeout :', e.name, e.code); }
try { await mine.get('/slow'); } catch (e) { console.log('fetch timeout :', e.name); }

// Raw fetch pitfall: leading slash and a base path
console.log(new URL('/books', 'http://host/api/').href, '|', new URL('books', 'http://host/api/').href);
try { await (await fetch(`${base}/lines`)).json(); } catch (e) { console.log('json() on NDJSON:', e.name); }
close();

axios : 200 2 | fetch client: 200 2
axios : { id: 3, title: 'A' }
fetch : { id: 3, title: 'A' }
axios 404 : AxiosError ERR_BAD_REQUEST 404 { error: 'not found' }
fetch 404 : HttpError 404 { error: 'not found' }
axios timeout : AxiosError ECONNABORTED
fetch timeout : TimeoutError
http://host/books | http://host/api/books
json() on NDJSON: SyntaxError