코드 기어 Code Gear - 개발 강좌

다음은 이 글의 동영상 강의 입니다.

https://youtu.be/LbyfF6ALMo0

비밀번호 암호와의 필요성

BCrypt

예제 소스 다운로드

여기서 사용하는 예제 소스는 아래 URL에서 받으실 수 있습니다.

https://github.com/CodeGearGit/nest-sample

bcrypt  추가

npm install --save bcrypt @types/bcrypt

회원 가입 시 비밀번호 암호화

import * as bcrypt from 'bcrypt';

async transformPassword(user: UserDTO): Promise<void> {
	user.password = await bcrypt.hash(
		user.password, 10,
	);
	return Promise.resolve();
}

async save(userDTO: UserDTO): Promise<UserDTO | undefined> {
	await this.transformPassword(userDTO);
	console.log(userDTO);
	return await this.userRepository.save(userDTO);
}

결과

로그인시 패스워드 체크 로직 수정

import * as bcrypt from 'bcrypt';

async validateUser(userDTO: UserDTO): Promise<string | undefined> {
	let userFind: UserDTO = await this.userService.findByFields({
		where: { username: userDTO.username }
	});
	const validatePassword = await bcrypt.compare(userDTO.password, userFind.password)
	if(!userFind || !validatePassword) {
		throw new UnauthorizedException();
	}
	return "Login Success!";
}

다음은 이 글의 동영상 강의 입니다.

https://youtu.be/4mjd5P7cZIA

https://youtu.be/NCqCfyQoNz8

Nest로 로그인 기능을 구현하기 위해 우선적으로 회원 가입을 만들어봅니다.

이 예제의 소스는 아래 사이트에서 받으실 수 있습니다.

https://github.com/CodeGearGit/nest-register-sample

USER 테이블의 구조는 다음과 같습니다.

auth 모듈을 만듭니다.

nest g module auth

auth/entity/user.entity.ts 를 만듭니다.

import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";

@Entity('user')
export class User{
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    username: string;
    
    @Column()
    password: string;
}

auth/user.repository.ts 를 만듭니다.

import { EntityRepository, Repository } from "typeorm";
import { User } from "./entity/user.entity";

@EntityRepository(User)
export class UserRepository extends Repository<User>{}

auth/dto/user.dto.ts 를 만듭니다.

export class UserDTO {
    username: string;
    password: string;
}

auth/user.servict.ts 를만듭니다.

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { FindOneOptions } from "typeorm";
import { UserDTO } from "./dto/user.dto";
import { UserRepository } from "./user.repository";

@Injectable()
export class UserService{
    constructor(@InjectRepository(UserRepository) private userRepository: UserRepository){}

    async findByFields(options: FindOneOptions<UserDTO>): Promise<UserDTO | undefined> {
        return await this.userRepository.findOne(options);
    }

    async save(userDTO: UserDTO): Promise<UserDTO | undefined> {
        return await this.userRepository.save(userDTO);
    }
}

auth/auth.service.ts 를 만듭니다.

(nest g service auth)

import { HttpException, HttpStatus, Injectable } from "@nestjs/common";
import { UserDTO } from "./dto/user.dto";
import { UserService } from "./user.service";

@Injectable()
export class AuthService {
    constructor(
        private userService: UserService
    ){}

    async registerNewUser(newUser: UserDTO): Promise<UserDTO> {
        let userFind: UserDTO = await this.userService.findByFields({ where: { username: newUser.username } });
        if(userFind){
            throw new HttpException('Username already used!', HttpStatus.BAD_REQUEST);
        }
        return this.userService.save(newUser);
    }
}

auth/auth.controller.ts를 만듭니다.

(nest g controller auth)

import { Body, Controller, Post, Req } from "@nestjs/common";
import { Response, Request } from 'express';
import { AuthService } from "./auth.service";
import { UserDTO } from "./dto/user.dto";

