18.Next.js와 Nest.js로 사용자 인증 구현하기, 클라이언트 측에서 JWT 인증 토큰 처리 방법

최근 웹 애플리케이션 개발에서 사용자 인증은 매우 중요한 요소입니다. 특히, 프로젝트 규모가 커질수록 보안과 사용자 관리의 필요성이 증가합니다. Nest.js와 Next.js는 각각 서버 및 클라이언트 사이드에서 강력한 기능을 제공하여 사용자의 인증을 보다 쉽게 구현할 수 있습니다. 이 게시물에서는 Nest.js를 백엔드로 사용하여 JWT(JSON Web Token)를 사용한 사용자 인증을 설정하고, Next.js 클라이언트에서 이 과정을 처리하는 방법에 대해 자세히 설명하겠습니다.

1. Nest.js 소개

Nest.js는 Node.js 환경에서 서버사이드 애플리케이션을 구축하는 데 사용되는 프레임워크로, Angular에서 영감을 받아 모듈화와 의존성 주입 기능을 제공합니다. Nest.js는 TypeScript로 작성되어 있어 정적 타입 검사와 더 나은 개발 경험을 제공합니다. 빠른 개발과 유지 관리, 높은 성능을 제공하며, RESTful API 및 GraphQL 서비스를 쉽게 구축할 수 있도록 도와줍니다.

2. Next.js 소개

Next.js는 React 프레임워크를 기반으로 하는 서버 사이드 렌더링(SSR) 및 정적 웹사이트 생성(SSG)을 가능하게 해주는 프레임워크입니다. Next.js는 페이지 기반 라우팅, API 라우팅, 정적 데이터 패칭, 빠른 빌드 속도 등 다양한 기능을 제공하여 리액트 애플리케이션을 만드는 개발자들에게 많은 사랑을 받고 있습니다. 클라이언트 측 사용자 인터페이스는 Next.js를 통해 효율적으로 관리할 수 있습니다.

3. JWT(Json Web Token) 소개

JWT는 클라이언트와 서버 간의 안전한 정보 전송을 위한 오픈 스탠다드(JSON Web Token)입니다. JWT는 JSON 객체로 구성되어 있으며, 이러한 정보는 디지털 서명을 통해 안전하게 보호됩니다. JWT를 사용하여 사용자의 인증 토큰을 생성하고 클라이언트 측에서 이를 저장하여 후속 요청 시 사용자 정보를 증명할 수 있습니다.

4. Nest.js에서 사용자 인증 구현하기

4.1 Nest.js 프로젝트 설정

먼저, Nest.js 프로젝트를 생성합니다. 아래 명령어를 사용하여 Nest CLI를 설치한 후 새로운 프로젝트를 생성합니다.

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

이제 생성된 프로젝트 폴더로 이동하고 필요한 패키지를 추가합니다.

cd project-name
npm install @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt

4.2 인증 모듈 및 서비스 생성

이제 사용자 인증을 위한 모듈과 서비스를 생성해야 합니다. 먼저, 사용자 인증과 관련된 기능을 구현할 AuthModule을 생성합니다.

nest g module auth
nest g service auth
nest g controller auth

4.3 사용자 엔티티 정의

사용자 정보를 저장할 엔티티를 정의합니다.

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

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

    @Column({ unique: true })
    email: string;

    @Column()
    password: string;
}

4.4 JWT 생성 및 검증

이제 JWT를 생성하고 검증하는 방법을 설정합니다. AuthService에 다음 코드를 추가합니다.

import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { User } from './user.entity';

@Injectable()
export class AuthService {
    constructor(private jwtService: JwtService) {}

    async login(user: User) {
        const payload = { email: user.email, sub: user.id };
        return {
            access_token: this.jwtService.sign(payload),
        };
    }
}

4.5 로그인 API 구현

이제 클라이언트가 로그인할 수 있도록 로그인 API를 구현해 보겠습니다. AuthController에 로그인 메서드를 추가합니다.

import { Controller, Post, Body } from '@nestjs/common';
import { AuthService } from './auth.service';

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

    @Post('login')
    async login(@Body() loginDto: { email: string; password: string }) {
        // 실제로는 DB에서 사용자 확인 로직이 필요합니다.
        const user = { id: 1, email: loginDto.email }; 
        return this.authService.login(user);
    }
}

