From 706d7fb8cc16a6ce405310ef8cf0ca81b4b22033 Mon Sep 17 00:00:00 2001 From: chanwoo7 Date: Thu, 19 Nov 2026 04:52:44 +0900 Subject: [PATCH 1/3] =?UTF-8?q?feat:=20=EC=BB=A4=EC=8A=A4=ED=85=80=20?= =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EC=9D=B4=EB=AF=B8=EC=A7=80=20=EC=84=A0?= =?UTF-8?q?=EC=97=85=EB=A1=9C=EB=93=9C=EC=99=80=20=EB=AF=B8=EC=82=AC?= =?UTF-8?q?=EC=9A=A9=20=EC=97=85=EB=A1=9C=EB=93=9C=20=EC=A0=95=EB=A6=AC=20?= =?UTF-8?q?=ED=81=AC=EB=A1=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 구매자가 커스텀 이미지(3D 렌더·슬롯형 합성·자유 편집 참고 사진)를 주문 전에 presign으로 올리고 주문 생성 때 URL을 내도록 발급 API와 발급 기록을 둔다. 주문에 쓰이지 않은 업로드는 worker가 하루 뒤 S3에서 지우고, 주문된 파일은 보관한다. 주문 생성의 업로드 연결(소유·용도·상태 검사 후 ATTACHED)은 다음 PR이 붙인다. 변경점 - 스키마·마이그레이션(order_custom_upload): OrderCustomUpload(account_id, purpose RENDER·COMPOSITE·REFERENCE, object_key unique, content_type, content_length, status PENDING·ATTACHED·PURGING, attached_at, purge_started_at), (status, created_at)·(status, purge_started_at)·account_id 인덱스. 새 표라 백필 없음 - 업로드 용도: TS UploadPurpose·UPLOAD_POLICIES에 ORDER_CUSTOM_RENDER·COMPOSITE·REFERENCE(order-custom/{renders,composites,references}, 10MB, JPEG·PNG·WebP). 판매자·관리자 SDL UploadPurpose에는 섞지 않았다 - createOrderCustomUploadUrl(purpose: OrderCustomUploadPurpose!, contentType, contentLength): UploadUrl!. 구매자 계정만(USER_ONLY), 발급 뒤 PENDING으로 기록한다 - S3Service.deleteObjects(keys): 요청당 1000개, 키별 오류와 요청 실패를 실패 목록으로 돌려주고 던지지 않는다 - 정리 크론(매시 20분, 역할 게이트, 겹친 틱 건너뜀): PURGING ∧ 1시간 경과, PENDING ∧ 24시간 경과를 상태별 인덱스 범위로 LIMIT 500 FOR UPDATE SKIP LOCKED로 잡아 PURGING 표시·커밋 → S3 삭제 → 지워진 행만 하드 삭제. 실패한 키는 PURGING으로 남기고 error 경보(key order-custom-upload:purge), 그 틱에서는 더 잡지 않는다. 한 틱 최대 20묶음 - IAM: terraform/aws.tf 앱 정책에 s3:DeleteObject(order-custom/*) statement. apply는 사람 키로 한다 - resetSeedScope: 시드 사용자의 업로드 기록을 지운다. model-ownership: OrderCustomUpload는 order 테스트 - 정리 크론 7건(real DB, S3·경보 stub): 대상 경계(PENDING 24h·24h−1ms, PURGING 1h·1h−1ms, ATTACHED 72h 미선택), 부분 실패 PURGING 유지·경보·1시간 뒤 재시도, 묶음 이어 잡기·실패 뒤 중단, 주문 tx가 잡은 행 건너뜀, api 역할 미실행, 겹친 틱, DB 실패 경보 - S3 deleteObjects 5건(조용한 모드·키별 오류·요청 실패·1000개 분할·빈 목록), 용도 정책 3종 × 형식·크기 - 발급: 용도 3종 키·기록, 형식·크기·0 거절과 미기록, 판매자 USER_ONLY, 리졸버 1건 - resetSeedScope 업로드 기록 1건 --- .../migration.sql | 22 ++ prisma/schema.prisma | 35 +++ prisma/seed/idempotent.ts | 5 + src/features/order/order-checkout.graphql | 25 ++ src/features/order/order.module.ts | 5 + .../order-custom-upload.repository.ts | 86 ++++++ .../order-checkout-mutation.resolver.spec.ts | 30 +++ .../order-checkout-mutation.resolver.ts | 15 ++ .../services/order-checkout.service.spec.ts | 85 ++++++ .../order/services/order-checkout.service.ts | 48 +++- ...er-custom-upload-cleanup.scheduler.spec.ts | 253 ++++++++++++++++++ .../order-custom-upload-cleanup.scheduler.ts | 90 +++++++ .../storage/constants/storage.constants.ts | 16 ++ .../storage/s3.service.delete-objects.spec.ts | 113 ++++++++ src/global/storage/s3.service.spec.ts | 32 +++ src/global/storage/s3.service.ts | 47 ++++ src/global/storage/types/storage.types.ts | 5 +- src/test/factories/order.factory.ts | 34 +++ src/test/model-ownership.ts | 1 + src/test/seed-reset-scope.spec.ts | 21 ++ terraform/aws.tf | 7 + 21 files changed, 973 insertions(+), 2 deletions(-) create mode 100644 prisma/migrations/20261118190324_order_custom_upload/migration.sql create mode 100644 src/features/order/repositories/order-custom-upload.repository.ts create mode 100644 src/features/order/services/order-custom-upload-cleanup.scheduler.spec.ts create mode 100644 src/features/order/services/order-custom-upload-cleanup.scheduler.ts create mode 100644 src/global/storage/s3.service.delete-objects.spec.ts diff --git a/prisma/migrations/20261118190324_order_custom_upload/migration.sql b/prisma/migrations/20261118190324_order_custom_upload/migration.sql new file mode 100644 index 00000000..d85a4e12 --- /dev/null +++ b/prisma/migrations/20261118190324_order_custom_upload/migration.sql @@ -0,0 +1,22 @@ +-- 구매자 커스텀 이미지 presign 발급 기록. 정리 크론이 주문에 쓰이지 않은 객체를 지운다(기존 데이터 없음). +-- CreateTable +CREATE TABLE `order_custom_upload` ( + `id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT, + `account_id` BIGINT UNSIGNED NOT NULL, + `purpose` ENUM('RENDER', 'COMPOSITE', 'REFERENCE') NOT NULL, + `object_key` VARCHAR(512) NOT NULL, + `content_type` VARCHAR(50) NOT NULL, + `content_length` INTEGER UNSIGNED NOT NULL, + `status` ENUM('PENDING', 'ATTACHED', 'PURGING') NOT NULL DEFAULT 'PENDING', + `attached_at` DATETIME(3) NULL, + `purge_started_at` DATETIME(3) NULL, + `created_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3), + `updated_at` DATETIME(3) NOT NULL, + + UNIQUE INDEX `uk_order_custom_upload_key`(`object_key`), + INDEX `idx_order_custom_upload_status_created`(`status`, `created_at`), + INDEX `idx_order_custom_upload_status_purge`(`status`, `purge_started_at`), + INDEX `idx_order_custom_upload_account`(`account_id`), + PRIMARY KEY (`id`) +) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; + diff --git a/prisma/schema.prisma b/prisma/schema.prisma index 85b33b30..27ee7339 100644 --- a/prisma/schema.prisma +++ b/prisma/schema.prisma @@ -68,6 +68,20 @@ enum CustomImageKind { SLOT_COMPOSITE } +// 구매자 커스텀 이미지 선업로드 용도(3D 렌더·슬롯형 합성·자유 편집 참고 사진) +enum OrderCustomUploadPurpose { + RENDER + COMPOSITE + REFERENCE +} + +// 발급(PENDING) → 주문에 쓰임(ATTACHED, 보관) 또는 정리 중(PURGING, 주문에 붙일 수 없다) +enum OrderCustomUploadStatus { + PENDING + ATTACHED + PURGING +} + enum OrderStatus { SUBMITTED CONFIRMED @@ -1188,6 +1202,27 @@ model OrderItemCustomImage { @@map("order_item_custom_image") } +// 커스텀 이미지 presign 발급 기록. 주문에 쓰이지 않은 객체는 정리 크론이 S3에서 지우고 행도 지운다(주문된 파일은 보관) +model OrderCustomUpload { + id BigInt @id @default(autoincrement()) @db.UnsignedBigInt + account_id BigInt @db.UnsignedBigInt + purpose OrderCustomUploadPurpose + object_key String @unique(map: "uk_order_custom_upload_key") @db.VarChar(512) + content_type String @db.VarChar(50) + content_length Int @db.UnsignedInt + status OrderCustomUploadStatus @default(PENDING) + attached_at DateTime? @db.DateTime(3) + purge_started_at DateTime? @db.DateTime(3) + + created_at DateTime @default(now()) @db.DateTime(3) + updated_at DateTime @updatedAt @db.DateTime(3) + + @@index([status, created_at], map: "idx_order_custom_upload_status_created") + @@index([status, purge_started_at], map: "idx_order_custom_upload_status_purge") + @@index([account_id], map: "idx_order_custom_upload_account") + @@map("order_custom_upload") +} + // 주문 1건의 결제. 계좌이체는 PENDING으로 만들고 입금 확인(관리자, 후속 연동은 AUTO) 때 CONFIRMED가 된다. model Payment { id BigInt @id @default(autoincrement()) @db.UnsignedBigInt diff --git a/prisma/seed/idempotent.ts b/prisma/seed/idempotent.ts index ac9f8973..1761bba3 100644 --- a/prisma/seed/idempotent.ts +++ b/prisma/seed/idempotent.ts @@ -185,6 +185,11 @@ export async function resetSeedScope(prisma: PrismaClient): Promise { }); await prisma.review.deleteMany({ where: { account_id: { in: userIds } } }); + // 커스텀 이미지 선업로드 기록(계정 FK는 없지만 시드 사용자 것은 함께 지운다) + await prisma.orderCustomUpload.deleteMany({ + where: { account_id: { in: userIds } }, + }); + // 찜 await prisma.wishlistItem.deleteMany({ where: { account_id: { in: userIds } }, diff --git a/src/features/order/order-checkout.graphql b/src/features/order/order-checkout.graphql index 6e799e08..7ddba327 100644 --- a/src/features/order/order-checkout.graphql +++ b/src/features/order/order-checkout.graphql @@ -7,6 +7,31 @@ extend type Mutation { CONCURRENT_REQUEST(CONFLICT)다. 로그인 필수. """ createOrder(input: CreateOrderInput!): CreateOrderOutput! + """ + 커스텀 이미지 업로드용 Presigned URL 발급(구매자). uploadUrl로 PUT한 뒤 publicUrl을 주문 생성의 커스텀 입력에 넣는다. + JPEG·PNG·WebP, 장당 10MB 이하(아니면 INVALID_CONTENT_TYPE·FILE_TOO_LARGE). 주문에 쓰이지 않은 파일은 발급 하루 뒤 지워진다. + 구매자 계정만 쓸 수 있다(아니면 USER_ONLY). 로그인 필수. + """ + createOrderCustomUploadUrl( + """이미지 용도. 주문 생성 때 이 용도의 자리에만 쓸 수 있다.""" + purpose: OrderCustomUploadPurpose! + """파일 MIME 타입(image/jpeg·image/png·image/webp).""" + contentType: String! + """파일 크기(바이트, 1 이상 10MB 이하).""" + contentLength: Int! + ): UploadUrl! +} + +""" +구매자 커스텀 이미지 업로드 용도. 값은 늘어날 수 있으니 모르는 값을 받아도 화면이 죽지 않게 처리한다. +""" +enum OrderCustomUploadPurpose { + """3D 렌더 이미지(윗면·옆면 앞·뒤·좌·우).""" + RENDER + """슬롯형 합성 이미지(바탕 + 문구, 구매자가 본 그대로).""" + COMPOSITE + """자유 편집 참고 사진.""" + REFERENCE } """주문 생성 입력. 커스텀 필드는 커스텀 스펙 확정 후 optional로 확장 예정.""" diff --git a/src/features/order/order.module.ts b/src/features/order/order.module.ts index db97fa0e..b831613f 100644 --- a/src/features/order/order.module.ts +++ b/src/features/order/order.module.ts @@ -6,6 +6,7 @@ import { AuthModule } from '@/features/auth'; import { OrderCancelPolicy } from '@/features/order/policies/order-cancel.policy'; import { OrderStatusTransitionPolicy } from '@/features/order/policies/order-status-transition.policy'; import { OrderBookedRepository } from '@/features/order/repositories/order-booked.repository'; +import { OrderCustomUploadRepository } from '@/features/order/repositories/order-custom-upload.repository'; import { OrderStoreDailyLimitRepository } from '@/features/order/repositories/order-store-daily-limit.repository'; import { OrderTransitionRepository } from '@/features/order/repositories/order-transition.repository'; import { OrderRepository } from '@/features/order/repositories/order.repository'; @@ -30,6 +31,7 @@ import { OrderSubscriptionResolver } from '@/features/order/resolvers/order-subs import { OrderAdminAlertConsumer } from '@/features/order/services/order-admin-alert.consumer'; import { AdminOrderService } from '@/features/order/services/order-admin.service'; import { OrderCheckoutService } from '@/features/order/services/order-checkout.service'; +import { OrderCustomUploadCleanupScheduler } from '@/features/order/services/order-custom-upload-cleanup.scheduler'; import { AdminDepositService } from '@/features/order/services/order-deposit-admin.service'; import { OrderEventsService } from '@/features/order/services/order-events.service'; import { UserOrderService } from '@/features/order/services/order-my.service'; @@ -68,6 +70,9 @@ import { StoreModule } from '@/features/store'; OrderSubscriptionResolver, OrderCheckoutService, OrderCheckoutMutationResolver, + // 커스텀 이미지 선업로드 기록과 미사용분 정리(worker 크론) + OrderCustomUploadRepository, + OrderCustomUploadCleanupScheduler, // 판매자 주문 관리(목록·상세·상태 변경·거절·취소) — 주문 도메인이 소유한다 SellerOrderService, SellerOrderQueryResolver, diff --git a/src/features/order/repositories/order-custom-upload.repository.ts b/src/features/order/repositories/order-custom-upload.repository.ts new file mode 100644 index 00000000..a6570926 --- /dev/null +++ b/src/features/order/repositories/order-custom-upload.repository.ts @@ -0,0 +1,86 @@ +import { Injectable } from '@nestjs/common'; + +import { + OrderCustomUploadStatus, + type OrderCustomUploadPurpose, +} from '@/generated/prisma/client'; +import { PrismaService } from '@/prisma'; + +export interface PurgeClaim { + id: bigint; + object_key: string; +} + +@Injectable() +export class OrderCustomUploadRepository { + constructor(private readonly prisma: PrismaService) {} + + async create(args: { + accountId: bigint; + purpose: OrderCustomUploadPurpose; + objectKey: string; + contentType: string; + contentLength: number; + }): Promise { + await this.prisma.orderCustomUpload.create({ + data: { + account_id: args.accountId, + purpose: args.purpose, + object_key: args.objectKey, + content_type: args.contentType, + content_length: args.contentLength, + }, + }); + } + + /** + * 정리 대상(오래된 PENDING, 지우다 만 PURGING)을 PURGING으로 표시하고 커밋한다. 표시 뒤에는 주문이 이 업로드를 + * 붙이지 못하므로 S3에서 지워도 된다. 주문 tx가 잡고 있는 행은 SKIP LOCKED로 건너뛴다(다음 정리에서 다시 본다). + */ + async claimForPurge(args: { + now: Date; + pendingCreatedBefore: Date; + purgingStartedBefore: Date; + limit: number; + }): Promise { + return this.prisma.$transaction(async (tx) => { + // 상태별 인덱스 범위만 잠그도록 두 번 나눠 읽는다 + const retries = await tx.$queryRaw` + SELECT id, object_key FROM order_custom_upload + WHERE status = ${OrderCustomUploadStatus.PURGING} + AND purge_started_at <= ${args.purgingStartedBefore} + ORDER BY purge_started_at, id + LIMIT ${args.limit} + FOR UPDATE SKIP LOCKED`; + const fresh = + retries.length < args.limit + ? await tx.$queryRaw` + SELECT id, object_key FROM order_custom_upload + WHERE status = ${OrderCustomUploadStatus.PENDING} + AND created_at <= ${args.pendingCreatedBefore} + ORDER BY created_at, id + LIMIT ${args.limit - retries.length} + FOR UPDATE SKIP LOCKED` + : []; + const claimed = [...retries, ...fresh]; + if (claimed.length > 0) { + await tx.orderCustomUpload.updateMany({ + where: { id: { in: claimed.map((row) => row.id) } }, + data: { + status: OrderCustomUploadStatus.PURGING, + purge_started_at: args.now, + }, + }); + } + return claimed; + }); + } + + /** S3에서 지운 업로드 기록을 지운다. 정리 중인 행만 대상이다. */ + async deletePurged(ids: bigint[]): Promise { + if (ids.length === 0) return; + await this.prisma.orderCustomUpload.deleteMany({ + where: { id: { in: ids }, status: OrderCustomUploadStatus.PURGING }, + }); + } +} diff --git a/src/features/order/resolvers/order-checkout-mutation.resolver.spec.ts b/src/features/order/resolvers/order-checkout-mutation.resolver.spec.ts index 4645d706..091deeec 100644 --- a/src/features/order/resolvers/order-checkout-mutation.resolver.spec.ts +++ b/src/features/order/resolvers/order-checkout-mutation.resolver.spec.ts @@ -2,6 +2,7 @@ import { ClockService } from '@/common/providers/clock.service'; import { RandomService } from '@/common/providers/random.service'; import { AUDIT_LOG_REPOSITORY } from '@/features/audit-log'; import { AuditLogRepository } from '@/features/audit-log/repositories/audit-log.repository'; +import { OrderCustomUploadRepository } from '@/features/order/repositories/order-custom-upload.repository'; import { OrderRepository } from '@/features/order/repositories/order.repository'; import { PaymentSettingRepository } from '@/features/order/repositories/payment-setting.repository'; import { OrderCheckoutMutationResolver } from '@/features/order/resolvers/order-checkout-mutation.resolver'; @@ -23,6 +24,11 @@ import { } from '@/test/factories'; import { createTestingModuleWithRealDb } from '@/test/modules/testing-module.builder'; import { outboxPublisherProviders } from '@/test/outbox'; +import { s3TestProviders } from '@/test/storage/s3-test.helper'; + +jest.mock('@aws-sdk/s3-request-presigner', () => ({ + getSignedUrl: jest.fn().mockResolvedValue('https://mock-presigned-url.com'), +})); // 2026-09-16(수) 16:00 KST 고정 const NOW = new Date('2026-09-16T07:00:00.000Z'); @@ -39,6 +45,8 @@ describe('OrderCheckout Mutation Resolver (real DB)', () => { OrderCheckoutMutationResolver, OrderCheckoutService, OrderRepository, + OrderCustomUploadRepository, + ...s3TestProviders(), PaymentSettingRepository, ProductRepository, { provide: AUDIT_LOG_REPOSITORY, useClass: AuditLogRepository }, @@ -114,4 +122,26 @@ describe('OrderCheckout Mutation Resolver (real DB)', () => { expect(saved.account_id).toBe(account.id); expect(saved.request_note).toBe('초는 빼 주세요'); }); + + it('createOrderCustomUploadUrl: 구매자에게 용도별 업로드 URL을 발급하고 기록한다', async () => { + const account = await createAccount(prisma, { account_type: 'USER' }); + await createUserProfile(prisma, { account_id: account.id }); + const user = { accountId: account.id.toString() } as JwtUser; + + const result = await resolver.createOrderCustomUploadUrl( + user, + 'COMPOSITE', + 'image/png', + 1024, + ); + + expect(result.key).toMatch( + new RegExp(`^order-custom/composites/${account.id}/`), + ); + await expect( + prisma.orderCustomUpload.findUniqueOrThrow({ + where: { object_key: result.key }, + }), + ).resolves.toMatchObject({ account_id: account.id, purpose: 'COMPOSITE' }); + }); }); diff --git a/src/features/order/resolvers/order-checkout-mutation.resolver.ts b/src/features/order/resolvers/order-checkout-mutation.resolver.ts index 55328011..3541a9d5 100644 --- a/src/features/order/resolvers/order-checkout-mutation.resolver.ts +++ b/src/features/order/resolvers/order-checkout-mutation.resolver.ts @@ -4,12 +4,14 @@ import { Args, Mutation, Resolver } from '@nestjs/graphql'; import { CreateOrderInput } from '@/features/order/dto/inputs/create-order.input'; import { OrderCheckoutService } from '@/features/order/services/order-checkout.service'; import type { CreateOrderOutput } from '@/features/order/types/create-order-output.type'; +import type { OrderCustomUploadPurpose } from '@/generated/prisma/client'; import { CurrentUser, JwtAuthGuard, parseAccountId, type JwtUser, } from '@/global/auth'; +import type { CreateUploadUrlOutput } from '@/global/storage/types/storage.types'; @Resolver('Mutation') @UseGuards(JwtAuthGuard) @@ -23,4 +25,17 @@ export class OrderCheckoutMutationResolver { ): Promise { return this.checkoutService.createOrder(parseAccountId(user), input); } + + @Mutation('createOrderCustomUploadUrl') + createOrderCustomUploadUrl( + @CurrentUser() user: JwtUser, + @Args('purpose') purpose: OrderCustomUploadPurpose, + @Args('contentType') contentType: string, + @Args('contentLength') contentLength: number, + ): Promise { + return this.checkoutService.createOrderCustomUploadUrl( + parseAccountId(user), + { purpose, contentType, contentLength }, + ); + } } diff --git a/src/features/order/services/order-checkout.service.spec.ts b/src/features/order/services/order-checkout.service.spec.ts index 36b42a9a..94bd0a2e 100644 --- a/src/features/order/services/order-checkout.service.spec.ts +++ b/src/features/order/services/order-checkout.service.spec.ts @@ -10,6 +10,7 @@ import { parseOrderPaymentPendingPayload, } from '@/features/order/events/order-payment-pending.event'; import { ORDER_SUBMITTED } from '@/features/order/events/order-submitted.event'; +import { OrderCustomUploadRepository } from '@/features/order/repositories/order-custom-upload.repository'; import { pendingPaymentLockName } from '@/features/order/repositories/order-pending-payment-lock.helper'; import { OrderRepository } from '@/features/order/repositories/order.repository'; import { PaymentSettingRepository } from '@/features/order/repositories/payment-setting.repository'; @@ -42,6 +43,11 @@ import { import { createTestingModuleWithRealDb } from '@/test/modules/testing-module.builder'; import { outboxPublisherProviders } from '@/test/outbox'; import { collectTopic } from '@/test/pubsub'; +import { s3TestProviders, TEST_S3_CONFIG } from '@/test/storage/s3-test.helper'; + +jest.mock('@aws-sdk/s3-request-presigner', () => ({ + getSignedUrl: jest.fn().mockResolvedValue('https://mock-presigned-url.com'), +})); // 2026-09-16(수) 16:00 KST 고정 const NOW = new Date('2026-09-16T07:00:00.000Z'); @@ -62,6 +68,8 @@ describe('OrderCheckoutService (real DB)', () => { providers: [ OrderCheckoutService, OrderRepository, + OrderCustomUploadRepository, + ...s3TestProviders(), PaymentSettingRepository, ProductRepository, { provide: AUDIT_LOG_REPOSITORY, useClass: AuditLogRepository }, @@ -206,6 +214,83 @@ describe('OrderCheckoutService (real DB)', () => { }; } + describe('createOrderCustomUploadUrl', () => { + async function buyer(): Promise { + const account = await createAccount(prisma, { account_type: 'USER' }); + await createUserProfile(prisma, { account_id: account.id }); + return account; + } + + it.each([ + ['RENDER', 'order-custom/renders'], + ['COMPOSITE', 'order-custom/composites'], + ['REFERENCE', 'order-custom/references'], + ] as const)( + '%s 용도는 %s/{accountId}/ 아래로 발급하고 PENDING으로 기록한다', + async (purpose, prefix) => { + const account = await buyer(); + + const result = await service.createOrderCustomUploadUrl(account.id, { + purpose, + contentType: 'image/webp', + contentLength: 10 * 1024 * 1024, + }); + + expect(result.key).toMatch( + new RegExp( + `^${prefix}/${account.id}/\\d{4}-\\d{2}-\\d{2}/[a-f0-9-]+\\.webp$`, + ), + ); + expect(result.publicUrl).toBe( + `https://${TEST_S3_CONFIG.bucket}.s3.${TEST_S3_CONFIG.region}.amazonaws.com/${result.key}`, + ); + expect(await prisma.orderCustomUpload.findMany()).toEqual([ + expect.objectContaining({ + account_id: account.id, + purpose, + object_key: result.key, + content_type: 'image/webp', + content_length: 10 * 1024 * 1024, + status: 'PENDING', + attached_at: null, + purge_started_at: null, + }), + ]); + }, + ); + + it.each([ + ['형식이 이미지가 아님', 'video/mp4', 1024, 'INVALID_CONTENT_TYPE'], + ['10MB 초과', 'image/png', 10 * 1024 * 1024 + 1, 'FILE_TOO_LARGE'], + ['크기 0', 'image/png', 0, 'INVALID_CONTENT_LENGTH'], + ] as const)( + '%s이면 %s이고 기록하지 않는다', + async (_case, contentType, contentLength, code) => { + const account = await buyer(); + await expect( + service.createOrderCustomUploadUrl(account.id, { + purpose: 'RENDER', + contentType, + contentLength, + }), + ).rejects.toThrowDomain(code); + expect(await prisma.orderCustomUpload.count()).toBe(0); + }, + ); + + it('구매자 계정이 아니면 USER_ONLY이고 기록하지 않는다', async () => { + const seller = await createAccount(prisma, { account_type: 'SELLER' }); + await expect( + service.createOrderCustomUploadUrl(seller.id, { + purpose: 'RENDER', + contentType: 'image/png', + contentLength: 1024, + }), + ).rejects.toThrowDomain('USER_ONLY'); + expect(await prisma.orderCustomUpload.count()).toBe(0); + }); + }); + describe('createOrder', () => { it('주문을 생성하고 가격·옵션·상태 히스토리를 스냅샷한다', async () => { const store = await makeOpenStore(); diff --git a/src/features/order/services/order-checkout.service.ts b/src/features/order/services/order-checkout.service.ts index 368ba7a8..45fb0d37 100644 --- a/src/features/order/services/order-checkout.service.ts +++ b/src/features/order/services/order-checkout.service.ts @@ -10,6 +10,7 @@ import { buildRegionLabel } from '@/common/utils/region-label'; import { codePointLength } from '@/common/utils/text-cleaner'; import { evaluateActiveUserAccount } from '@/features/auth'; import type { CreateOrderInput } from '@/features/order/dto/inputs/create-order.input'; +import { OrderCustomUploadRepository } from '@/features/order/repositories/order-custom-upload.repository'; import { OrderRepository, type CreatedOrderRow, @@ -21,7 +22,15 @@ import { toOrderPaymentOutput } from '@/features/order/services/order-payment-ma import type { CreateOrderOutput } from '@/features/order/types/create-order-output.type'; import { ProductRepository, type ProductDetailRow } from '@/features/product'; import { StorePickupScheduleService } from '@/features/store'; -import { Prisma } from '@/generated/prisma/client'; +import { + Prisma, + type OrderCustomUploadPurpose, +} from '@/generated/prisma/client'; +import { S3Service } from '@/global/storage/s3.service'; +import type { + CreateUploadUrlOutput, + UploadPurpose, +} from '@/global/storage/types/storage.types'; // 0/O·1/I 등 혼동 문자를 뺀 대문자 영숫자. 주문번호 무작위부에 사용. const ORDER_NUMBER_ALPHABET = 'ABCDEFGHJKMNPQRSTUVWXYZ23456789'; @@ -38,6 +47,12 @@ const PAYMENT_WINDOW_MS = 60 * 60_000; /** 은행 입금자명과 대조하는 값이라 자르지 않고 입력을 요구한다. */ const MAX_DEPOSITOR_NAME_LENGTH = 20; +const CUSTOM_UPLOAD_PURPOSES = { + RENDER: 'ORDER_CUSTOM_RENDER', + COMPOSITE: 'ORDER_CUSTOM_COMPOSITE', + REFERENCE: 'ORDER_CUSTOM_REFERENCE', +} as const satisfies Record; + interface ResolvedOptionSelection { optionGroupId: bigint; optionItemId: bigint; @@ -55,8 +70,39 @@ export class OrderCheckoutService { private readonly clock: ClockService, private readonly random: RandomService, private readonly paymentSettings: PaymentSettingRepository, + private readonly customUploads: OrderCustomUploadRepository, + private readonly s3: S3Service, ) {} + /** + * 커스텀 이미지(3D 렌더·슬롯형 합성·참고 사진) 선업로드 URL. 발급을 기록해 두고, 주문에 쓰이지 않으면 + * 정리 크론이 하루 뒤 지운다. 형식·크기는 S3 정책이 검증한다. + */ + async createOrderCustomUploadUrl( + accountId: bigint, + input: { + purpose: OrderCustomUploadPurpose; + contentType: string; + contentLength: number; + }, + ): Promise { + await this.requireActiveBuyer(accountId); + const issued = await this.s3.createUploadUrl({ + accountId, + purpose: CUSTOM_UPLOAD_PURPOSES[input.purpose], + contentType: input.contentType, + contentLength: input.contentLength, + }); + await this.customUploads.create({ + accountId, + purpose: input.purpose, + objectKey: issued.key, + contentType: input.contentType, + contentLength: input.contentLength, + }); + return issued; + } + /** * 옵션 그룹 규칙·픽업 일시를 서버가 재검증하고 가격을 스냅샷한 뒤 입금 대기 주문을 만든다. * 판매자에게는 입금 확인 뒤에 보이므로 여기서는 판매자 구독을 발행하지 않는다. diff --git a/src/features/order/services/order-custom-upload-cleanup.scheduler.spec.ts b/src/features/order/services/order-custom-upload-cleanup.scheduler.spec.ts new file mode 100644 index 00000000..bf6efcee --- /dev/null +++ b/src/features/order/services/order-custom-upload-cleanup.scheduler.spec.ts @@ -0,0 +1,253 @@ +import { Logger } from '@nestjs/common'; + +import { ClockService } from '@/common/providers/clock.service'; +import { HOUR_MS } from '@/common/utils/kst-time'; +import { OrderCustomUploadRepository } from '@/features/order/repositories/order-custom-upload.repository'; +import { + OrderCustomUploadCleanupScheduler, + PURGE_BATCH_LIMIT, +} from '@/features/order/services/order-custom-upload-cleanup.scheduler'; +import type { + OrderCustomUploadStatus, + PrismaClient, +} from '@/generated/prisma/client'; +import { AlertService } from '@/global/alerting'; +import { + S3Service, + type DeleteObjectsFailure, +} from '@/global/storage/s3.service'; +import { disconnectTestPrismaClient } from '@/test/db/prisma-test-client'; +import { closeTruncateConnection, truncateAll } from '@/test/db/truncate'; +import { createAccount, createOrderCustomUpload } from '@/test/factories'; +import { createTestingModuleWithRealDb } from '@/test/modules/testing-module.builder'; + +const NOW = new Date('2026-11-19T11:20:00.000Z'); +const ago = (ms: number) => new Date(NOW.getTime() - ms); + +// 정리 대상 판정(오래된 PENDING·멈춘 PURGING, ATTACHED는 제외)·S3 삭제·기록 삭제·실패 시 PURGING 유지와 경보. S3는 외부라 stub이다. +describe('OrderCustomUploadCleanupScheduler (real DB)', () => { + let scheduler: OrderCustomUploadCleanupScheduler; + let repository: OrderCustomUploadRepository; + let prisma: PrismaClient; + let accountId: bigint; + let now = NOW; + const deleteObjects = jest.fn< + Promise, + [readonly string[]] + >(); + const alerts = { notify: jest.fn().mockResolvedValue('sent') }; + const savedRole = process.env.APP_ROLE; + + beforeAll(async () => { + const { module, prisma: p } = await createTestingModuleWithRealDb({ + providers: [ + OrderCustomUploadCleanupScheduler, + OrderCustomUploadRepository, + { provide: ClockService, useValue: { now: () => now } }, + { provide: S3Service, useValue: { deleteObjects } }, + { provide: AlertService, useValue: alerts }, + ], + }); + scheduler = module.get(OrderCustomUploadCleanupScheduler); + repository = module.get(OrderCustomUploadRepository); + prisma = p; + }); + afterAll(async () => { + if (savedRole === undefined) delete process.env.APP_ROLE; + else process.env.APP_ROLE = savedRole; + await closeTruncateConnection(); + await disconnectTestPrismaClient(); + }); + beforeEach(async () => { + await truncateAll(); + process.env.APP_ROLE = 'worker'; + now = NOW; + deleteObjects.mockReset(); + deleteObjects.mockResolvedValue([]); + alerts.notify.mockClear(); + jest.spyOn(Logger.prototype, 'error').mockImplementation(() => undefined); + accountId = (await createAccount(prisma, { account_type: 'USER' })).id; + }); + afterEach(() => jest.restoreAllMocks()); + + async function upload( + key: string, + status: OrderCustomUploadStatus, + at: { createdAgo?: number; purgeStartedAgo?: number } = {}, + ) { + return createOrderCustomUpload(prisma, { + account_id: accountId, + object_key: key, + status, + created_at: ago(at.createdAgo ?? 0), + purge_started_at: + at.purgeStartedAgo === undefined ? null : ago(at.purgeStartedAgo), + }); + } + + const statusOf = async () => + Object.fromEntries( + (await prisma.orderCustomUpload.findMany()).map((u) => [ + u.object_key, + u.status, + ]), + ); + + it('하루 지난 PENDING과 한 시간 지난 PURGING만 S3에서 지우고 기록도 지운다', async () => { + await upload('pending-24h', 'PENDING', { createdAgo: 24 * HOUR_MS }); + await upload('pending-23h59', 'PENDING', { createdAgo: 24 * HOUR_MS - 1 }); + await upload('purging-1h', 'PURGING', { + createdAgo: 30 * HOUR_MS, + purgeStartedAgo: HOUR_MS, + }); + await upload('purging-59m', 'PURGING', { + createdAgo: 30 * HOUR_MS, + purgeStartedAgo: HOUR_MS - 1, + }); + // 주문에 쓰인 파일은 오래돼도 보관한다 + await upload('attached-old', 'ATTACHED', { createdAgo: 72 * HOUR_MS }); + + await scheduler.purgeUnusedUploads(); + + expect(deleteObjects).toHaveBeenCalledTimes(1); + expect([...deleteObjects.mock.calls[0][0]].sort()).toEqual([ + 'pending-24h', + 'purging-1h', + ]); + expect(await statusOf()).toEqual({ + 'pending-23h59': 'PENDING', + 'purging-59m': 'PURGING', + 'attached-old': 'ATTACHED', + }); + expect(alerts.notify).not.toHaveBeenCalled(); + }); + + it('S3 삭제에 실패한 키는 PURGING으로 남기고 경보하며, 한 시간 뒤 정리에서 다시 지운다', async () => { + await upload('ok', 'PENDING', { createdAgo: 25 * HOUR_MS }); + await upload('denied', 'PENDING', { createdAgo: 25 * HOUR_MS }); + deleteObjects.mockResolvedValueOnce([ + { key: 'denied', code: 'AccessDenied' }, + ]); + + await scheduler.purgeUnusedUploads(); + + const left = await prisma.orderCustomUpload.findMany(); + expect(left).toEqual([ + expect.objectContaining({ + object_key: 'denied', + status: 'PURGING', + purge_started_at: NOW, + }), + ]); + expect(alerts.notify).toHaveBeenCalledWith( + expect.objectContaining({ + level: 'error', + key: 'order-custom-upload:purge', + detail: expect.stringContaining('1/2건 실패(AccessDenied)'), + }), + ); + + now = new Date(NOW.getTime() + HOUR_MS - 1); + await scheduler.purgeUnusedUploads(); + expect(deleteObjects).toHaveBeenCalledTimes(1); + + now = new Date(NOW.getTime() + HOUR_MS); + await scheduler.purgeUnusedUploads(); + expect(deleteObjects).toHaveBeenLastCalledWith(['denied']); + expect(await prisma.orderCustomUpload.count()).toBe(0); + }); + + it('묶음 상한을 넘으면 다음 묶음을 이어 잡고, 실패한 묶음 뒤에는 더 잡지 않는다', async () => { + const createdAt = ago(25 * HOUR_MS); + await prisma.orderCustomUpload.createMany({ + data: Array.from({ length: PURGE_BATCH_LIMIT + 1 }, (_, i) => ({ + account_id: accountId, + purpose: 'RENDER' as const, + object_key: `k${i}`, + content_type: 'image/png', + content_length: 1, + created_at: createdAt, + })), + }); + deleteObjects.mockImplementationOnce((keys) => + Promise.resolve(keys.map((key) => ({ key, code: 'InternalError' }))), + ); + + await scheduler.purgeUnusedUploads(); + expect(deleteObjects).toHaveBeenCalledTimes(1); + expect(deleteObjects.mock.calls[0][0]).toHaveLength(PURGE_BATCH_LIMIT); + expect( + await prisma.orderCustomUpload.count({ where: { status: 'PENDING' } }), + ).toBe(1); + + now = new Date(NOW.getTime() + HOUR_MS); + await scheduler.purgeUnusedUploads(); + expect(deleteObjects.mock.calls.slice(1).map((c) => c[0].length)).toEqual([ + PURGE_BATCH_LIMIT, + 1, + ]); + expect(await prisma.orderCustomUpload.count()).toBe(0); + }); + + it('주문 tx가 잡고 있는 업로드는 건너뛴다', async () => { + const held = await upload('held', 'PENDING', { createdAgo: 25 * HOUR_MS }); + await upload('free', 'PENDING', { createdAgo: 25 * HOUR_MS }); + + await prisma.$transaction(async (tx) => { + await tx.$queryRaw`SELECT id FROM order_custom_upload WHERE id = ${held.id} FOR UPDATE`; + await scheduler.purgeUnusedUploads(); + }); + + expect(deleteObjects).toHaveBeenCalledWith(['free']); + expect(await statusOf()).toEqual({ held: 'PENDING' }); + }); + + it('api 역할에서는 아무것도 하지 않는다', async () => { + process.env.APP_ROLE = 'api'; + await upload('old', 'PENDING', { createdAgo: 25 * HOUR_MS }); + + await scheduler.purgeUnusedUploads(); + + expect(deleteObjects).not.toHaveBeenCalled(); + expect(await statusOf()).toEqual({ old: 'PENDING' }); + }); + + it('앞 틱이 도는 중이면 겹친 틱은 건너뛴다', async () => { + await upload('old', 'PENDING', { createdAgo: 25 * HOUR_MS }); + let release!: () => void; + deleteObjects.mockImplementationOnce( + () => new Promise((resolve) => (release = () => resolve([]))), + ); + + const first = scheduler.purgeUnusedUploads(); + while (deleteObjects.mock.calls.length === 0) { + await new Promise((resolve) => setTimeout(resolve, 10)); + } + await scheduler.purgeUnusedUploads(); + release(); + await first; + + expect(deleteObjects).toHaveBeenCalledTimes(1); + expect(await prisma.orderCustomUpload.count()).toBe(0); + }); + + it('기록을 읽다 실패하면 경보하고 던지지 않는다', async () => { + jest + .spyOn(repository, 'claimForPurge') + .mockRejectedValueOnce(new Error('db down')); + + await expect(scheduler.purgeUnusedUploads()).resolves.toBeUndefined(); + + expect(alerts.notify).toHaveBeenCalledWith( + expect.objectContaining({ + level: 'error', + key: 'order-custom-upload:purge', + detail: 'db down', + }), + ); + // 실패 뒤에도 다음 틱은 돈다 + await upload('old', 'PENDING', { createdAgo: 25 * HOUR_MS }); + await scheduler.purgeUnusedUploads(); + expect(deleteObjects).toHaveBeenCalledWith(['old']); + }); +}); diff --git a/src/features/order/services/order-custom-upload-cleanup.scheduler.ts b/src/features/order/services/order-custom-upload-cleanup.scheduler.ts new file mode 100644 index 00000000..9853bf95 --- /dev/null +++ b/src/features/order/services/order-custom-upload-cleanup.scheduler.ts @@ -0,0 +1,90 @@ +import { Injectable, Logger } from '@nestjs/common'; +import { Cron } from '@nestjs/schedule'; + +import { ClockService } from '@/common/providers/clock.service'; +import { HOUR_MS } from '@/common/utils/kst-time'; +import { resolveAppRole, runsBackgroundJobs } from '@/config/app.config'; +import { OrderCustomUploadRepository } from '@/features/order/repositories/order-custom-upload.repository'; +import { AlertService } from '@/global/alerting'; +import { S3Service } from '@/global/storage/s3.service'; + +/** 발급 뒤 이만큼 주문에 쓰이지 않은 업로드를 지운다. */ +export const UNUSED_UPLOAD_TTL_MS = 24 * HOUR_MS; +/** 정리 중(PURGING)으로 남은 업로드는 이만큼 지나 다시 지운다. */ +export const PURGE_RETRY_AFTER_MS = HOUR_MS; +export const PURGE_BATCH_LIMIT = 500; +/** 한 틱에서 도는 묶음 상한(밀린 양이 많아도 다음 틱으로 넘긴다). */ +export const PURGE_MAX_BATCHES = 20; + +/** + * 주문에 쓰이지 않은 커스텀 업로드 정리(매시 20분, worker). PURGING 표시를 먼저 커밋해 주문이 붙이지 못하게 한 뒤 + * S3에서 지우고, 지워진 것만 기록을 지운다. 삭제 실패는 PURGING으로 남겨 다음 정리에서 다시 시도하고 경보한다. + */ +@Injectable() +export class OrderCustomUploadCleanupScheduler { + private readonly logger = new Logger(OrderCustomUploadCleanupScheduler.name); + private running = false; + + constructor( + private readonly uploads: OrderCustomUploadRepository, + private readonly s3: S3Service, + private readonly clock: ClockService, + private readonly alerts: AlertService, + ) {} + + /** 크론(ScheduleModule)은 worker에만 실리지만 역할도 함께 본다 — api·ws에서 호출돼도 S3를 지우지 않게. */ + @Cron('0 20 * * * *') + async purgeUnusedUploads(): Promise { + if (!runsBackgroundJobs(resolveAppRole()) || this.running) return; + this.running = true; + try { + await this.run(); + } catch (error) { + const detail = error instanceof Error ? error.message : String(error); + this.logger.error(`커스텀 업로드 정리 실패: ${detail}`); + await this.alerts.notify({ + level: 'error', + title: '커스텀 업로드 정리 실패', + key: 'order-custom-upload:purge', + detail, + }); + } finally { + this.running = false; + } + } + + private async run(): Promise { + const now = this.clock.now(); + for (let batch = 0; batch < PURGE_MAX_BATCHES; batch++) { + const claimed = await this.uploads.claimForPurge({ + now, + pendingCreatedBefore: new Date(now.getTime() - UNUSED_UPLOAD_TTL_MS), + purgingStartedBefore: new Date(now.getTime() - PURGE_RETRY_AFTER_MS), + limit: PURGE_BATCH_LIMIT, + }); + if (claimed.length === 0) return; + + const failures = await this.s3.deleteObjects( + claimed.map((row) => row.object_key), + ); + const failedKeys = new Set(failures.map((f) => f.key)); + await this.uploads.deletePurged( + claimed + .filter((row) => !failedKeys.has(row.object_key)) + .map((row) => row.id), + ); + if (failures.length > 0) { + // 남은 행은 PURGING이라 1시간 뒤 정리에서 다시 시도한다. S3 장애면 더 묶음을 잡지 않는다 + const codes = [...new Set(failures.map((f) => f.code))].join(', '); + await this.alerts.notify({ + level: 'error', + title: '커스텀 업로드 S3 삭제 실패', + key: 'order-custom-upload:purge', + detail: `${failures.length}/${claimed.length}건 실패(${codes}) — 다음 정리에서 다시 시도`, + }); + return; + } + if (claimed.length < PURGE_BATCH_LIMIT) return; + } + } +} diff --git a/src/global/storage/constants/storage.constants.ts b/src/global/storage/constants/storage.constants.ts index bb6b85fb..9d5e4957 100644 --- a/src/global/storage/constants/storage.constants.ts +++ b/src/global/storage/constants/storage.constants.ts @@ -35,4 +35,20 @@ export const UPLOAD_POLICIES: Record = { maxSizeBytes: 5 * 1024 * 1024, allowedContentTypes: ['image/jpeg', 'image/png', 'image/webp'], }, + // 구매자 커스텀 주문 이미지는 리뷰 이미지와 같은 정책. 주문에 쓰이지 않으면 정리 크론이 order-custom/ 아래를 지운다 + ORDER_CUSTOM_RENDER: { + keyPrefix: 'order-custom/renders', + maxSizeBytes: 10 * 1024 * 1024, + allowedContentTypes: ['image/jpeg', 'image/png', 'image/webp'], + }, + ORDER_CUSTOM_COMPOSITE: { + keyPrefix: 'order-custom/composites', + maxSizeBytes: 10 * 1024 * 1024, + allowedContentTypes: ['image/jpeg', 'image/png', 'image/webp'], + }, + ORDER_CUSTOM_REFERENCE: { + keyPrefix: 'order-custom/references', + maxSizeBytes: 10 * 1024 * 1024, + allowedContentTypes: ['image/jpeg', 'image/png', 'image/webp'], + }, } as const; diff --git a/src/global/storage/s3.service.delete-objects.spec.ts b/src/global/storage/s3.service.delete-objects.spec.ts new file mode 100644 index 00000000..1ce2d8a8 --- /dev/null +++ b/src/global/storage/s3.service.delete-objects.spec.ts @@ -0,0 +1,113 @@ +import { S3ServiceException } from '@aws-sdk/client-s3'; +import { ConfigService } from '@nestjs/config'; +import { Test } from '@nestjs/testing'; + +import { CustomLoggerService } from '@/global/logger/custom-logger.service'; +import { S3Service } from '@/global/storage/s3.service'; + +const mockSend = jest.fn(); + +jest.mock('@aws-sdk/client-s3', () => ({ + ...jest.requireActual('@aws-sdk/client-s3'), + S3Client: jest.fn().mockImplementation(() => ({ + send: (command: unknown) => mockSend(command), + })), + DeleteObjectsCommand: jest.fn().mockImplementation((input: unknown) => input), +})); + +interface DeleteInput { + Bucket: string; + Delete: { Objects: { Key: string }[]; Quiet: boolean }; +} + +const sentKeyCounts = () => + (mockSend.mock.calls as [DeleteInput][]).map( + ([input]) => input.Delete.Objects.length, + ); + +describe('S3Service.deleteObjects', () => { + let service: S3Service; + const logger = { error: jest.fn(), warn: jest.fn() }; + + beforeEach(async () => { + mockSend.mockReset(); + logger.error.mockClear(); + const module = await Test.createTestingModule({ + providers: [ + S3Service, + { + provide: ConfigService, + useValue: { + get: () => ({ + region: 'ap-northeast-2', + bucket: 'caquick-media-test', + presignExpiresSeconds: 600, + }), + }, + }, + { provide: CustomLoggerService, useValue: logger }, + ], + }).compile(); + service = module.get(S3Service); + }); + + it('이 버킷에 조용한 모드로 한 번에 지우고, 오류가 없으면 실패 없음이다', async () => { + mockSend.mockResolvedValue({}); + + await expect(service.deleteObjects(['a.png', 'b.png'])).resolves.toEqual( + [], + ); + expect(mockSend).toHaveBeenCalledTimes(1); + expect(mockSend.mock.calls[0][0]).toEqual({ + Bucket: 'caquick-media-test', + Delete: { Objects: [{ Key: 'a.png' }, { Key: 'b.png' }], Quiet: true }, + }); + }); + + it('키별 오류는 키·코드로 돌려준다', async () => { + mockSend.mockResolvedValue({ + Errors: [{ Key: 'b.png', Code: 'AccessDenied', Message: 'denied' }], + }); + + await expect(service.deleteObjects(['a.png', 'b.png'])).resolves.toEqual([ + { key: 'b.png', code: 'AccessDenied' }, + ]); + }); + + it('요청 자체가 실패하면 그 묶음 전부를 실패로 돌려주고 던지지 않는다', async () => { + mockSend.mockRejectedValue( + new S3ServiceException({ + name: 'AccessDenied', + $fault: 'client', + $metadata: { httpStatusCode: 403 }, + message: 'denied', + }), + ); + + await expect(service.deleteObjects(['a.png', 'b.png'])).resolves.toEqual([ + { key: 'a.png', code: 'AccessDenied' }, + { key: 'b.png', code: 'AccessDenied' }, + ]); + expect(logger.error).toHaveBeenCalledWith( + 'S3 객체 삭제 실패', + expect.objectContaining({ keys: 2 }), + ); + }); + + it('1000개를 넘으면 1000개씩 나눠 보내고, 실패한 묶음만 실패로 돌려준다', async () => { + const keys = Array.from({ length: 1001 }, (_, i) => `k${i}`); + mockSend + .mockResolvedValueOnce({}) + .mockRejectedValueOnce(new Error('socket hang up')); + + const failures = await service.deleteObjects(keys); + + expect(sentKeyCounts()).toEqual([1000, 1]); + expect(failures).toEqual([{ key: 'k1000', code: 'Error' }]); + }); + + it('빈 목록이면 요청하지 않는다', async () => { + await expect(service.deleteObjects([])).resolves.toEqual([]); + expect(mockSend).not.toHaveBeenCalled(); + }); +}); diff --git a/src/global/storage/s3.service.spec.ts b/src/global/storage/s3.service.spec.ts index 7d714038..023e9921 100644 --- a/src/global/storage/s3.service.spec.ts +++ b/src/global/storage/s3.service.spec.ts @@ -198,6 +198,38 @@ describe('S3Service', () => { }); }); + describe.each([ + ['ORDER_CUSTOM_RENDER', 'order-custom/renders/'], + ['ORDER_CUSTOM_COMPOSITE', 'order-custom/composites/'], + ['ORDER_CUSTOM_REFERENCE', 'order-custom/references/'], + ] as const)('%s purpose', (purpose, prefix) => { + const input = { ...baseInput, purpose }; + + it.each(['image/jpeg', 'image/png', 'image/webp'])( + `%s 10MB를 ${prefix} 아래로 발급한다`, + async (contentType) => { + const result = await service.createUploadUrl({ + ...input, + contentType, + contentLength: 10 * 1024 * 1024, + }); + expect(result.key.startsWith(`${prefix}1/`)).toBe(true); + }, + ); + + it('10MB 초과·이미지가 아닌 형식은 거부한다', async () => { + await expect( + service.createUploadUrl({ + ...input, + contentLength: 10 * 1024 * 1024 + 1, + }), + ).rejects.toThrowDomain('FILE_TOO_LARGE'); + await expect( + service.createUploadUrl({ ...input, contentType: 'video/mp4' }), + ).rejects.toThrowDomain('INVALID_CONTENT_TYPE'); + }); + }); + describe('contentLength 검증', () => { it('0이면 거부해야 한다', async () => { await expect( diff --git a/src/global/storage/s3.service.ts b/src/global/storage/s3.service.ts index 6ebc9aa3..cb766c46 100644 --- a/src/global/storage/s3.service.ts +++ b/src/global/storage/s3.service.ts @@ -1,6 +1,7 @@ import { randomUUID } from 'node:crypto'; import { + DeleteObjectsCommand, GetObjectCommand, PutObjectCommand, S3Client, @@ -34,6 +35,13 @@ const CONTENT_TYPE_TO_EXT: Record = { const IMAGE_HEADER_BYTES = 64 * 1024; /** 객체가 없거나(404) 0바이트라 범위를 못 읽는(416) 경우는 장애가 아니라 읽을 수 없는 이미지다. */ const UNREADABLE_OBJECT_STATUS = new Set([404, 416]); +/** DeleteObjects 요청 1건의 키 상한. */ +const DELETE_OBJECTS_MAX_KEYS = 1000; + +export interface DeleteObjectsFailure { + key: string; + code: string; +} @Injectable() export class S3Service { @@ -170,6 +178,45 @@ export class S3Service { return full === null ? null : measureImage(full.bytes); } + /** + * 이 버킷의 객체를 지운다(요청당 1000개). 없는 객체는 S3가 지운 것으로 답한다. 키별 실패와 요청 자체의 실패를 + * 모두 실패 목록으로 돌려주고 던지지 않는다 — 호출부가 지워진 키만 골라 기록을 정리한다. + */ + async deleteObjects( + keys: readonly string[], + ): Promise { + const failures: DeleteObjectsFailure[] = []; + for (let i = 0; i < keys.length; i += DELETE_OBJECTS_MAX_KEYS) { + const chunk = keys.slice(i, i + DELETE_OBJECTS_MAX_KEYS); + try { + const res = await this.client.send( + new DeleteObjectsCommand({ + Bucket: this.bucket, + Delete: { Objects: chunk.map((Key) => ({ Key })), Quiet: true }, + }), + ); + for (const error of res.Errors ?? []) { + failures.push({ + key: error.Key ?? '', + code: error.Code ?? 'Unknown', + }); + } + } catch (error) { + const code = error instanceof Error ? error.name : 'Unknown'; + this.logger.error('S3 객체 삭제 실패', { + bucket: this.bucket, + keys: chunk.length, + cause: + error instanceof Error + ? `${error.name}: ${error.message}` + : String(error), + }); + failures.push(...chunk.map((key) => ({ key, code }))); + } + } + return failures; + } + private keyOfPublicUrl(url: string): string | null { try { const parsed = new URL(url); diff --git a/src/global/storage/types/storage.types.ts b/src/global/storage/types/storage.types.ts index abe438a2..f7525e59 100644 --- a/src/global/storage/types/storage.types.ts +++ b/src/global/storage/types/storage.types.ts @@ -4,7 +4,10 @@ export type UploadPurpose = | 'REVIEW_VIDEO' | 'PRODUCT_IMAGE' | 'STORE_IMAGE' - | 'BANNER_IMAGE'; + | 'BANNER_IMAGE' + | 'ORDER_CUSTOM_RENDER' + | 'ORDER_CUSTOM_COMPOSITE' + | 'ORDER_CUSTOM_REFERENCE'; export interface CreateUploadUrlInput { accountId: bigint; diff --git a/src/test/factories/order.factory.ts b/src/test/factories/order.factory.ts index 75deb59d..89c91530 100644 --- a/src/test/factories/order.factory.ts +++ b/src/test/factories/order.factory.ts @@ -4,6 +4,7 @@ import type { CustomImageKind, CustomMode, Order, + OrderCustomUpload, OrderItem, OrderStatus, Payment, @@ -269,3 +270,36 @@ export async function createThreeDOrderItemCustom( }); } } + +export type OrderCustomUploadOverrides = Partial< + Pick< + OrderCustomUpload, + | 'account_id' + | 'purpose' + | 'object_key' + | 'status' + | 'created_at' + | 'purge_started_at' + | 'attached_at' + > +>; + +/** 커스텀 이미지 선업로드 기록. 계정을 안 주면 구매자를 새로 만든다. */ +export async function createOrderCustomUpload( + prisma: PrismaClient, + overrides: OrderCustomUploadOverrides = {}, +): Promise { + const accountId = + overrides.account_id ?? + (await createAccount(prisma, { account_type: 'USER' })).id; + return prisma.orderCustomUpload.create({ + data: { + purpose: 'RENDER', + object_key: `order-custom/renders/${accountId}/2026-11-19/${nextSeq()}.png`, + content_type: 'image/png', + content_length: 1024, + ...overrides, + account_id: accountId, + }, + }); +} diff --git a/src/test/model-ownership.ts b/src/test/model-ownership.ts index 8e8580d2..da7341c2 100644 --- a/src/test/model-ownership.ts +++ b/src/test/model-ownership.ts @@ -92,6 +92,7 @@ export const MODEL_OWNERSHIP: Readonly> = { OrderItemCustomFreeEditAttachment: order([]), OrderItemCustomDesign: order([]), OrderItemCustomImage: order([]), + OrderCustomUpload: order(), Payment: order(), Refund: order(), DepositRecord: order(), diff --git a/src/test/seed-reset-scope.spec.ts b/src/test/seed-reset-scope.spec.ts index 6c035f5b..91304c9e 100644 --- a/src/test/seed-reset-scope.spec.ts +++ b/src/test/seed-reset-scope.spec.ts @@ -29,6 +29,7 @@ import { createAccount, createNotification, createOrder, + createOrderCustomUpload, createOrderItem, createReview, createReviewReport, @@ -182,6 +183,26 @@ describe('resetSeedScope (real DB)', () => { expect(await counts()).toEqual([0, 2]); }); + it('시드 사용자의 커스텀 업로드 기록은 지우고 시드 밖 계정 것은 남긴다', async () => { + const [seedUser] = await seedThroughReviews(); + const outsider = await createAccount(prisma, { account_type: 'USER' }); + for (const [accountId, key] of [ + [seedUser.id, 'order-custom/renders/seed.png'], + [outsider.id, 'order-custom/renders/outsider.png'], + ] as const) { + await createOrderCustomUpload(prisma, { + account_id: accountId, + object_key: key, + }); + } + + await resetSeedScope(prisma); + await seedThroughReviews(); + + const left = await prisma.orderCustomUpload.findMany(); + expect(left.map((u) => u.account_id)).toEqual([outsider.id]); + }); + it('시드 밖 계정이 시드 밖 매장에 넣은 주문은 남긴다', async () => { await seedThroughReviews(); const { order, item } = await outsiderOrder(); diff --git a/terraform/aws.tf b/terraform/aws.tf index afe5c82c..e61d3325 100644 --- a/terraform/aws.tf +++ b/terraform/aws.tf @@ -185,6 +185,13 @@ data "aws_iam_policy_document" "app" { actions = ["s3:PutObject", "s3:GetObject"] resources = [for b in aws_s3_bucket.media : "${b.arn}/*"] } + # 주문에 쓰이지 않은 커스텀 이미지 정리(worker 크론). 다른 접두는 지우지 못한다 + statement { + sid = "OrderCustomUploadCleanup" + effect = "Allow" + actions = ["s3:DeleteObject"] + resources = [for b in aws_s3_bucket.media : "${b.arn}/order-custom/*"] + } } resource "aws_iam_policy" "app" { From bfa336a4cd3550df1e14535291c526ee14b7e45b Mon Sep 17 00:00:00 2001 From: chanwoo7 Date: Thu, 19 Nov 2026 05:15:05 +0900 Subject: [PATCH 2/3] =?UTF-8?q?test:=20=EC=BB=A4=EC=8A=A4=ED=85=80=20?= =?UTF-8?q?=EC=97=85=EB=A1=9C=EB=93=9C=20=EC=9A=A9=EB=8F=84=20=EC=9E=85?= =?UTF-8?q?=EB=A0=A5=20enum=EC=9D=B4=20=EC=84=9C=EB=B2=84=20enum=EC=9D=84?= =?UTF-8?q?=20=EB=B2=97=EC=96=B4=EB=82=98=EC=A7=80=20=EC=95=8A=EA=B2=8C=20?= =?UTF-8?q?SDL=20=EB=8F=99=EA=B8=B0=ED=99=94=20=EA=B2=8C=EC=9D=B4=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 입력 SDL enum OrderCustomUploadPurpose에만 값이 늘면 발급 서비스의 용도 → 업로드 정책 매핑이 비어 S3Service에서 TypeError가 나고 500으로 떨어진다. 매핑은 Prisma enum으로만 satisfies 검사되고, enum-sdl-sync는 출력 방향(Prisma ⊆ SDL)만 대조해 이 어긋남을 잡지 못했다. 변경점 - enum-sdl-sync에 입력 쌍 목록(INPUT_PAIRS)을 두고 반대 방향(SDL ⊆ Prisma)을 대조한다. 첫 쌍은 OrderCustomUploadPurpose - 대조 함수 이름을 방향 중립(missingFrom)으로 바꿨다 테스트 - enum-sdl-sync 20건 통과(입력 방향 2건 추가: 반증 — SDL에 값을 더하면 잡는다, 실제 SDL 대조) - 반증: 실제 SDL에 SKETCH를 더하면 실제 대조가 실패하는 것을 확인하고 되돌렸다 --- src/test/enum-sdl-sync.spec.ts | 63 +++++++++++++++++++++++++++++++--- 1 file changed, 58 insertions(+), 5 deletions(-) diff --git a/src/test/enum-sdl-sync.spec.ts b/src/test/enum-sdl-sync.spec.ts index 4e59d5e8..cb7f242a 100644 --- a/src/test/enum-sdl-sync.spec.ts +++ b/src/test/enum-sdl-sync.spec.ts @@ -14,6 +14,7 @@ import { OrderActor, OrderCancelFault, OrderCancelReason, + OrderCustomUploadPurpose, OrderStatus, RefundKind, RefundStatus, @@ -115,8 +116,23 @@ function sdlEnumValues(source: string, enumName: string): string[] { throw new Error(`enum ${enumName}이 SDL에 없습니다`); } -function missingInSdl(prisma: string[], sdl: string[]): string[] { - return prisma.filter((v) => !sdl.includes(v)); +/** + * 입력 SDL enum은 방향이 반대다 — SDL 값이 서버 enum에 모두 있어야 한다. SDL에만 값이 늘면 그 값을 받은 + * 요청이 서버 매핑(예: 업로드 용도 → 정책)을 찾지 못해 500으로 떨어진다. + */ +const INPUT_PAIRS: Array< + [label: string, prisma: string[], file: string, sdl: string] +> = [ + [ + 'OrderCustomUploadPurpose', + Object.values(OrderCustomUploadPurpose), + 'src/features/order/order-checkout.graphql', + 'OrderCustomUploadPurpose', + ], +]; + +function missingFrom(values: string[], target: string[]): string[] { + return values.filter((v) => !target.includes(v)); } const read = (file: string) => readFileSync(join(process.cwd(), file), 'utf8'); @@ -133,14 +149,14 @@ describe('Prisma enum·TS 상수 ⊆ SDL enum', () => { node.name.value === removed ? null : undefined, }), ); - expect(missingInSdl(prisma, sdlEnumValues(broken, sdl))).toEqual([ + expect(missingFrom(prisma, sdlEnumValues(broken, sdl))).toEqual([ removed, ]); }, ); it('SDL에만 있는 값은 허용한다(부분집합 판정)', () => { - expect(missingInSdl(['A'], ['A', 'B'])).toEqual([]); + expect(missingFrom(['A'], ['A', 'B'])).toEqual([]); }); it('SDL에 enum이 없으면 실패한다', () => { @@ -154,7 +170,44 @@ describe('Prisma enum·TS 상수 ⊆ SDL enum', () => { '%s: 서버 값이 SDL에 모두 있다', (_label, prisma, file, sdl) => { expect(prisma.length).toBeGreaterThan(0); - expect(missingInSdl(prisma, sdlEnumValues(read(file), sdl))).toEqual([]); + expect(missingFrom(prisma, sdlEnumValues(read(file), sdl))).toEqual([]); + }, + ); +}); + +describe('입력 SDL enum ⊆ Prisma enum', () => { + it.each(INPUT_PAIRS)( + '%s: 검사기 반증 — SDL에 값을 하나 더하면 서버에 없다고 잡는다', + (_label, prisma, file, sdl) => { + const added = print( + visit(parse(read(file)), { + EnumTypeDefinition: (node) => + node.name.value === sdl + ? { + ...node, + values: [ + ...(node.values ?? []), + { + kind: Kind.ENUM_VALUE_DEFINITION, + name: { kind: Kind.NAME, value: 'ADDED_IN_SDL' }, + }, + ], + } + : undefined, + }), + ); + expect(missingFrom(sdlEnumValues(added, sdl), prisma)).toEqual([ + 'ADDED_IN_SDL', + ]); + }, + ); + + it.each(INPUT_PAIRS)( + '%s: SDL 값이 서버에 모두 있다', + (_label, prisma, file, sdl) => { + const values = sdlEnumValues(read(file), sdl); + expect(values.length).toBeGreaterThan(0); + expect(missingFrom(values, prisma)).toEqual([]); }, ); }); From 0dcb9f19974520773f850e989f936d0738f5c2b1 Mon Sep 17 00:00:00 2001 From: chanwoo7 Date: Thu, 19 Nov 2026 05:19:20 +0900 Subject: [PATCH 3/3] =?UTF-8?q?fix:=20=EC=97=85=EB=A1=9C=EB=93=9C=20?= =?UTF-8?q?=EB=B0=9C=EA=B8=89=20=EC=98=A4=EB=A5=98=20=EC=BD=94=EB=93=9C=20?= =?UTF-8?q?=EC=84=A4=EB=AA=85=EA=B3=BC=20=EC=A0=95=EB=A6=AC=20=EC=9E=AC?= =?UTF-8?q?=EC=8B=9C=EB=8F=84=20=EC=A3=BC=EC=84=9D=20=EC=A0=95=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit createOrderCustomUploadUrl 설명이 실제로 나는 오류 코드 일부를 빠뜨렸고, 입력 전용 enum에 출력 enum용 문구가 붙어 있었다. 정리 크론의 재시도 주석은 매시 크론이라 실제로는 1~2시간 뒤 다시 지우는 것을 1시간 뒤로 적고 있었다. 변경점 - SDL 설명: INVALID_CONTENT_LENGTH(크기 0 이하)·BUYER_ACCOUNT_NOT_ACTIVE(정지·탈퇴·프로필 없음) 추가, OrderCustomUploadPurpose 설명에서 출력용 문구 삭제 - 정리 크론: 재시도 시점 주석을 '1시간이 지난 뒤의 정리(1~2시간 뒤)'로 정정(판정 기준 1시간은 그대로) 테스트 - 정리 크론·발급 리졸버 spec 통과, docs:check 통과 --- src/features/order/order-checkout.graphql | 9 ++++----- .../services/order-custom-upload-cleanup.scheduler.ts | 3 ++- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/features/order/order-checkout.graphql b/src/features/order/order-checkout.graphql index 7ddba327..30a60af5 100644 --- a/src/features/order/order-checkout.graphql +++ b/src/features/order/order-checkout.graphql @@ -9,8 +9,9 @@ extend type Mutation { createOrder(input: CreateOrderInput!): CreateOrderOutput! """ 커스텀 이미지 업로드용 Presigned URL 발급(구매자). uploadUrl로 PUT한 뒤 publicUrl을 주문 생성의 커스텀 입력에 넣는다. - JPEG·PNG·WebP, 장당 10MB 이하(아니면 INVALID_CONTENT_TYPE·FILE_TOO_LARGE). 주문에 쓰이지 않은 파일은 발급 하루 뒤 지워진다. - 구매자 계정만 쓸 수 있다(아니면 USER_ONLY). 로그인 필수. + JPEG·PNG·WebP, 장당 1바이트 이상 10MB 이하(아니면 INVALID_CONTENT_TYPE·INVALID_CONTENT_LENGTH·FILE_TOO_LARGE). + 주문에 쓰이지 않은 파일은 발급 하루 뒤 지워진다. 구매자 계정만 쓸 수 있고(아니면 USER_ONLY), 정지·탈퇴 등으로 + 이용할 수 없는 계정이면 BUYER_ACCOUNT_NOT_ACTIVE다. 로그인 필수. """ createOrderCustomUploadUrl( """이미지 용도. 주문 생성 때 이 용도의 자리에만 쓸 수 있다.""" @@ -22,9 +23,7 @@ extend type Mutation { ): UploadUrl! } -""" -구매자 커스텀 이미지 업로드 용도. 값은 늘어날 수 있으니 모르는 값을 받아도 화면이 죽지 않게 처리한다. -""" +"""구매자 커스텀 이미지 업로드 용도.""" enum OrderCustomUploadPurpose { """3D 렌더 이미지(윗면·옆면 앞·뒤·좌·우).""" RENDER diff --git a/src/features/order/services/order-custom-upload-cleanup.scheduler.ts b/src/features/order/services/order-custom-upload-cleanup.scheduler.ts index 9853bf95..149f40b1 100644 --- a/src/features/order/services/order-custom-upload-cleanup.scheduler.ts +++ b/src/features/order/services/order-custom-upload-cleanup.scheduler.ts @@ -74,7 +74,8 @@ export class OrderCustomUploadCleanupScheduler { .map((row) => row.id), ); if (failures.length > 0) { - // 남은 행은 PURGING이라 1시간 뒤 정리에서 다시 시도한다. S3 장애면 더 묶음을 잡지 않는다 + // 남은 행은 PURGING이라 1시간이 지난 뒤의 정리(매시 크론이라 1~2시간 뒤)에서 다시 지운다. + // S3 장애일 수 있어 이 틱에서는 더 잡지 않는다 const codes = [...new Set(failures.map((f) => f.code))].join(', '); await this.alerts.notify({ level: 'error',