✨ Feature: 파일 업로드 기능 추가

build.gradle

@@ -31,6 +31,7 @@ ext {
 }
 
 dependencies {
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
     implementation 'org.springframework.boot:spring-boot-starter-web'
@@ -41,8 +42,17 @@ dependencies {
     annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.jetbrains.kotlin:kotlin-test-junit5'
+    testImplementation("org.mockito.kotlin:mockito-kotlin:5.3.1")
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
     runtimeOnly 'org.postgresql:postgresql'
+    testRuntimeOnly("com.h2database:h2")
+
+    // swagger
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.7.0'
+
+    // s3
+    implementation(platform("software.amazon.awssdk:bom:2.25.70"))
+    implementation("software.amazon.awssdk:s3")
 }
 
 dependencyManagement {

src/main/kotlin/simplerag/ragback/domain/document/controller/DataFileController.kt

@@ -0,0 +1,44 @@
+package simplerag.ragback.domain.document.controller
+
+import io.swagger.v3.oas.annotations.Parameter
+import io.swagger.v3.oas.annotations.media.Content
+import jakarta.validation.Valid
+import jakarta.validation.constraints.Size
+import org.springframework.http.HttpStatus
+import org.springframework.http.MediaType
+import org.springframework.validation.annotation.Validated
+import org.springframework.web.bind.annotation.*
+import org.springframework.web.multipart.MultipartFile
+import simplerag.ragback.domain.document.dto.DataFileBulkCreateRequest
+import simplerag.ragback.domain.document.dto.DataFileResponseList
+import simplerag.ragback.domain.document.service.DataFileService
+import simplerag.ragback.global.response.ApiResponse
+
+@RestController
+@RequestMapping("/api/v1/data-files")
+@Validated
+class DataFileController(
+    private val dataFileService: DataFileService
+) {
+
+    @PostMapping(
+        consumes = [
+            MediaType.MULTIPART_FORM_DATA_VALUE,
+        ]
+    )
+    @ResponseStatus(HttpStatus.CREATED)
+    fun upload(
+        @RequestPart("files")
+        @Size(min = 1, message = "최소 하나 이상 업로드해야 합니다")
+        files: List<MultipartFile>,
+
+        @Parameter(content = [Content(mediaType = MediaType.APPLICATION_JSON_VALUE)])
+        @RequestPart("request")
+        @Valid
+        req: DataFileBulkCreateRequest
+    ): ApiResponse<DataFileResponseList> {
+        val saved = dataFileService.upload(files, req)
+        return ApiResponse.ok(saved, "업로드 완료")
+    }
+
+}

src/main/kotlin/simplerag/ragback/domain/document/dto/DataFileRequestDTO.kt

@@ -0,0 +1,20 @@
+package simplerag.ragback.domain.document.dto
+
+import jakarta.validation.Valid
+import jakarta.validation.constraints.NotBlank
+import jakarta.validation.constraints.Size
+
+data class DataFileBulkCreateRequest(
+    @field:Size(min = 1, message = "최소 하나 이상 업로드해야 합니다")
+    @Valid
+    val items: List<DataFileCreateItem>
+)
+
+data class DataFileCreateItem(
+    @field:NotBlank(message = "title은 비어있을 수 없습니다")
+    @field:Size(max = 100)
+    val title: String,
+
+    @field:Size(max = 10, message = "태그는 최대 10개까지 가능합니다")
+    val tags: List<String> = emptyList()
+)

src/main/kotlin/simplerag/ragback/domain/document/dto/DataFileResponseDTO.kt

@@ -0,0 +1,10 @@
+package simplerag.ragback.domain.document.dto
+
+data class DataFileResponseList(
+    val dataFilePreviewResponseList: List<DataFilePreviewResponse>,
+)
+
+data class DataFilePreviewResponse(
+    val id: Long,
+    val sha256: String,
+)

src/main/kotlin/simplerag/ragback/domain/document/entity/DataFile.kt

@@ -0,0 +1,36 @@
+package simplerag.ragback.domain.document.entity
+
+import jakarta.persistence.*
+import java.time.LocalDateTime
+
+@Entity
+@Table(
+    name = "data_file",
+    uniqueConstraints = [UniqueConstraint(columnNames = ["sha256"])]
+)
+class DataFile(
+
+    @Column(nullable = false, length = 255)
+    val title: String,
+
+    @Column(name = "file_type", nullable = false, length = 120)
+    val type: String,
+
+    @Column(name = "size_bytes", nullable = false)
+    val sizeBytes: Long,
+
+    @Column(nullable = false, length = 64)
+    val sha256: String,
+
+    @Column(nullable = false, length = 2048)
+    val fileUrl: String,
+
+    @Column(nullable = false)
+    val updatedAt: LocalDateTime,
+
+    @Column(nullable = false)
+    val createdAt: LocalDateTime,
+
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    val id: Long? = null,
+)

src/main/kotlin/simplerag/ragback/domain/document/entity/DataFileTag.kt

@@ -0,0 +1,22 @@
+package simplerag.ragback.domain.document.entity
+
+import jakarta.persistence.*
+
+@Entity
+@Table(
+    name = "data_file_tags",
+    uniqueConstraints = [UniqueConstraint(columnNames = ["data_file_id", "tag_id"])]
+)
+class DataFileTag(
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "tag_id", nullable = false)
+    var tag: Tag,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "data_file_id", nullable = false)
+    var dataFile: DataFile,
+
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    val id: Long? = null,
+)

