Nest.js kontroleri

Posted on 06/08/2024 at 09:22.Written by Dragoljub Živanović

Šta su kontroleri?

Kontroleri u Nest.js su klasične TypeScript klase koje su dekorisane @Controller() dekoratorom. U ovakvim klasama se definišu metode koji odgovaraju HTTP operacijama kao što su GET, POST, PUT, DELETE, gde je svaki metod u okviru kontrolera dekorisan odgovarajućim HTTP dekoratorom.

Primer jednostavnog kontrolera:

import { Controller, Get, Post, Body, Param } from '@nestjs/common';

@Controller('users')
export class UsersController {
private users = [];

@Get()
findAll(): any[] {
return this.users;
}

@Get(':id')
findOne(@Param('id') id: string): any {
return this.users.find(user => user.id === id);
}

@Post()
create(@Body() user: any): string {
this.users.push(user);
return 'User created successfully';
}
}

import { Controller, Get, Post, Body, Param } from '@nestjs/common';

@Controller('users')

export class UsersController {

private users = [];

@Get()

findAll(): any[] {

return this.users;

}

@Get(':id')

findOne(@Param('id') id: string): any {

return this.users.find(user => user.id === id);

}

@Post()

create(@Body() user: any): string {

this.users.push(user);

return 'User created successfully';

}

U ovom primeru @Controller('users') dekorator definiše osnovnu rutu (“/users“) za sve metode unutar kontrolera. Ovaj kontroler iz primera ima tri metode za tri tipa zahteva, i sve tri metode su obeležene sa odgovajućim dekoratorima u zavisnosti od tipa HTTP zahteva koji obrađuju:

findAll(): Obradjuje GET zahtev na ruti /users i vraća listu svih korisnika.
findOne(): Obradjuje GET zahtev na ruti /users/:id i vraća korisnika sa zadatim ID-om.
create(): Obradjuje POST zahtev na ruti /users i kreira novog korisnika.

Kreiranje kontrolera

Da biste dodali kontroler u modul, najlakše je koristiti sledeće komande u terminalu:

nest generate controller users

1	nest generate controller users

Ova komanda će generisati users.controller.ts fajl u okviru novog foldera “users” i njega će smestiti u root projekta tj. src/users:

import { Controller } from '@nestjs/common';

@Controller('users')
export class UsersController {}

import { Controller } from '@nestjs/common';

@Controller('users')

export class UsersController {}

NAPOMENA:
Ako ne postoji direktorijum pod nazivom “users” ova komanda će i njega napraviti. Ukoliko ipak ne želimo da napravimo folder pod nazivom kontrolera već samo kontroler fajl, onda koristimo flag --flat.

nest generate controller nekiKontroler --flat

1	nest generate controller nekiKontroler --flat

Prethodna naredba će napraviti u root direktorijumu (“src”) samo fajl vezan za kontroler nekiKontroler.controller.ts, takodje postoji način da kreiramo novi kontroler fajl u već postojeći folder, a za to koristimo sledeću sintaksu:

nest generate controller nekiFolder/noviKontroler --flat

1	nest generate controller nekiFolder/noviKontroler --flat

Sa ovom naredbom će biti kreiran fajl “noviKontroler.controller.ts” u okviru foldera pod nazivom “nekiFolder”.

Naredba će pored toga će istovremeno dodati taj kontroler i u modul u okviru liste svih kontrolera:

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UsersController } from './cats/Users.controller';

@Module({
  imports: [],
  controllers: [AppController, UsersController],
  providers: [AppService],
})
export class AppModule {}

import { Module } from '@nestjs/common';

import { AppController } from './app.controller';

import { AppService } from './app.service';

import { UsersController } from './cats/Users.controller';

@Module({

imports: [],

controllers: [AppController, UsersController],

providers: [AppService],

})

export class AppModule {}

Dekoratori za pristup podacima request-a

Pored dekoratora za obeležavanje tipa request-a (@Get(), @Post()…), postoje i dekoratori za lakši pristup podacima zahteva. Ovi dekoratori olakšavaju rad sa različitim delovima HTTP zahteva i omogućavaju jednostavno i čitljivo rukovanje zahtevima unutar kontrolera:

