<div id="readability-page-1" class="page"><div>
                                <div id="SE-aecec7ad-5ddf-4f50-8491-b9cf4812d26b">
                                    <p id="SE-bdb42c3b-be19-4e91-94a7-2af5fa4c3c76"><span id="SE-c66803bd-da62-4998-bd06-7b4eaa027001">​</span></p><p id="SE-c55971d4-7d4f-4c0a-b435-f3fbd9c397bf"><span id="SE-89754bfb-bf21-4d63-a05f-6e76a528df09">이번 글에는 각 API 응답을 DTO로 설정해 보겠습니다. 다른 글에 비해 비교적 간단한 작업이니 빠르게 훑어 보겠습니다. 먼저 사용자 응답 DTO를 생성합니다. DTO 내부에는 static of 정적 메서드를 정의합니다. 정적 메서드는 인스턴스를 생성하지 않고도 클래스 이름을 통해 직접 호출할 수 있는 메서드로, 특정 작업을 수행하는 데 사용됩니다.</span></p><p id="SE-4560ab59-2242-45d6-b123-86cb58b36f3b"><span id="SE-9ee27916-bc11-48ee-8a78-4e5939abadea">​</span></p><p id="SE-22dfd134-9e83-4faf-aef2-83dc7f0814c3"><span id="SE-2f94e7ff-10f4-4fc0-91c6-8cdf9d106641">여기서는 UserEntity 객체를 매개변수로 받아, 이를 UserResponseDto 객체로 변환하여 반환하는 역할을 합니다. 즉, 데이터베이스에서 얻은 사용자 데이터(UserEntity)를 API 응답으로 적합한 형태(UserResponseDto)로 포맷팅하는 데 사용됩니다.</span></p>
                            </div>                <div id="SE-5e15b71d-65c8-4f49-8851-324fa5018143">
                                    <p>// src/resource/user/dto/user.response.dto.ts
import { ApiProperty } from '@nestjs/swagger';
import { UserEntity } from '../../../entities/user.entity';

export class UserResponseDto {
    @ApiProperty()
    id: number;

    @ApiProperty()
    createdAt: Date;

    @ApiProperty()
    email: string;

    static of(user: UserEntity) {
        const dto = new this();
        dto.id = user.id;
        dto.createdAt = user.createdAt;
        dto.email = user.email;

        return dto;
    }
}</p>
                                </div>                <div id="SE-6cae796b-912c-4ea6-b1c6-773bb1f4fd6e">
                                    <p id="SE-1efe0382-7505-435a-9488-03bbbb64379b"><span id="SE-8db924cf-38de-471d-ace6-11daad331b63">​</span></p><p id="SE-1811a97a-db59-453a-af62-aabcc23f09c7"><span id="SE-25fd0b63-1a0e-4ab4-89ac-78d26989a483">사용자 퍼샤드에 사용자 응답 DTO를 적용합니다.</span></p>
                            </div>                <div id="SE-9d208149-47a1-4753-9410-3ab5521c0524">
                                    <p>// src/resource/user/user.facade.ts