src/main/kotlin/simplerag/ragback/domain/document/entity/Tag.kt

@@ -0,0 +1,17 @@
+package simplerag.ragback.domain.document.entity
+
+import jakarta.persistence.*
+
+@Entity
+@Table(
+    name = "tags",
+    uniqueConstraints = [UniqueConstraint(columnNames = ["name"])]
+)
+class Tag(
+
+    @Column(nullable = false, length = 60)
+    val name: String,
+
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    val id: Long? = null,
+)

src/main/kotlin/simplerag/ragback/domain/document/repository/DataFileRepository.kt

@@ -0,0 +1,8 @@
+package simplerag.ragback.domain.document.repository
+
+import org.springframework.data.jpa.repository.JpaRepository
+import simplerag.ragback.domain.document.entity.DataFile
+
+interface DataFileRepository : JpaRepository<DataFile, Long> {
+    fun existsBySha256(sha256: String): Boolean
+}

src/main/kotlin/simplerag/ragback/domain/document/repository/DataFileTagRepository.kt

@@ -0,0 +1,8 @@
+package simplerag.ragback.domain.document.repository
+
+import org.springframework.data.jpa.repository.JpaRepository
+import simplerag.ragback.domain.document.entity.DataFileTag
+
+interface DataFileTagRepository : JpaRepository<DataFileTag, Long> {
+    fun existsByDataFileIdAndTagId(dataFileId: Long, tagId: Long): Boolean
+}

src/main/kotlin/simplerag/ragback/domain/document/repository/TagRepository.kt

@@ -0,0 +1,11 @@
+package simplerag.ragback.domain.document.repository
+
+import org.springframework.data.jpa.repository.JpaRepository
+import simplerag.ragback.domain.document.entity.Tag
+
+interface TagRepository : JpaRepository<Tag, Long> {
+
+    fun findByName(name: String): Tag?
+
+    fun findByNameIn(names: Collection<String>): List<Tag>
+}

src/main/kotlin/simplerag/ragback/domain/document/service/DataFileService.kt