5. Next.js에서 클라이언트 인증 구현하기

5.1 Next.js 프로젝트 생성

Next.js 프로젝트를 생성하려면 다음 명령어를 실행합니다.

npx create-next-app@latest project-name

그 후 생성된 프로젝트 폴더로 이동합니다.

cd project-name

5.2 axios 설치

서버와 통신하기 위해 Axios를 설치합니다.

npm install axios

5.3 로그인 페이지 생성

로그인 기능을 구현할 로그인 페이지를 생성합니다. pages 폴더에 login.js를 만든 후 다음과 같이 구현합니다.

import axios from 'axios';
import { useState } from 'react';

const Login = () => {
    const [email, setEmail] = useState('');
    const [password, setPassword] = useState('');

    const handleSubmit = async (e) => {
        e.preventDefault();
        try {
            const response = await axios.post('http://localhost:3000/auth/login', {
                email,
                password,
            });
            localStorage.setItem('token', response.data.access_token);
        } catch (error) {
            console.error('Login failed:', error);
        }
    };

    return (
        
setEmail(e.target.value)} /> setPassword(e.target.value)} />
); }; export default Login;

5.4 JWT 저장 및 클라이언트 인증 처리

로그인 후 받은 JWT를 로컬 스토리지에 저장합니다. 이렇게 해 놓으면 다른 API 요청 시 토큰을 포함시켜 사용자 인증을 수행할 수 있습니다. 이를 위해 API 요청을 보내는 Axios 인스턴스를 생성하고 해당 토큰을 포함시킵니다.

import axios from 'axios';

const axiosInstance = axios.create({
    baseURL: 'http://localhost:3000',
});

axiosInstance.interceptors.request.use((config) => {
    const token = localStorage.getItem('token');
    if (token) {
        config.headers['Authorization'] = `Bearer ${token}`;
    }
    return config;
});

export default axiosInstance;

6. 결론

이번 포스트에서는 Nest.js와 Next.js를 사용하여 JWT 기반의 사용자 인증을 구현하는 방법을 살펴보았습니다. Nest.js는 강력한 서버 사이드 기능을 제공하며, Next.js는 클라이언트 측에서 사용자 인증을 처리하는 데 유용합니다. 이 조합은 현대 웹 애플리케이션에서 안전하고 효율적인 사용자 인증 시스템을 구축할 수 있게 해줍니다. 프로젝트 제작 시 이와 같은 인증 시스템을 반드시 구현하여 보안을 강화하는 것이 중요합니다.

미래의 어플리케이션에서는 사용자 경험을 향상시키고 보안을 강화하기 위해 다양한 인증 방법이 지속적으로 발전할 것입니다. 따라서, 최신의 인증 방식과 보안 정책을 이해하는 것이 중요합니다. 이 강좌가 여러분의 Nest.js와 Next.js 프로젝트에 도움이 되기를 바랍니다.

7. 참고 자료

14.Next.js와 Nest.js 연동하여 데이터 가져오기, Nest.js API와 프론트엔드의 통신 구조 이해

프론트엔드와 백엔드 개발의 통합은 현대 웹 애플리케이션 개발의 중요한 요소 중 하나입니다. 본 글에서는 Next.js와 Nest.js를 사용하여 데이터 가져오기와 API 통신 구조에 대해 깊이 있는 설명을 제공합니다.

1. Next.js와 Nest.js 소개

Next.js는 React 기반의 프레임워크로, 서버 사이드 렌더링(SSR) 및 정적 사이트 생성을 지원합니다. 이로 인해 SEO 최적화 및 빠른 페이지 로딩 속도를 구현할 수 있습니다. 반면, Nest.js는 TypeScript 기반의 백엔드 프레임워크로, 모듈화 및 테스트 용이성을 중시하는 구조를 가지고 있습니다. 이 두 프레임워크의 결합은 강력한 풀스택 개발 환경을 만들어냅니다.

2. Nest.js API 생성하기

Nest.js를 사용하여 RESTful API를 생성하는 과정은 다음과 같습니다.