import { Injectable } from '@nestjs/common';
import { UserService } from './user.service';
import { CreateUserDto } from './dto/user.dto';
import { UserResponseDto } from './dto/user.response.dto';

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

    async getUsers() {
        const users = await this.userService.getUsers();
        return users.map((user) =&gt; UserResponseDto.of(user));
    }

    async postUser(createUserDto: CreateUserDto) {
        const user = await this.userService.postUser(createUserDto);
        return UserResponseDto.of(user);
    }

    async deleteUser(id: number) {
        return await this.userService.deleteUser(id);
    }
}
</p>
                                </div>                <div id="SE-bb14cabe-9f0b-471b-b0e1-83f3feb7d39a">
                                    <p id="SE-2ca49e4f-c3f8-4b44-b6b3-364c7546efa6"><span id="SE-bc549b2b-f6fb-4374-9400-c763cedea1f7">​</span></p><p id="SE-9afab7ba-1666-4ccc-afa6-9983580b15a7"><span id="SE-37b20ab4-4491-48f2-a85a-b764379f5623">사용자 컨트롤러에는 ApiOkResponse, ApiCreatedResponse 등을 사용하여 DTO를 정의합니다.</span></p><p id="SE-7f23868e-6109-430d-825d-9da893cd6da5"><span id="SE-042cc3be-8d65-4377-acca-27d40df03280">​</span></p><ul><li><p id="SE-a083b337-9195-40b8-b6f3-69c8bcf47b09"><span id="SE-db76eac8-f33b-4606-9caa-161f1400094b"><b>ApiOkResponse</b></span><span id="SE-69c6b5d8-e76c-4749-9ab2-a0237430e3bd"> : HTTP 200 OK 응답을 나타내며, 요청이 성공적으로 처리되었고, 클라이언트가 요청한 데이터를 성공적으로 받았을 때 사용됩니다. 이 데코레이터는 주로 조회 작업(GET 요청)에 사용되어 API가 성공적으로 데이터를 반환했을 때의 응답 형식을 문서화합니다.</span></p></li><li><p id="SE-b6b32beb-2173-4bbb-86ca-76ca46531334"><span id="SE-08667d54-bd36-415b-b184-ae28fe4889ca"><b>ApiCreatedResponse</b></span><span id="SE-650c6b37-ab25-4426-8805-cb5e744d3ed2"> : HTTP 201 Created 응답을 나타내며, 새로운 리소스가 성공적으로 생성되었음을 나타낼 때 사용됩니다. 이 데코레이터는 주로 데이터 생성 작업(POST 요청)에 사용되어, 새로운 데이터가 서버에 성공적으로 생성된 후 클라이언트에 반환되는 응답의 형태를 문서화합니다.</span></p></li></ul>
                            </div>                <div id="SE-9e95b73b-cf81-4278-8d29-76b0d7dc41e8">
                                    <p>// src/resource/user/user.controller.ts
import {
    ApiBody,
    ApiCreatedResponse,
    ApiOkResponse,
    ApiOperation,
    ApiParam,
    ApiResponse,
    ApiTags,
} from '@nestjs/swagger';
import { Body, Controller, Delete, Get, Param, Post } from '@nestjs/common';
import { UserEntity } from '../../entities/user.entity';
import { CreateUserDto } from './dto/user.dto';
import { Public } from '../../common/decorators/public.decorator';
import { EntityExistsPipe } from '../../common/pipes/entity-exists.pipe';
import { UserFacade } from './user.facade';
import { UserResponseDto } from './dto/user.response.dto';

@ApiTags('사용자')
@Controller('user')
export class UserController {
    constructor(private readonly userFacade: UserFacade) {}

    @ApiOperation({ summary: '전체 사용자 조회', description: '전체 사용자를 가져옵니다.' })
    @ApiOkResponse({ type: [UserResponseDto] })
    @Public()
    @Get()
    async getUsers() {
        return this.userFacade.getUsers();
    }

    @ApiOperation({ summary: '사용자 생성', description: '사용자를 생성합니다.' })
    @ApiBody({ type: CreateUserDto })
    @ApiCreatedResponse({ type: UserResponseDto })
    @Public()
    @Post()
    async postUser(@Body() createUserDto: CreateUserDto) {
        return await this.userFacade.postUser(createUserDto);
    }

    @ApiOperation({ summary: '사용자 삭제', description: '사용자를 삭제합니다.' })
    @ApiParam({
        name: 'id',
        description: '사용자 아이디',
        example: 8,
        required: true,
    })
    @Public()
    @Delete(':id')
    async deleteUser(@Param('id', EntityExistsPipe(UserEntity)) id: number) {
        return await this.userFacade.deleteUser(id);
    }
}
</p>
                                </div>                                                                <div id="SE-74637e72-1458-4b54-af93-2a1b4bf88809">
                                    <p>// src/resource/report/dto/report.response.dto.ts
import { ApiProperty } from '@nestjs/swagger';
import { ReportEntity } from '../../../entities/report.entity';
import { UserResponseDto } from '../../user/dto/user.response.dto';

export class ReportResponseDto {
    @ApiProperty()
    id: number;

    @ApiProperty()
    createdAt: Date;

    @ApiProperty()
    space: number;

    @ApiProperty()
    middle: number;

    @ApiProperty()
    elementary: number;

    @ApiProperty()
    kindergarten: number;

    @ApiProperty()
    barrier: number;

    @ApiProperty()
    hill: number;

    @ApiProperty()
    layout: number;

    @ApiProperty()
    distance: number;

    @ApiProperty()
    sound: number;

    @ApiProperty()
    underground: number;

    @ApiProperty()
    parking: number;

