Validacija podataka u NestJS-u korišćenjem “Pipe”

Posted on 06/11/2024 at 11:28.Written by Dragoljub Živanović

Uvodu u Nest.js “Pipe”

Pipes u NestJS-u su specijalne komponente koje se koriste za transformaciju i validaciju podataka pre nego što stignu do kontrolera ili metoda kontrolera. Pipes su korisni kada želimo da osiguramo da podaci koje primamo u API zahtevima ispunjavaju određene uslove ili da se na specifičan način transformišu.

Nest.js dolazi sa ugrađenim pipes koji se mogu koristiti za transformaciju i validaciju podataka. Ugrađeni pipe-ovi, pružaju brza i efikasna rešenja za osnovne zadatke kao što su validacija i transformacija. Evo nekih ugrađeni pipes:

ValidationPipe: Automatska validacija podataka koristeći dekoratore.
ParseIntPipe: Automatska konverzija stringa u broj.
ParseBoolPipe: Automatska konverzija stringa u boolean.
ParseArrayPipe: Automatska konverzija stringa u niz.
ParseUUIDPipe: Automatska validacija UUID formata.
DefaultValuePipe: Postavljanje podrazumevane vrednosti ako vrednost nije definisana.

Međutim, ako su vaši zahtevi specifični, možete kreirati “custom pipe-ove” koristeći interfejs “PipeTransform”.

pipes

ValidationPipe

Ako se “ValidationPipe” koriste za DTO validaciju onda je potrebno da instaliramo dodatne biblioteke (kod drugih ugrađenih pipe-ove to nije potrebno). Ovo su dve neophodne biblioteke:

class-validator: Omogućava definisanje i proveru pravila validacije.
class-transformer: Transformiše ulazne podatke u instance klasa DTO-a.

Koristite sledeću komandu za instalaciju:

npm install class-validator class-transformer

1	npm install class-validator class-transformer

Šta je “class-transformer”?

“class-transformer” je TypeScript biblioteka koja omogućava pretvaranje (transformaciju) plain JavaScript objekata u instance klasa i obrnuto. Obično su to jednostavni JavaScript objekti (dobijeni, na primer, iz JSON-a) u instance definisanih klasa. Takođe omogućava dodavanje logike za prilagođene transformacije i rad sa ugneždenim strukturama objekata.

Primer: JS objekt u instancu klase

import { plainToClass } from 'class-transformer';

class User {
  firstName: string;
  lastName: string;
}

const plainObject = { firstName: 'John', lastName: 'Doe' };
const user = plainToClass(User, plainObject);

console.log(user instanceof User); // true

import { plainToClass } from 'class-transformer';

class User {

firstName: string;

lastName: string;

}

const plainObject = { firstName: 'John', lastName: 'Doe' };

const user = plainToClass(User, plainObject);

console.log(user instanceof User); // true

Primer: klasa u plain JS objekat

import { classToPlain } from 'class-transformer';

const user = new User();
user.firstName = 'John';
user.lastName = 'Doe';

const plainObject = classToPlain(user);
console.log(plainObject); // { firstName: 'John', lastName: 'Doe' }

import { classToPlain } from 'class-transformer';

const user = new User();

user.firstName = 'John';

user.lastName = 'Doe';

const plainObject = classToPlain(user);

console.log(plainObject); // { firstName: 'John', lastName: 'Doe' }

Šta je “class-validator”?

“class-validator” je TypeScript biblioteka koja omogućava definisanje i proveru pravila validacije za JavaScript objekte. Ova biblioteka koristi dekoratore za definisanje pravila validacije, kao što su provera tipova, dužine, minimalne i maksimalne vrednosti, obavezna polja, regularni izrazi i mnoga druga pravila.

Ovo su najčešće korišćeni:

@IsString(): Proverava da li je vrednost string.
@IsInt(): Proverava da li je vrednost integer.
@IsBoolean(): Proverava da li je vrednost boolean.
@IsEmail(): Proverava da li je vrednost validna email adresa.
@IsNotEmpty(): Proverava da li je vrednost prazna.
@MinLength(): Proverava minimalnu dužinu stringa.
@MaxLength(): Proverava maksimalnu dužinu stringa.
@Min(): Proverava minimalnu vrednost broja.
@Max(): Proverava maksimalnu vrednost broja.
@Matches(): Proverava da li vrednost odgovara regularnom izrazu.

