Desenvolvimento e produção

Curso Intermédio Gratuito

Node.js — Os fundamentos

Compreender o motor de execução Node.js: módulos, assincronismo, npm e criação de um pequeno servidor.

  • 4 guias
  • 44 noções
Começar a leitura

Os guias

  1. 01 Guia Glossário de Node.js Explicar cada noção ligando-a a uma operação do projeto. 15 noções
  2. 02 Guia Os essenciais de Node.js Escolher uma instrução ou um comando e prever o seu efeito. 13 noções
  3. 03 Guia Oficina de Node.js · À table ! Reproduzir o projeto, verificar os seus comportamentos e superar uma modificação autónoma. 9 noções
  4. 04 Guia Recursos e balanço Justificar as suas escolhas e encontrar uma informação na documentação. 7 noções

Percurso recomendado

  1. 01. Node.js: expor e testar uma API HTTP de receitas e consumi-la depois a partir do navegador.
  2. 02. SCSS: organizar a apresentação do miniblogue em módulos e compilar uma folha de estilos CSS.
  3. 03. TypeScript: modelar as receitas e verificar as respostas da API antes de as apresentar.

Fontes e referências

Oficina de nível confirmado, etapa 1/3. Reproduzir os ficheiros num projeto local distinto do Technipédia. Os pré-requisitos, os resultados esperados e os limites são indicados nos guias.

Ficheiros de exemplo

package.json
{
  "name": "a-table-mini-blog",
  "private": true,
  "type": "module",
  "engines": {
    "node": ">=24 <25"
  },
  "scripts": {
    "start": "node src/index.js",
    "dev": "node --watch src/index.js",
    "test": "node --test"
  }
}
src/recettes.js
export function recettesInitiales() {
  // Un nouveau tableau à chaque serveur facilite l'isolation des tests.
  return [
    { id: 1, titre: "Soupe de carottes", duree_minutes: 20, portions: 2, categorie: "Plat",
      ingredients: ["4 carottes", "1 oignon", "500 ml d’eau"],
      etapes: ["Éplucher et couper les légumes.", "Cuire dans l’eau 15 minutes puis mixer."] },
    { id: 2, titre: "Salade de tomates", duree_minutes: 10, portions: 2, categorie: "Entrée",
      ingredients: ["3 tomates", "1 cuillère d’huile d’olive", "Quelques feuilles de basilic"],
      etapes: ["Laver et couper les tomates.", "Ajouter l’huile et le basilic, mélanger."] },
    { id: 3, titre: "Tarte aux pommes", duree_minutes: 45, portions: 4, categorie: "Dessert",
      ingredients: ["1 pâte brisée", "3 pommes", "2 cuillères de compote"],
      etapes: ["Préchauffer le four à 180 °C et étaler la pâte.", "Garnir de compote et de pommes puis cuire 30 minutes."] }
  ];
}

export function filtrerRecettes(recettes, q = "", dureeMax = 0) {
  const terme = q.trim().toLocaleLowerCase("fr");
  return recettes.filter((recette) =>
    recette.titre.toLocaleLowerCase("fr").includes(terme) &&
    (dureeMax === 0 || recette.duree_minutes <= dureeMax)
  );
}

