티포의개발일지

우리가 만약 getOne으로 데이터를 찾고자 하는데 실수로 입력을 했다고 치면 데이터가 없는지, 어떤 오류가 있는지 에러 핸들링을 해주어야 한다.

movies.service.ts

    getOne(id:string): Movie {
        
        const movie = this.movies.find(movie => movie.id === parseInt(id));
        if(!movie) {
            throw new NotFoundException(" ID가 존재하지 않습니다. ")
        }

        return movie;

    }

이런 식으로  getOne부분에 movie가 존재하지 않을 경우 error를 내보내도록 했다.

실제로 postman에서 request를 보내보면

이런식으로 에러가 뜨는 것을 확인할 수 있다.

방금 만든 getOne() 함수로 우리가 데이터를 삭제할 때 해당 Id를 가지고 있는 Movie가 존재하는지 먼저 확인해 볼 수 있고 에러 처리를 할 수도 있다. 때문에 코드가 더 깔끔해진다.

    deleteOne(id:string) {
        this.getOne(id)
        this.movies = this.movies.filter(movie => movie.id !== parseInt(id))
    }

이번엔 update service를 만들어보자. 먼저, Controller 부분을 바꿔주자.

    @Patch('/:id')
    patch(@Param('id') movieId:string, @Body() updateData) {
        return this.moviesService.update(movieId,updateData)
    }

아직 Service부분에서 update 함수를 선언하지 않았기 때문에 당연히 에러가 뜬다. Service부분을 보자.

movies.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { NotFoundError } from 'rxjs';
import { Movie } from './entities/movie.entity';

@Injectable()
export class MoviesService {
    private movies: Movie[] = [];

    getAll(): Movie[] {
        return this.movies;
    }

    getOne(id:string): Movie {
        
        const movie = this.movies.find(movie => movie.id === parseInt(id));
        if(!movie) {
            throw new NotFoundException(" ID가 존재하지 않습니다. ")
        }

        return movie;

    } 

    deleteOne(id:string) {
        this.getOne(id)
        this.movies = this.movies.filter(movie => movie.id !== parseInt(id))
    }

    create(movieData) {
        this.movies.push({
            id: this.movies.length + 1,
            ...movieData
        })
        return true;
    }

    update(id: string, updateData) {
        const movie = this.getOne(id);
        this.deleteOne(id)
        this.movies.push({ ...movie, ...updateData})
    }

}

postman에서 실행해보면 정상작동하는것을 확인할 수 있다.

REST API를 개발할 때, 여러 메소드로 실험을 해보는것이 좋다.

그러기 위해 있는 좋은 프로그램이 postman이라는 프로그램이다.

먼저 사이트에서 다운을 받는다.

https://www.postman.com/downloads/

그 다음 계정을 생성한다.

My Workspace에 들어간다.

우측 상단에 New를 클릭한다.

HTTP Request를 클릭한다.

원하는 URL을 추가해주고 동작을 할 수 있다.

Service는 movie의 로직을 관리하는 역할을 맡을 것이다. Controller가 URL을 받아오면, 원하는 비즈니스 로직을

실행해준다. ( DB 작업 등이 이곳에서 이루어질 것이다. )

먼저 Controller를 만들었던것과 같이 Service를 만들어보자.

nest g s

그럼, 이름을 입력하라고 하는데, Controller와 같은 movies로 만들어보겠다.

이렇게 실행을 해주면!

위와 같이 자동으로 파일들이 생성되고, 루트 모듈에서 선언되는것을 확인 할 수 있다. ( 매우 편리한 기능! )

위에서 말했듯이 Service에선 주로 DB작업등과 같은 로직을 실행하는데, 이 강의에서는 실제DB를 다루는 것은 하진 않는다. 내 블로그에 있는 MongoDB 파트를 완벽히 이해하면 충분히 할 수 있을 것이다.

먼저, src 폴더 아래 다음과 같이 파일을 생성해준다.

그 다음 Movie class를 만들어준다.

movie.entity.ts