2.1 Nest.js 설치

우선 Nest.js를 설치합니다. 터미널에서 다음 명령어를 실행합니다:
npm i -g @nestjs/cli
그 후 새로운 프로젝트를 생성합니다:
nest new project-name

2.2 컨트롤러 및 서비스 생성

API의 기본 구성 요소로서 컨트롤러와 서비스를 생성합니다. 예를 들어, 사용자 데이터를 가져오는 API를 추가합니다. 터미널에서 다음 명령어를 실행합니다:
nest generate controller users
nest generate service users

2.3 비즈니스 로직 구현

users.service.ts 파일에서 간단한 메모리 기반의 사용자 데이터를 추가합니다:

class UsersService {
    private users = [
        { id: 1, name: 'John Doe' },
        { id: 2, name: 'Jane Doe' },
    ];

    findAll() {
        return this.users;
    }
}
                

2.4 API Route 설정

users.controller.ts 파일을 수정하여 GET 요청을 처리합니다:

@Controller('users')
export class UsersController {
    constructor(private readonly usersService: UsersService) {}

    @Get()
    findAll() {
        return this.usersService.findAll();
    }
}
                

2.5 Nest.js 서버 실행

모든 설정이 완료되면 Nest.js 서버를 실행합니다:
npm run start
이로써 API 서버가 http://localhost:3000/users에서 실행됩니다.

3. Next.js에서 API 호출하기

이제 Next.js를 사용하여 Nest.js에서 만든 API로부터 데이터를 가져오는 과정을 설명합니다.

3.1 Next.js 설치

새로운 Next.js 프로젝트를 생성합니다. 터미널에서 다음 명령어를 실행합니다:
npx create-next-app client

3.2 API 호출 구현

Next.js의 페이지 인터페이스에서 Nest.js API를 호출합니다. pages/index.js 파일을 수정하여 데이터를 가져옵니다:

import { useEffect, useState } from 'react';

export default function Home() {
    const [users, setUsers] = useState([]);

    useEffect(() => {
        fetch('http://localhost:3000/users')
            .then(response => response.json())
            .then(data => setUsers(data));
    }, []);

    return (
        

사용자 목록

    {users.map(user => (
  • {user.name}
  • ))}
); }

3.3 CORS 설정

Nest.js와 Next.js가 서로 다른 포트를 사용하기 때문에 CORS 설정이 필요합니다. main.ts 파일을 수정하여 CORS를 허용합니다:

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

4. 데이터 통신 구조 이해하기

Next.js와 Nest.js 간의 데이터 통신 구조는 클라이언트-서버 아키텍처에 기반합니다. 클라이언트는 사용자 요청을 생성하고, 서버는 요청을 처리하여 응답을 반환합니다. 이 과정에서 API 요청 시 발생하는 데이터를 어떻게 관리할지에 대한 고민이 필요합니다.

4.1 상태 관리

Next.js에서 데이터의 상태 관리에는 React의 상태 관리 훅을 사용할 수 있으며, 이외에도 Redux나 Zustand와 같은 외부 상태 관리 라이브러리를 활용할 수 있습니다.

4.2 응답 구조 설계

API의 응답 구조도 고려해야 합니다. 예를 들어, 클라이언트에서 데이터를 구분하기 쉽도록 응답 시 각 데이터에 대한 메타 정보를 포함시켜 구현할 수 있습니다.

5. 결론

Next.js와 Nest.js의 조합은 현대 웹 애플리케이션 개발에 매우 강력한 도구입니다. 두 프레임워크를 통합하면 SEO 최적화 및 모듈화된 코드 베이스를 유지하면서도 효율적인 데이터 통신 구조를 설계할 수 있습니다. 이 글을 통해 기본적인 데이터 가져오기와 API 통신 구조에 대한 이해를 돕고자 했습니다. 지속적인 학습을 통해 보다 깊이 있는 통합 개발을 경험하시길 바랍니다.

25.블로그 포스트 작성 및 에디터 기능 추가, Next.js에 마크다운 에디터 추가하기

