NestJS로 API 만들기

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

// 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.controller.ts

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

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

	@Get("/hello")
	getHello(): string {
		return this.appService.getHello()
	}
}

// app.service.ts

import { Injectable } from "@nestjs/common"

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

nest g co // 컨트롤러 생성

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

@Controller("movies")
export class MoviesController {
	@Get()
	getAll() {
		return "This will return all movies"
	}

	@Get("/:id")
	getOne(@Param("id") movieId: string) {
		return `This will return one movie with the id:${movieId}`
	}

	@Post()
	create() {
		return "This will create a movie"
	}

	@Delete("/:id")
	remove(@Param("id") movieId: string) {
		return `This will delete a movie with the id:${movieId}`
	}

	@Patch("/:id")
	patch(@Param("id") movieId: string) {
		return `This will patch a movie with the id:${movieId}`
	}
}

@Get('search')
  search(@Query('year') searchingYear: string) {
    return `We are searching for a movie made after: ${searchingYear}`;
}

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

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

nest g s

// entities/movie.entity.ts

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

// movies.service.ts'
import { Injectable, NotFoundException } 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 {
		const movie = this.movies.find(movie => movie.id === +id)
		if (!movie) {
			throw new NotFoundException(`Movie with ID ${id} not found.`)
		}
		return movie
	}

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

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

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

// movies.controller.ts

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

@Controller("movies")
export class MoviesController {
	constructor(private readonly moviesService: MoviesService) {}
	@Get()
	getAll(): Movie[] {
		return this.moviesService.getAll()
	}

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

	@Post()
	create(@Body() movieData) {
		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 this.moviesService.update(movieId, updateData)
	}
}

npm i class-transformer class-validator

// movie/dto/create-movie-dto.ts

import { IsString, IsNumber } from "class-validator"

export class CreateMovieDto {
	@IsString()
	readonly title: string

	@IsNumber()
	readonly year: number

	@IsString({ each: true })
	readonly genres: string[]
}

// 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({
			whitelist: true,
			forbidNonWhitelisted: true,
			transform: true,
		})
	)
	await app.listen(3000)
}
bootstrap()

@nestjs/swagger

import { ApiProperty } from "@nestjs/swagger"

export class CreateCatDto {
	@ApiProperty()
	name: string

	@ApiProperty()
	age: number

	@ApiProperty()
	breed: string
}

export class UpdateCatDto extends PartialType(CreateCatDto) {}

export class UpdateCatAgeDto extends PickType(CreateCatDto, ["age"] as const) {}

export class UpdateCatDto extends OmitType(CreateCatDto, ["name"] as const) {}

export class AdditionalCatInfo {
	@ApiProperty()
	color: string
}

export class UpdateCatDto extends IntersectionType(
	CreateCatDto,
	AdditionalCatInfo
) {}

export class UpdateCatDto extends PartialType(
	OmitType(CreateCatDto, ["name"] as const)
) {}

// 모듈 만들기
nest g mo

// app.module.ts

import { Module } from "@nestjs/common"
import { MoviesModule } from "./movies/movies.module"

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

// movies.module.ts

import { Module } from "@nestjs/common"
import { MoviesController } from "./movies.controller"
import { MoviesService } from "./movies.service"

@Module({
	controllers: [MoviesController],
	providers: [MoviesService],
})
export class MoviesModule {}

import { Test, TestingModule } from '@nestjs/testing';
import { MoviesService } from './movies.service';
import { NotFoundException } from '@nestjs/common';

describe('MoviesService', () => {
  let service: MoviesService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [MoviesService],
    }).compile();
    service = module.get<MoviesService>(MoviesService);
  });

 it('should be defined', () => {
    expect(service).toBeDefined();
  });

describe("getAll", () => {
	it("should return an array", () => {
		const result = service.getAll()
		expect(result).toBeInstanceOf(Array)
	})
})

describe("getOne", () => {
	it("should return a movie", () => {
		service.create({
			title: "Test Movie",
			genres: ["test"],
			year: 2000,
		})
		const movie = service.getOne(1)
		expect(movie).toBeDefined()
	})

	it("should throw 404 error", () => {
		try {
			service.getOne(999)
		} catch (e) {
			expect(e).toBeInstanceOf(NotFoundException)
		}
	})
})

describe("deleteOne", () => {
	it("deletes a movie", () => {
		service.create({
			title: "Test Movie",
			genres: ["test"],
			year: 2000,
		})
		const beforeDelete = service.getAll().length
		service.deleteOne(1)
		const afterDelete = service.getAll().length
		expect(afterDelete).toBeLessThan(beforeDelete)
	})
	it("should return a 404", () => {
		try {
			service.deleteOne(999)
		} catch (e) {
			expect(e).toBeInstanceOf(NotFoundException)
		}
	})
})

describe("create", () => {
	it("should create a movie", () => {
		const beforeCreate = service.getAll().length
		service.create({
			title: "Test Movie",
			genres: ["test"],
			year: 2000,
		})
		const afterCreate = service.getAll().length
		expect(afterCreate).toBeGreaterThan(beforeCreate)
	})
})

import { Test, TestingModule } from "@nestjs/testing"
import { INestApplication, ValidationPipe } from "@nestjs/common"
import * as request from "supertest"
import { AppModule } from "./../src/app.module"

describe("AppController (e2e)", () => {
	let app: INestApplication

	beforeAll(async () => {
		const moduleFixture: TestingModule = await Test.createTestingModule({
			imports: [AppModule],
		}).compile()

		app = moduleFixture.createNestApplication()
		app.useGlobalPipes(
			new ValidationPipe({
				whitelist: true,
				forbidNonWhitelisted: true,
				transform: true,
			})
		)
		await app.init()
	})

	describe("/movies", () => {
		it("GET", () => {
			return request(app.getHttpServer())
				.get("/movies")
				.expect(200)
				.expect([])
		})
		it("POST 201", () => {
			return request(app.getHttpServer())
				.post("/movies")
				.send({
					title: "Test",
					year: 2000,
					genres: ["test"],
				})
				.expect(201)
		})
		it("POST 400", () => {
			return request(app.getHttpServer())
				.post("/movies")
				.send({
					title: "Test",
					year: 2000,
					genres: ["test"],
					other: "thing",
				})
				.expect(400)
		})
		it("DELETE", () => {
			return request(app.getHttpServer())
				.delete("/movies")
				.expect(404)
		})
	})

	describe("/movies/:id", () => {
		it("GET 200", () => {
			return request(app.getHttpServer())
				.get("/movies/1")
				.expect(200)
		})
		it("GET 404", () => {
			return request(app.getHttpServer())
				.get("/movies/999")
				.expect(404)
		})
		it("PATCH 200", () => {
			return request(app.getHttpServer())
				.patch("/movies/1")
				.send({ title: "Updated Test" })
				.expect(200)
		})
		it("DELETE 200", () => {
			return request(app.getHttpServer())
				.delete("/movies/1")
				.expect(200)
		})
	})
})