@Controller('api')
export class AuthController {
    constructor(private authService: AuthService){}

    @Post('/register')
    async registerAccount(@Req() req: Request, @Body() userDTO: UserDTO): Promise<any> {
        return await this.authService.registerNewUser(userDTO);
    }
}

auth/auth.module.ts를 아래와 같이 수정합니다.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UserRepository } from './user.repository';
import { UserService } from './user.service';

@Module({
    imports: [TypeOrmModule.forFeature([UserRepository])],
    exports: [TypeOrmModule],
    controllers: [AuthController],
    providers: [AuthService, UserService]
  })
export class AuthModule {}

서버를 start 합니다.

npm run start:dev

postman에서 다음과 같이 테스트를 합니다.

POST http://localhost:3000/api/register
Body-raw-JSON
{
    "username": "codegear",
    "password": "1111"
}

실행 결과는 다음과 같습니다.

user 테이블에서도 다음과 같이 확인하실 수 있습니다.

다음은 이 글의 동영상 강의입니다.

https://youtu.be/MEaTJTyHVnc

다음은 실습 동영상입니다.

https://youtu.be/J8HWEoZSC-Y

* 이 글은 nestjs 공식 홈페이지를 참조하여 작성하였습니다.

https://docs.nestjs.kr/middleware

Nest의 미들웨어란?

미들웨어는 라우터 핸들러 이전에 호출되는 함수입니다.

다시말해 위 그림에서와 같이 클라이언트의 요청을 라우터 핸들러가 받기 전에 가로채 다른 작업을 처리할 수 있습니다.

이를 응용하면 여러가지 공통적으로 처리해야 하는 부분들의 처리를 중복 없이 개발할 수 있습니다.

예를 들면 다음과 같은 것들을 할 수 있습니다.

• 모든 코드가 공통으로 실행해야 하는 인증, 로깅등을 처리할 수 있습니다.
• 요청과 응답 객체를 변경할 수 있습니다.
• 요청의 validation을 체크하여 오류 처리를 할 수 있습니다.

Nest의 미들웨어 사용법

Nest에서 미들웨는 다음과 같이 사용할 수 있습니다.

• @Injectable 데코레이터를 사용합니다.
• NestMiddleware 인터페이스를 implements 해서 사용합니다.
• Module의 class 내부에 configure를 사용하여 선언합니다. 이때 NestModule 인터페이스를 implements 합니다.

다음은 Log를 위한 Middleware 예제입니다.

지금까지의 실습 소스는 아래 git 주소에서 받으시면 됩니다.

https://github.com/CodeGearGit/nest-cats.git

logger.middleware.ts

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

app.module.ts

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('cats');
  }
}

다음과 같이 라우트를 특정하여 사용할 수도 있습니다.

.forRoutes({ path: 'cats', method: RequestMethod.GET });

다음과 같이 패턴 기반의 라우팅도 지원됩니다.

.forRoutes({ path: 'ab*cd', method: RequestMethod.ALL });

Middleware 관리를 위한 내장 모듈 - MiddlewareConsumer

MiddlewareConsumer라는 헬퍼클래스를 사용하면 여러 스타일로 미들웨어를 설정할 수 있습니다.

forRoutes() 메소드는 단일 문자열, 여러 문자열, RouteInfo 객체, 컨트롤러 클래스 및 여러 컨트롤러 클래스를 사용할 수 있습니다.

다음은 Controller의 사용 예입니다.

app.module.ts

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';
import { CatsController } from './cats/cats.controller.ts';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes(CatsController);
  }
}

apply 메서드는 여러 미들웨어를 지정할 수 있습니다.

라우트 예외처리

다음과 같이 exclude() 메소드로 라우트를 제외할 수 있습니다.

consumer
  .apply(LoggerMiddleware)
  .exclude(
    { path: 'cats', method: RequestMethod.GET },
    { path: 'cats', method: RequestMethod.POST },
    'cats/(.*)',
  )
  .forRoutes(CatsController);

