NestJS Multer 파일 업로드

POST /upload HTTP/1.1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="username"

john
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="avatar"; filename="photo.jpg"
Content-Type: image/jpeg

(바이너리 데이터)
------WebKitFormBoundary7MA4YWxkTrZu0gW--

import { Controller, Post, UseInterceptors, UploadedFile } from '@nestjs/common';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('files')
export class FileController {
  @Post('upload')
  @UseInterceptors(FileInterceptor('file'))
  uploadFile(@UploadedFile() file: Express.Multer.File) {
    console.log(file);
    return { filename: file.originalname, size: file.size };
  }
}

npm install -D @types/multer

import { Controller, Post, UseInterceptors, UploadedFiles } from '@nestjs/common';
import { FilesInterceptor } from '@nestjs/platform-express';

@Controller('files')
export class FileController {
  @Post('upload-multiple')
  @UseInterceptors(FilesInterceptor('files', 10)) // 최대 10개
  uploadMultiple(@UploadedFiles() files: Express.Multer.File[]) {
    return files.map(f => ({ name: f.originalname, size: f.size }));
  }
}

import { Controller, Post, UseInterceptors, UploadedFiles } from '@nestjs/common';
import { FileFieldsInterceptor } from '@nestjs/platform-express';

@Controller('files')
export class FileController {
  @Post('upload-fields')
  @UseInterceptors(
    FileFieldsInterceptor([
      { name: 'avatar', maxCount: 1 },
      { name: 'resume', maxCount: 1 },
    ]),
  )
  uploadFields(
    @UploadedFiles() files: { avatar?: Express.Multer.File[]; resume?: Express.Multer.File[] },
  ) {
    return {
      avatar: files.avatar?.[0]?.originalname,
      resume: files.resume?.[0]?.originalname,
    };
  }
}

import { AnyFilesInterceptor } from '@nestjs/platform-express';

@Post('upload-any')
@UseInterceptors(AnyFilesInterceptor())
uploadAny(@UploadedFiles() files: Express.Multer.File[]) {
  return files.map(f => ({ field: f.fieldname, name: f.originalname }));
}

import {
  UploadedFile,
  ParseFilePipe,
  MaxFileSizeValidator,
  FileTypeValidator,
} from '@nestjs/common';

@Post('upload')
@UseInterceptors(FileInterceptor('file'))
uploadFile(
  @UploadedFile(
    new ParseFilePipe({
      validators: [
        new MaxFileSizeValidator({ maxSize: 5 * 1024 * 1024 }), // 5MB
        new FileTypeValidator({ fileType: /image\/(png|jpg|jpeg|webp)/ }),
      ],
    }),
  )
  file: Express.Multer.File,
) {
  return { filename: file.originalname };
}

new MaxFileSizeValidator({
  maxSize: 10 * 1024 * 1024,
  message: '파일 크기는 10MB를 초과할 수 없습니다.',
})

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

export class ImageDimensionValidator extends FileValidator<{ maxWidth: number; maxHeight: number }> {
  constructor(options: { maxWidth: number; maxHeight: number }) {
    super(options);
  }

  isValid(file: Express.Multer.File): boolean | Promise<boolean> {
    // sharp 등의 라이브러리로 이미지 크기 검사
    // 실제 구현에서는 비동기 처리가 필요
    return true;
  }

  buildErrorMessage(): string {
    return `이미지 크기는 ${this.validationOptions.maxWidth}x${this.validationOptions.maxHeight}px 이하여야 합니다.`;
  }
}

@UploadedFile(
  new ParseFilePipe({
    validators: [
      new MaxFileSizeValidator({ maxSize: 5 * 1024 * 1024 }),
      new ImageDimensionValidator({ maxWidth: 2000, maxHeight: 2000 }),
    ],
  }),
)

new ParseFilePipe({
  fileIsRequired: false,
  validators: [
    new MaxFileSizeValidator({ maxSize: 5 * 1024 * 1024 }),
  ],
})

