Skip to content

5. Die HTTP-Funktionen von TypeScript

Hier stellen wir zwei Möglichkeiten vor, HTTP-Anfragen in TypeScript zu stellen: die Funktion [fetch], die seit Version 18 nativ in Node enthalten ist, und die Drittanbieter-Bibliothek [axios]. Die Skripte dieses Kapitels befinden sich im Ordner [http] des Projekts.

Image

5.1. Auswahl der HTTP-Werkzeuge

Im Jahr 2019 war fetch in node.js noch nicht implementiert, und das Originaldokument empfahl das Paket node-fetch . Seit Node 18 (2022) ist [fetch] eine native globale Funktion, standardisiert durch den WHATWG-Fetch-Standard – sie muss nicht mehr importiert werden.

[axios] bleibt jedoch eine interessante Bibliothek: kompatibel mit node.js und Browsern, bietet sie eine etwas reichhaltigere API (Interceptors, automatische JSON-Serialisierung, standardisierte Fehlerbehandlung). Wir stellen beide anhand desselben Beispiels vor, um zu zeigen, dass der Programmieransatz ähnlich ist.

5.2. Der Steuerberechnungsserver

Dieses Kapitel bezieht sich, wie die folgenden, auf den zuvor installierten NestJS-Server. Die Testarchitektur sieht wie folgt aus:

 

In [A-B] sendet JavaScript-Code, der von [node.js] ausgeführt wird, über [1] Anfragen an die Webanwendung [C]. Die Webanwendung sendet JSON-Antworten zurück (4). Der clientseitige JavaScript-Code lässt sich in Schichten gliedern [UI, business, dao] (UI: User Interface). Das tun wir später. Um die folgenden Skripte auszuführen, muss Ihr NestJS-Server laufen.

5.3. Skript [fetch-01]

Dieses Skript verwendet [fetch] , um eine JSON-Sitzung mit dem Steuerberechnungsserver zu initialisieren:

'use strict';

// [Update 2026] 2019 musste man das Paket [node-fetch] installieren, um die
// Funktion [fetch] auf der Node-Seite zu haben. Seit Node 18 (2022) ist [fetch] eine native globale
// Funktion, standardisiert durch den "WHATWG Fetch Standard": Sie muss nicht mehr importiert werden.
// Importe
import qs from 'qs';
import { sprintf } from 'sprintf-js';
import moment from 'moment';


// Basis-URL des Servers für die Steuerberechnung
const baseUrl: string = 'http://localhost:3000/main.php?';
// Sitzung initialisieren
async function initSession(): Promise<any> {
  // [Update 2026] Das native [fetch] kennt die Option [timeout] nicht.
  // Um die Wartezeit zu begrenzen, übergeben wir ein [signal], das von
  // [AbortSignal.timeout(ms)] erzeugt wird (verfügbar seit Node 17.3): Nach dieser Frist
  // wird die Anfrage automatisch abgebrochen und [fetch] wirft einen Fehler.
  const options: RequestInit = {
    method: "GET",
    signal: AbortSignal.timeout(2000)
  };
  // Ausführung der HTTP-Anfrage [get /main.php?action=init-session&type=json]
  let fetchStart: moment.Moment | undefined;
  try {
    // asynchrone Anfrage - [fetch] liefert ein Promise
    fetchStart = moment(Date.now());
    const response = await fetch(baseUrl + qs.stringify({
      action: 'init-session',
      type: 'json'
    }), options);
    // [response] ist die gesamte HTTP-Antwort des Servers (HTTP-Header + die Antwort selbst)
    // wir zeigen diese Antwort an, um ihre Struktur zu sehen
    console.log(sprintf("fetch response formatted as json,=%j, %s", response, time(fetchStart)));
    console.log("fetch response in javascript=", response);
    // Wir können auf die HTTP-Header zugreifen
    console.log("response headers=", response.headers);
    // Ist die Antwort vom Typ application / json, erhält man die json-Antwort des Servers mit der asynchronen Funktion [response.json()]
    // in diesem Fall bekommt der aufrufende Code ein [Promise]-Objekt
    // [await] ermöglicht es, die [json]-Antwort des Servers statt ihres Promise zu erhalten
    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;
    // Ist die Antwort vom Typ text / plain, erhält man die Textantwort des Servers mit [response.text()]
    // in diesem Fall bekommt der aufrufende Code ein [Promise]-Objekt
    // [await] ermöglicht es, die [text]-Antwort des Servers statt ihres Promise zu erhalten
    // const text = await response.text();
    // console.log("text response=", text);
    // return text;
  } catch (error: any) {
    // Wir sind hier, weil der Server einen Fehlercode [404 Not Found, ...] mit leerem Body gesendet hat - wir zeigen den Fehler an, um seine Struktur zu sehen
    // oder weil der [fetch]-Client eine Exception geworfen hat (Netzwerk nicht erreichbar, ...)
    // wir zeigen die Struktur des Fehlers an
    console.log(sprintf("fetch error in json=%j, %s", error, time(fetchStart)));
    console.log("fetch error in javascript=", typeof (error), error);
    // Wir werfen die empfangene Fehlermeldung
    throw error.message;
  }
}