@Param('id'): Omogućava pristup parametru id iz URL-a
@Body(): Omogućava pristup telu POST zahteva.
@Headers() omogućava pristup HTTP zaglavljima.
@Ip() omogućava pristup IP adresi klijenta.
@Body() omogućava pristup telu POST zahteva.
@Session() omogućava pristup sesijskim podacima.
@Cookies() omogućava pristup kolačićima.
@HostParam('host') omogućava pristup parametrima hosta.

Primer

Evo kako možete koristiti neke od ovih dekoratora u kontroleru:

import { Controller, Get, Post, Body, Param, Query, Headers, Session, Ip, HostParam } from '@nestjs/common';

@Controller('example')
export class ExampleController {

    //URL: http://localhost:3000/example/123?search=test

    @Get(':id')
    findOne(
      @Param('id') id: string,
      @Query() query: any,
      @Ip() ip: string
    ): string {
        console.log('Query:', query);           // Query: { search: 'test' }
        console.log('IP Address:', ip);         // IP Address: 127.0.0.1
        return `User with id ${id}`;            // User with id 123
    }

    // URL: http://localhost:3000/example

    @Post()
    create(
      @Body() body: any, 
      @Session() session: any, 
      @Cookies() cookies: any): string {
    console.log('Body:', body);             // Body: { name: 'John Doe' }
    console.log('Session:', session);       // Session: { ... }  // sesijski podaci, ako su prisutni
    console.log('Cookies:', cookies);       // Cookies: { ... }  // podaci iz kolačića, ako su prisutni
    return 'User created successfully';
    }

    // URL: http://subdomain.example.com:3000/example

    @Get()
    findWithHostParam(
      @HostParam('host') host: string): string {
    console.log('Host:', host);             // Host: subdomain.example.com
    return `Host is ${host}`;
    }
}

import { Controller, Get, Post, Body, Param, Query, Headers, Session, Ip, HostParam } from '@nestjs/common';

@Controller('example')

export class ExampleController {

//URL: http://localhost:3000/example/123?search=test

@Get(':id')

findOne(

@Param('id') id: string,

@Query() query: any,

@Ip() ip: string

): string {

console.log('Query:', query); // Query: { search: 'test' }

console.log('IP Address:', ip); // IP Address: 127.0.0.1

return `User with id ${id}`; // User with id 123

}

// URL: http://localhost:3000/example

@Post()

create(

@Body() body: any,

@Session() session: any,

@Cookies() cookies: any): string {

console.log('Body:', body); // Body: { name: 'John Doe' }

console.log('Session:', session); // Session: { ... } // sesijski podaci, ako su prisutni

console.log('Cookies:', cookies); // Cookies: { ... } // podaci iz kolačića, ako su prisutni

return 'User created successfully';

}

// URL: http://subdomain.example.com:3000/example

@Get()

findWithHostParam(

@HostParam('host') host: string): string {

console.log('Host:', host); // Host: subdomain.example.com

return `Host is ${host}`;

}

U prethodnom primeru dekorator @Get označava da će metoda findOne() odgovoriti na zahtev. Dekorator @Param(‘id’) izvlači parametar pod imenom “id” iz URL-a zahteva, dok dekorator @Query() izvlači sve query parametre iz URL-a zahteva i čuva ih u objektu “query” (npr. za URL /users/123?search=test, query će biti { search: ‘test’ }). Dekorator @Ip() obezbedjuje IP adresu klijenta koji je poslao zahtev.

Dostupnost servisa u kontrolerima

Servisi se koriste za enkapsulaciju poslovne logike i omogućavaju ponovnu upotrebu koda. Servisi se mogu lako uvesti u kontrolere korišćenjem mehanizma za injekciju zavisnosti (dependency injection) koji pruža Nest.js. U Nest.js postoji nekoliko načina za injekciju servisa u kontroler.

Injectovanje servisa kroz konstruktor

Najčešći način je putem konstruktora, kao što je prikazano u sledećem primeru:

import { Controller, Get, Post, Body, Param } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  findAll(): any[] {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string): any {
    return this.usersService.findOne(id);
  }

  @Post()
  create(@Body() user: any): string {
    return this.usersService.create(user);
  }
}

import { Controller, Get, Post, Body, Param } from '@nestjs/common';