최근 몇 년간 블로그와 콘텐츠 관리 시스템에서 마크다운(Markdown)의 사용이 급증했습니다.
마크다운은 간편하고 직관적인 문법을 제공하여, 사용자가 텍스트를 쉽게 포맷할 수 있게 해줍니다.
이번 포스트에서는 Next.js를 기반으로 마크다운 에디터를 추가하는 방법에 대해 자세히 설명하겠습니다.
또한 블로그 포스트 작성 및 에디터 기능 추가에 필요한 기술 스택과 구성 요소에 대해서도 다룰 것입니다.

1. Next.js 개요

Next.js는 React 기반의 정적 웹사이트 및 서버 사이드 렌더링(SSR) 웹 애플리케이션을 구축하기 위한 프레임워크입니다.
Next.js는 SEO 친화적이며, 페이지 최적화 및 코드 스플리팅을 자동으로 처리하여 성능을 극대화합니다.
이외에도 API 라우팅, 이미지 최적화, 정적 생성 등 다양한 기능을 제공하여 개발자들이 생산성을 높일 수 있도록 돕습니다.

Next.js 설치 및 설정

Next.js 프로젝트를 시작하려면 Node.js 및 npm이 설치되어 있어야 합니다.
다음 명령어를 통해 Next.js 프로젝트를 생성할 수 있습니다.

npx create-next-app my-blog

2. 마크다운 및 마크다운 에디터

마크다운은 텍스트 기반의 경량 마크업 언어로, HTML과 유사한 형식을 사용하여 문서의 구조를 정의할 수 있습니다.
마크다운을 활용하면 블로그 글 작성 시 포맷팅이 간편하고 빠르게 진행될 수 있습니다.
이번 섹션에서는 간단한 마크다운 문서를 작성해 보겠습니다.

마크다운 예시


# 제목 1
## 제목 2
### 제목 3

이것은 두 번째 단락입니다.

- 리스트 항목 1
- 리스트 항목 2
- 리스트 항목 3

[링크 텍스트](http://example.com)

**강조된 텍스트**
    

3. Next.js에 마크다운 에디터 추가하기

Next.js 프로젝트에 마크다운 에디터를 추가하기 위해 여러 패키지를 설치하고 설정해야 합니다.
다음은 우리가 사용할 주요 패키지 목록입니다.

  • react-markdown: 마크다운을 React 컴포넌트로 변환합니다.
  • react-quill: WYSIWYG 마크다운 에디터를 제공합니다.
  • remark-gfm: GitHub 스타일 마크다운을 지원합니다.

패키지 설치

아래 명령어를 사용하여 필요한 패키지를 설치합니다.

npm install react-markdown react-quill remark-gfm

에디터 컴포넌트 만들기

React 컴포넌트를 사용하여 마크다운 에디터를 만들고, 이를 Next.js에 통합합니다.
components/MarkdownEditor.js라는 파일을 생성하고 다음 코드를 추가합니다.


import React, { useState } from 'react';
import ReactQuill from 'react-quill';
import 'react-quill/dist/quill.snow.css'; // 스타일 추가

const MarkdownEditor = () => {
    const [text, setText] = useState('');

    return (
        

미리보기

); }; export default MarkdownEditor;

페이지에서 에디터 사용하기

이제 작성한 에디터 컴포넌트를 페이지에서 사용해 보겠습니다.
pages/index.js 파일에 아래의 코드를 추가합니다.


import MarkdownEditor from '../components/MarkdownEditor';

export default function Home() {
    return (
        

블로그 포스트 작성

); }

4. 마크다운 파일 저장 및 불러오기

작성한 내용은 어딘가에 저장되어야 합니다. 이번 섹션에서는 마크다운 파일을 저장하고 불러오는 로직을 구현합니다.
파일 시스템 모듈을 사용하여 만들 수 있습니다.

파일 시스템 사용하기


import fs from 'fs';
import path from 'path';

const filePath = path.join(process.cwd(), 'posts', 'my-post.md');

const savePost = (content) => {
    fs.writeFileSync(filePath, content);
};

const loadPost = () => {
    return fs.readFileSync(filePath, 'utf8');
};
    

요청 핸들러 구축하기

Next.js의 API 라우트를 사용하여 클라이언트와 서버 간의 데이터 요청을 처리할 수 있습니다.
pages/api/posts.js 파일을 생성하고 POST, GET 요청을 처리하는 코드를 추가합니다.


export default function handler(req, res) {
    if (req.method === 'POST') {
        savePost(req.body.content);
        res.status(200).json({ message: '포스트 저장 완료' });
    } else {
        const content = loadPost();
        res.status(200).json({ content });
    }
}
    

5. 전체 구현 예시

위의 모든 코드를 모아 완성된 블로그 포스트 작성기 에디터를 구현해보겠습니다. 최종 코드는 아래와 같습니다.


// components/MarkdownEditor.js
import React, { useState, useEffect } from 'react';
import ReactQuill from 'react-quill';
import ReactMarkdown from 'react-markdown';
import remarkGfm from 'remark-gfm';
import 'react-quill/dist/quill.snow.css';

const MarkdownEditor = () => {
    const [text, setText] = useState('');

    useEffect(() => {
        const loadPost = async () => {
            const response = await fetch('/api/posts');
            const data = await response.json();
            setText(data.content);
        };

        loadPost();
    }, []);

    const savePost = async () => {
        await fetch('/api/posts', {
            method: 'POST',
            body: JSON.stringify({ content: text }),
            headers: {
                'Content-Type': 'application/json',
            },
        });
    };

    return (
        

미리보기

); }; export default MarkdownEditor; // pages/index.js import MarkdownEditor from '../components/MarkdownEditor'; export default function Home() { return (

블로그 포스트 작성

); } // pages/api/posts.js import fs from 'fs'; import path from 'path'; const filePath = path.join(process.cwd(), 'posts', 'my-post.md'); const savePost = (content) => { fs.writeFileSync(filePath, content); }; const loadPost = () => { return fs.readFileSync(filePath, 'utf8'); }; export default function handler(req, res) { if (req.method === 'POST') { savePost(req.body.content); res.status(200).json({ message: '포스트 저장 완료' }); } else { const content = loadPost(); res.status(200).json({ content }); } }