// die Hauptfunktion führt die asynchrone Funktion [initSession] aus
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();

// Hilfsfunktion zur Anzeige von Uhrzeit und Dauer
function time(start?: moment.Moment): string {
  // Uhrzeit des aktuellen Moments
  const now = moment(Date.now());
  // Formatierung der Uhrzeit
  let result = "time=" + now.format("HH:mm:ss:SSS");
  // soll eine Dauer berechnet werden?
  if (start) {
    const duration = now.valueOf() - start.valueOf();
    const milliseconds = duration % 1000;
    const seconds = Math.floor(duration / 1000);
    // Formatierung von Uhrzeit + Dauer
    result = result + sprintf(", duration= %s second(s) and %s milliseconds", seconds, milliseconds);
  }
  // result
  return result;
}
  • Zeilen 3–5: [2026 update] – Kommentar, der darauf hinweist, dass fetch im Gegensatz zu 2019 nun nativ ist;
  • Zeile 13: Diese Zeile ist wichtig. Sie legt den Anfang der URL fest, die das Skript abfragt. Dieser wird durch eventuelle Parameter ergänzt. Hier haben wir die im Abschnitt „Installation eines NestJS-Servers“ definierte Konfiguration verwendet;
  • Zeile 22: AbortSignal.timeout(2000) – ersetzt die Option timeout von node-fetch (die im nativen fetch nicht existiert): Dauert die Anfrage länger als 2 Sekunden, wird sie automatisch abgebrochen;
  • Zeile 29: fetch(URL, options) – die Syntax bleibt die des Standard-fetch: eine URL und ein Options-Objekt (Methode, Abbruchsignal usw.);
  • Zeilen 30–31: Eine JSON-Sitzung wird gestartet;
  • Zeile 36: Die gesamte Serverantwort wird angezeigt;
  • Zeile 38: Die Antwort-Header werden angezeigt;
  • Zeile 43: await response.json() – extrahiert den JSON-Body aus der Antwort; dies ist selbst eine asynchrone Operation (die Antwort kann ein Stream sein, der noch empfangen wird);
  • Zeile 52: fetch löst nur dann eine Exception aus, wenn die HTTP-Anfrage fehlgeschlagen ist (Netzwerk nicht erreichbar, Timeout usw.). Wird eine Antwort empfangen, auch mit einem Fehlercode (400, 500 usw.), fetch löst keine Exception aus: Die Antwort steht normal zur Verfügung, Zeile 38.
npx tsx http/fetch-01.ts