export class Movie {
    id: number;
    title: string;
    year: number;
    genres: string[];
}

이 class를 Service 파일에서 가져온다.

movie.service.ts

import { Injectable } from '@nestjs/common';
import { Movie } from './entities/movie.entity';

@Injectable()
export class MoviesService {
    private movies: Movie[] = [];
}

그 다음  Controller에서 쓸 함수를 정의한다. 이 때 이름은 중복되어도 상관이 없다.

movie.service.ts

import { Injectable } from '@nestjs/common';
import { Movie } from './entities/movie.entity';

@Injectable()
export class MoviesService {
    private movies: Movie[] = [];

    getAll(): Movie[] {
        return this.movies;
    }

    getOne(id:string): Movie {
        return this.movies.find(movie => movie.id === parseInt(id));
    } 
}

DB에 접근해서 모든 Movie를 조회하는 함수와 id를 통해 Movie 한개를 조회하는 함수를 작성했다.

이번엔 Controller에서 방금 만들었던 Service를 사용해보자. express.js처럼 수도으로 import하는 방법은 Nest.js에서 기본적으로 쓰는 방법이 아니다. 우리가 요청을 해야한다.

먼저 class에 구조체(constructor)를 가져오고, getAll() 부분과 getOne() 부분을 바꿔보겠다.

import { Controller, Get, Param, Post, Delete, Patch, Body, Query } from '@nestjs/common';
import { Movie } from './entities/movie.entity';
import { MoviesService } from './movies.service';

@Controller('movies')
export class MoviesController {
    constructor(private readonly moviesService: MoviesService) {}

    @Get()
    getAll(): Movie[] {
        return this.moviesService.getAll();
    }

    @Get('search') 
    search(@Query('year') searchingYear : string) {
        return `${searchingYear} 이라는 데이터를 찾을 것입니다.`
    }

    @Get('/:id')
    getOne(@Param('id') movieId: string){
        return this.moviesService.getOne(movieId)
    }

    @Post()
    create(@Body() movieData : Object) {
        return movieData;
    }

    @Delete('/:id')
    remove(@Param('id') movieId:string) {
        return `${movieId} id를 가진 movie를 삭제합니다.`;
    }

    @Patch('/:id')
    patch(@Param('id') movieId:string, @Body() updateData) {
        return {
            updatedMovie : movieId,
            ...updateData
        }
    }
}

이번엔 Service에서 delete함수와 create함수를 만들어보겠다.

movies.service.ts

import { Injectable } from '@nestjs/common';
import { Movie } from './entities/movie.entity';

@Injectable()
export class MoviesService {
    private movies: Movie[] = [];

    getAll(): Movie[] {
        return this.movies;
    }

    getOne(id:string): Movie {
        return this.movies.find(movie => movie.id === parseInt(id));
    } 

    deleteOne(id:string): boolean {
        this.movies.filter(movie => movie.id !== parseInt(id))
        return true;
    }

    create(movieData) {
        this.movies.push({
            id: this.movies.length + 1,
            ...movieData
        })
        return true;
    }
}

그리고 Controller 부분을 바꿔주자. search부분은 이미 설명을 했으니 삭제하겠다.

movies.controller.ts

import { Controller, Get, Param, Post, Delete, Patch, Body, Query } from '@nestjs/common';
import { Movie } from './entities/movie.entity';
import { MoviesService } from './movies.service';

@Controller('movies')
export class MoviesController {
    constructor(private readonly moviesService: MoviesService) {}

    @Get()
    getAll(): Movie[] {
        return this.moviesService.getAll();
    }

    @Get('/:id')
    getOne(@Param('id') movieId: string){
        return this.moviesService.getOne(movieId)
    }

    @Post()
    create(@Body() movieData : Object) {
        return this.moviesService.create(movieData);
    }

    @Delete('/:id')
    remove(@Param('id') movieId:string) {
        return this.moviesService.deleteOne(movieId);
    }

    @Patch('/:id')
    patch(@Param('id') movieId:string, @Body() updateData) {
        return {
            updatedMovie : movieId,
            ...updateData
        }
    }
}