6. 마무리

이번 포스트에서는 Next.js를 기반으로 마크다운 에디터를 추가하는 방법에 대해 알아보았습니다.
간단한 WYSIWYG 에디터를 통해 블로그 포스트를 작성하고, 서버에 데이터를 저장하는 방법까지 다뤘습니다.
앞으로 추가적인 기능을 구현하여 더욱더 풍부한 블로그 작성 경험을 제공할 수 있습니다.
Next.js의 애드온을 사용하여 자신만의 블로그 플랫폼을 만들어 보세요!

29.이미지 업로드 및 미디어 관리, Nest.js에서 파일 업로드 API 구축

이 글에서는 Nest.js 프레임워크를 사용하여 이미지 업로드 및 미디어 관리 기능을 갖춘 API를 구축하는 방법에 대해 단계별로 설명하겠습니다. 또한, 파일 업로드와 관련된 여러 가지 이론적 배경과 이를 구현하기 위한 코드를 포함하겠습니다.

1. Nest.js 소개

Nest.js는 모던 JavaScript와 TypeScript 기반의 웹 애플리케이션 프레임워크입니다. 엔터프라이즈 애플리케이션을 구축하기 위해 필요한 기능을 갖추고 있으며, 효율적인 모듈화와 테스트 용이성을 제공합니다. 기존의 Express.js에 기반하고 있지만, 더 많은 기능과 구조를 제공합니다.

2. 파일 업로드 API 구축의 필요성

파일 업로드는 웹 애플리케이션에서 흔히 필요한 기능 중 하나입니다. 사용자에게 파일을 업로드할 수 있는 기능을 제공함으로써 다양한 서비스—사진 공유, 문서 첨부, 미디어 관리—를 가능하게 합니다. 이러한 API를 통해 사용자는 사용자의 데이터를 서버에 안전하게 저장할 수 있습니다.

3. Nest.js 프로젝트 설정하기

먼저 Nest.js 프로젝트를 설정해야 합니다. 아래 명령어를 사용하여 프로젝트를 생성합니다.

npm i -g @nestjs/cli
nest new media-upload

프로젝트를 생성한 후, 필요한 모듈을 설치합니다. 주요 모듈로는 multer@nestjs/platform-express가 있습니다.

