Synthese: die Bücher-API

import express from "express";

export const router = express.Router();

const notizen = [
  { id: 1, text: "Milch kaufen", wichtig: false },
  { id: 2, text: "Steuer abgeben", wichtig: true },
];

let naechsteId = 3;

function baueFehler(status, code, meldung, felder) {
  const fehler = new Error(meldung);
  fehler.status = status;
  fehler.code = code;
  fehler.felder = felder;
  return fehler;
}

function pruefe(koerper = {}) {
  const verstoesse = [];

  if (typeof koerper.text !== "string" || koerper.text.trim() === "") {
    verstoesse.push({ feld: "text", meldung: "fehlt oder ist leer" });
  }

  if (typeof koerper.wichtig !== "boolean") {
    verstoesse.push({ feld: "wichtig", meldung: "fehlt oder ist kein Wahrheitswert" });
  }

  return verstoesse;
}

router.get("/", (req, res) => {
  res.json({ anzahl: notizen.length, daten: notizen });
});

router.get("/:id", (req, res, next) => {
  const notiz = notizen.find((eintrag) => eintrag.id === Number(req.params.id));

  if (notiz === undefined) {
    return next(baueFehler(404, "nicht_gefunden", `Notiz ${req.params.id} gibt es nicht`));
  }

  res.json(notiz);
});

router.post("/", (req, res, next) => {
  const verstoesse = pruefe(req.body);

  if (verstoesse.length > 0) {
    return next(baueFehler(400, "ungueltig", "Die Eingabe ist unvollstaendig", verstoesse));
  }

  const notiz = { id: naechsteId++, text: req.body.text, wichtig: req.body.wichtig };
  notizen.push(notiz);

  res.status(201).location(`/api/notizen/${notiz.id}`).json(notiz);
});

router.delete("/:id", (req, res, next) => {
  const platz = notizen.findIndex((eintrag) => eintrag.id === Number(req.params.id));

  if (platz === -1) {
    return next(baueFehler(404, "nicht_gefunden", `Notiz ${req.params.id} gibt es nicht`));
  }

  notizen.splice(platz, 1);
  res.status(204).end();
});

import express from "express";
import { router as notizenRouter } from "./routen/notizen.js";

const app = express();
app.use(express.json());

app.use("/api/notizen", notizenRouter);

// Standardfall und Fehler-Handler, beide ganz unten und beide in
// derselben Form wie alles andere.
app.use((req, res) => {
  res.status(404).json({ fehler: { code: "nicht_gefunden", meldung: "Diesen Pfad gibt es nicht" } });
});

app.use((fehler, req, res, next) => {
  const status = fehler.status ?? 500;
  console.error(fehler.message);

  res.status(status).json({
    fehler: {
      code: fehler.code ?? "serverfehler",
      meldung: status === 500 ? "Unerwarteter Fehler" : fehler.message,
      felder: fehler.felder,
    },
  });
});

app.listen(3000);

import express from "express";

const app = express();
app.use(express.json());

const notizen = [
  { id: 1, text: "Milch kaufen", wichtig: false },
  { id: 2, text: "Steuer abgeben", wichtig: true },
];

let naechsteId = 3;

app.get("/api/notizen/:id", (req, res) => {
  const notiz = notizen.find((eintrag) => eintrag.id === Number(req.params.id));

  if (notiz === undefined) {
    return res.status(404).json({ fehler: { code: "nicht_gefunden", meldung: "gibt es nicht" } });
  }

  res.json(notiz);
});

app.post("/api/notizen", (req, res) => {
  // Der Rueckfall faengt den Fall ab, dass der Content-Type fehlt und
  // req.body deshalb undefined ist. Der letzte curl-Aufruf zeigt ihn.
  const koerper = req.body ?? {};

  if (typeof koerper.text !== "string" || typeof koerper.wichtig !== "boolean") {
    return res.status(400).json({
      fehler: { code: "ungueltig", meldung: "text und wichtig werden gebraucht" },
    });
  }

  const notiz = { id: naechsteId++, text: koerper.text, wichtig: koerper.wichtig };
  notizen.push(notiz);
  res.status(201).location(`/api/notizen/${notiz.id}`).json(notiz);
});

app.delete("/api/notizen/:id", (req, res) => {
  const platz = notizen.findIndex((eintrag) => eintrag.id === Number(req.params.id));

  if (platz === -1) {
    return res.status(404).json({ fehler: { code: "nicht_gefunden", meldung: "gibt es nicht" } });
  }

  notizen.splice(platz, 1);
  res.status(204).end();
});

app.listen(3000);

import { spawn, execSync } from "node:child_process";
import { setTimeout as warte } from "node:timers/promises";

// Der Server laeuft als eigener Prozess. Muesste er im selben laufen,
// blockierte ihn das synchrone execSync und keine Anfrage kaeme durch.
const kind = spawn("node", ["notizen-server.js"], { stdio: "ignore" });

for (let versuch = 0; versuch < 100; versuch++) {
  try {
    await fetch("http://127.0.0.1:3000/api/notizen/1");
    break;
  } catch {
    await warte(50);
  }
}

const befehle = [
  "curl -s -w ' [%{http_code}]' http://127.0.0.1:3000/api/notizen/2",
  "curl -s -w ' [%{http_code}]' -X POST -H 'Content-Type: application/json' -d '{\"text\":\"Neu\",\"wichtig\":false}' http://127.0.0.1:3000/api/notizen",
  "curl -s -w ' [%{http_code}]' -X DELETE http://127.0.0.1:3000/api/notizen/1",
  "curl -s -w ' [%{http_code}]' -X POST -d '{\"text\":\"Ohne Kopfzeile\",\"wichtig\":false}' http://127.0.0.1:3000/api/notizen",
];

for (const befehl of befehle) {
  // Das Statusanhaengsel und der Rechnername sind ueberall gleich, die
  // Ausgabe kuerzt sie deshalb weg.
  console.log(befehl.replace(" -w ' [%{http_code}]'", "").replace("http://127.0.0.1:3000", ""));
  console.log(`  ${execSync(befehl).toString()}`);
}

kind.kill();

import express from "express";

const app = express();
app.use(express.json());

const buecher = [{ id: 1, titel: "Node in der Praxis", jahr: 2024 }];
let naechsteId = 2;

app.get("/buecher", (req, res) => res.json({ anzahl: buecher.length }));

app.post("/buecher", (req, res) => {
  const buch = { id: naechsteId++, titel: req.body.titel, jahr: req.body.jahr };
  buecher.push(buch);
  res.status(201).json(buch);
});

// Dieser Server beendet sich selbst, denn zweimal-starten.js startet
// ihn als Kindprozess und wartet auf sein Ende.
const server = app.listen(3000, async () => {
  await fetch("http://127.0.0.1:3000/buecher", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ titel: "Neu", jahr: 2026 }),
  });

  const liste = await (await fetch("http://127.0.0.1:3000/buecher")).json();
  console.log(`nach dem Anlegen ${liste.anzahl} Buecher`);
  server.close();
});

import { execSync } from "node:child_process";

// Zweimal derselbe Prozess, zweimal von vorn. Nichts von dem, was der
// erste Lauf angelegt hat, ist im zweiten noch da.
for (const lauf of [1, 2]) {
  const ausgabe = execSync("node fluechtig.js").toString().trim();
  console.log(`Lauf ${lauf}: ${ausgabe}`);
}