feat(be): implement image upload

.devcontainer/devcontainer.json

@@ -7,7 +7,7 @@
     "database",
     "cache",
     "rabbitmq",
-    "testcase",
+    "storage",
     "test-database"
   ],
   "workspaceFolder": "/workspace",

.env.development

@@ -22,17 +22,26 @@ RABBITMQ_CONSUMER_CONNECTION_NAME=iris-consumer
 RABBITMQ_CONSUMER_TAG=consumer
 RABBITMQ_PRODUCER_CONNECTION_NAME=iris-producer
 
+# Storage
+STORAGE_BUCKET_ENDPOINT_URL=http://127.0.0.1:9000
 # Testcase Endpoint
 TESTCASE_BUCKET_NAME=test-bucket
-TESTCASE_ENDPOINT_URL=http://127.0.0.1:9000
+# TESTCASE_ENDPOINT_URL=http://127.0.0.1:9000
 TESTCASE_ACCESS_KEY=skku
 TESTCASE_SECRET_KEY=skku1234
 
+# Media Upload Endpoint
+MEDIA_BUCKET_NAME=image-bucket
+# MEDIA_BUCKET_BASE_URL=http://127.0.0.1:9000/image-bucket/
+MEDIA_ACCESS_KEY=skku
+MEDIA_SECRET_KEY=skku1234
+
 REDIS_HOST=127.0.0.1
 REDIS_PORT=6380
 
 DATABASE_URL=postgresql://postgres:1234@127.0.0.1:5433/skkuding?schema=public
 TEST_DATABASE_URL=postgresql://postgres:1234@127.0.0.1:5434/skkuding?schema=public
 
+
 # TODO: Add information where each of these variables are used
 # TODO: I want to edit values after the container is created...

.gitpod.yml

@@ -23,7 +23,7 @@ ports:
   - port: 15672 # RabbitMQ Dashboard
     onOpen: ignore
 
-  - port: 30000 # Testcase Server
+  - port: 30000 # Storage Server
     onOpen: ignore
 
 tasks:

backend/apps/admin/src/problem/model/image.output.ts

@@ -0,0 +1,10 @@
+import { Field, ObjectType } from '@nestjs/graphql'
+
+@ObjectType({ description: 'image' })
+export class Image {
+  @Field(() => String)
+  src: string
+
+  @Field(() => String)
+  alt: string
+}

backend/apps/admin/src/problem/problem.module.ts

@@ -1,11 +1,12 @@
 import { Module } from '@nestjs/common'
+import { ConfigModule } from '@nestjs/config'
 import { StorageModule } from '@admin/storage/storage.module'
 import { ProblemTagResolver, TagResolver } from './problem-tag.resolver'
 import { ProblemResolver } from './problem.resolver'
 import { ProblemService } from './problem.service'
 
 @Module({
-  imports: [StorageModule],
+  imports: [StorageModule, ConfigModule],
   providers: [ProblemResolver, ProblemTagResolver, TagResolver, ProblemService]
 })
 export class ProblemModule {}

backend/apps/admin/src/problem/problem.resolver.ts

@@ -33,6 +33,7 @@ import {
   UnprocessableDataException
 } from '@libs/exception'
 import { CursorValidationPipe, GroupIDPipe, RequiredIntPipe } from '@libs/pipe'
+import { Image } from './model/image.output'
 import {
   CreateProblemInput,
   UploadFileInput,
@@ -105,6 +106,19 @@ export class ProblemResolver {
     }
   }
 