    @ApiProperty()
    clean: number;

    @ApiProperty()
    playground: number;

    @ApiProperty()
    store: number;

    @ApiProperty()
    atm: number;

    @ApiProperty()
    memo: string;

    @ApiProperty()
    totalScore: number;

    @ApiProperty()
    user: UserResponseDto;

    static of(report: ReportEntity) {
        const dto = new this();

        dto.id = report.id;
        dto.createdAt = report.createdAt;
        dto.space = report.space;
        dto.middle = report.middle;
        dto.elementary = report.elementary;
        dto.kindergarten = report.kindergarten;
        dto.barrier = report.barrier;
        dto.hill = report.hill;
        dto.layout = report.layout;
        dto.distance = report.distance;
        dto.sound = report.sound;
        dto.underground = report.underground;
        dto.parking = report.parking;
        dto.clean = report.clean;
        dto.playground = report.playground;
        dto.store = report.store;
        dto.atm = report.atm;
        dto.memo = report.memo;
        dto.totalScore = report.totalScore;
        dto.user = UserResponseDto.of(report.user);

        return dto;
    }
}
</p>
                                </div>                <div id="SE-4797381f-dc77-4a1a-9a58-e70e181dc2fa">
                                    <p id="SE-d8c92533-b028-4096-a7fa-9ea7e31af4e8"><span id="SE-3812e309-8926-417e-82be-1b87754ec130">​</span></p><p id="SE-46cd5e09-e7f9-4d6a-9b2f-ac8f90dc5b04"><span id="SE-5ed60a2f-677e-4282-8a04-f15711c8dd19">해당 DTO를 반영하기 위해 보고서 서비스 일부 코드를 수정합니다.</span></p>
                            </div>                <div id="SE-59e4359d-ff2b-425b-82f5-79a8982bea69">
                                    <p>// src/resource/report/report/report.service.ts
import { Injectable } from '@nestjs/common';
import { ReportRepository } from './report.repository';
import { CreateReportDto, UpdateReportDto } from './dto/report.dto';
import { UserRepository } from '../user/user.repository';

@Injectable()
export class ReportService {
    constructor(
        private readonly reportRepo: ReportRepository,
        private readonly userRepo: UserRepository,
    ) {}

    async getReports() {
        return await this.reportRepo.findAll();
    }

    async getReport(id: number) {
        return await this.reportRepo.findById(id);
    }

    async postReport(createReportDto: CreateReportDto) {
        const user = await this.userRepo.findById(18);
        const createReport = this.reportRepo.create({
            ...createReportDto,
            user,
        });
        return await this.reportRepo.save(createReport);
    }

    async putReport(id: number, updateReportDto: UpdateReportDto) {
        const user = await this.userRepo.findById(18);
        return await this.reportRepo.save({
            id,
            ...updateReportDto,
            user,
        });
    }

    async deleteReport(id: number) {
        return await this.reportRepo.softDelete({ id });
    }
}
</p>
                                </div>                                <div id="SE-7b671e25-fd9a-42cb-a7a9-6f50ce342e10">
                                    <p>// src/resource/report/report/report.facade.ts
import { Injectable } from '@nestjs/common';
import { ReportService } from './report.service';
import { CreateReportDto, UpdateReportDto } from './dto/report.dto';
import { ReportResponseDto } from './dto/report.response.dto';

@Injectable()
export class ReportFacade {
    constructor(private readonly reportService: ReportService) {}

    async getReports() {
        const reports = await this.reportService.getReports();
        return reports.map((report) =&gt; ReportResponseDto.of(report));
    }

    async getReport(id: number) {
        const report = await this.reportService.getReport(id);
        return ReportResponseDto.of(report);
    }

    async postReport(createReportDto: CreateReportDto) {
        const report = await this.reportService.postReport(createReportDto);
        return ReportResponseDto.of(report);
    }

    async putReport(id: number, updateReportDto: UpdateReportDto) {
        const report = await this.reportService.putReport(id, updateReportDto);
        return ReportResponseDto.of(report);
    }