Ausführungsergebnis:

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
  • Zeilen 3–22: die gesamte Serverantwort;
  • Zeile 4: der Statuscode 200 bedeutet, dass der Server die angeforderte URL verarbeiten konnte. Dies wird in Zeile 21 angezeigt. Wir haben diese URL bereits mit dem Client Postman getestet;
  • Zeilen 23–32: die Antwort-Header. Sie liefern Informationen über die folgende Antwort. In Zeile 29 teilt der Server beispielsweise mit, dass diese Antwort 84 Zeichen lang ist;
  • Zeile 28: Der Server hat ein Sitzungs-Cookie gesendet. Dadurch kann ein Client auf dem Server einen Speicherbereich unterhalten, der Sitzung genannt wird. Diese wird vom Webserver verwaltet. Nach dem Empfang dieses Sitzungs-Cookies – das tatsächlich die Kennung des Clients beim Server ist – muss der Client es bei jeder neuen Anfrage zurücksenden. Beachten Sie das Format dieses Sitzungs-Cookies. Wir werden es in Kürze in einem TypeScript-Client auslesen.
  • Zeile 33: die JSON-Antwort des Servers;

5.4. Skript [fetch-02]

Dieses Skript greift fetch-01 wieder auf und entfernt dabei alle Demonstrationsdetails, die für den täglichen Gebrauch unnötig sind:

'use strict';

// [Aktualisierung 2026] [fetch] ist jetzt eine native globale Funktion von node
// (seit Node 18): das Paket [node-fetch] muss nicht mehr importiert werden wie 2019.
// Importe
import qs from 'qs';

// Basis-URL des Servers für die Steuerberechnung
const baseUrl: string = 'http://localhost:3000/main.php?';
// Sitzung initialisieren
async function initSession(): Promise<any> {
  // Optionen der HHTP-Anfrage [get /main.php?action=init-session&type=json]
  // [AbortSignal.timeout(ms)] ersetzt die Option [timeout], die es bei nativem fetch nicht gibt
  const options: RequestInit = {
    method: "GET",
    signal: AbortSignal.timeout(2000)
  };
  // Ausführung der HTTP-Anfrage [get /main.php?action=init-session&type=json]
  const response = await fetch(baseUrl + qs.stringify({
    action: 'init-session',
    type: 'json'
  }), options);
  // in JSON empfangenes Ergebnis
  return await response.json();
}

// die Hauptfunktion führt die asynchrone Funktion [initSession] aus
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);
  }
}

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

Ausführungsergebnis:

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. Skript [axios-01]

Dasselbe Beispiel mit [axios]:

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

// Standardkonfiguration von axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';

// Sitzung initialisieren
async function initSession(axios: AxiosInstance): Promise<any> {
  // Optionen der HHTP-Anfrage [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [TypeScript-Aktualisierung] axios.request() akzeptiert im Hinblick auf die Typisierung nur ein
    // Konfigurationsargument: die URL muss daher in [options.url] stehen
    // statt als separater 1. Parameter von request()
    url: 'main.php',
    method: "GET",
    // URL-Parameter
    params: {
      action: 'init-session',
      type: 'x'
    }
  };
  // Ausführung der HTTP-Anfrage [get /main.php?action=init-session&type=json]
  try {
    // asynchrone Anfrage
    const response = await axios.request(options);
    // response ist die gesamte HTTP-Antwort des Servers (HTTP-Header + die eigentliche Antwort)
    // wir zeigen diese Antwort an, um ihre Struktur zu sehen
    // console.log("axios response=", response);
    // die Antwort des Servers steht in [response.data]
    return response.data;
  } catch (error: any) {
    // wir sind hier, weil der Server einen Fehlercode gesendet hat [404 Not Found, 500 Internal Server Error, ...]
    // der Parameter [error] ist eine Exception-Instanz - sie kann verschiedene Formen annehmen
    // wir zeigen sie an, um ihre Struktur zu sehen
    // console.log("axios error=", typeof (error), error);
    if (error.response) {
      // der Server hat einen Fehler im HTTP-Status gemeldet, aber auch eine Antwort gesendet,
      // die dann in [error.response.data] steht
      // wir wissen, dass der Server JSON-Antworten mit der Struktur {action, status, response} sendet
      // und dass im Fehlerfall die Fehlermeldung in [response] steht
      return error.response.data;
    } else {
      // wir werfen den Fehler
      throw error;
    }
  }
}