Functional middleware

지금까지 만든 Class 미들웨어는 아래와 같이 간단한 Funtional middleware로 변경할 수 있습니다.

logger.middleware.ts

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

export function logger(req: Request, res: Response, next: NextFunction) {
  console.log(`Request...`);
  next();
};

위의 logger functrion은 Module에서 다음과 같이 사용할 수 있습니다.

app.module.ts

consumer
  .apply(logger)
  .forRoutes(CatsController);

여러개 미들웨어 사용

다음과 같이 apply() 메서드에 여러개의 미들웨어를 사용할 수 있습니다,

consumer.apply(cors(), helmet(), logger).forRoutes(CatsController);

Global 미들웨어

모든 경로에서 사용하는 미들웨어는 INestApplication 인스턴스에서 제공하는 user() 메서드를 사용할 수 있습니다.

const app = await NestFactory.create(AppModule);
app.use(logger);
await app.listen(3000);

• 단, Global 미들웨어에서 DI 컨테이너에 액세스할 수 없습니다.
• app.use()에서 미들웨어를 사용할 때는 대신 functional middleware를 사용하고 있습니다.

이 글의 동영상 강의 입니다.

https://youtu.be/BQAR-0JCA7o

* 이 글은 아래 사이트를 참조하여 작성하였습니다.

https://docs.nestjs.kr/providers

Providers

• provider는 services, repositories, factories, helpers 등이 있습니다. 
• provider는 종속성에 의해 Inject(주입)할 수 있습니다.
• 즉, provider 객체의 생성 및 연결은 nest runtime 시스템에 위임될 수 있습니다.
• 컨트롤러는 HTTP 요청을 처리하고 복잡한 작업은 Provider에게 위임을 합니다.
• provider는 module에서 선언하는 일반 javascript class 입니다.

Service

다음과 같이 CatsService를 만들어 보겠습니다.

CatsService는 지난 시간에 만든 CatsController에서 사용할 Service이며, 데이터의 조회, 저장, 수정, 삭제를 처리합니다.

서비스는 다음과 같이 generate script를 사용하여 만들 수 있습니다.

nest g service cats

cats.service.ts

import { Injectable } from '@nestjs/common';
import { Cat } from './interfaces/cat.interface';

@Injectable()
export class CatsService {
  private readonly cats: Cat[] = [];

  create(cat: Cat) {
    this.cats.push(cat);
  }

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

@Injectable() 데코레이터는 이 class가 Nest IoC 컨테이너에서 관리하는 class 임을 선언하는 것입니다.

다음은 CatsService에서 사용한 Cat 인터페이스입니다.

cat.interface.ts

export interface Cat {
  name: string;
  age: number;
  breed: string;
}

이제 CatsController를 다음과 같이 바꿀 수 있습니다.

cats.controller.ts

import { Controller, Get, Post, Body } from '@nestjs/common';
import { CreateCatDto } from './dto/create-cat.dto';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';

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

  @Post()
  async create(@Body() createCatDto: CreateCatDto) {
    this.catsService.create(createCatDto);
  }

  @Get()
  async findAll(): Promise<Cat[]> {
    return this.catsService.findAll();
  }
}

CatsService는constructor를 통해 주입됩니다. private을 사용하면 선언과 초기화가 동시에 이루어 집니다.

이상으로 provider의 개념과 service를 만들어보았습니다.

다음은 이 글의 동영상 강의입니다.

https://youtu.be/v66oRI3peh8

아래는 컨트롤러 실습 강의 영상입니다.

https://youtu.be/BJbL6zT16DM

* 이글은 NestJS 홈페이지를 참조하여 작성하였습니다.

https://docs.nestjs.kr/controllers

Controller의 역할

NestJS의 Controller는 Client의 request(요청)를 받아 처리한 후 response(응답)하는 역할을 합니다.