export function validerRecette(valeur) {
  if (typeof valeur !== "object" || valeur === null || Array.isArray(valeur)) {
    return { erreurs: ["Le corps doit être un objet JSON."] };
  }
  const titre = typeof valeur.titre === "string" ? valeur.titre.trim() : "";
  const categories = ["Entrée", "Plat", "Dessert"];
  const listeValide = (liste) => Array.isArray(liste) && liste.length >= 1 && liste.length <= 30 &&
    liste.every((ligne) => typeof ligne === "string" && ligne.trim().length >= 1 && ligne.length <= 500);
  const erreurs = [];
  if (titre.length < 3 || titre.length > 120) erreurs.push("Titre : 3 à 120 unités UTF-16.");
  if (!Number.isInteger(valeur.duree_minutes) || valeur.duree_minutes < 1 || valeur.duree_minutes > 1440) {
    erreurs.push("Durée : entier entre 1 et 1440.");
  }
  if (!Number.isInteger(valeur.portions) || valeur.portions < 1 || valeur.portions > 20) {
    erreurs.push("Portions : entier entre 1 et 20.");
  }
  if (!categories.includes(valeur.categorie)) erreurs.push("Catégorie : Entrée, Plat ou Dessert.");
  if (!listeValide(valeur.ingredients)) erreurs.push("Ingrédients : 1 à 30 lignes non vides, 500 unités UTF-16 par ligne au maximum.");
  if (!listeValide(valeur.etapes)) erreurs.push("Étapes : 1 à 30 lignes non vides, 500 unités UTF-16 par ligne au maximum.");
  if (erreurs.length) return { erreurs };
  // Seules les propriétés autorisées sont conservées. L'id est produit par le serveur.
  return { erreurs: [], recette: {
    titre, duree_minutes: valeur.duree_minutes, portions: valeur.portions,
    categorie: valeur.categorie,
    ingredients: valeur.ingredients.map((ligne) => ligne.trim()),
    etapes: valeur.etapes.map((ligne) => ligne.trim())
  } };
}
src/server.js
import { createServer } from "node:http";
import { readFile } from "node:fs/promises";
import { recettesInitiales, filtrerRecettes, validerRecette } from "./recettes.js";

class ErreurHttp extends Error {
  constructor(statut, message) { super(message); this.statut = statut; }
}

function json(reponse, statut, valeur, entetes = {}) {
  reponse.writeHead(statut, {
    "Content-Type": "application/json; charset=utf-8",
    "Cache-Control": "no-store",
    "X-Content-Type-Options": "nosniff",
    ...entetes
  });
  reponse.end(JSON.stringify(valeur));
}