// die Hauptfunktion führt die asynchrone Funktion [initSession] aus
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);
  }
}

// Test
main();
  • Die URL-Anfrage wird aus den Angaben in den Zeilen 6, 15, 19 und 20 zusammengesetzt;
  • Zeile 26: axios.request(options) – anders als bei fetch werden die URL und die Optionen in einem einzigen Konfigurationsobjekt zusammengefasst (Zeile 11);
  • Zeile 37: error.response – wenn der Server geantwortet hat (auch mit einem Fehlercode), legt Axios diese Antwort in error.response ab, auf die im catch-Block zugegriffen werden kann – anders als bei fetch löst Axios immer eine Exception aus, sobald der Statuscode kein Erfolg (2xx) ist;
  • Zeile 31: Die erfolgreiche Antwort befindet sich in response.data – axios extrahiert JSON automatisch; ein separates await response.json() ist nicht nötig wie bei fetch.
npx tsx http/axios-01.ts

Ausführungsergebnis:

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] Skript – Authentifizierung

Dieses Skript verkettet zwei Anfragen: init-session, gefolgt von authenticate-user per **[POST], mit einem Body, der von der Bibliothek **[qs] codiert wird:

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

// Konfiguration von axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';


// Sitzung initialisieren
async function initSession(axios: AxiosInstance): Promise<any> {
  // Optionen der HHTP-Anfrage [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [TypeScript-Aktualisierung] URL in [options.url] enthalten (das typisierte axios.request() akzeptiert nur ein Argument)
    url: 'main.php',
    method: "GET",
    // URL-Parameter
    params: {
      action: 'init-session',
      type: 'json'
    }
  };
  try {
    // Ausführung der HTTP-Anfrage [get /main.php?action=init-session&type=json]
    const response = await axios.request(options);
    // die Antwort des Servers steht in [response.data]
    return response.data;
  } catch (error: any) {
    // Antwort des Servers
    if (error.response) {
      // die JSON-Antwort steht in [error.response.data]
      return error.response.data;
    } else {
      // wir werfen den Fehler erneut
      throw error;
    }
  }
}

async function authenticateUser(axios: AxiosInstance, user: string, password: string): Promise<any> {
  // Optionen der HHTP-Anfrage [post /main.php?action=authenticate-user]
  const options: AxiosRequestConfig = {
    // [TypeScript-Aktualisierung] URL in [options.url] enthalten
    url: 'main.php',
    method: "POST",
    headers: {
      'Content-type': 'application/x-www-form-urlencoded',
    },
    // POST-Body
    data: qs.stringify({
      user: user,
      password: password
    }),
    // URL-Parameter
    params: {
      action: 'authenticate-user'
    }
  };
  try {
    // Ausführung der HTTP-Anfrage [post /main.php?action=authenticate-user]
    const response = await axios.request(options);
    // die Antwort des Servers steht in [response.data]
    return response.data;
  } catch (error: any) {
    // Antwort des Servers
    if (error.response) {
      // die JSON-Antwort steht in [error.response.data]
      return error.response.data;
    } else {
      // wir werfen den Fehler erneut
      throw error;
    }
  }
}

// die Hauptfunktion führt die asynchronen Funktionen nacheinander aus
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);
  }
}