// 메모리 스토리지 (기본값이므로 별도 설정 불필요)
@UseInterceptors(FileInterceptor('file'))

import { diskStorage } from 'multer';
import { extname } from 'path';
import { v4 as uuid } from 'uuid';

@UseInterceptors(
  FileInterceptor('file', {
    storage: diskStorage({
      destination: './uploads',
      filename: (req, file, callback) => {
        const ext = extname(file.originalname);
        const filename = `${uuid()}${ext}`;
        callback(null, filename);
      },
    }),
  }),
)

@UseInterceptors(
  FileInterceptor('file', {
    limits: {
      fileSize: 10 * 1024 * 1024, // 10MB
      files: 5, // 최대 파일 수
    },
  }),
)

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import * as fs from 'fs/promises';
import * as path from 'path';
import { v4 as uuid } from 'uuid';

import { FileEntity } from './file.entity';

@Injectable()
export class FileService {
  private readonly basePath = '/app/uploads';

  constructor(
    @InjectRepository(FileEntity)
    private readonly fileRepository: Repository<FileEntity>,
  ) {}

  async upload(file: Express.Multer.File, userId: number) {
    // 날짜별 디렉토리 생성
    const today = new Date().toISOString().split('T')[0];
    const targetDir = path.join(this.basePath, today);
    await fs.mkdir(targetDir, { recursive: true });

    // UUID 기반 파일명으로 저장
    const ext = path.extname(file.originalname);
    const filename = `${uuid()}${ext}`;
    const filePath = path.join(targetDir, filename);

    await fs.writeFile(filePath, file.buffer);

    // DB에 메타데이터 저장
    const saved = await this.fileRepository.save({
      originalName: file.originalname,
      mimetype: file.mimetype,
      size: file.size,
      path: filePath,
      userId,
    });

    return {
      id: saved.id,
      url: this.generateAccessUrl(filePath),
    };
  }

  async delete(fileId: number) {
    const file = await this.fileRepository.findOne({ where: { id: fileId } });
    if (!file) throw new NotFoundException('파일을 찾을 수 없습니다.');

    // 파일 시스템에서 삭제
    try {
      await fs.access(file.path);
      await fs.unlink(file.path);
    } catch {
      // 파일이 이미 없어도 DB 레코드는 삭제
    }

    await this.fileRepository.delete(fileId);
  }

  private generateAccessUrl(filePath: string): string {
    return filePath.replace(this.basePath, '/files');
  }
}

import { Module } from '@nestjs/common';
import { ServeStaticModule } from '@nestjs/serve-static';
import { join } from 'path';

@Module({
  imports: [
    ServeStaticModule.forRoot({
      rootPath: '/app/uploads',
      serveRoot: '/files',
    }),
  ],
})
export class AppModule {}

interface MulterOptions {
  storage?: StorageEngine;       // 메모리 or 디스크 스토리지
  limits?: {
    fieldNameSize?: number;      // 필드명 최대 바이트 (기본 100)
    fieldSize?: number;          // 필드 값 최대 바이트 (기본 1MB)
    fields?: number;             // 비파일 필드 최대 수 (기본 무제한)
    fileSize?: number;           // 파일 최대 바이트 (기본 무제한)
    files?: number;              // 파일 최대 수 (기본 무제한)
    parts?: number;              // 파트(필드+파일) 최대 수 (기본 무제한)
    headerPairs?: number;        // 헤더 키-값 쌍 최대 수 (기본 2000)
  };
  fileFilter?: (
    req: Request,
    file: Express.Multer.File,
    callback: (error: Error | null, acceptFile: boolean) => void,
  ) => void;                     // 파일 필터링 함수
}

@UseInterceptors(
  FileInterceptor('file', {
    fileFilter: (req, file, callback) => {
      if (!file.mimetype.match(/image\/(png|jpg|jpeg|webp)/)) {
        callback(new BadRequestException('이미지 파일만 업로드할 수 있습니다.'), false);
        return;
      }
      callback(null, true);
    },
    limits: { fileSize: 5 * 1024 * 1024 },
  }),
)