동작은 postman에서 확인할 수 있다.

참조

https://nomadcoders.co/nestjs-fundamentals/lectures/1947

우리가 클라이언트에서 어떤 데이터를 원할 때는 백엔드에 요청을 해야된다.

예를들어 백엔드에서 POST 메소드로 josn body를 요청받아 movie를 create하고 싶다면,

    @Post()
    create(@Body() movieData : Object) {
        return movieData;
    }

이런식으로 해당 부분을 바꿔주면 된다.

또한 PATCH 메소드를 통해 update를 하고 싶다면,

    @Patch('/:id')
    patch(@Param('id') movieId:String, @Body() updateData) {
        return {
            updatedMovie : movieId,
            ...updateData
        }
    }

이런식으로 Patch로 받은 데이터를 추가하고 반환할 수 있다.

node.js로 json데이터를 주고 받을 때는 따로 설정을 해야될 것들이 있었지만, Nest.js는 이러한 과정을

아주 편리하게 이용할 수 있도록 해준다.

우리가 Movie에 대해 year이라는 속성으로 데이터를 찾고자 할 때는

    @Get('/:id')
    getOne(@Param('id') movieId: String){
        return `id is ${movieId}`;
    }

    @Get('search') 
    search(@Query('year') searchingYear : string) {
        return `${searchingYear} 이라는 데이터를 찾을 것입니다.`
    }

이런식으로 사용할 수 있다. 하지만  위와 같이 /:id를 param으로 갖는 곳 하단에 선언을 해주고, 실행을 해보면

이런 식으로 search를 id로 인식하여 원하는 값을 얻지 못하게 된다. 따라서 GET /:id 상단에 선언을 해야 된다.

    @Get('search') 
    search(@Query('year') searchingYear : string) {
        return `${searchingYear} 이라는 데이터를 찾을 것입니다.`
    }

    @Get('/:id')
    getOne(@Param('id') movieId: String){
        return `id is ${movieId}`;
    }

이렇게 만들고 다시 실행을 해보면

이런 식으로 우리가 원하는 값을 얻을 수 있게 된다.

참조

https://nomadcoders.co/nestjs-fundamentals/lectures/1946

참조 ( 제가 존경하는 노마드 코더님의 강의영상 )

https://nomadcoders.co/nestjs-fundamentals/lectures/1945

먼저 완전 아무것도 없는 상태로 시작을 해보겠다.

Nest.js 에서는 generate라는 훌륭한 명령어가 있다.

커맨드 라인에 관하여 상당히 편리하게 되어있기 때문에 우리는 거의 모든 걸 편리하게 생성할 수 있다.

$ nest

이 명령어를 치면 우리가 사용할 수 있는 명령어들이 나타난다.

그 중 generate 옵션을 살펴보면,

이런식으로 콘솔에 나타난다. controller를 생성해보자.

$ nest g co

Controller의 이름을 어떻게 사용할건지에 대해 물어본다.

movies라고 입력하면 

import { Module } from '@nestjs/common';
import { MoviesController } from './movies/movies.controller';

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

자동으로 movies라는 폴더가 생성되고, 루트 모듈 파일에 자동으로 Moviescontroller가 생성되는걸 확인할 수 있다

movies.controller.ts

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

@Controller('movies')
export class MoviesController {

    @Get()
    getAll(){
        return 'hello movies'
    }
}

movies.controller.ts 파일을 고치고 npm run start를 실행해보면..!

이렇게 에러메세지가 뜬다.. 왜그럴까?

기본적인 Controller 데코레이터에서는 비어있지만, 명령어로 만든 Controller는 이와같이 안에 문자열이

생성된 채로 만들어진다. 때문에 마지막 ip주소 마지막 부분에 /movies를 붙이면

이렇게 잘 뜨는 것을 확인 할 수 있을것이다.

이번에는 파라미터를 가지는 GET메소드를 구현해보자!

movies.controller.ts

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

@Controller('movies')
export class MoviesController {

    @Get()
    getAll(){
        return 'hello movies'
    }

