Skip to content

NestJS ​

Ar trebui să îți construiești aplicația ca pe un arbore de module, controllere și furnizori (providers). Aplicația de pornire expune un singur endpoint GET / care returnează "Hello, World!" — extinde-o adăugând mai multe rute, servicii și module urmând același model.

Fișierul de intrare ​

Fișierele soluției sunt organizate sub src/:

  • src/main.ts — inițializează aplicația și pornește serverul HTTP pe portul 3000 (preîncărcat, ascuns, doar citire).
  • src/app.module.ts — modulul rădăcină care conectează controllerele și furnizorii (preîncărcat, doar citire).
  • src/app.controller.ts — controllerul rădăcină care expune GET / (preîncărcat, doar citire).
  • src/app.service.ts — serviciul care oferă șirul de răspuns (fișier de soluție editabil).

Configurarea serverului pentru API Tester ​

Serverul este pornit de src/main.ts (NestFactory.create(AppModule) care ascultă pe portul 3000), deci rulează atunci când folosești tab-ul API Tester. API Tester trimite cereri HTTP reale către aplicația ta NestJS și afișează răspunsul în paralel.

typescript
import 'reflect-metadata';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap(): Promise<void> {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}

bootstrap();

Versiune ​

Rulează pe Node.js v22.0.0 cu NestJS 11.

Limbi suportate ​

TypeScript

Cadru de testare ​

Vitest

Recomandări speciale și detalii de implementare ​

  • Fiecare furnizor are nevoie de decoratorul @Injectable(). Omiterea acestuia duce la o eroare confuză de tipul Nest can't resolve dependencies la runtime.
  • Fiecare controller și furnizor trebuie înregistrat în tabloul controllers: [...] sau providers: [...] al unui modul. Dacă adaugi FooService dar uiți să îl listezi, NestJS nu îl va vedea.
  • Testele folosesc @nestjs/testing pentru a porni un mic TestingModule doar cu furnizorii de care are nevoie un controller — nu este nevoie să inițializezi întreaga aplicație.

Exemplu cu @nestjs/testing: ​

typescript
import 'reflect-metadata';
import { describe, it, expect, beforeEach } from 'vitest';
import { Test, TestingModule } from '@nestjs/testing';
import { AppController } from './src/app.controller';
import { AppService } from './src/app.service';

describe('AppController', () => {
  let controller: AppController;

  beforeEach(async () => {
    const moduleRef: TestingModule = await Test.createTestingModule({
      controllers: [AppController],
      providers: [AppService]
    }).compile();

    controller = moduleRef.get<AppController>(AppController);
  });

  it('returns "Hello, World!" on GET /', () => {
    expect(controller.getHello()).toBe('Hello, World!');
  });
});

Biblioteci incluse ​

Provocări write-tests ​

Acest șablon acceptă provocări write-tests. Soluția de referință este deja scrisă, iar tu scrii testele: acestea trebuie să treacă pe soluția de referință și să prindă fiecare bug ascuns. Run Tests (Rulează testele) îți rulează testele doar pe soluția de referință, iar Verify tests (Verifică testele) și Submit (Trimite) le rulează și pe copii ascunse ale ei, fiecare cu câte un bug. Citește Rezolvarea unei provocări write-tests pentru întregul flux.

  • Runner de teste: Vitest + @nestjs/testing
  • Începe fiecare fișier de test cu import 'reflect-metadata'; și construiește un modul de testare cu Test.createTestingModule, înregistrând fiecare controller și provider de care are nevoie unitatea testată.
  • Păstrează fișierele de test în rădăcină și denumește-le *.test.ts. Preview-ul web le exclude din build-ul Nest, așa că testele tale nu strică niciodată serverul care rulează.

Un exemplu complet găsești în Exemple de write-tests după șablon.

Cum se depanează ​

NestJS este un framework de backend — codul tău rulează în Node, nu în browser. Există trei moduri principale de a inspecta comportamentul la runtime:

1. Jurnale (logs) de la controllere și servicii ​

Folosește console.log sau utilitarul integrat Logger pentru o afișare structurată:

typescript
import { Controller, Get, Logger } from '@nestjs/common';

@Controller('items')
export class ItemsController {
  private readonly logger = new Logger(ItemsController.name);

  @Get()
  list() {
    this.logger.log('GET /items called');
    return [];
  }
}

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

2. API Tester ​

Folosește tab-ul API Tester din panoul din dreapta pentru a trimite cereri HTTP reale (GET / POST / PUT / PATCH / DELETE) către serverul tău NestJS aflat în funcțiune. Alege o metodă, scrie o cale (de exemplu, /items), adaugă antete/parametri/corp (headers/params/body) și apasă pe Send. Răspunsul (status, antete, corp, timp) se afișează în paralel, astfel încât să poți lucra la controllere și servicii fără a părăsi editorul.

3. Pași pentru depanare folosind console.log ​

  1. Identifică zona cu probleme: Determină dacă problema este în controller, într-un serviciu sau într-un furnizor personalizat.

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

  3. Verifică rezultatele testelor tale

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

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

Greșeli frecvente ​

  • Lipsa @Injectable() de pe un furnizor → DI eșuează cu o eroare confuză „Nest can't resolve dependencies”. Adaugă decoratorul la fiecare serviciu.
  • Ai uitat să înregistrezi în app.module.ts → controllerul sau furnizorul este invizibil pentru runtime. Adaugă-l în controllers: [...] sau providers: [...].
  • Eșecuri de teste cu Nest can't resolve dependencies în Test.createTestingModule(...) → listează fiecare furnizor de care are nevoie controllerul, chiar și în mod tranzitiv.