// Test
main();
  • Zeilen 42–53: Die POST-Anfrage sendet ihre Parameter (user, password), codiert als application/x-www-form-urlencoded, über qs.stringify(...) in options.data;
  • Zeilen 55–57: Die URL ([post /main.php?action=authenticate-user]) hat ebenfalls einen Parameter;
  • beide Funktionen werden nacheinander in main (mit await eine nach der anderen) ausgeführt (Zeilen 81, 86): Die zweite ergibt nur Sinn, wenn die erste erfolgreich war, da sie vom Sitzungs-Cookie abhängt, das von init-session gesetzt wird.
npx tsx http/axios-03.ts

Ausführungsergebnis:

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]' ]
}
  • Zeilen 10–14: Die Aktion [authenticate-user] ist fehlgeschlagen. Der Grund ist folgender:
    • Die Aktion [init-session] hat das Sitzungs-Cookie nicht an den Server gesendet. Dieses ist die Kennung des Clients beim Server. Da er diese Kennung nicht gesendet hat, ist der Client dem Server unbekannt. In seiner Antwort hat der Server ein Sitzungs-Cookie mitgeschickt. Dieses teilt dem Client mit: „Hier ist Ihre Kennung für Ihre künftigen Anfragen“;
    • aber die Aktion [authenticate-user] hat das Sitzungs-Cookie ebenfalls nicht an den Server gesendet. Das liegt daran, dass [init-session] es nicht gespeichert hat. Der Server erkennt den Client daher nicht und weiß nicht, dass dieser zuvor eine JSON-Sitzung gestartet hat, und teilt dies dem Client mit;

Die Lösung dieses Problems besteht darin, das vom Server gesendete Sitzungs-Cookie zu verwalten:

  • Die allererste Anfrage an den Server muss das vom Server gesendete Sitzungs-Cookie speichern;
  • nachfolgende Anfragen müssen dieses Sitzungs-Cookie auslesen und an den Server senden, um sich zu authentifizieren;

5.7. Skript [axios-04] – Verwaltung des Sitzungs-Cookies

Der Code ist derselbe wie zuvor, fügt aber eine Funktion [getRemoteData] zur Verwaltung des Sitzungs-Cookies hinzu:

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

// Konfiguration von axios
axios.defaults.timeout = 2000;
axios.defaults.baseURL = 'http://localhost:3000/';

// Session-Cookie
const sessionCookieName: string = "connect.sid";
let sessionCookie: string = '';

// Sitzung initialisieren
async function initSession(axios: AxiosInstance): Promise<any> {
  // Optionen der HHTP-Anfrage [get /main.php?action=init-session&type=json]
  const options: AxiosRequestConfig = {
    // [TypeScript-Aktualisierung] URL in [options.url] enthalten
    url: 'main.php',
    method: "GET",
    // URL-Parameter
    params: {
      action: 'init-session',
      type: 'json'
    }
  };
  // Ausführung der HTTP-Anfrage
  return await getRemoteData(axios, options);
}

async function authenticateUser(axios: AxiosInstance, user: string, password: string): Promise<any> {
  // Optionen der HHTP-Anfrage [post /main.php?action=authenticate-user]
  const options: AxiosRequestConfig = {
    // [TypeScript-Aktualisierung] URL in [options.url] enthalten
    url: 'main.php',
    method: "POST",
    headers: {
      'Content-type': 'application/x-www-form-urlencoded',
    },
    // POST-Body
    data: qs.stringify({
      user: user,
      password: password
    }),
    // URL-Parameter
    params: {
      action: 'authenticate-user'
    }
  };
  // Ausführung der HTTP-Anfrage
  return await getRemoteData(axios, options);
}