    @Get('/:id')
    getOne(){
        return 'hello one movie'
    }
}

/:id에 값이 들어올 경우 정상적으로 뜨는 것을 확인할 수 있다. (ex localhost:3000/movies/1)

또한 다음과 같이 파라미터의 자료형을 지정하고 자유자재로 쓸 수도 있다.

movies.controller.ts

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

@Controller('movies')
export class MoviesController {

    @Get()
    getAll(){
        return 'hello movies'
    }

    @Get('/:id')
    getOne(@Param('id') movieid: String){
        return `id is ${movieid}`
    }
}

자 그럼 이번엔 다른 메소드들도 사용해서 controller의 틀을 잡아보자.

movies.controller.ts

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

@Controller('movies')
export class MoviesController {

    @Get()
    getAll(){
        return 'hello movies';
    }

    @Get('/:id')
    getOne(@Param('id') movieId: String){
        return `id is ${movieId}`;
    }

    @Post()
    create() {
        return 'This will create a Movie';
    }

    @Delete('/:id')
    remove(@Param('id') movieId:String) {
        return `${movieId} id를 가진 movie를 삭제합니다.`
    }

    @Patch('/:id')
    patch(@Param('id') movieId:String) {
        return `${movieId} id를 가진 movie를 변경합니다.`
    }
}

여기까지 멋진 Controller를 만들어보았다.

일단 먼저 우리만의 모듈을 만들어보자. 이름은 cats라고 하겠다.

$ nest g module cats

루트 폴더에서 이 명령어를 실행해주면

이렇게 자동으로 폴더가 생성된다.

전체적인 파일 구조는 이런식이 될 것이다.

Feature Modules(기능 모듈)

먼저 cats.module.ts를 다음과 같이 수정해보자.

cat.module.ts

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

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

이렇게 controllers와 provider를 가지는 모듈을 한 개 생성하였다. ( controller와 provider는 아직 생성 안 함.)

그 다음 app.module.ts(루트 모듈) 파일을 수정해주어야 한다.

app.module.ts

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

@Module({
  imports: [CatsModule],
})
export class AppModule {}

여기까지가 기능 모듈의 기본적인 예이다. 모듈을 생성하고, 루트 모듈에 연결해주었다.

Shared Modules( 공유 모듈)

Nest에서의 모듈은 기본적으로 싱글톤이다. 여러 모듈간에 쉽게 프로바이더의 인스턴스를 공유할 수 있다.

공유를 하기 위해서 만들었던 모듈에 export 옵션을 만들어주어야한다.  여기서 모듈에서 사용하는 용어를 살펴보면,

이렇게 되어있다. export를 써보자.

cat.module.ts

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

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

이렇게 하면 CatsModule을 가져오는 모든 모듈이 CatService에 액세스 할 수 있다.

( 가져올 때는 import를 써준다. )

Global modules

모든 곳에서 동일한 모듈 세트를 가져와야할 때 @Global() 데코레이터를 이용하여 전역 모듈을 생성할 수 있다.

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

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

이런식으로 exports 옵션에 넣어주면 CatService를 필요로 하는 모듈에서 가져와 쓸 수 있다.

Global 데코레이터는 일반적으로 루트 또는 코어 모듈에서 한번만 등록을 해야한다. 서비스를 가져오려는 모듈에서

가져오기 배열에서 CatModule을 가져올 필요가 없다.

소개에서 다루었던 파일들을 다시 한번 보자.

main.ts

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

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

이곳에서 async await로 Appmodule을 앱으로 만들어 포트를 할당해준다.

app.modules.ts

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

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

이곳에서 AppController와 AppService 파일들을 가져와 모듈을 만들어준다.

app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

이곳에서 AppService 파일을 import 하고 Controller를 만들어준다.

app.service.ts

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

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

마지막으로 Service에선 Controller에서 return할 때 쓰인 getHello()함수를 명시하여 선언해준다.