npm install --save multer @nestjs/platform-express

4. 이미지 업로드를 위한 DTO 설계

이미지 업로드를 처리하기 위한 데이터 전송 객체(DTO)를 설계합니다. DTO는 클라이언트와 서버 간에 데이터가 전송될 때의 구조를 정의합니다. 아래는 파일 업로드를 위한 간단한 DTO 예시입니다.

import { IsNotEmpty } from 'class-validator';
        
        export class UploadImageDto {
            @IsNotEmpty()
            readonly image: Express.Multer.File;
        }

5. 파일 업로드를 위한 서비스 구현

이제 파일 업로드를 처리할 서비스를 구현해야 합니다. 이를 위해, ‘upload.service.ts’ 파일을 생성하고 다음의 내용을 구현합니다.

import { Injectable } from '@nestjs/common';
        import { join } from 'path';
        import { v4 as uuid } from 'uuid';
        
        @Injectable()
        export class UploadService {
            async uploadFile(file: Express.Multer.File): Promise {
                const fileName = `${uuid()}-${file.originalname}`;
                const filePath = join(__dirname, '..', '..', 'uploads', fileName);
                // file system API 등을 사용해 파일을 저장
                return filePath;
            }
        }

위의 서비스에서는 UUID를 사용하여 파일 이름을 생성하고, 파일이 업로드될 경로를 정의합니다. 이후 파일 시스템 API를 사용하여 파일을 저장합니다.

6. 파일 업로드를 위한 컨트롤러 구현

이제 사용자가 파일을 업로드할 수 있도록 제어하는 컨트롤러를 작성합니다. 아래는 ‘upload.controller.ts’의 예시입니다.

import { Controller, Post, UseInterceptors, UploadedFile, Body } from '@nestjs/common';
        import { FileInterceptor } from '@nestjs/platform-express';
        import { UploadService } from './upload.service';
        import { UploadImageDto } from './dto/upload-image.dto';
        
        @Controller('uploads')
        export class UploadController {
            constructor(private readonly uploadService: UploadService) {}
        
            @Post('image')
            @UseInterceptors(FileInterceptor('image'))
            async uploadImage(@UploadedFile() file: Express.Multer.File, @Body() uploadImageDto: UploadImageDto) {
                const filePath = await this.uploadService.uploadFile(file);
                return { url: filePath };
            }
        }

위의 컨트롤러에서는 HTTP POST 요청을 처리하여 사용자가 업로드한 이미지 파일을 받아 처리합니다. ‘FileInterceptor’를 사용하여 파일 업로드를 간편하게 처리할 수 있습니다.

7. 업로드 경로 설정하기

파일이 업로드될 경로를 설정하는 방법입니다. Nest.js에서는 multer를 사용하여 파일 업로드를 쉽게 처리할 수 있습니다. 기본적으로 multer의 저장 옵션을 사용하거나, 사용자가 원하는 경로를 지정할 수 있습니다.

import { multerOptions } from './multer.options';

        export const multerOptions = {
            storage: multer.diskStorage({
                destination: (req, file, cb) => {
                    cb(null, 'uploads/');
                },
                filename: (req, file, cb) => {
                    cb(null, `${uuid()}-${file.originalname}`);
                },
            }),
        };
        

8. 미디어 관리 API 구축

이미지 업로드 API 외에도 미디어 관리를 위한 API를 구축하는 방법도 설명하겠습니다. 사용자는 업로드한 미디어 파일을 조회, 삭제할 수 있어야 합니다. 이를 위한 간단한 API를 작성해보겠습니다.

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

        @Controller('media')
        export class MediaController {
            @Get()
            findAll() {
                // DB에서 모든 미디어 파일 조회
                return mediaList;
            }

            @Delete(':id')
            remove(@Param('id') id: string) {
                // 특정 미디어 파일 삭제 처리
                return { message: 'File removed' };
            }
        }

9. 테스트 및 디버깅

이제 모든 컴포넌트가 준비되었으므로, API를 테스트하고 디버깅하는 단계입니다. Postman 또는 Insomnia와 같은 도구를 사용하여 API를 호출하고, 정상적으로 작동하는지 확인합니다.

10. 마치며