Listu svih dekoratora možete pronaći na ovome linku.

Primer

import { IsString } from 'class-validator';

export class CreateUserDto {
  @IsString()
  name: string;
}

import { IsString } from 'class-validator';

export class CreateUserDto {

@IsString()

}

ValidationPipe opcije

Validation Pipe u NestJS-u ima nekoliko korisnih opcija za prilagođavanje ponašanja prilikom validacije. Ove opcije omogućavaju detaljniju kontrolu nad načinom na koji će validacija biti izvršena i pomažu pri rukovanju sa nepotrebnim ili nevalidnim podacima. U nastavku su objašnjene glavne opcije koje možete koristiti sa Validation Pipe-om.

a) Opcija whitelist

Opcija whitelist služi za automatsko uklanjanje svih svojstava koja nisu definisana u DTO (Data Transfer Object) klasi. Kada je ova opcija omogućena, svi dodatni podaci koji nisu eksplicitno definisani u DTO klasi biće ignorisani, čime se osigurava da samo željena svojstva budu obrađena.

Primer:

@UsePipes(new ValidationPipe({ whitelist: true }))
@Post()
createUser(@Body() createUserDto: CreateUserDto) {
    return createUserDto;
}

@UsePipes(new ValidationPipe({ whitelist: true }))

@Post()

createUser(@Body() createUserDto: CreateUserDto) {

return createUserDto;

}

b) Opcija forbidNonWhitelisted

Opcija forbidNonWhitelisted radi u kombinaciji sa whitelist. Kada je omogućena, ova opcija baca grešku svaki put kada se pojavi neko polje koje nije definisano u DTO klasi, umesto da ga samo ignoriše. Ovo je korisno ako želite striktno kontrolisati podatke i sprečiti prolazak bilo kakvih dodatnih informacija koje ne pripadaju zahtevanoj strukturi.

Primer:

@UsePipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
@Post()
createUser(@Body() createUserDto: CreateUserDto) {
    return createUserDto;
}

@UsePipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))

@Post()

createUser(@Body() createUserDto: CreateUserDto) {

return createUserDto;

}

c) Opcija transform

Opcija transform omogućava automatsko prebacivanje ulaznih podataka u instance DTO klasa. Kada je omogućena, ulazni podaci će se automatski transformisati u instancu DTO klase, što omogućava lakši pristup metodama i tipovima u okviru objekta.

Primer:

@UsePipes(new ValidationPipe({ transform: true }))
@Post()
createUser(@Body() createUserDto: CreateUserDto) {
    return createUserDto;
}

@UsePipes(new ValidationPipe({ transform: true }))

@Post()

createUser(@Body() createUserDto: CreateUserDto) {

return createUserDto;

}

ValidatePipe na nivou parametra

ValidationPipe se može primeniti na pojedinačni parametar rute za validaciju ulaznih podataka.

import { Controller, Get, Param, ValidationPipe } from '@nestjs/common';
import { IsUUID } from 'class-validator';

class FindUserDto {
  @IsUUID()
  id: string;
}

@Controller('users')
export class UsersController {
  @Get(':id')
  findOne(@Param('id', new ValidationPipe()) id: string) {
    return `User with ID: ${id}`;
  }
}

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

import { IsUUID } from 'class-validator';

class FindUserDto {

@IsUUID()

id: string;

}

@Controller('users')

export class UsersController {

@Get(':id')

findOne(@Param('id', new ValidationPipe()) id: string) {

return `User with ID: ${id}`;

}

Ako korisnik pošalje zahtev sa nevalidnim id (npr. nije UUID), API vraća grešku:

{
  "statusCode": 400,
  "message": ["id must be a UUID"],
  "error": "Bad Request"
}

{

"statusCode": 400,

"message": ["id must be a UUID"],

"error": "Bad Request"

}

ValidatePipe na nivou metode

Dekorator @UsePipes se koristi da primeni ValidationPipe na nivou metode kontrolera.

import { Controller, Post, Body, UsePipes, ValidationPipe } from '@nestjs/common';
import { IsString, IsInt, Min } from 'class-validator';

class CreateUserDto {
  @IsString()
  name: string;