Client의 요청이 들어왔을 때 요청에 따라 처리할 Controller로 분기 처리하는 것을 Routing이라고 합니다.

@Controller()

Controller는 @Controller() 데코레이터를 사용합니다.

마지막에 사용된 () 안에는 다음과 같이 요청 라우팅 path를 지정할 수 있습니다.

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

@Controller('cats')
export class CatsController {}

이때 정의된 cats는 하위 메소드들의 접두어 역할을 하므로 반복하여 작성할 필요가 없습니다.

라우팅 path가 없을 경우에는 root path('/')로 사용됩니다.

사용 예는 다음과 같습니다.

• http://localhost:3000/   =>  @Controller()
• http://localhost:3000/cats   =>  @Controller('cats')

Controller에서는 다음과 같이 HTTP Request Method 데코레이터를 사용할 수 있습니다.

@Get, @Post, @Put, @Delete

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

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

위의 @Get() 데코레이터는 Controller의 라우팅 패스를 상속 받기 때문에 Client에서는 다음과 같이 요청할 수 있습니다.

• http://localhost:3000/cats

@Get() 데코레이터도 @Controller와 마찬가지로 routing path를 지정할 수 있습니다.

• @Get('profile') 

이 경우 사용자의 요청 URL은 다음과 같습니다.

• http://localhost:/3000/cats/profile

@Get() 데코레이터 아래 선언된 Method의 이름은 어떤 의미도 부여하지 않습니다.
다만, 코드를 해석하기 쉬운 형태로 작성해 주시면 됩니다.

Method 옆에 선언된 type은 response 형식입니다.

@Get()
findAll(): string

Request 객체

NestJS는 Express를 사용하고 있으므로 인해 Request 객체를 사용할 수 있습니다.

핸들러 parameter에 @Req() 데코레이터를 사용하면 됩니다.

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

@Controller('cats')
export class CatsController {
  @Get()
  findAll(@Req() request: Request): string {
    console.log(request);
    return 'This action returns all cats';
  }
}

Route parameters

동적 라우팅을 위해서는 매개변수를 ':'과 함께 사용할 수 있습니다.

다음은 동적 매개변수를 사용한 예입니다.

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

만약 id가 1일 경우 호출 url은 다음과 같습니다.

• http://localhost:3000/cats/1

매개 변수는 @Param() 데코레이터로 받아서 처리하면 됩니다.

위에서는 params.id로 라우팅 매개변수 값을 추출할 수 있습니다.

다음과 같은 방법으로도 처리할 수 있습니다.

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

비동기 처리

비동기 함수는 아래 예제와 같이 Promise를 반환해야 합니다.

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

Post의 Body DTO

Post 라우트 핸들러에서는 @Body() 데코레이터를 사용할 수 있습니다.

이때 DTO 스키마 클래스를 생성해서 데이터를 처리할 수 있습니다.

다음은 DTO를 사용한 예제입니다.

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

 해당 DTO를 Controller에서 사용하는 방법은 다음과 같습니다.

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

일반적인 API의 구조를 모두 포함한 예제는 다음과 같습니다.

• findAll : 전체 데이터 목록 조회
• findOne : 데이터 상세 조회
• create : 데이터 생성
• update : 데이터 수정
• remove : 데이터 삭제

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

이상으로 nestjs의 controller에 대해 알아보았습니다.

다음은 이글의 동영상 강의 입니다.

https://youtu.be/mz03kWu0CvU

NestJS는 소스코드를 자동으로 생성해주는 Generator가 있습니다.

이 개념은 Angular의 Generator와 똑같은 기능을 수행합니다.

자동생성은 Module, Controller, Service등을 생성할 수 있습니다.

모듈 자동 생성하기

nest g module 모듈명

다음은 users 모듈을 generator로 생성한 것입니다.

module이 생성이 완료되면 다음과 같이 폴더와 파일이 생성된걸 보실 수 있습니다.