import { UsersService } from './users.service';

@Controller('users')

export class UsersController {

constructor(private readonly usersService: UsersService) {}

@Get()

findAll(): any[] {

return this.usersService.findAll();

}

@Get(':id')

findOne(@Param('id') id: string): any {

return this.usersService.findOne(id);

}

@Post()

create(@Body() user: any): string {

return this.usersService.create(user);

}

U ovom primeru, UsersController koristi UsersService za obradu zahteva. Servis se ubacuje u kontroler kroz konstruktor.

Injektovanje servisa kroz svojstvo

Iako nije toliko često korišćena, moguća je i injekcija servisa putem svojstava koristeći dekorator @Inject.

import { Controller, Get, Post, Body, Param, Inject } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  @Inject(UsersService)
  private readonly usersService: UsersService;

  @Get()
  findAll(): any[] {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string): any {
    return this.usersService.findOne(id);
  }

  @Post()
  create(@Body() user: any): string {
    return this.usersService.create(user);
  }
}

import { Controller, Get, Post, Body, Param, Inject } from '@nestjs/common';

import { UsersService } from './users.service';

@Controller('users')

export class UsersController {

@Inject(UsersService)

private readonly usersService: UsersService;

@Get()

findAll(): any[] {

return this.usersService.findAll();

}

@Get(':id')

findOne(@Param('id') id: string): any {

return this.usersService.findOne(id);

}

@Post()

create(@Body() user: any): string {

return this.usersService.create(user);

}

NAPOMENA:
Takodje postoji i “Manuelna injekcija” servisa ali je prilično komplikovana a koristi se samo u specifičnim slučajevima kada ne možete koristiti konstruktorsku ili property-based injekciju. Ovaj pristup koristi ModuleRef, koji omogućava pristup Nest.js Dependency Injection (DI) kontejneru za ručno dobijanje instanci servisa.

Uvod u Nest.js

Posted on 29/07/2024 at 11:25.Written by Dragoljub Živanović

Šta je Nest.js?

Nest.js je Node.js framework za izradu server-side aplikacija. Koristi modularnu arhitekturu što podrazumeva da se aplikacija deli na module, gde svaki modul grupiše povezane funkcionalnost, tako da se lako mogu dodati nove funkcionalnosti bez narušavanja postojećih delova aplikacije.

Nest.js korisi TypeScript jezik (mada se može koristiti i JavaScript), uz korišćenje dekoratora (dekoratori su specijalne oznake koje se dodaju iznad koda sa kojima definišemo dodatna uputstva). Pored HTTP-a, Nest.js podržava WebSockets, GraphQL, gRPC i druge protokole.

Moduli

U Nest.js, moduli su osnovni gradivni blokovi aplikacije i služe za organizaciju i strukturu koda. Oni grupišu povezane komponente kao što su kontroleri, provajderi (servisi), repozitorijumi i drugi moduli u logične jedinice. Moduli se definišu pomoću @Module() dekoratora.

Polja Modula:

imports: Lista modula koji su uvezeni u trenutni modul. Ovi moduli su dostupni unutar modula.
controllers: Lista kontrolera definisanih u modulu. Kontroleri su zaduženi za rukovanje HTTP zahtevima.
providers: Lista provajdera (servisa) definisanih u modulu. Provajderi obavljaju poslovnu logiku i mogu biti injektovani u kontrolere ili druge provajdere.
exports: Lista provajdera koji su eksportovani iz modula i mogu biti korišćeni u drugim modulima.

Kreiranje modula

Korišćenjem Nest CLI, možete brzo i jednostavno kreirati module u vašoj Nest.js aplikaciji. Da biste kreirali novi modul, možete koristiti nest generate (ili skraćeno nest g) komandu. Na primer, da biste kreirali modul pod nazivom cats, koristite sledeću komandu:

nest generate module cats

1	nest generate module cats

Ova komanda će generisati novu datoteku cats.module.ts u src/cats direktorijumu, koja izgleda ovako:

import { Module } from '@nestjs/common';

@Module({})
export class CatsModule {}

import { Module } from '@nestjs/common';

@Module({})

export class CatsModule {}

Primer Modula

Evo kako se definiše jednostavan modul u Nest.js:

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  imports: [], // Ovaj modul ne uvozi nijedan drugi modul
  controllers: [CatsController], // Definiše CatsController kao kontroler u ovom modulu
  providers: [CatsService], // Definiše CatsService kao provajder u ovom modulu
  exports: [CatsService], // Eksplicitno eksportuje CatsService za upotrebu u drugim modulima
})
export class CatsModule {}