이번 포스트에서는 Nest.js를 사용하여 이미지 업로드 및 미디어 관리 API를 구축하는 방법에 대해 알아보았습니다. Nest.js는 TS 기반 프레임워크로, 멀티미디어 파일 처리를 효율적으로 할 수 있도록 도와줍니다. 이와 같은 기능은 웹 애플리케이션 개발의 필수적인 요소로, 이를 통해 사용자에게 더 나은 경험을 제공할 수 있습니다. 추가적으로, 여러 가지 보안 또는 관리 기능을 추가하여 서비스를 더욱 안전하게 사용할 수 있도록 할 수 있습니다.

작성자: {작성자 이름}

날짜: {작성 날짜}

10.Nest.js로 RESTful API 구축하기, 블로그 API의 기본 엔드포인트 설정하기 (CRUD)

Nest.js는 현대적인 웹 애플리케이션 개발을 위한 강력한 프레임워크로, TypeScript로 작성되어 있습니다. Nest.js는 다양한 아키텍처와 디자인 패턴을 지원하며, 특히 RESTful API 구축에 유용합니다. 이 글에서는 Nest.js를 사용하여 블로그 API의 기본 엔드포인트를 설정하고, CRUD(Create, Read, Update, Delete) 작업을 구현하는 과정을 살펴보겠습니다.

1. Nest.js 소개

Nest.js는 Angular에서 영감을 받아 만들어진 Node.js의 프레임워크로, 모듈화, 의존성 주입(DI), 그리고 유연한 구조를 제공합니다. Nest.js는 Express.js를 기반으로 하며, 다양한 라이브러리와 미들웨어를 활용하여 강력한 API 서버를 구축할 수 있습니다.

2. Nest.js 설치 및 프로젝트 생성

Nest.js를 사용하기 위해 먼저 Nest CLI를 설치하고, 새로운 프로젝트를 생성해야 합니다. Nest CLI는 Nest.js 프로젝트를 빠르게 생성하고 관리할 수 있는 도구입니다.

npm install -g @nestjs/cli
nest new blog-api

명령어를 입력하면, 새로운 디렉터리가 생성되고 관련 파일과 종속성이 설치됩니다. 프로젝트 디렉터리로 이동하여 서버를 실행할 수 있습니다.

cd blog-api
npm run start

3. 블로그 API 기본 엔드포인트 설계

블로그 API는 여러 개의 엔드포인트를 통해 블로그 게시물을 관리합니다. 기본적인 CRUD 작업을 위한 엔드포인트는 다음과 같습니다.

  • GET /posts: 모든 게시물 조회
  • GET /posts/:id: 특정 게시물 조회
  • POST /posts: 새로운 게시물 생성
  • PUT /posts/:id: 게시물 수정
  • DELETE /posts/:id: 게시물 삭제

4. 게시물 모듈 생성

Nest.js의 모듈 시스템을 이용하여 게시물 모듈을 생성할 수 있습니다. 아래 명령어를 입력하여 게시물 모듈을 생성합니다.

nest generate module posts
nest generate controller posts
nest generate service posts

위 명령어를 통해 posts라는 이름의 모듈, 컨트롤러, 서비스를 생성합니다. 생성된 파일들은 src/posts 디렉터리 안에 위치하게 됩니다.

5. 게시물 DTO(Data Transfer Object) 정의

게시물 데이터의 형식을 정의하기 위해 DTO를 설정합니다. DTO는 클라이언트와의 데이터 교환을 위한 객체로, 데이터의 유효성을 검사하는 데도 사용됩니다. 다음과 같은 게시물 DTO를 정의하겠습니다.

import { IsNotEmpty, IsString } from 'class-validator';

export class CreatePostDto {
    @IsNotEmpty()
    @IsString()
    readonly title: string;

    @IsNotEmpty()
    @IsString()
    readonly content: string;
}

6. 게시물 서비스 구현

게시물 서비스를 사용하여 데이터의 비즈니스 로직을 관리합니다. 서비스는 데이터베이스와의 상호작용, 데이터 처리 등을 담당합니다. 다음은 간단한 게시물 서비스 코드입니다.