async function getRemoteData(axios: AxiosInstance, options: AxiosRequestConfig): Promise<any> {
  // für das Session-Cookie
  if (!options.headers) {
    options.headers = {} as any;
  }
  (options.headers as any).Cookie = sessionCookie;
  // Ausführung der HTTP-Anfrage
  let response: AxiosResponse;
  try {
    // asynchrone Anfrage
    response = await axios.request(options);
  } catch (error: any) {
    // der Parameter [error] ist eine Exception-Instanz - sie kann verschiedene Formen annehmen
    if (error.response) {
      // die Antwort des Servers steht in [error.response]
      response = error.response;
    } else {
      // wir werfen den Fehler erneut
      throw error;
    }
  }
  // response is the whole HTTP response of the server (HTTP headers + the response itself)
  // wir rufen das Session-Cookie ab, falls vorhanden
  const setCookie = response.headers['set-cookie'];
  if (setCookie) {
    // setCookie ist ein Array
    // wir suchen das Session-Cookie in diesem Array
    let found = false;
    let i = 0;
    while (!found && i < setCookie.length) {
      // wir suchen das Session-Cookie
      const results = RegExp('^(' + sessionCookieName + '.+?);').exec(setCookie[i]);
      if (results) {
        // wir speichern das Session-Cookie
        // eslint-disable-next-line require-atomic-updates
        sessionCookie = results[1];
        // gefunden
        found = true;
      } else {
        // nächstes Element
        i++;
      }
    }
  }
  // the server's response is in [response.data]
  return response.data;
}


// die Hauptfunktion führt die asynchronen Funktionen nacheinander aus
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();

Dieses Skript fasst initSession und authenticateUser um eine gemeinsame Funktion zusammen, [getRemoteData], die das Sitzungs-Cookie explizit behandelt (hier connect.sid, siehe Zeile 10) – was unerlässlich ist, da der Server Authentifizierung und Simulationen einer HTTP-Sitzung zuordnet:

  • Zeile 10: der Name des gesuchten Sitzungs-Cookies. Er hängt vom verwendeten Webserver ab. Der in diesem Kurs verwendete NestJS-Server nutzt ein Sitzungs-Cookie namens [connect.sid];
  • Zeile 53: Die Funktion [getRemoteData] übernimmt das Senden der Anfragen und den Empfang der Serverantwort. Sie verwaltet außerdem das Sitzungs-Cookie. Sie nimmt zwei Parameter entgegen:
    • das Objekt [AxiosInstance], das die allgemeine Mechanik der HTTP-Anfragen von Axios abwickelt. Dieses und weitere Objekte werden über den Import in Zeile 2 bezogen;
    • das Objekt [AxiosRequestConfig], das die Optionen für eine bestimmte Anfrage definiert;
  • Zeilen 54–58: [options.headers] legt den Header der HTTP-Anfrage fest, die an den Server gesendet wird. Existiert ein Sitzungs-Cookie, muss es in diesem Header enthalten sein. Zeile 58 erledigt dies. Nach Abschluss der ersten Anfrage [getRemoteData] speichert dieses Cookie in der in Zeile 11 definierten globalen Variablen. Während der ersten Anfrage ist ihr Wert eine leere Zeichenkette. Bei den folgenden Anfragen ist es die Zeichenkette des Sitzungs-Cookies, das der Server als Antwort auf die erste Anfrage gesendet hat.
  • Zeile 63: Die HTTP-Anfrage wird ausgeführt;
  • Zeile 76: Im Antwort-Header wird geprüft, ob eine „set-cookie“-Zeile vorhanden ist. Diese Zeile ist nur vorhanden, wenn die vorherige Anfrage des Clients keine „Cookie“-Zeile in ihren Headern enthielt. Erhält der Server eine HTTP-Anfrage des Clients, die die Zeile „Cookie“ enthält, sendet er das Sitzungs-Cookie nicht mehr, da er weiß, dass der Client es bereits besitzt. Der Client muss es bei jeder neuen Anfrage erneut senden. Dies geschieht in Zeile 58;
  • Zeile 77: Hat der Server den Header [Set-Cookie] gesendet, muss dessen Inhalt ausgelesen werden. Dieser Header kann mehrere Cookies in der Form [cookie_name=value] enthalten. Die Zeilen 77–95 werden während der Ausführung des Skripts nur einmal ausgeführt. Wie erwähnt, sendet der Server das Sitzungs-Cookie nicht als Antwort auf Anfragen, die mit diesem Sitzungs-Cookie authentifiziert wurden;
  • Zeile 84: Wir suchen explizit nach dem Cookie, dessen Name in Zeile 10 gespeichert wurde;
  • Zeile 88: Wird es gefunden, wird es in der in Zeile 11 definierten globalen Variablen gespeichert;