import { Module } from '@nestjs/common';

import { CatsController } from './cats.controller';

import { CatsService } from './cats.service';

@Module({

imports: [], // Ovaj modul ne uvozi nijedan drugi modul

controllers: [CatsController], // Definiše CatsController kao kontroler u ovom modulu

providers: [CatsService], // Definiše CatsService kao provajder u ovom modulu

exports: [CatsService], // Eksplicitno eksportuje CatsService za upotrebu u drugim modulima

})

export class CatsModule {}

Glavni Modul (App Module)

Svaka Nest.js aplikacija ima glavni modul, obično nazvan AppModule, koji je korenski modul aplikacije. On može uvoziti druge module i služi kao ulazna tačka za aplikaciju.

import { Module } from '@nestjs/common';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule], // Uvozi CatsModule u glavni modul
})
export class AppModule {}

import { Module } from '@nestjs/common';

import { CatsModule } from './cats/cats.module';

@Module({

imports: [CatsModule], // Uvozi CatsModule u glavni modul

})

export class AppModule {}

Controllers (Kontroleri)

Kontroleri su odgovorni za rukovanje HTTP zahtevima i vraćanje odgovarajućih odgovora klijentima. U Nest.js, kontroleri služe kao posrednici između klijenta i servisa. Oni definišu rute i metode koje se aktiviraju kada se određene rute pogode. Kontroleri se obeležavaju pomoću @Controller() dekoratora. Dekorartori se takodje koriste i u okviru samog kontrolera da obeleže specifične metode ili rute kao što su: @Get(), @Post(), @Put(), @Delete(), itd.

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

@Controller('cats')
export class CatsController {
  @Get()
  findAll(): string {
    return 'This action returns all cats';
  }
}

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

@Controller('cats')

export class CatsController {

@Get()

findAll(): string {

return 'This action returns all cats';

}

U ovom primeru, CatsController ima jednu rutu koja odgovara na GET zahteve na /cats i vraća string ‘This action returns all cats’.

Dodavanje kontrolera u modul

Nakon kreiranja kontrolera ili servisa, potrebno je ažurirati modul da ih uključi:

Primer

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';

@Module({
  controllers: [CatsController],
  providers: [],
})
export class CatsModule {}

import { Module } from '@nestjs/common';

import { CatsController } from './cats.controller';

@Module({

controllers: [CatsController],

providers: [],

})

export class CatsModule {}

Services (Servisi)

Servisi predstavljaju sloj aplikacije koji obavlja poslovnu logiku i obezbeđuje podatke za kontrolere. Servisi obično sadrže metode koje se koriste za obavljanje različitih zadataka kao što su pristup bazi podataka, rad sa API-jevima trećih strana, obrada podataka i sl.

Definisanje servisa: Servisi se definišu kao klase i obično koriste @Injectable() dekorator kako bi ih Nest.js mogao injektovati u kontrolere ili druge servise.
Injekcija zavisnosti: Servisi se mogu ubaciti (injektovati) u kontrolere ili druge servise koristeći konstruktor.

Kreiranje servisa

Da biste dodali novi servis, koristite nest generate service (ili skraćeno nest g service) komandu.

nest generate service cats

1	nest generate service cats

Ova komanda će generisati cats.service.ts datoteku u src/cats direktorijumu sa osnovnom implementacijom servisa:

import { Injectable } from '@nestjs/common';

@Injectable()
export class CatsService {
 private readonly cats = ['Cat1', 'Cat2'];
 