  @IsInt()
  @Min(1)
  age: number;
}

@Controller('users')
export class UsersController {
  @Post()
  @UsePipes(ValidationPipe)
  createUser(@Body() createUserDto: CreateUserDto) {
    return `User created with name: ${createUserDto.name}, age: ${createUserDto.age}`;
  }
}

import { Controller, Post, Body, UsePipes, ValidationPipe } from '@nestjs/common';

import { IsString, IsInt, Min } from 'class-validator';

class CreateUserDto {

@IsString()

@IsInt()

@Min(1)

age: number;

}

@Controller('users')

export class UsersController {

@Post()

@UsePipes(ValidationPipe)

createUser(@Body() createUserDto: CreateUserDto) {

return `User created with name: ${createUserDto.name}, age: ${createUserDto.age}`;

}

Validan zahtev:

{
  "name": "John",
  "age": 25
}

{

"name": "John",

"age": 25

}

Nevalidan zahtev:

{
  "name": "",
  "age": -1
}

{

"name": "",

"age": -1

}

API odgovara sa greškom:

{
  "statusCode": 400,
  "message": [
    "name should not be empty",
    "age must not be less than 1"
  ],
  "error": "Bad Request"
}

{

"statusCode": 400,

"message": [

"name should not be empty",

"age must not be less than 1"

"error": "Bad Request"

}

ValidatePipe na nivou klase

Dekorator @UsePipes može se primeniti na klasu kontrolera, čime se ValidationPipe primenjuje na sve metode u okviru te klase.

import { Controller, Post, Body, UsePipes, ValidationPipe } from '@nestjs/common';
import { IsString, IsInt, Min } from 'class-validator';

class CreateUserDto {
  @IsString()
  name: string;

  @IsInt()
  @Min(1)
  age: number;
}

@UsePipes(ValidationPipe)
@Controller('users')
export class UsersController {
  @Post()
  createUser(@Body() createUserDto: CreateUserDto) {
    return `User created with name: ${createUserDto.name}, age: ${createUserDto.age}`;
  }

  @Post('update')
  updateUser(@Body() updateUserDto: CreateUserDto) {
    return `User updated with name: ${updateUserDto.name}, age: ${updateUserDto.age}`;
  }
}

import { Controller, Post, Body, UsePipes, ValidationPipe } from '@nestjs/common';

import { IsString, IsInt, Min } from 'class-validator';

class CreateUserDto {

@IsString()

@IsInt()

@Min(1)

age: number;

}

@UsePipes(ValidationPipe)

@Controller('users')

export class UsersController {

@Post()

createUser(@Body() createUserDto: CreateUserDto) {

return `User created with name: ${createUserDto.name}, age: ${createUserDto.age}`;

}

@Post('update')

updateUser(@Body() updateUserDto: CreateUserDto) {

return `User updated with name: ${updateUserDto.name}, age: ${updateUserDto.age}`;

}

Prednost: Svi zahtevi u okviru kontrolera automatski prolaze validaciju, što smanjuje potrebu za pojedinačnim deklarisanjem.

ValidatePipe na globalnom nivou

ValidationPipe se može registrovati kao globalni Pipe, čime se primenjuje na sve rute u aplikaciji.

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Globalna registracija ValidationPipe-a
  app.useGlobalPipes(new ValidationPipe({
    whitelist: true,
    forbidNonWhitelisted: true,
    transform: true,
  }));

  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);

// Globalna registracija ValidationPipe-a

app.useGlobalPipes(new ValidationPipe({

whitelist: true,

forbidNonWhitelisted: true,

transform: true,

}));

await app.listen(3000);

}

bootstrap();

Opcije za ValidationPipe:

whitelist: true – Automatski uklanja svojstva koja nisu definisana u DTO klasi.
forbidNonWhitelisted: true – Baca grešku ako se pojave nepoznata svojstva.
transform: true – Transformiše ulazne podatke u instance DTO klasa.

Prednost: Validacija se primenjuje automatski na sve zahteve, bez potrebe za deklarisanjem u svakom kontroleru.

Custom pipes

Ako su vaši zahtevi specifični, onda je nepohodno kreirati “custom pipe-ove”. Za kreiranje pipes, je potrebno:

Kreirate novu klasu koja implementira PipeTransform interfejs.
Implementirate metodu transform(), koja prima dva parametra:
- value: Ulazna vrednost koja dolazi iz zahteva.
- metadata: Informacije o vrednosti (opciono, sadrži podatke o tipu i dekoratorima).

Primer 1: Pipe za validaciju broja

Kreiramo Pipe koji proverava da li je ulazni string validan broj. Ako nije, baca grešku.

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

@Injectable()
export class ParseIntPipe implements PipeTransform {
  transform(value: any): number {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new BadRequestException('Validation failed: Not a number');
    }
    return val;
  }
}

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

@Injectable()

export class ParseIntPipe implements PipeTransform {

transform(value: any): number {

const val = parseInt(value, 10);

if (isNaN(val)) {

throw new BadRequestException('Validation failed: Not a number');

}

return val;

}

Korišćenje u kontroleru:

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

@Controller('users')
export class UsersController {
  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return `User with ID ${id}`;
  }
}

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

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

@Controller('users')

export class UsersController {

@Get(':id')

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

return `User with ID ${id}`;

}

Ako klijent pošalje zahtev na /users/123, vrednost 123 se uspešno konvertuje u broj.

Ako pošalje /users/abc, API baca grešku:

{
  "statusCode": 400,
  "message": "Validation failed: Not a number",
  "error": "Bad Request"
}

{

"statusCode": 400,

"message": "Validation failed: Not a number",

"error": "Bad Request"

}

Primer 2: Pipe za dozvoljene vrednosti

Pipe proverava da li je vrednost iz liste dozvoljenih vrednosti.

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

@Injectable()
export class AllowedValuesPipe implements PipeTransform {
  constructor(private readonly allowedValues: any[]) {}