이 때 Controller에서 바로 return 'Hello World'를 쓸 수도 있는데 왜 굳이 Service를 만들어주어야 하는지 의문점이 들 수 있다. 구조와 아키텍처에 관한 설명이 필요하다.

Controller는 그저 Url을 가져오는 역할이며, Service는 비즈니스 로직을 만드는 역할을 수행한다.

즉, Controller는 Url에 따른 함수를 가져오게 하고,  Service가 그 함수가 되는 것이다.

Url에 따라 분명 똑같은 비즈니스 로직이 실행되어야 할 때가 있다. 그럴 땐 Service에서 지정한 함수를 Controller에서 재사용이 가능하며, 유지 및 보수를 할 때 해당 로직에 문제가 생길 경우 수정 또한 쉽게 할 수 있다.

Route parameters

동적 데이터를 일부 수락해야 하는 경우 @Get() 데코레이터에서 파라미터를 정의해주는 방법이 있다.

@Get(':id')
findOne(@Param() params): string {
  console.log(params.id);
  return `This action returns a #${params.id} cat`;
}

@nestjs/common 패키지에서 Param을 가져옵니다.

Asynchronicity

모든 비동기 함수는  Promise를 반환해야 한다. Nest가 자체적으로 해결할 수 있는 지연된 값을 반환할 수 있다.

cats.controller.ts

@Get()
async findAll(): Promise<any[]> {
  return [];
}

Request payloads

이전 예제에서 POST 라우터의 매개변수를 다루지 않았다. 여기에 @Body() 데코레이터를 추가해 문제를 해결해보겠다.

그러기 전에 먼저 DTO( 데이터 전송 개체 )스키마를 결정해야 한다. 아래와 같이 할 수 있다.

export class CreateCatDto {
  name: string;
  age: number;
  breed: string;
}

그 다음 CatsController 내부에서 생성된 DTO를 사용할 수 있다.

cats.contoller.ts

@Post()
async create(@Body() createCatDto: CreateCatDto) {
  return 'This action adds a new cat';
}

Full resource sample

다음은 여러 데코레이터를 사용하여 기본 컨트롤러를 만드는 예제이다.

cats.controller.ts