@@ -0,0 +1,133 @@
+package simplerag.ragback.domain.document.service
+
+import org.springframework.dao.DataIntegrityViolationException
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import org.springframework.transaction.support.TransactionSynchronization
+import org.springframework.transaction.support.TransactionSynchronizationManager
+import org.springframework.web.multipart.MultipartFile
+import simplerag.ragback.domain.document.dto.DataFileBulkCreateRequest
+import simplerag.ragback.domain.document.dto.DataFilePreviewResponse
+import simplerag.ragback.domain.document.dto.DataFileResponseList
+import simplerag.ragback.domain.document.entity.DataFile
+import simplerag.ragback.domain.document.entity.DataFileTag
+import simplerag.ragback.domain.document.entity.Tag
+import simplerag.ragback.domain.document.repository.DataFileRepository
+import simplerag.ragback.domain.document.repository.DataFileTagRepository
+import simplerag.ragback.domain.document.repository.TagRepository
+import simplerag.ragback.global.error.CustomException
+import simplerag.ragback.global.error.ErrorCode
+import simplerag.ragback.global.error.FileException
+import simplerag.ragback.global.util.S3Type
+import simplerag.ragback.global.util.S3Util
+import simplerag.ragback.global.util.computeMetricsStreaming
+import simplerag.ragback.global.util.resolveContentType
+import java.time.LocalDateTime
+import java.util.*
+
+@Service
+class DataFileService(
+    private val dataFileRepository: DataFileRepository,
+    private val tagRepository: TagRepository,
+    private val dataFileTagRepository: DataFileTagRepository,
+    private val s3Util: S3Util,
+) {
+
+    @Transactional
+    fun upload(
+        files: List<MultipartFile>,
+        req: DataFileBulkCreateRequest
+    ): DataFileResponseList {
+        if (files.isEmpty() || files.size != req.items.size) {
+            throw CustomException(ErrorCode.INVALID_INPUT)
+        }
+
+        val now = LocalDateTime.now()
+        val uploadedUrls = mutableListOf<String>()
+
+        registerRollbackCleanup(uploadedUrls)
+
+        val responses = files.mapIndexed { idx, file ->
+            val meta = req.items[idx]
+
+            val metrics = file.computeMetricsStreaming()
+            val sha256 = metrics.sha256
+            val sizeBytes = metrics.sizeByte
+            val type = file.resolveContentType()
+
+            if (dataFileRepository.existsBySha256(sha256)) {
+                throw FileException(ErrorCode.ALREADY_FILE, sha256)
+            }
+
+            val fileUrl = s3Util.upload(file, S3Type.ORIGINAL_FILE)
+            uploadedUrls += fileUrl
+
+            val dataFile = try {
+                dataFileRepository.save(DataFile(meta.title, type, sizeBytes, sha256, fileUrl, now, now))
+            } catch (ex: DataIntegrityViolationException) {
+                throw FileException(ErrorCode.ALREADY_FILE, sha256)
+            }
+
+            val tags = getOrCreateTags(meta.tags)
+            attachTagsIfMissing(dataFile, tags)
+
+            DataFilePreviewResponse(requireNotNull(dataFile.id), dataFile.sha256)
+        }
+
+        return DataFileResponseList(responses)
+    }
+
+    private fun registerRollbackCleanup(uploadedUrls: MutableList<String>) {
+        if (TransactionSynchronizationManager.isSynchronizationActive()) {
+            TransactionSynchronizationManager.registerSynchronization(object : TransactionSynchronization {
+                override fun afterCompletion(status: Int) {
+                    if (status == TransactionSynchronization.STATUS_ROLLED_BACK) {
+                        uploadedUrls.forEach { runCatching { s3Util.deleteByUrl(it) } }
+                    }
+                }
+            })
+        }
+    }
+
+
+    private fun getOrCreateTags(names: List<String>): List<Tag> {
+        val normalized = names
+            .map { it.trim().uppercase(Locale.ROOT) }
+            .filter { it.isNotEmpty() }
+            .distinct()
+
+        if (normalized.isEmpty()) return emptyList()
+
+        val existing = tagRepository.findByNameIn(normalized)
+        val existingByName = existing.associateBy { it.name }
+
+        val toCreate = normalized
+            .asSequence()
+            .filter { it !in existingByName }
+            .map { Tag(name = it) }
+            .toList()
+
+        val created = if (toCreate.isNotEmpty()) {
+            try {
+                tagRepository.saveAllAndFlush(toCreate)
+            } catch (ex: DataIntegrityViolationException) {
+                tagRepository.findByNameIn(toCreate.map { it.name })
+            }
+        } else emptyList()
+
+        return existing + created
+    }
+
+
+    private fun attachTagsIfMissing(dataFile: DataFile, tags: List<Tag>) {
+        val fileId = dataFile.id ?: return
+        tags.forEach { tag ->
+            val tagId = tag.id ?: return@forEach
+            val exists = dataFileTagRepository.existsByDataFileIdAndTagId(fileId, tagId)
+            if (!exists) {
+                dataFileTagRepository.save(DataFileTag(tag = tag, dataFile = dataFile))
+            }
+        }
+    }
+
+}