async function lireJson(requete) {
  const type = (requete.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase();
  if (type !== "application/json") throw new ErreurHttp(415, "Envoyer du JSON avec Content-Type: application/json.");
  let taille = 0;
  let tropGrand = false;
  const morceaux = [];
  // Ne plus conserver de données au-delà de la limite, mais finir de lire le flux.
  for await (const morceau of requete) {
    taille += morceau.length;
    if (taille > 16 * 1024) { tropGrand = true; morceaux.length = 0; }
    else if (!tropGrand) morceaux.push(morceau);
  }
  if (tropGrand) throw new ErreurHttp(413, "Corps limité à 16 Kio.");
  try { return JSON.parse(Buffer.concat(morceaux).toString("utf8")); }
  catch { throw new ErreurHttp(400, "JSON mal formé."); }
}

export function creerServeur() {
  const recettes = recettesInitiales();
  let prochainId = Math.max(...recettes.map((r) => r.id)) + 1;
  // Liste fixe : le chemin demandé n'est jamais concaténé à un chemin de disque.
  const fichiers = new Map([
    ["/", ["index.html", "text/html; charset=utf-8"]],
    ["/index.html", ["index.html", "text/html; charset=utf-8"]],
    ["/style.css", ["style.css", "text/css; charset=utf-8"]],
    ["/app.js", ["app.js", "text/javascript; charset=utf-8"]],
    ["/modeles.js", ["modeles.js", "text/javascript; charset=utf-8"]]
  ]);
  const serveur = createServer(async (requete, reponse) => {
    try {
      const url = new URL(requete.url ?? "/", "http://localhost");
      const chemin = url.pathname;
      const methode = requete.method ?? "GET";
      if (chemin === "/api/recettes") {
        if (methode === "GET") {
          const q = url.searchParams.get("q") ?? "";
          const dureeSaisie = url.searchParams.get("duree") ?? "0";
          if (q.length > 120 || !/^\d{1,4}$/.test(dureeSaisie) || Number(dureeSaisie) > 1440) {
            throw new ErreurHttp(400, "Filtres invalides : q limité à 120 unités UTF-16, duree entre 0 et 1440.");
          }
          const donnees = filtrerRecettes(recettes, q, Number(dureeSaisie));
          return json(reponse, 200, { donnees, total: donnees.length });
        }
        if (methode === "POST") {
          const resultat = validerRecette(await lireJson(requete));
          if (resultat.erreurs.length) return json(reponse, 422, { erreurs: resultat.erreurs });
          const recette = { id: prochainId++, ...resultat.recette };
          recettes.push(recette);
          return json(reponse, 201, { donnees: recette }, { Location: `/api/recettes/${recette.id}` });
        }
        return json(reponse, 405, { erreur: "Méthode non autorisée." }, { Allow: "GET, POST" });
      }
      const fiche = /^\/api\/recettes\/([^/]+)$/.exec(chemin);
      if (fiche) {
        if (methode !== "GET") return json(reponse, 405, { erreur: "Méthode non autorisée." }, { Allow: "GET" });
        const idSaisi = fiche[1];
        const id = Number(idSaisi);
        if (!/^[1-9]\d*$/.test(idSaisi) || !Number.isSafeInteger(id)) throw new ErreurHttp(400, "Identifiant invalide.");
        const recette = recettes.find((r) => r.id === id);
        if (!recette) throw new ErreurHttp(404, "Recette introuvable.");
        return json(reponse, 200, { donnees: recette });
      }
      if (fichiers.has(chemin)) {
        if (methode !== "GET") return json(reponse, 405, { erreur: "Méthode non autorisée." }, { Allow: "GET" });
        const [nom, type] = fichiers.get(chemin);
        const contenu = await readFile(new URL(`../public/${nom}`, import.meta.url));
        reponse.writeHead(200, { "Content-Type": type, "X-Content-Type-Options": "nosniff" });
        return reponse.end(contenu);
      }
      return json(reponse, 404, { erreur: "Adresse introuvable." });
    } catch (erreur) {
      if (erreur instanceof ErreurHttp) return json(reponse, erreur.statut, { erreur: erreur.message });
      if (erreur?.code === "ENOENT") return json(reponse, 404, { erreur: "Fichier public absent." });
      console.error("Erreur interne de la requête.");
      if (!reponse.headersSent) json(reponse, 500, { erreur: "Erreur interne." });
      else reponse.end();
    }
  });
  serveur.requestTimeout = 15_000;
  return serveur;
}
src/index.js
import { creerServeur } from "./server.js";

const port = Number(process.env.PORT ?? 3000);
if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("PORT invalide.");
const serveur = creerServeur();
serveur.on("error", (erreur) => {
  console.error(`Démarrage impossible : ${erreur.code ?? "erreur inconnue"}`);
  process.exitCode = 1;
});
serveur.listen(port, "127.0.0.1", () => console.log(`À table ! http://127.0.0.1:${port}`));
public/index.html
<!doctype html>
<html lang="fr">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>À table ! · Le mini-blog connecté</title>
  <link rel="stylesheet" href="/style.css">
  <script type="module" src="/app.js"></script>
</head>
<body>
  <a class="evitement" href="#contenu">Aller au contenu</a>
  <header class="entete"><h1>À table !</h1><p>Nos recettes maison, servies par une API.</p></header>
  <main id="contenu" class="conteneur">
    <h2>Nos recettes</h2>
    <form id="filtres">
      <label for="recherche">Rechercher par titre</label>
      <input id="recherche" name="q" type="search" maxlength="120">
      <label for="duree-max">Durée maximale</label>
      <select id="duree-max" name="duree">
        <option value="0">Toutes les durées</option>
        <option value="20">20 minutes</option>
        <option value="45">45 minutes</option>
      </select>
      <button type="submit">Rechercher</button>
      <button type="reset">Réinitialiser</button>
    </form>
    <p id="message" role="status" aria-live="polite">Chargement des recettes…</p>
    <div id="liste" class="recettes"></div>
    <noscript>Activer JavaScript pour consulter cette version connectée du blog. La version HTML du parcours débutant reste consultable sans script.</noscript>
  </main>
  <footer class="pied"><p>À table ! · L’Akadémie du Digital</p></footer>
</body>
</html>
public/app.js
const formulaire = document.querySelector("#filtres");
const recherche = document.querySelector("#recherche");
const dureeMax = document.querySelector("#duree-max");
const liste = document.querySelector("#liste");
const message = document.querySelector("#message");
let numeroRequete = 0;

function afficher(recettes) {
  liste.replaceChildren();
  for (const recette of recettes) {
    const article = document.createElement("article");
    article.className = "recette";
    const titre = document.createElement("h3");
    titre.textContent = recette.titre;
    const meta = document.createElement("p");
    meta.className = "meta";
    meta.textContent = `${recette.duree_minutes} min · ${recette.portions} personnes · ${recette.categorie}`;
    article.append(titre, meta);
    for (const [intitule, lignes, balise] of [
      ["Ingrédients", recette.ingredients, "ul"],
      ["Préparation", recette.etapes, "ol"]
    ]) {
      const sousTitre = document.createElement("h4");
      sousTitre.textContent = intitule;
      const groupe = document.createElement(balise);
      for (const ligne of lignes) {
        const item = document.createElement("li");
        item.textContent = ligne;
        groupe.append(item);
      }
      article.append(sousTitre, groupe);
    }
    liste.append(article);
  }
}

async function charger() {
  // Une ancienne réponse ne doit pas remplacer une recherche plus récente.
  const numero = ++numeroRequete;
  const params = new URLSearchParams({ q: recherche.value.trim(), duree: dureeMax.value });
  message.textContent = "Chargement…";
  liste.replaceChildren();
  try {
    const reponse = await fetch(`/api/recettes?${params}`);
    if (!reponse.ok) throw new Error(`Erreur HTTP ${reponse.status}`);
    // Le client TypeScript ajoutera une validation explicite de ce contrat JSON.
    const resultat = await reponse.json();
    if (numero !== numeroRequete) return;
    afficher(resultat.donnees);
    message.textContent = resultat.total === 0 ? "Aucune recette trouvée." : `${resultat.total} recette(s) trouvée(s).`;
  } catch (erreur) {
    if (numero === numeroRequete) message.textContent = "Impossible de charger les recettes. Vérifier le serveur puis réessayer.";
  }
}

formulaire.addEventListener("submit", (evenement) => { evenement.preventDefault(); void charger(); });
formulaire.addEventListener("reset", () => { setTimeout(() => { void charger(); }, 0); });
void charger();
public/style.css
/* Le sélecteur universel inclut aussi les pseudo-éléments. */
*, *::before, *::after { box-sizing: border-box; }

:root {
  --fond: #fff8ed;
  --texte: #29251f;
  --accent: #8b351b;
  --carte: #ffffff;
}

body {
  margin: 0;
  font-family: system-ui, sans-serif;
  line-height: 1.6;
  color: var(--texte);
  background: var(--fond);
}

.entete, .pied { padding: 1.5rem 1rem; text-align: center; }
.entete { background: var(--accent); color: white; }
.entete a { color: inherit; }
nav { display: flex; justify-content: center; flex-wrap: wrap; gap: 1rem; }
a { color: var(--accent); text-underline-offset: 0.2em; }
.conteneur { width: min(100% - 2rem, 70rem); margin-inline: auto; }
section { margin-block: 2rem; }
h1, h2, h3, h4 { line-height: 1.25; }
.recettes { display: grid; grid-template-columns: 1fr; gap: 1.25rem; }
.recette {
  padding: 1.25rem;
  border: 1px solid #cbbba9;
  border-radius: 0.75rem;
  background: var(--carte);
  overflow-wrap: anywhere;
}
.recette h3 { margin-top: 0; color: var(--accent); }
.meta { font-weight: 600; }
img { display: block; max-width: 100%; height: auto; }
figure { margin: 0; }
label { font-weight: 600; }
input, select, button, textarea { font: inherit; max-width: 100%; }
input, select, textarea { padding: 0.5rem; border: 1px solid #796e61; border-radius: 0.25rem; }
button { padding: 0.5rem 1rem; border: 0; border-radius: 0.25rem; background: var(--accent); color: white; cursor: pointer; }
#filtres { display: flex; align-items: center; flex-wrap: wrap; gap: 0.75rem; }
/* Une règle display ne doit pas réafficher un contrôle marqué hidden. */
[hidden] { display: none !important; }
:focus-visible { outline: 3px solid #185ea0; outline-offset: 4px; }
.evitement { position: absolute; top: 0; left: 1rem; padding: 0.5rem; background: white; transform: translateY(-120%); }
.evitement:focus { transform: translateY(0); }
.pied { border-top: 1px solid #cbbba9; }

@media (min-width: 48rem) {
  .recettes { grid-template-columns: repeat(3, minmax(0, 1fr)); }
}
test/api.test.js
import test from "node:test";
import assert from "node:assert/strict";
import { creerServeur } from "../src/server.js";

test("API : filtrer, valider, créer et retrouver une recette", async (t) => {
  const serveur = creerServeur();
  await new Promise((resolve, reject) => { serveur.once("error", reject); serveur.listen(0, "127.0.0.1", resolve); });
  t.after(() => new Promise((resolve, reject) => serveur.close((erreur) => erreur ? reject(erreur) : resolve())));
  const origine = `http://127.0.0.1:${serveur.address().port}`;
  const appeler = (chemin, options) => fetch(origine + chemin, options);

  const liste = await appeler("/api/recettes");
  assert.equal(liste.status, 200);
  assert.equal((await liste.json()).total, 3);
  const rapide = await (await appeler("/api/recettes?duree=20")).json();
  assert.deepEqual(rapide.donnees.map((r) => r.titre), ["Soupe de carottes", "Salade de tomates"]);
  const vide = await (await appeler("/api/recettes?q=tarte&duree=20")).json();
  assert.equal(vide.total, 0);
  assert.equal((await appeler("/api/recettes?duree=abc")).status, 400);
  assert.equal((await appeler("/api/recettes/abc")).status, 400);
  assert.equal((await appeler("/api/recettes/9999")).status, 404);

  const recette = { titre: "Compote d’automne <maison>", duree_minutes: 15, portions: 2,
    categorie: "Dessert", ingredients: ["2 pommes"], etapes: ["Cuire puis écraser."] };
  const poster = (valeur) => appeler("/api/recettes", {
    method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(valeur)
  });
  assert.equal((await poster({ ...recette, duree_minutes: -1 })).status, 422);
  const creation = await poster(recette);
  assert.equal(creation.status, 201);
  const emplacement = creation.headers.get("location");
  const fiche = await (await appeler(emplacement)).json();
  assert.equal(fiche.donnees.titre, recette.titre);
  assert.equal((await (await appeler("/api/recettes")).json()).total, 4);
  assert.equal((await appeler("/api/recettes", { method: "DELETE" })).status, 405);
  assert.equal((await appeler("/src/server.js")).status, 404);
});
compote.json
{
  "titre": "Compote de pommes",
  "duree_minutes": 15,
  "portions": 2,
  "categorie": "Dessert",
  "ingredients": [
    "2 pommes",
    "Un peu d’eau"
  ],
  "etapes": [
    "Couper les pommes.",
    "Cuire puis écraser."
  ]
}

Partilhar este artigo

Na mesma categoria

Curso

Desenvolvimento e produção · Iniciante

HTML — As bases

Estruturar uma página web semântica e acessível, passo a passo, com o fio condutor «À mesa!»: um miniblogue de receitas.

4 guias · 38 noções Na mesma série

Curso

Desenvolvimento e produção · Iniciante

CSS — As bases

Formatar e tornar responsivo o miniblogue de receitas: seletores, caixas, flexbox, grelha e mobile first.

4 guias · 39 noções Na mesma série

Curso

Desenvolvimento e produção · Iniciante

JavaScript — As bases

Tornar a página interativa: variáveis, funções, DOM e eventos para filtrar as receitas sem recarregar.

4 guias · 38 noções Na mesma série