그리고, app.module.ts에 해당 모듈이 자동으로 import 됩니다.

이렇게 되면 UsersModule을 사용할 수 있게 됩니다.

Controller 자동 생성하기

다음 명령으로 Controller를 생성합니다.

nest g controller 컨트롤러명

명령이 완료되면 users.controller.ts가 생성되고, users.module.ts가 업데이트 됩니다.

users.module.ts에는 UsersController가 자동으로 추가 되었습니다.

users.controller.ts에는 'users'라는 라우팅 패스가 자동으로 추가되었습니다.

서비스 생성하기

다음 명령으로 service를 생성할 수 있습니다.

nest g service 서비스명

명령이 완료되면 users.service.ts 파일이 생성되고, user.module.ts가 업데이트 됩니다.

users.module.ts에는 providers에 UserService가 자동으로 추가됩니다.

생성된 users.service.ts는 다음과 같습니다.

Service는 @Injectable() 데코레이터를 사용합니다.

이는 스프링의 DI(Dependency Injection)이라는 개념을 사용하는 것입니다.

즉, Service를 사용할 곳에 선언해주면 필요한 시점에 자동으로 객체를 생성해주는 역할을 합니다.

이때 객체 생성시 사용하던 new를 사용할 필요가 없습니다.

이상으로 NestJS에서 Module, Controller, Service를 자동생성하는 법을 알아보았습니다.

이 글은 동영상 강의로 제공됩니다.

https://youtu.be/qmthF-dq3Ak

NestJS의 Module 개념

• NestJS는 여러 모듈들의 집합입니다.
• NestJS는 하나 이상의 모듈이 반드시 있어야 합니다.
• 기본 모듈은 AppModule입니다.
• 기능별로 모듈을 생성하여 개발할 수 있습니다.
• 생성된 각 모듈을 Root Module에 imports 시켜주어야 합니다.(하위모듈의 하위모듈...)
• CLI로 모듈을 생성하면 자동으로 Root Module에 import가 됩니다.
• export를 통해 외부에서 module을 사용할 수 있습니다.

NestJS CLI로 생성된 소스를 자세히 살펴보겠습니다.

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

• main.ts는 Application의 진입점(Entry Point)입니다.
• main.ts에서는 NestFactory를 사용하여 Application 인스턴스를 생성합니다.
• 생성시에는 AppModule을 사용하도록 지정을 했습니다.

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 {}

• AppModule은 main.ts에서 지정한 root module입니다.
• NestJS는 모듈 단위로 개발을 진행합니다.
• module은 @Module 데코레이터를 사용하여 선언합니다.
• imports는 다른 module을 가져올때 사용합니다.
• controllers는 이 모듈에서 사용하는 컨트롤러의 세트입니다.
• providers는 NestJS의 injector에 의해 인스턴스화 되는 class를 지정합니다.
• export를 통해 모듈을 다른 곳에서 사용할 수 있습니다.

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

• controller는 client의 요청에 대한 라우팅을 처리합니다.
• provider인 AppService에게 비즈니스 처리 요청을 보냅니다.
• 서비스에서 받은 결과를 client에 응답으로 보냅니다.

app.service.ts

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

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

• controller의 요청을 받은 서비스는 비즈니스 로직을 처리한 후 controller에게 return합니다.

이상으로 NestJS의 구조에 대해 살펴보았습니다.

이 글의 동영상 강의입니다.

https://youtu.be/lwJLrv6zj04

* Nestjs 개발을 위해서는 Nodejs가 설치되어 있어야 합니다.

* Editor는 Visual Studio Code(VSCode)를 사용했습니다.

NestJS 프로젝트를 만들기 위해서는 Nestjs CLI(Command Line Interface)를 설치해야 합니다.

• 아래와 같이 Nestjs cli를 설치합니다.

npm i -g @nestjs/cli

• 설치가 완료되면 아래와 같이 CLI를 이용해 프로젝트를 만들 수 있습니다.