 findAll(): string[] {
   return this.cats;
 }
}

import { Injectable } from '@nestjs/common';

@Injectable()

export class CatsService {

private readonly cats = ['Cat1', 'Cat2'];

findAll(): string[] {

return this.cats;

}

Dodavanje servisa u modul

Kada kreirate novi servis pomoću komande nest generate service cats, Nest CLI će automatski ažurirati odgovarajući modul da uključi novokreirani servis u providers polje tog modula. Ovo omogućava da servis bude dostupan u okviru modula bez dodatne manuelne intervencije.

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}

import { Module } from '@nestjs/common';

import { CatsController } from './cats.controller';

import { CatsService } from './cats.service';

@Module({

controllers: [CatsController],

providers: [CatsService],

})

export class CatsModule {}

Primer:

import { Injectable } from '@nestjs/common';

@Injectable()
export class UsersService {
  private readonly users = ['User1', 'User2'];

  findAll(): string[] {
    return this.users;
  }
}

import { Injectable } from '@nestjs/common';

@Injectable()

export class UsersService {

private readonly users = ['User1', 'User2'];

findAll(): string[] {

return this.users;

}

U ovom primeru, UsersService ima metodu findAll koja vraća listu korisnika.

Middleware

Middleware su funkcije koje se izvršavaju tokom obrade HTTP zahteva. Middleware funkcioniše u prostoru između primanja zahteva i povratka odgovora, omogućavajući modifikaciju zahteva i odgovora, preusmeravanje toka ili završavanje zahteva. U Nest.js, middleware se definiše kao klase koje implementiraju NestMiddleware interfejs ili kao obične funkcije. Middleware se može primeniti na određene rute ili globalno na sve rute.

Kreiranje middleware-a

Da biste dodali novi middleware, koristite nest generate middleware (ili skraćeno nest g middleware) komandu.

nest generate middleware logger

1	nest generate middleware logger

Ova komanda će generisati logger.middleware.ts datoteku u src direktorijumu sa osnovnom implementacijom middleware-a:

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`Request...`);
    next();
  }
}

import { Injectable, NestMiddleware } from '@nestjs/common';

import { Request, Response, NextFunction } from 'express';

@Injectable()

export class LoggerMiddleware implements NestMiddleware {

use(req: Request, res: Response, next: NextFunction) {

console.log(`Request...`);

next();

}

U ovom primeru, LoggerMiddleware loguje svaki zahtev koji prolazi kroz aplikaciju.

Registrovanje middleware-a u modul:

Da biste registrovali middleware, potrebno je da ga dodate u odgovarajući modul.

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common'; @Module({}) export class AppModule implements NestModule { configure(consumer: MiddlewareConsumer) { consumer .apply(LoggerMiddleware) .forRoutes('users'); } }

1
2
3
4
5
6
7
8
9
10

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';

@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('users');
  }
}

U ovom primeru, LoggerMiddleware će se primenjivati na sve zahteve koji idu na /users rutu.

Providers (Provajderi)

Nest.js ima ugrađen mehanizam za injektiranje zavisnosti, koji olakšava upravljanje zavisnostima i testiranje koda. Ovo znači da komponente kao što su usluge (services) mogu biti automatski ubačene (injected) tamo gde su potrebne, umesto da ih eksplicitno instancirate. Više o dependency injection-u pročitajte u članku “Šta je Dependency Injection”.

Provajderi su osnovni koncept u Nest.js koji omogućavaju kreiranje i deljenje instanci objekata. Obično se koriste za implementaciju servisa, ali mogu takođe obuhvatati bilo koju klasu koju želite da bude dostupna putem Dependency Injection (DI) mehanizma tj. provajderi mogu biti servisi, repozitorijumi, fabričke funkcije, itd.

Obležavanje provajdera

Provajderi se obeležavaju kao klase koje koriste @Injectable() dekorator.

Primer

import { Injectable } from '@nestjs/common';

@Injectable()
export class CatsService {
 private readonly cats = ['Cat1', 'Cat2', 'Cat3'];

 findAll(): string[] {
   return this.cats;
 }
}

import { Injectable } from '@nestjs/common';

@Injectable()

export class CatsService {

private readonly cats = ['Cat1', 'Cat2', 'Cat3'];

findAll(): string[] {

return this.cats;

}

U ovom primeru, CatsService je provajder definisan sa @Injectable() dekoratorom.

Registrovanje provajdera

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
 controllers: [CatsController],
 providers: [CatsService],
})
export class CatsModule {}

import { Module } from '@nestjs/common';

import { CatsController } from './cats.controller';

import { CatsService } from './cats.service';

