Fastify

Ar trebui să îți construiești aplicația prin înregistrarea rutelor pe o instanță FastifyInstance returnată de o fabrică buildApp(). Proiectul de pornire expune o singură rută GET / care returnează "Hello, World!" — extinde-o prin adăugarea de noi rute, pluginuri și decoratori.

Fișier de intrare

Fișierele soluției sunt organizate în src/:

• src/main.ts — scriptul de bootstrap care apelează buildApp() și începe să asculte pe portul 3000 (preîncărcat, ascuns, doar pentru citire).
• src/app.ts — fabrica buildApp() unde înregistrezi rutele și pluginurile (fișier de soluție editabil).

Separarea fabricii de ascultător (listener) îți permite să reutilizezi buildApp() în teste cu app.inject() în loc să te conectezi la un port real.

Configurarea serverului pentru API Tester

Serverul este pornit de src/main.ts (buildApp().listen({ port: 3000, host: '0.0.0.0' })), deci rulează atunci când folosești tabul API Tester. API Tester trimite cereri HTTP reale către aplicația ta Fastify și redă răspunsul.

import { buildApp } from './app';

const app = buildApp();

app.listen({ port: 3000, host: '0.0.0.0' }).catch((error) => {
  console.error('Server failed to start:', error);
  process.exit(1);
});

Versiune

Rulează pe Node.js v22.0.0 cu Fastify 5.

Limbi suportate

TypeScript

Framework de testare

Vitest

Memento-uri speciale și detalii de implementare

• Handlerele de rută ar trebui să fie async ori de câte ori efectuează operațiuni I/O — Fastify va aștepta promisiunea returnată și va serializa valoarea rezolvată ca corp al răspunsului.
• Nu apela reply.send() ȘI să returnezi o valoare în același timp — Fastify va avertiza despre un răspuns dublu (double-reply). Alege un singur stil pentru fiecare handler.
• Testele folosesc injectorul HTTP încorporat în Fastify, app.inject(), astfel încât nu trebuie să te conectezi efectiv la un port. Apelează întotdeauna await app.close() în afterEach pentru ca porturile să nu rămână blocate între fișierele de test (spec files).

Exemplu cu Vitest + app.inject():

import { describe, it, expect, afterEach } from 'vitest';
import type { FastifyInstance } from 'fastify';
import { buildApp } from './src/app';

describe('GET /', () => {
  let app: FastifyInstance;

  afterEach(async () => {
    await app?.close();
  });

  it("returns 'Hello, World!' with status 200", async () => {
    app = buildApp();
    const response = await app.inject({ method: 'GET', url: '/' });
    expect(response.statusCode).toBe(200);
    expect(response.body).toBe('Hello, World!');
  });
});

Biblioteci incluse

• fastify
• typescript
• vitest

Cum se face depanarea

Fastify este un framework de backend — codul tău rulează în Node, nu în browser. Există trei modalități principale de a inspecta comportamentul la rulare:

1. Jurnale (logs) de la handlerele de rută

Folosește request.log sau console.log. Pentru a folosi loggerul de cereri, activează-l la construirea aplicației:

const app = Fastify({ logger: true });

app.get('/items', async (request) => {
  request.log.info('GET /items called');
  return [];
});

Rezultatul apare în terminalul serverului de dezvoltare (sau în panoul de depanare al ferestrei Preview încorporate).

2. API Tester

Folosește tabul API Tester din panoul din dreapta pentru a trimite cereri HTTP reale (GET / POST / PUT / PATCH / DELETE) către serverul tău Fastify pornit. Alege o metodă, introdu o cale (de exemplu, /items), adaugă headere/parametri/corp (body) și apasă pe Trimite (Send).

3. Pași pentru depanare folosind Console Logs

1. Identifică zona cu probleme: Decide dacă problema se află într-un handler de rută, un plugin sau în configurarea buildApp().

2. Introdu instrucțiuni console.log(): Adaugă apeluri de log înainte și după codul suspect. Toate jurnalele Fastify merg în terminalul serverului.

3. Verifică rezultatul testelor (Results Output)

4. Folosește pictograma de depanare (Debug) din zona Preview: Fă clic pe pictograma de depanare din zona Preview pentru a verifica rezultatul din terminal.

5. Analizează rezultatul: Compară jurnalele cu răspunsurile din API Tester pentru a depista valori greșite, rute ratate sau erori netratate.

Greșeli frecvente

• Omiterea async la un handler care efectuează operațiuni I/O → valorile returnate sunt serializate înainte ca promisiunea să fie rezolvată. Declară întotdeauna handlerele asincrone ca async (request, reply) => { ... }.
• Apelarea reply.send() ȘI returnarea unei valori → Fastify va avertiza despre un răspuns dublu (double-reply). Alege un singur stil pentru fiecare handler.
• Neînchiderea aplicației în teste → scurgerile de porturi (port leaks) se acumulează între fișierele de test. Apelează întotdeauna await app.close() în afterEach / afterAll.