  transform(value: any): any {
    if (!this.allowedValues.includes(value)) {
      throw new BadRequestException(`Value '${value}' is not allowed.`);
    }
    return value;
  }
}

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

@Injectable()

export class AllowedValuesPipe implements PipeTransform {

constructor(private readonly allowedValues: any[]) {}

transform(value: any): any {

if (!this.allowedValues.includes(value)) {

throw new BadRequestException(`Value '${value}' is not allowed.`);

}

return value;

}

Korišćenje u kontroleru:

import { Controller, Get, Query } from '@nestjs/common';
import { AllowedValuesPipe } from './allowed-values.pipe';

@Controller('products')
export class ProductsController {
  @Get()
  findByType(@Query('type', new AllowedValuesPipe(['electronics', 'furniture'])) type: string) {
    return `Products of type: ${type}`;
  }
}

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

import { AllowedValuesPipe } from './allowed-values.pipe';

@Controller('products')

export class ProductsController {

@Get()

findByType(@Query('type', new AllowedValuesPipe(['electronics', 'furniture'])) type: string) {

return `Products of type: ${type}`;

}

Validan zahtev: /products?type=electronics

Nevalidan zahtev: /products?type=clothing

{
  "statusCode": 400,
  "message": "Value 'clothing' is not allowed.",
  "error": "Bad Request"
}

{

"statusCode": 400,

"message": "Value 'clothing' is not allowed.",

"error": "Bad Request"

}

Primer 3: Pipe za transformaciju u veliki tekst

Pipe transformiše string u uppercase.

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

@Injectable()
export class UppercasePipe implements PipeTransform {
  transform(value: string): string {
    return value.toUpperCase();
  }
}

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

@Injectable()

export class UppercasePipe implements PipeTransform {

transform(value: string): string {

return value.toUpperCase();

}

Korišćenje u kontroleru:

import { Controller, Post, Body } from '@nestjs/common';
import { UppercasePipe } from './uppercase.pipe';

@Controller('messages')
export class MessagesController {
  @Post()
  createMessage(@Body('text', UppercasePipe) text: string) {
    return `Message: ${text}`;
  }
}

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

import { UppercasePipe } from './uppercase.pipe';

@Controller('messages')

export class MessagesController {

@Post()

createMessage(@Body('text', UppercasePipe) text: string) {

return `Message: ${text}`;

}

Ulaz: {“text”: “hello world”}

Izlaz: Message: HELLO WORLD

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}`;

}