Dieser Mechanismus stellt sicher, dass:

  • das Sitzungs-Cookie aus der Antwort auf die erste HTTP-Anfrage ausgelesen wird;
  • es anschließend systematisch bei jeder neuen Anfrage an den Server gesendet wird, sodass der Server seinen Client erkennen kann;

Der Code wird ausgeführt:

npx tsx http/axios-04.ts

Ausführungsergebnis:

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. Skript [fetch-03] – Abbrechen von Anfragen

[NEW since 2019] Dieses Skript veranschaulicht zwei Einsatzmöglichkeiten des Mechanismus zum Abbrechen von fetch-Anfragen, der seit Node 18 nativ verfügbar ist:

'use strict';
// ========================================================================
// [NEU seit 2019] natives fetch + Abbrechen einer HTTP-Anfrage
// ========================================================================

// [fetch] ist seit Node 18 global: das Paket [node-fetch] wird nicht mehr benötigt,
// das 2019 in fetch-01.js/fetch-02.js verwendet wurde (siehe die Kommentare [Aktualisierung 2026]
// in diesen beiden Dateien)

// Basis-URL des Servers für die Steuerberechnung (siehe http/README.md)
// wie bei axios-01.js setzt dieses Skript voraus, dass der PHP-Server des Kurses lokal läuft:
// ohne ihn scheitern die Anfragen mit "fetch failed", was normal ist
const baseUrl: string = 'http://localhost:3000/main.php';

// Beispiel 1: Anfrage mit maximaler Wartezeit dank AbortSignal.timeout()
async function requestWithMaximumDelay(): Promise<void> {
  console.log("--- request with AbortSignal.timeout ---");
  try {
    const response = await fetch(baseUrl + '?action=init-session&type=json', {
      // nach mehr als 2 Sekunden wird die Anfrage automatisch abgebrochen
      signal: AbortSignal.timeout(2000)
    });
    const data = await response.json();
    console.log("response =", data);
  } catch (error: any) {
    // wird die Wartezeit überschritten,
    // ist [error.name] je nach Fall "TimeoutError" oder "AbortError"
    console.log("error.name =", error.name, ", message =", error.message);
  }
}

// Beispiel 2: manueller Abbruch einer Anfrage, zum Beispiel, weil
// der Benutzer es sich anders überlegt hat (z. B.: er tippt in einem Suchfeld neu)
async function manuallyCancellableRequest(): Promise<void> {
  console.log("--- manually cancelled request ---");
  const controller = new AbortController();

  // wir planen nach 500 ms einen "fachlichen" Abbruch
  // (in einer echten Anwendung wäre das zum Beispiel ein Klick auf eine Schaltfläche "Abbrechen")
  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)]: bricht die Anfrage automatisch ab, wenn sie das angegebene Timeout überschreitet – ein Muster, das bereits im Skript fetch-01 zu sehen war;
  • [AbortController]: ermöglicht ein manuelles Abbrechen, ausgelöst durch ein beliebiges Anwendungsereignis (hier ein setTimeout , der zum Beispiel einen Klick auf eine Schaltfläche „Abbrechen“ simuliert oder einen neuen Text in einem Suchfeld, der die vorherige Anfrage ungültig macht).
npx tsx http/fetch-03.ts

Ausführungsergebnis:

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
  • Zeilen 2–6: Die erste Anfrage wurde normal abgeschlossen;
  • Zeilen 8–9: die zweite Anfrage wurde wegen des sehr kurzen Timeouts (10 ms), das für die Anfrage festgelegt wurde (Zeile 43 des Codes), abgebrochen;