import { Controller, Get, Query, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { CreateCatDto, UpdateCatDto, ListAllEntities } from './dto';

@Controller('cats')
export class CatsController {
  @Post()
  create(@Body() createCatDto: CreateCatDto) {
    return 'This action adds a new cat';
  }

  @Get()
  findAll(@Query() query: ListAllEntities) {
    return `This action returns all cats (limit: ${query.limit} items)`;
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return `This action returns a #${id} cat`;
  }

  @Put(':id')
  update(@Param('id') id: string, @Body() updateCatDto: UpdateCatDto) {
    return `This action updates a #${id} cat`;
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return `This action removes a #${id} cat`;
  }
}

컨트롤러는 들어오는 request를 처리하고 response를 클라이언트에게 반환하는 역할을 한다.

예제를 살펴보면, 

cats.controller.ts

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

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

컨트롤러를 정의하는 데 필수인 @Controller() 안에 선택적 라우트 경로(path) 접두사인 cats를 지정한다.

이렇게 지정을 해두면 /cats로 들어오는 요청들을 컨트롤 할 수 있다.

CLI를 사용하여 컨트롤러를 만들려면 
$ nest g controller cats
 명령을 실행하면 됩니다.

findAll() 메서드 앞에 있는 @Get() HTTP 요청 메서드 데코레이터는 Nest에 HTTP 요청에 대한 특정 엔드포인트에 대한 핸들러를 생성하도록 지시한다. 

예를 들어 @Get('profile')과 결합된 constomer의 경로 접두사는  GET /customers/profile 과 같은 요청에 대한 라우트 매핑을

생성한다.

메소드 핸들러 시그니처(예: findAll(@Res() response))에서 @Res() 데코레이터를 사용하여 삽입할 수 있는 라이브러리별(예: Express) 응답객체를 사용할 수 있습니다. 예를 들어 Express에서는 response.status(200).send() 와 같은 코드를 사용하여 응답을 구성할 수 있습니다.

정리해보면,

• /cats 로 요청을 받을 때 @Controller('cats') 로 지정해준다.
• GET 메소드로 요청을 받을 때 @Get()을 선언해준다.
• GET 메소드 하위경로를 지정해줄 땐 @Get() 안에 경로 이름을 지정해준다.
• 기본적으로 지정된 라우터는 findAll()로 들어오게된다.
• @Req() 데코레이터를 추가하면 요청객체에 액세스 할 수 있다.

다음으로 POST 핸들러를 만들어보자.

cats.controller.ts

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

@Controller('cats')
export class CatsController {
  @Post()
  create(): string {
    return 'This action adds a new cat';
  }

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

GET 메소드 요청 처리를 이해하면,  POST 핸들러는 아주 쉽게 이해할 수 있다.

@Get(), @Post(), @Put(), @Delete(), @Patch(), @Options() 및 @Head(). 또한 @All()은 이들 모두를 처리하는 엔드 포인트를 정의한다.

Route wildcards

패턴 기반 라우트 또한 제공한다. 별표는 와일드카드로 사용되며 모든 문자조합과 일치한다.

@Get('ab*cd')
findAll() {
  return 'This route uses a wildcard';
}

Status code

201인 POST 요청을 제외하고 상태코드는 기본적으로 항상 200이다. @HttpCode() 데코레이션을 추가하여 변경할 수 있다.

@Post()
@HttpCode(204)
create() {
  return 'This action adds a new cat';
}

@nestjs/common 패키지에서 HttpCode를 가져옵니다.

Headers

커스텀 응답헤더를 지정하려면 @Header() 데코레이터를 이용한다. ( res.header()를 직접 호출 )

@Post()
@Header('Cache-Control', 'none')
create() {
  return 'This action adds a new cat';
}

@nestjs/common 패키지에서 Header를 가져옵니다.

Redirection

응답을 특정 URL로 리디렉션 하려면 @Redirect() 데코레이터를 이용한다. ( res.redirect()를 직접 호출)

@Get()
@Redirect('https://nestjs.com', 301)

그럼 이런식으로 반환하게 된다.

{
  "url": string,
  "statusCode": number
}

반환된 값은 @Redirect() 데코레이터에 전달된 모든 인수를 재정의 할 수 있다.

@Get('docs')
@Redirect('https://docs.nestjs.com', 302)
getDocs(@Query('version') version) {
  if (version && version === '5') {
    return { url: 'https://docs.nestjs.com/v5/' };
  }
}

설정

우리는 먼저 새 프로젝트를 설정해야 한다. 전 글에서 말했듯이 먼저 npm이 설치되어있는 상태로 진행해보겠다.

$ sudo npm i -g @nestjs/cli
$ nest new project-name

먼저 패키지매니저를 설정할 수 있다. ( 저는 npm이 편해서 npm으로 했습니다! )

그러면 project-name 폴더가 생성되고 다른 몇가지의 상용구 파일들이 설치되며  src/  폴더가 생성되는것을 확인할 수 있다.

src폴더의 하위파일들을 살펴보면,

app.controller.ts ( 하나의 라우트가 있는 기본 컨트롤러 )

import { Test, TestingModule } from '@nestjs/testing';
import { AppController } from './app.controller';
import { AppService } from './app.service';

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

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

    appController = app.get<AppController>(AppController);
  });

  describe('root', () => {
    it('should return "Hello World!"', () => {
      expect(appController.getHello()).toBe('Hello World!');
    });
  });
});

app.controller.spec.ts ( 컨트롤러를 위한 유닛 테스트 )

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

app.module.ts ( 애플리케이션의 루트 모듈 )

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

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

app.service.ts ( 단일 메소드를 사용하는 기본 서비스 )

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

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

main.ts ( 핵심기능을 사용하여 Nest 애플리케이션 인스턴스를 생성하는 애플리케이션 엔트리 파일 )

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

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

애플리케이션 실행

$ npm run start

script 파일을 살펴보면 nest start와 같다는 것을 확인할 수 있다.