+  @Mutation(() => Image)
+  async uploadImage(@Args('input') input: UploadFileInput) {
+    try {
+      return await this.problemService.uploadImage(input)
+    } catch (error) {
+      if (error instanceof UnprocessableDataException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
+  }
+
   @Query(() => [Problem])
   async getProblems(
     @Args(

backend/apps/admin/src/problem/problem.service.ts

@@ -1,11 +1,15 @@
 import { CACHE_MANAGER } from '@nestjs/cache-manager'
 import { Cache } from '@nestjs/cache-manager'
 import { Inject, Injectable } from '@nestjs/common'
+import { ConfigService } from '@nestjs/config'
 import { Language } from '@generated'
 import type { ContestProblem, Tag, WorkbookProblem } from '@generated'
 import { Level } from '@generated'
 import type { ProblemWhereInput } from '@generated'
+import { randomUUID } from 'crypto'
 import { Workbook } from 'exceljs'
+import type { ReadStream } from 'fs'
+import { MAX_IMAGE_SIZE } from '@libs/constants'
 import {
   DuplicateFoundException,
   EntityNotExistException,
@@ -36,6 +40,7 @@ export class ProblemService {
   constructor(
     private readonly prisma: PrismaService,
     private readonly storageService: StorageService,
+    private readonly config: ConfigService,
     @Inject(CACHE_MANAGER) private readonly cacheManager: Cache
   ) {}
 
@@ -128,25 +133,20 @@ export class ProblemService {
       throw new UnprocessableDataException(
         'Extensions except Excel(.xlsx, .xls) are not supported.'
       )
-
     const header = {}
     const problems: CreateProblemInput[] = []
-
     const workbook = new Workbook()
     const worksheet = (await workbook.xlsx.read(createReadStream()))
       .worksheets[0]
-
     worksheet.getRow(1).eachCell((cell, idx) => {
       if (!ImportedProblemHeader.includes(cell.text))
         throw new UnprocessableFileDataException(
-          `Field ${cell.text} is not supported`,
-          filename,
-          1
+          `Field ${cell.text} is not supported: ${1}`,
+          filename
         )
       header[cell.text] = idx
     })
     worksheet.spliceRows(1, 1)
-
     const unsupportedFields = [
       header['InputFileName'],
       header['InputFilePath'],
@@ -157,9 +157,8 @@ export class ProblemService {
       for (const colNumber of unsupportedFields) {
         if (row.getCell(colNumber).text !== '')
           throw new UnprocessableFileDataException(
-            'Using inputFile, outputFile is not supported',
-            filename,
-            rowNumber + 1
+            `Using inputFile, outputFile is not supported: ${rowNumber + 1}`,
+            filename
           )
       }
       const title = row.getCell(header['문제제목']).text
@@ -169,17 +168,13 @@ export class ProblemService {
       const languages: Language[] = []
       const level: Level = Level['Level' + levelText]
       const template: Template[] = []
-
       for (let text of languagesText) {
         if (text === 'Python') {
           text = 'Python3'
         }
-
         if (!(text in Language)) continue
-
         const language = text as keyof typeof Language
         const code = row.getCell(header[`${language}SampleCode`]).text
-
         template.push({
           language,
           code: [
@@ -192,42 +187,33 @@ export class ProblemService {
         })
         languages.push(Language[language])
       }
-
       if (!languages.length) {
         throw new UnprocessableFileDataException(
-          'A problem should support at least one language',
-          filename,
-          rowNumber + 1
+          `A problem should support at least one language: ${rowNumber + 1}`,
+          filename
         )
       }
-
       //TODO: specify timeLimit, memoryLimit(default: 2sec, 512mb)
-
       const testCnt = parseInt(row.getCell(header['TestCnt']).text)
       const inputText = row.getCell(header['Input']).text
       const outputs = row.getCell(header['Output']).text.split('::')
       const scoreWeights = row.getCell(header['Score']).text.split('::')
-
       if (testCnt === 0) return
-
       let inputs: string[] = []
       if (inputText === '' && testCnt !== 0) {
         for (let i = 0; i < testCnt; i++) inputs.push('')
       } else {
         inputs = inputText.split('::')
       }
-
       if (
         (inputs.length !== testCnt || outputs.length !== testCnt) &&
         inputText != ''
       ) {
         throw new UnprocessableFileDataException(
-          'TestCnt must match the length of Input and Output. Or Testcases should not include ::.',
-          filename,
-          rowNumber + 1
+          `TestCnt must match the length of Input and Output. Or Testcases should not include ::. :${rowNumber + 1}`,
+          filename
         )
       }
-
       const testcaseInput: Testcase[] = []
       for (let i = 0; i < testCnt; i++) {
         testcaseInput.push({
@@ -236,7 +222,6 @@ export class ProblemService {
           scoreWeight: parseInt(scoreWeights[i]) || undefined
         })
       }
-
       problems.push({
         title,
         description,
@@ -255,7 +240,6 @@ export class ProblemService {
         samples: []
       })
     })
-
     return await Promise.all(
       problems.map(async (data) => {
         const problem = await this.createProblem(data, userId, groupId)
@@ -264,6 +248,64 @@ export class ProblemService {
     )
   }
 
+  async uploadImage(input: UploadFileInput) {
+    const { filename, mimetype, createReadStream } = await input.file
+    const newFilename = randomUUID() + filename
+
+    if (!mimetype.includes('image/')) {
+      throw new UnprocessableDataException('Only image files can be accepted')
+    }
+
+    const fileSize = await this.getFileSize(createReadStream())
+    if (fileSize > MAX_IMAGE_SIZE) {
+      throw new UnprocessableDataException('Image size limitation exceeded')
+    }
+
+    try {
+      await this.storageService.uploadImage(
+        newFilename,
+        fileSize,
+        createReadStream(),
+        mimetype
+      )
+    } catch (error) {
+      throw new UnprocessableFileDataException(
+        'Error occurred during image upload.',
+        newFilename
+      )
+    }
+
+    return {
+      imageUrl:
+        this.config.get('STORAGE_BUCKET_ENDPOINT_URL') +
+        '/' +
+        this.config.get('MEDIA_BUCKET_NAME') +
+        '/' +
+        newFilename
+    }
+  }
+
+  async getFileSize(readStream: ReadStream): Promise<number> {
+    return new Promise((resolve) => {
+      const chunks: Buffer[] = []
+
+      readStream.on('data', (chunk: Buffer) => {
+        chunks.push(chunk)
+      })
+
+      readStream.on('end', () => {
+        const fileSize = chunks.reduce((acc, chunk) => acc + chunk.length, 0)
+        resolve(fileSize)
+      })
+
+      readStream.on('error', () => {
+        throw new UnprocessableDataException(
+          'Error occurred during calculating image size.'
+        )
+      })
+    })
+  }
+
   async getProblems(
     input: FilterProblemsInput,
     groupId: number,

backend/apps/admin/src/storage/s3.provider.ts

@@ -9,11 +9,29 @@ export const S3Provider = {
     new S3Client({
       region: 'ap-northeast-2',
       // TODO: production 환경에서는 endpoint, forcePathStyle 삭제
-      endpoint: config.get('TESTCASE_ENDPOINT_URL'),
+      // endpoint: config.get('TESTCASE_ENDPOINT_URL'),
+      endpoint: config.get('STORAGE_BUCKET_ENDPOINT_URL'),
       forcePathStyle: true,
       credentials: {
         accessKeyId: config.get('TESTCASE_ACCESS_KEY') ?? '',
         secretAccessKey: config.get('TESTCASE_SECRET_KEY') ?? ''
       }
     })
 }
+
+export const S3MediaProvider = {
+  provide: 'S3_CLIENT_MEDIA',
+  import: [ConfigModule],
+  inject: [ConfigService],
+  useFactory: async (config: ConfigService) =>
+    new S3Client({
+      region: 'ap-northeast-2',
+      // TODO: production 환경에서는 endpoint, forcePathStyle 삭제
+      endpoint: config.get('STORAGE_BUCKET_ENDPOINT_URL'),
+      forcePathStyle: true,
+      credentials: {
+        accessKeyId: config.get('MEDIA_ACCESS_KEY') ?? '',
+        secretAccessKey: config.get('MEDIA_SECRET_KEY') ?? ''
+      }
+    })
+}

backend/apps/admin/src/storage/storage.module.ts

@@ -1,11 +1,11 @@
 import { Module } from '@nestjs/common'
 import { ConfigModule } from '@nestjs/config'
-import { S3Provider } from './s3.provider'
+import { S3MediaProvider, S3Provider } from './s3.provider'
 import { StorageService } from './storage.service'
 
 @Module({
   imports: [ConfigModule],
-  providers: [S3Provider, StorageService],
+  providers: [S3Provider, S3MediaProvider, StorageService],
   exports: [StorageService]
 })
 export class StorageModule {}

backend/apps/admin/src/storage/storage.service.ts

@@ -6,13 +6,15 @@ import {
   PutObjectCommand,
   S3Client
 } from '@aws-sdk/client-s3'
+import type { ReadStream } from 'fs'
 import { type ContentType, ContentTypes } from './content.type'
 
 @Injectable()
 export class StorageService {
   constructor(
     private readonly config: ConfigService,
-    @Inject('S3_CLIENT') private readonly client: S3Client
+    @Inject('S3_CLIENT') private readonly client: S3Client,
+    @Inject('S3_CLIENT_MEDIA') private readonly mediaClient: S3Client
   ) {}
 
   async uploadObject(filename: string, content: string, type: ContentType) {
@@ -26,6 +28,23 @@ export class StorageService {
     )
   }
 
+  async uploadImage(
+    filename: string,
+    fileSize: number,
+    content: ReadStream,
+    type: string
+  ) {
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.config.get('MEDIA_BUCKET_NAME'),
+        Key: filename,
+        Body: content,
+        ContentType: type,
+        ContentLength: fileSize
+      })
+    )
+  }
+
   // TODO: uploadFile
 
   async readObject(filename: string) {