import { Injectable, NotFoundException } from '@nestjs/common';
import { CreatePostDto } from './dto/create-post.dto';

@Injectable()
export class PostsService {
    private posts = [];

    create(createPostDto: CreatePostDto) {
        const newPost = {
            id: this.posts.length + 1,
            ...createPostDto,
        };
        this.posts.push(newPost);
        return newPost;
    }

    findAll() {
        return this.posts;
    }

    findOne(id: number) {
        const post = this.posts.find(p => p.id === id);
        if (!post) {
            throw new NotFoundException(`Post with ID ${id} not found`);
        }
        return post;
    }

    update(id: number, updatePostDto: CreatePostDto) {
        const postIndex = this.posts.findIndex(p => p.id === id);
        if (postIndex === -1) {
            throw new NotFoundException(`Post with ID ${id} not found`);
        }
        this.posts[postIndex] = { id, ...updatePostDto };
        return this.posts[postIndex];
    }

    delete(id: number) {
        const postIndex = this.posts.findIndex(p => p.id === id);
        if (postIndex === -1) {
            throw new NotFoundException(`Post with ID ${id} not found`);
        }
        this.posts.splice(postIndex, 1);
        return { message: 'Post deleted successfully' };
    }
}

7. 게시물 컨트롤러 구현

마지막으로, HTTP 요청을 처리하는 게시물 컨트롤러를 구현합니다. 각 엔드포인트에 해당하는 메소드를 정의하여 요청을 처리합니다.

import { Controller, Get, Post, Body, Param, Put, Delete } from '@nestjs/common';
import { PostsService } from './posts.service';
import { CreatePostDto } from './dto/create-post.dto';

@Controller('posts')
export class PostsController {
    constructor(private readonly postsService: PostsService) {}

    @Post()
    create(@Body() createPostDto: CreatePostDto) {
        return this.postsService.create(createPostDto);
    }

    @Get()
    findAll() {
        return this.postsService.findAll();
    }

    @Get(':id')
    findOne(@Param('id') id: string) {
        return this.postsService.findOne(+id);
    }

    @Put(':id')
    update(@Param('id') id: string, @Body() updatePostDto: CreatePostDto) {
        return this.postsService.update(+id, updatePostDto);
    }

    @Delete(':id')
    delete(@Param('id') id: string) {
        return this.postsService.delete(+id);
    }
}

8. API 테스트

API를 테스트하기 위해 Postman 또는 Insomnia와 같은 API 클라이언트를 사용할 수 있습니다. 아래는 각 엔드포인트를 테스트하기 위한 방법입니다.

  • POST /posts: 새 게시물 생성
  • GET /posts: 모든 게시물 조회
  • GET /posts/:id: 특정 게시물 조회
  • PUT /posts/:id: 게시물 업데이트
  • DELETE /posts/:id: 게시물 삭제

8.1 새 게시물 생성 예제

POST /posts
Content-Type: application/json

{
    "title": "첫 번째 게시물",
    "content": "이것은 첫 번째 게시물의 내용입니다."
}

8.2 모든 게시물 조회 예제

GET /posts

8.3 특정 게시물 조회 예제

GET /posts/1

8.4 게시물 수정 예제

PUT /posts/1
Content-Type: application/json

{
    "title": "수정된 게시물 제목",
    "content": "수정된 내용입니다."
}

8.5 게시물 삭제 예제

DELETE /posts/1

9. 결론

이번 글에서는 Nest.js를 사용하여 블로그 API의 기본 CRUD 엔드포인트를 생성하는 방법을 살펴보았습니다. Nest.js는 직관적이고 유연한 API 개발을 가능하게 하며, 간결하고 유지보수하기 쉬운 코드를 작성할 수 있게 도와줍니다. 이제 여러분은 Nest.js를 활용하여 자신의 요구에 맞는 API를 완성해보시기 바랍니다.

10. 다음 단계

이 튜토리얼을 마친 후, 다음 단계로는 데이터베이스와의 연동을 추가하여 영속성을 제공하는 방법을 분석할 수 있습니다. TypeORM 또는 Sequelize와 같은 ORM 라이브러리를 사용하여 데이터베이스에 저장하고 관리하는 방법에 대해 배우는 것도 추천합니다.