nest new project-name

• 생성된 프로젝트의 구조는 다음과 같습니다.
  • dist : typescript 코드를 컴파일해서 빌드한 .js 파일이 저장되는 폴더
  • node_moduels : package.json에 정의된 패키지 모듈이 설치되는 폴더
  • src : typescript 코드가 저장되는 사용자 소스 폴더
  • test : test 소스가 저장되는 폴더

• 자동생성된 프로젝트 소스 폴더의 구조는 다음과 같습니다.
  • app.controller.spec.ts : test용 소스 - controller를 테스트합니다.
  • app.controller.ts : controller 소스 - client의 request을 처리하고, response를 보냅니다. 
  • app.module.ts : module 소스 - 모듈을 정의합니다.(controller와 service 정의)
  • app.service.ts : service 소스 - controller가 요청한 비즈니스 로직을 처리합니다.
  • main.ts : 프로젝트 시작점(Entry Point)

• main.ts
  • 애플리케이션 Entry Point 즉, 시작 소스입니다.
  • 서버를 스타트하고 포트 설정, CORS 등을 정의합니다.

• package.json
  • 프로젝트의 설정 파일입니다.
  • 사용하는 모듈, 서버 실행 및 빌드등의 스크립트를 정의합니다.

프로젝트 실행

• VSCode 상단메뉴에서 터미널-새터미널을 클릭합니다.
• package.json에 정의된 실행 스크립트를 실행합니다.

npm start

• 브라우저에서 다음 URL을 입력합니다.

http://localhost:3000

• 브라우저에 다음과 같이 내용이 출력됩니다.

* 본 문서는 nestjs 홈페이지(https://docs.nestjs.com/)를 참조하였습니다.

* nestjs 한글 홈페이지 주소 : https://docs.nestjs.kr/

이 글의 동영상 강의입니다.

https://youtu.be/QniEcuwvLSU

Nest(NestJS)의 특징

• Nest는 nodejs 서버 애플리케이션을 구축하기 위한 프레임워크입니다.
• Nest는 서버 애플리케이션 개발시 필요한 많은 부분들을 기본적으로 제공하고 있습니다.
• Nest는 Express 기반으로 만들어졌습니다.
• Nest는Typescript를 사용합니다. javascript도 코딩이 가능합니다.
• Nest는 다음 요소를 포함합니다.
  • OOP - 객체지향 프로그래밍
  • FP - Functional 프로그래밍
  • FRP - Functional React 프로그래밍
• Nest는 외부 모듈을 자유롭게 이용할 수 있습니다.
• Nest는 unit 테스트와 e2e 테스트를 할 수 있는 툴을 제공합니다.

Nest의 탄생배경

• 최근 Nodejs로 인해 javascript를 이용한 풀스택(클라이언트+서버) 개발이 활발해졌습니다.
• javascript라는 한가지 언어로 개발을 하기 때문에 생산성을 향상시키고 빠른 개발이 가능해졌습니다.
• 그러나 Node.js의 높은 자유도로 인해 Architecture 구성이 어렵고 효과적이지 못했습니다.
• 이를 해결하기 위해 Angular의 아키텍처 사상을 기반으로 Nest가 만들어졌습니다.

Nest를 사용하면 좋은 점

• Nest는 Java의 Spring과 같이 규칙을 제공합니다. 
  이로 인해 개발자들이 아키텍처의 구성에 대해 고민해야 할 부분이 많이 줄어듭니다.
• 기본적으로 제공하는 라우팅, 보안등의 기능이 많이 탑재되어 있어 편리합니다.
• 외부모듈을 통한 확장이 얼마든지 가능합니다.
• Java+Spring 사용자라면 아키텍처 구조가 비슷해서 쉽게 배울 수 있습니다.
• Angular 사용자라면 기본적인 사용법이 동일하므로 쉽게 배울 수 있습니다.