    async deleteReport(id: number) {
        return await this.reportService.deleteReport(id);
    }
}
</p>
                                </div>                <div id="SE-52143d31-00b1-4810-9132-14c4db85c283">
                                    <p id="SE-a6ba8cf1-ba81-488d-86f0-33173ac0bc86"><span id="SE-e950f42b-3db4-4a35-909a-988c46d94db6">​</span></p><p id="SE-4b7b2174-f603-4d88-983a-324120844f68"><span id="SE-0f9d2010-5cb3-48f3-ac2b-258310e37fcb">보고서 컨트롤러에도 ApiOkResponse, ApiCreatedResponse 데코레이터를 반영합니다.</span></p>
                            </div>                <div id="SE-b005abf9-c6c4-4d86-a19e-56d34e63f23e">
                                    <p>// src/resource/report/report/report.controller.ts
import { Body, Controller, Delete, Get, Param, Post, Put } from '@nestjs/common';
import { ReportEntity } from '../../entities/report.entity';
import {
    ApiBody,
    ApiCreatedResponse,
    ApiOkResponse,
    ApiOperation,
    ApiParam,
    ApiResponse,
    ApiTags,
} from '@nestjs/swagger';
import { CreateReportDto, UpdateReportDto } from './dto/report.dto';
import { EntityExistsPipe } from '../../common/pipes/entity-exists.pipe';
import { ReportFacade } from './report.facade';
import { ReportResponseDto } from './dto/report.response.dto';

@ApiTags('보고서')
@Controller('report')
export class ReportController {
    constructor(private readonly reportFacade: ReportFacade) {}

    @ApiOperation({ summary: '전체 보고서 조회', description: '전체 보고서를 가져옵니다.' })
    @ApiOkResponse({ type: [ReportResponseDto] })
    @Get()
    async getReports() {
        return await this.reportFacade.getReports();
    }

    @ApiOperation({ summary: '보고서 조회', description: '보고서를 조회합니다.' })
    @ApiParam({
        name: 'id',
        description: '보고서 아이디',
        example: 8,
        required: true,
    })
    @ApiOkResponse({ type: ReportResponseDto })
    @Get(':id')
    async getReport(@Param('id', EntityExistsPipe(ReportEntity)) id: number) {
        return await this.reportFacade.getReport(id);
    }

    @ApiOperation({ summary: '보고서 생성', description: '보고서를 생성합니다.' })
    @ApiBody({ type: CreateReportDto })
    @ApiCreatedResponse({ type: ReportResponseDto })
    @Post()
    async postReport(@Body() createReportDto: CreateReportDto) {
        return await this.reportFacade.postReport(createReportDto);
    }

    @ApiOperation({ summary: '보고서 수정', description: '보고서를 수정합니다.' })
    @ApiParam({
        name: 'id',
        description: '보고서 아이디',
        example: 8,
        required: true,
    })
    @ApiBody({ type: UpdateReportDto })
    @ApiOkResponse({ type: ReportResponseDto })
    @Put(':id')
    async putReport(@Param('id', EntityExistsPipe(ReportEntity)) id: number, @Body() updateReportDto: UpdateReportDto) {
        return await this.reportFacade.putReport(id, updateReportDto);
    }

    @ApiOperation({ summary: '보고서 삭제', description: '보고서를 삭제합니다.' })
    @ApiParam({
        name: 'id',
        description: '보고서 아이디',
        example: 8,
        required: true,
    })
    @Delete(':id')
    async deleteReport(@Param('id', EntityExistsPipe(ReportEntity)) id: number) {
        return await this.reportFacade.deleteReport(id);
    }
}
</p>
                                </div>                                    </div></div>

개발하는 기획자. 기획하는 개발자.

사용자 응답 DTO 생성 이번 글에는 각 API 응답을 DTO로 설정해 보겠습니다. 다른 글에 비해 비교적 간단한 작업이니 빠르게 훑어 보겠습니다. 먼저 사용자 응답 DTO를 생성합니다. DTO 내부에는 static of 정적 메서드를 정의합니다. 정적 메서드는 인스턴스를 생성하지 않고도 클래스 이름을 통해 직접 호출할 수 있는 메서드로, 특정 작업을 수행하는 데 사용됩니다. 여기서는 UserEntity 객체를 매개변수로 받아, 이를 UserResponseDto 객체로 변환하여 반환하는 역할을 합니다. 즉, 데이터베이스에서 얻은 사용자 데이터(UserEntity)를 API 응답으로 적합한 형태(UserResponseDto)로 포맷팅하는 데 사용됩니다. 사용자 퍼샤드에 사용자 응답.......

Nest.js - 보고서 프로젝트 응답값 설정

댓글