@Module({

controllers: [CatsController],

providers: [CatsService],

})

export class CatsModule {}

U ovom primeru, CatsService je registrovan kao provajder u CatsModule.

Injectovanje provajdera

Provajderi se mogu ubaciti (injektovati) u druge klase ili provajdere koristeći konstruktor.

Primer

import { Controller, Get } from '@nestjs/common';
import { CatsService } from './cats.service';

@Controller('cats')
export class CatsController {
 constructor(private readonly catsService: CatsService) {}

 @Get()
 findAll(): string[] {
   return this.catsService.findAll();
 }
}

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

import { CatsService } from './cats.service';

@Controller('cats')

export class CatsController {

constructor(private readonly catsService: CatsService) {}

@Get()

findAll(): string[] {

return this.catsService.findAll();

}

Repozitorijum

Repozitorijumi su sloj koji omogućava pristup podacima i upravljanje njima. Oni apstrahuju interakciju sa bazom podataka ili bilo kojim drugim izvorom podataka, čime omogućavaju čistiji i konzistentniji kod. Koriste se za obavljanje CRUD operacija (kreiranje, čitanje, ažuriranje, brisanje).

Primer

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserRepository {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

  findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  findOne(id: number): Promise<User> {
    return this.userRepository.findOneBy({ id });
  }

  create(user: User): Promise<User> {
    return this.userRepository.save(user);
  }

  async remove(id: number): Promise<void> {
    await this.userRepository.delete(id);
  }
}

import { Injectable } from '@nestjs/common';

import { InjectRepository } from '@nestjs/typeorm';

import { Repository } from 'typeorm';

import { User } from './user.entity';

@Injectable()

export class UserRepository {

constructor(

@InjectRepository(User)

private readonly userRepository: Repository<User>,

) {}

findAll(): Promise<User[]> {

return this.userRepository.find();

}

findOne(id: number): Promise<User> {

return this.userRepository.findOneBy({ id });

}

create(user: User): Promise<User> {

return this.userRepository.save(user);

}

async remove(id: number): Promise<void> {

await this.userRepository.delete(id);

}

U ovom primeru, UserRepository koristi TypeORM repozitorijum za interakciju sa User entitetom.

Exception Filters

Exception filters su kao sigurnosne mreže u programu koje hvataju greške i odlučuju šta da urade s njima. Kada se nešto neočekivano desi u aplikaciji, exception filteri omogućavaju da se uhvate greške i vrati odgovarajuća poruka korisniku. Exception filters omogućavaju da centralizovano rukujemo greškama i ukidaju potrebu da se svuda po kodu pišu akcije koje bi hendlovale greške.

Korak 1: Definisanje Exception Filtera

Definišemo filter koristeći @Catch() dekorator. Ovo je jednostavan primer filtera koji hvata sve greške:

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception instanceof HttpException ? exception.getStatus() : 500;

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';

import { Request, Response } from 'express';

@Catch()

export class AllExceptionsFilter implements ExceptionFilter {

catch(exception: unknown, host: ArgumentsHost) {

const ctx = host.switchToHttp();

const response = ctx.getResponse<Response>();

const request = ctx.getRequest<Request>();

const status = exception instanceof HttpException ? exception.getStatus() : 500;

response.status(status).json({

statusCode: status,

timestamp: new Date().toISOString(),

path: request.url,

});

}

Korak 2: Korišćenje Exception Filtera

Možemo primeniti filter na različitim nivoima: globalno (za celu aplikaciju), na nivou kontrolera ili na nivou pojedinačnih ruta.

Primena na Globalnom Nivou

Da bi filter radio za celu aplikaciju, dodaćemo ga u glavni fajl aplikacije (npr. main.ts):

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { AllExceptionsFilter } from './all-exceptions.filter';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new AllExceptionsFilter());
  await app.listen(3000);
}
bootstrap();

import { NestFactory } from '@nestjs/core';

import { AppModule } from './app.module';

import { AllExceptionsFilter } from './all-exceptions.filter';

async function bootstrap() {

const app = await NestFactory.create(AppModule);

app.useGlobalFilters(new AllExceptionsFilter());

await app.listen(3000);

}

bootstrap();

Primena na Nivou Kontrolera

Da bi filter radio samo za određeni kontroler, dodamo @UseFilters dekorator iznad kontrolera:

import { Controller, Get, UseFilters } from '@nestjs/common';
import { AllExceptionsFilter } from './all-exceptions.filter';

@Controller('cats')
@UseFilters(AllExceptionsFilter)
export class CatsController {
  @Get()
  findAll() {
    throw new Error('This is an error');
  }
}

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

import { AllExceptionsFilter } from './all-exceptions.filter';

@Controller('cats')

@UseFilters(AllExceptionsFilter)

export class CatsController {

@Get()

findAll() {

throw new Error('This is an error');

}

Primena na Nivou Pojedinačnih Ruta

Da bi filter radio samo za određenu rutu, dodamo @UseFilters dekorator iznad te rute:

import { Controller, Get, UseFilters } from '@nestjs.common';
import { AllExceptionsFilter } from './all-exceptions.filter';

@Controller('cats')
export class CatsController {
  @Get()
  @UseFilters(AllExceptionsFilter)
  findAll() {
    throw new Error('This is an error');
  }
}

import { Controller, Get, UseFilters } from '@nestjs.common';

import { AllExceptionsFilter } from './all-exceptions.filter';

@Controller('cats')

export class CatsController {

@Get()

@UseFilters(AllExceptionsFilter)

findAll() {

throw new Error('This is an error');

}

Pipes

Pipes u Nest.js su moćan alat koji omogućava transformaciju i validaciju podataka. Pipes mogu da transformišu dolazne podatke, verifikuju ih i čak odbace nevažeće podatke. To omogućava da se logika za transformaciju i validaciju centralizuje i lako ponovo koristi.

Kreiranje Pipes-a

Pipe se kreira implementirajući PipeTransform interfejs i definišući metodu transform koja će obraditi podatke.

Primer

U ovome primeru pipe koji konvertuje dolazni string u broj:

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class ParseIntPipe implements PipeTransform<string, number> {
  transform(value: string, metadata: ArgumentMetadata): number {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new BadRequestException('Validation failed');
    }
    return val;
  }
}

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()

export class ParseIntPipe implements PipeTransform<string, number> {

transform(value: string, metadata: ArgumentMetadata): number {

const val = parseInt(value, 10);

if (isNaN(val)) {

throw new BadRequestException('Validation failed');

}

return val;

}

Korišćenje Pipes-a

Pipes možete primeniti na globalnom nivou, nivou kontrolera ili nivou rute.

Globalna Primena

Globalno primenjivanje pipes-a koristi se u glavnom fajlu aplikacije (npr. main.ts):

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe());
  await app.listen(3000);
}
bootstrap();

import { NestFactory } from '@nestjs/core';

import { AppModule } from './app.module';

import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {

const app = await NestFactory.create(AppModule);

app.useGlobalPipes(new ValidationPipe());

await app.listen(3000);

}

bootstrap();

Primena na Kontroleru

Možete primeniti pipes na specifičan kontroler koristeći @UsePipes() dekorator:

import { Controller, Get, UsePipes, Param } from '@nestjs.common';
import { ParseIntPipe } from './parse-int.pipe';

@Controller('cats')
export class CatsController {
  @Get(':id')
  @UsePipes(ParseIntPipe)
  findOne(@Param('id') id: number) {
    return `This action returns a cat with id ${id}`;
  }
}

import { Controller, Get, UsePipes, Param } from '@nestjs.common';

import { ParseIntPipe } from './parse-int.pipe';

@Controller('cats')

export class CatsController {

@Get(':id')

@UsePipes(ParseIntPipe)

findOne(@Param('id') id: number) {

return `This action returns a cat with id ${id}`;

}

Primena na Ruti

Možete primeniti pipes na specifičnu rutu:

import { Controller, Get, Param } from '@nestjs.common';
import { ParseIntPipe } from './parse-int.pipe';

@Controller('cats')
export class CatsController {
  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return `This action returns a cat with id ${id}`;
  }
}

import { Controller, Get, Param } from '@nestjs.common';

import { ParseIntPipe } from './parse-int.pipe';

@Controller('cats')

export class CatsController {

@Get(':id')

findOne(@Param('id', ParseIntPipe) id: number) {

return `This action returns a cat with id ${id}`;

}