diff --git a/src/common/errors/error-catalog.ts b/src/common/errors/error-catalog.ts index d9bc2c24..eb2471d7 100644 --- a/src/common/errors/error-catalog.ts +++ b/src/common/errors/error-catalog.ts @@ -373,6 +373,10 @@ export const ERROR_CATALOG = { status: HttpStatus.BAD_REQUEST, message: '선택한 픽업 일시는 예약할 수 없습니다.', }, + NO_SHOW_NOT_ALLOWED: { + status: HttpStatus.BAD_REQUEST, + message: '노쇼는 픽업 시각부터 24시간 안에만 처리할 수 있습니다.', + }, ORDER_AMOUNT_OUT_OF_RANGE: { status: HttpStatus.BAD_REQUEST, message: '주문 금액이 처리 가능한 범위를 벗어났습니다.', diff --git a/src/features/notification/constants/notification-messages.ts b/src/features/notification/constants/notification-messages.ts index 6283a0b1..c06b3f84 100644 --- a/src/features/notification/constants/notification-messages.ts +++ b/src/features/notification/constants/notification-messages.ts @@ -8,6 +8,7 @@ export const ORDER_STATUS_NOTIFICATION_TITLES: Partial< [OrderStatus.CONFIRMED]: '주문확정', [OrderStatus.MADE]: '제작완료', [OrderStatus.PICKED_UP]: '픽업완료', + [OrderStatus.NO_SHOW]: '노쇼', }; /** 주문번호 prefix는 식별 필요 가능성에 대비해 유지한다 — 표시 여부는 FE 판단. */ @@ -18,6 +19,7 @@ export const ORDER_STATUS_NOTIFICATION_BODIES: Partial< [OrderStatus.CONFIRMED]: '주문이 확정되었어요.', [OrderStatus.MADE]: '주문하신 케이크 제작이 완료되었어요.', [OrderStatus.PICKED_UP]: '케이크 픽업이 완료되었어요.', + [OrderStatus.NO_SHOW]: '픽업 시간에 방문하지 않아 노쇼로 처리되었어요.', }; /** 취소는 사유 라벨을 덧붙인다(판매자·운영자·자동 미확정 공통). */ diff --git a/src/features/notification/services/notification-payloads.helper.spec.ts b/src/features/notification/services/notification-payloads.helper.spec.ts index 016f006e..d0fa8923 100644 --- a/src/features/notification/services/notification-payloads.helper.spec.ts +++ b/src/features/notification/services/notification-payloads.helper.spec.ts @@ -50,6 +50,12 @@ describe('notification-payloads.helper', () => { '픽업완료', '케이크 픽업이 완료되었어요.', ], + [ + 'NO_SHOW', + 'ORDER_NO_SHOW', + '노쇼', + '픽업 시간에 방문하지 않아 노쇼로 처리되었어요.', + ], ] as const)('%s는 %s(주문번호 접두)', (toStatus, event, title, body) => { expect(status(toStatus)).toEqual({ type: NotificationType.ORDER_STATUS, @@ -59,12 +65,15 @@ describe('notification-payloads.helper', () => { }); }); - it.each(['PENDING_PAYMENT', 'NO_SHOW'] as const)( - '매핑이 없는 상태(%s)는 null', - (toStatus) => { - expect(status(toStatus)).toBeNull(); - }, - ); + it('매핑이 없는 상태(PENDING_PAYMENT)는 null', () => { + expect(status('PENDING_PAYMENT')).toBeNull(); + }); + + it('자동 픽업 완료(SYSTEM)도 픽업 완료 알림이다', () => { + expect(status('PICKED_UP', { actorType: 'SYSTEM' })).toMatchObject({ + event: NotificationEvent.ORDER_PICKED_UP, + }); + }); it.each( Object.values(OrderCancelReason).filter( diff --git a/src/features/notification/services/notification-payloads.helper.ts b/src/features/notification/services/notification-payloads.helper.ts index f5819a8c..2b543e7c 100644 --- a/src/features/notification/services/notification-payloads.helper.ts +++ b/src/features/notification/services/notification-payloads.helper.ts @@ -39,6 +39,7 @@ const ORDER_STATUS_NOTIFICATION_EVENTS: Partial< [OrderStatus.CONFIRMED]: NotificationEvent.ORDER_CONFIRMED, [OrderStatus.MADE]: NotificationEvent.ORDER_MADE, [OrderStatus.PICKED_UP]: NotificationEvent.ORDER_PICKED_UP, + [OrderStatus.NO_SHOW]: NotificationEvent.ORDER_NO_SHOW, }; /** 매핑에 없는 상태와 구매자 본인 행위(취소)는 알림 없음(null). */ diff --git a/src/features/notification/services/seller-push-messages.helper.spec.ts b/src/features/notification/services/seller-push-messages.helper.spec.ts index 3b481b34..fdf5941d 100644 --- a/src/features/notification/services/seller-push-messages.helper.spec.ts +++ b/src/features/notification/services/seller-push-messages.helper.spec.ts @@ -1,6 +1,7 @@ import { buildBuyerMessagePush, buildOrderCanceledPush, + buildOrderConfirmReminderPush, buildOrderSubmittedPush, formatKstPickupAt, } from '@/features/notification/services/seller-push-messages.helper'; @@ -57,6 +58,22 @@ describe('seller-push-messages.helper', () => { ).toBe(`레터링 케이크 2개 · 픽업 10/5 12:05${suffix}`); }); + it('확정 마감 미리 알림: 상품명과 마감 시각(KST HH:mm), 딥링크 data는 kind·orderId', () => { + expect( + buildOrderConfirmReminderPush({ + orderId: '42', + orderNumber: 'ORD-1', + storeId: '3', + productName: '레터링 케이크', + confirmDeadlineAt: '2026-10-05T03:00:00.000Z', + }), + ).toEqual({ + title: '확정 마감 임박', + body: '레터링 케이크 주문을 12:00까지 확정하지 않으면 자동 취소돼요', + data: { kind: 'ORDER_CONFIRM_REMINDER', orderId: '42' }, + }); + }); + it('구매자 문의: 본문은 preview 그대로, data는 kind·conversationId', () => { expect( buildBuyerMessagePush({ diff --git a/src/features/notification/services/seller-push-messages.helper.ts b/src/features/notification/services/seller-push-messages.helper.ts index 53b5f0d5..1740bc44 100644 --- a/src/features/notification/services/seller-push-messages.helper.ts +++ b/src/features/notification/services/seller-push-messages.helper.ts @@ -5,6 +5,7 @@ import { } from '@/common/utils/kst-time'; import type { ConversationBuyerMessageSentPayload } from '@/features/conversation'; import type { + OrderConfirmReminderDuePayload, OrderStatusChangedPayload, OrderSubmittedPayload, } from '@/features/order'; @@ -14,6 +15,7 @@ import { OrderActor, OrderStatus } from '@/generated/prisma/client'; const SELLER_PUSH_KIND = { ORDER_SUBMITTED: 'ORDER_SUBMITTED', ORDER_CANCELED: 'ORDER_CANCELED', + ORDER_CONFIRM_REMINDER: 'ORDER_CONFIRM_REMINDER', BUYER_MESSAGE: 'BUYER_MESSAGE', } as const; @@ -85,6 +87,20 @@ export function buildOrderCanceledPush( }; } +/** 확정 마감 2시간 전. 마감은 2시간 안이라 시각만 적는다. */ +export function buildOrderConfirmReminderPush( + p: OrderConfirmReminderDuePayload, +): SellerPushContent { + const deadline = formatMinutesOfDay( + kstMinutesOfDay(new Date(p.confirmDeadlineAt)), + ); + return { + title: '확정 마감 임박', + body: `${p.productName} 주문을 ${deadline}까지 확정하지 않으면 자동 취소돼요`, + data: { kind: SELLER_PUSH_KIND.ORDER_CONFIRM_REMINDER, orderId: p.orderId }, + }; +} + export function buildBuyerMessagePush( p: ConversationBuyerMessageSentPayload, ): SellerPushContent { diff --git a/src/features/notification/services/seller-push-outbox.consumer.spec.ts b/src/features/notification/services/seller-push-outbox.consumer.spec.ts index 0bc97994..b558ffb9 100644 --- a/src/features/notification/services/seller-push-outbox.consumer.spec.ts +++ b/src/features/notification/services/seller-push-outbox.consumer.spec.ts @@ -490,6 +490,27 @@ describe('SellerPushOutboxConsumer (real DB)', () => { }); }); + it('order.confirm_reminder_due는 매장 디바이스에 확정 마감 미리 알림을 보낸다', async () => { + const { storeId } = await storeWithDevices(1); + + await consumer.handle( + event('order.confirm_reminder_due', { + orderId: '42', + orderNumber: 'ORD-1', + storeId: storeId.toString(), + productName: '레터링 케이크', + confirmDeadlineAt: '2026-10-05T03:00:00.000Z', + }), + ); + + expect(send.mock.calls[0][0][0]).toMatchObject({ + title: '확정 마감 임박', + body: '레터링 케이크 주문을 12:00까지 확정하지 않으면 자동 취소돼요', + data: { kind: 'ORDER_CONFIRM_REMINDER', orderId: '42' }, + }); + expect(await deliveries()).toHaveLength(1); + }); + it('conversation.buyer_message_sent는 preview를 본문으로, 딥링크는 대화 id', async () => { const { storeId, devices } = await storeWithDevices(1); diff --git a/src/features/notification/services/seller-push-outbox.consumer.ts b/src/features/notification/services/seller-push-outbox.consumer.ts index 3b014bac..21b18984 100644 --- a/src/features/notification/services/seller-push-outbox.consumer.ts +++ b/src/features/notification/services/seller-push-outbox.consumer.ts @@ -21,13 +21,16 @@ import { SellerPushDeviceRepository } from '@/features/notification/repositories import { buildBuyerMessagePush, buildOrderCanceledPush, + buildOrderConfirmReminderPush, buildOrderSubmittedPush, SELLER_PUSH_CHANNEL_ID, type SellerPushContent, } from '@/features/notification/services/seller-push-messages.helper'; import { + ORDER_CONFIRM_REMINDER_DUE, ORDER_STATUS_CHANGED, ORDER_SUBMITTED, + parseOrderConfirmReminderDuePayload, parseOrderStatusChangedPayload, parseOrderSubmittedPayload, } from '@/features/order'; @@ -55,6 +58,7 @@ import { MetricsService } from '@/global/metrics'; @SubscribeOutbox( ORDER_SUBMITTED, ORDER_STATUS_CHANGED, + ORDER_CONFIRM_REMINDER_DUE, CONVERSATION_BUYER_MESSAGE_SENT, ) export class SellerPushOutboxConsumer implements OutboxConsumer { @@ -181,6 +185,13 @@ export class SellerPushOutboxConsumer implements OutboxConsumer { ? { storeId: parseId(push.storeId), content: push.content } : null; } + case ORDER_CONFIRM_REMINDER_DUE: { + const p = parseOrderConfirmReminderDuePayload(event.payload); + return { + storeId: parseId(p.storeId), + content: buildOrderConfirmReminderPush(p), + }; + } case CONVERSATION_BUYER_MESSAGE_SENT: { const p = parseConversationBuyerMessageSentPayload(event.payload); return { diff --git a/src/features/order/dto/inputs/admin-complete-order-pickup.input.ts b/src/features/order/dto/inputs/admin-complete-order-pickup.input.ts new file mode 100644 index 00000000..4ab9c922 --- /dev/null +++ b/src/features/order/dto/inputs/admin-complete-order-pickup.input.ts @@ -0,0 +1,10 @@ +import { IsOptional, IsString } from 'class-validator'; + +export class AdminCompleteOrderPickupInput { + @IsString() + orderId!: string; + + @IsOptional() + @IsString() + note?: string | null; +} diff --git a/src/features/order/dto/inputs/seller-update-order-status.input.ts b/src/features/order/dto/inputs/seller-update-order-status.input.ts index a2d92270..b8e810df 100644 --- a/src/features/order/dto/inputs/seller-update-order-status.input.ts +++ b/src/features/order/dto/inputs/seller-update-order-status.input.ts @@ -6,7 +6,7 @@ export class SellerUpdateOrderStatusInput { @IsString() orderId!: string; - // 전이 가능 여부는 정책(assertSellerTransition)이 판정한다 + // 전이 가능 여부는 정책(assertTransition)이 판정한다 @IsEnum(OrderStatus) toStatus!: OrderStatus; diff --git a/src/features/order/events/order-confirm-reminder-due.event.spec.ts b/src/features/order/events/order-confirm-reminder-due.event.spec.ts new file mode 100644 index 00000000..de2b477b --- /dev/null +++ b/src/features/order/events/order-confirm-reminder-due.event.spec.ts @@ -0,0 +1,52 @@ +import { + ORDER_CONFIRM_REMINDER_DUE, + orderConfirmReminderDueEvent, + parseOrderConfirmReminderDuePayload, +} from '@/features/order/events/order-confirm-reminder-due.event'; +import type { Prisma } from '@/generated/prisma/client'; + +const VALID = { + orderId: '7', + orderNumber: 'ORD-20261119-ABC234', + storeId: '5', + productName: '딸기 케이크', + confirmDeadlineAt: '2026-11-19T09:00:00.000Z', +}; + +describe('order.confirm_reminder_due 이벤트', () => { + it('bigint·Date를 문자열로 싣고 order aggregate에 묶는다(시스템 발행이라 행위자 없음)', () => { + const occurredAt = new Date('2026-11-19T07:00:00.000Z'); + const event = orderConfirmReminderDueEvent({ + orderId: 7n, + orderNumber: VALID.orderNumber, + storeId: 5n, + productName: VALID.productName, + confirmDeadlineAt: new Date(VALID.confirmDeadlineAt), + occurredAt, + }); + + expect(event).toEqual({ + aggregateType: 'order', + aggregateId: '7', + eventType: ORDER_CONFIRM_REMINDER_DUE, + payload: VALID, + occurredAt, + actorAccountId: null, + }); + expect( + parseOrderConfirmReminderDuePayload(event.payload as Prisma.JsonValue), + ).toEqual(VALID); + }); + + it.each([ + ['배열', []], + ['null', null], + ['매장 누락', { ...VALID, storeId: undefined }], + ['마감 비ISO', { ...VALID, confirmDeadlineAt: 'not-a-date' }], + ['상품명 숫자', { ...VALID, productName: 3 }], + ])('%s payload는 던진다', (_label, value) => { + expect(() => + parseOrderConfirmReminderDuePayload(value as Prisma.JsonValue), + ).toThrow('order.confirm_reminder_due payload 형식 오류'); + }); +}); diff --git a/src/features/order/events/order-confirm-reminder-due.event.ts b/src/features/order/events/order-confirm-reminder-due.event.ts new file mode 100644 index 00000000..f823e22d --- /dev/null +++ b/src/features/order/events/order-confirm-reminder-due.event.ts @@ -0,0 +1,68 @@ +import type { OutboxEventInput } from '@/features/outbox'; +import type { Prisma } from '@/generated/prisma/client'; + +/** 확정 마감 2시간 전 판매자 미리 알림. payload는 생산 시점 스냅샷이다. */ +export const ORDER_CONFIRM_REMINDER_DUE = 'order.confirm_reminder_due'; + +export interface OrderConfirmReminderDuePayload { + orderId: string; + orderNumber: string; + storeId: string; + productName: string; + /** ISO 8601 */ + confirmDeadlineAt: string; +} + +export function orderConfirmReminderDueEvent(args: { + orderId: bigint; + orderNumber: string; + storeId: bigint; + productName: string; + confirmDeadlineAt: Date; + occurredAt: Date; +}): OutboxEventInput { + const payload: OrderConfirmReminderDuePayload = { + orderId: args.orderId.toString(), + orderNumber: args.orderNumber, + storeId: args.storeId.toString(), + productName: args.productName, + confirmDeadlineAt: args.confirmDeadlineAt.toISOString(), + }; + return { + aggregateType: 'order', + aggregateId: payload.orderId, + eventType: ORDER_CONFIRM_REMINDER_DUE, + payload: { ...payload }, + occurredAt: args.occurredAt, + actorAccountId: null, + }; +} + +/** 소비자용 방어적 파싱 — 형태가 어긋난 payload는 던져서 재시도·FAILED로 드러낸다. */ +export function parseOrderConfirmReminderDuePayload( + value: Prisma.JsonValue, +): OrderConfirmReminderDuePayload { + const p = value as Partial< + Record + >; + if ( + typeof value !== 'object' || + value === null || + Array.isArray(value) || + typeof p.orderId !== 'string' || + typeof p.orderNumber !== 'string' || + typeof p.storeId !== 'string' || + typeof p.productName !== 'string' || + typeof p.confirmDeadlineAt !== 'string' || + Number.isNaN(Date.parse(p.confirmDeadlineAt)) + ) { + throw new Error(`${ORDER_CONFIRM_REMINDER_DUE} payload 형식 오류`); + } + return { + orderId: p.orderId, + orderNumber: p.orderNumber, + storeId: p.storeId, + productName: p.productName, + confirmDeadlineAt: p.confirmDeadlineAt, + }; +} diff --git a/src/features/order/index.ts b/src/features/order/index.ts index 51dd02d5..f2fc4f16 100644 --- a/src/features/order/index.ts +++ b/src/features/order/index.ts @@ -32,3 +32,9 @@ export { type OrderSubmittedPayload, parseOrderSubmittedPayload, } from '@/features/order/events/order-submitted.event'; +// 확정 마감 미리 알림 이벤트 계약(outbox). 판매자 푸시 소비자(notification)가 읽는다. +export { + ORDER_CONFIRM_REMINDER_DUE, + type OrderConfirmReminderDuePayload, + parseOrderConfirmReminderDuePayload, +} from '@/features/order/events/order-confirm-reminder-due.event'; diff --git a/src/features/order/order-admin.graphql b/src/features/order/order-admin.graphql index b3d7f789..96d8f17f 100644 --- a/src/features/order/order-admin.graphql +++ b/src/features/order/order-admin.graphql @@ -27,6 +27,15 @@ extend type Mutation { 없으면 NOT_FOUND. 관리자 로그인 필수. ADMIN 계정이 아니면 FORBIDDEN. """ adminCancelOrder(input: AdminCancelOrderInput!): AdminOrderSummary! + """ + 주문을 픽업 완료로 처리한다. 확정·제작 완료 주문만 되고(이미 픽업 완료면 ORDER_STATUS_UNCHANGED, 그 밖은 + INVALID_ORDER_STATUS_TRANSITION, 모두 BAD_USER_INPUT), 매장이 숨김이어도 픽업 시각 전이어도 처리한다. + 확인된 결제액으로 정산을 확정하고(결제 도입 전 주문은 건너뜀) 구매자에게 픽업 완료 알림이 간다. + 없으면 NOT_FOUND. 관리자 로그인 필수. ADMIN 계정이 아니면 FORBIDDEN. + """ + adminCompleteOrderPickup( + input: AdminCompleteOrderPickupInput! + ): AdminOrderSummary! } """ @@ -227,6 +236,19 @@ type AdminOrderDetail { 강제 취소 다이얼로그의 선택지. 지금 상태 기준이다. """ cancelOptions: AdminOrderCancelOptions! + """ + 판매자 확정 마감 시각. 지나면 자동 취소·전액 환불된다. 접수(SUBMITTED) 상태가 아니거나 결제 도입 전 주문이면 null. + """ + confirmDeadlineAt: DateTime + """ + 자동 픽업 완료 예정 시각(픽업 시각 + 24시간). 확정·제작 완료 상태에서만 있고 그 밖은 null. + 매장이 숨김이면 자동으로 픽업 완료되지 않으므로 관리자가 건별로 픽업 완료(adminCompleteOrderPickup)하거나 취소(adminCancelOrder)한다. + """ + autoPickupAt: DateTime + """ + 노쇼 처리 시각. 노쇼가 아니면 null. + """ + noShowAt: DateTime } """ @@ -344,3 +366,14 @@ input AdminCancelOrderInput { """ refundAmount: Int } + +""" +주문 픽업 완료 입력. 확정·제작 완료 주문만 처리할 수 있다. +""" +input AdminCompleteOrderPickupInput { + orderId: ID! + """ + 처리 메모. 선택, 최대 500자. 상태 이력과 감사 로그에 남는다. + """ + note: String +} diff --git a/src/features/order/order-seller.graphql b/src/features/order/order-seller.graphql index 9a1cc892..1a994765 100644 --- a/src/features/order/order-seller.graphql +++ b/src/features/order/order-seller.graphql @@ -11,7 +11,10 @@ extend type Query { extend type Mutation { """ - 주문 상태를 변경한다. 취소(CANCELED)는 받지 않으므로 sellerCancelOrder를 쓴다(INVALID_ORDER_STATUS_TRANSITION). + 주문 상태를 변경한다. 접수 → 확정, 확정 → 제작 완료, 확정·제작 완료 → 픽업 완료·노쇼만 된다(그 밖은 + INVALID_ORDER_STATUS_TRANSITION, 같은 상태면 ORDER_STATUS_UNCHANGED). 노쇼는 픽업 시각부터 24시간(자동 픽업 완료 전) + 안에서만 되고 벗어나면 NO_SHOW_NOT_ALLOWED(BAD_USER_INPUT)다. 픽업 완료·노쇼는 정산 금액을 확정하고, 노쇼는 환불이 없다. + 취소(CANCELED)는 받지 않으므로 sellerCancelOrder를 쓴다(INVALID_ORDER_STATUS_TRANSITION). 판매자 로그인 필수. SELLER 계정이 아니면 FORBIDDEN, 매장을 보유하지 않으면 NOT_FOUND. """ sellerUpdateOrderStatus( @@ -77,6 +80,11 @@ type SellerOrderSummary { 내 매장 첫 품목의 커스텀 대표 이미지 URL(3D 윗면 렌더 또는 슬롯형 합성). 없으면 null. """ firstItemCustomImageUrl: String + """ + 확정 마감 시각. 이때까지 확정하지 않으면 자동 취소되고 결제액 전액이 환불된다. 접수(SUBMITTED) 상태가 아니거나 + 결제 도입 전 주문이면 null. + """ + confirmDeadlineAt: DateTime } """ @@ -226,6 +234,24 @@ type SellerOrderDetail { 취소 정보(주체·사유·사정·환불액·환불 진행). 취소되지 않은 주문이면 null. """ cancellation: OrderCancellation + """ + 확정 마감 시각. 이때까지 확정하지 않으면 자동 취소되고 결제액 전액이 환불된다. 접수(SUBMITTED) 상태가 아니거나 + 결제 도입 전 주문이면 null. + """ + confirmDeadlineAt: DateTime + """ + 자동 픽업 완료 예정 시각(픽업 시각 + 24시간). 확정·제작 완료 상태에서만 있고 그 밖은 null. + 매장이 숨김이면 자동으로 픽업 완료되지 않는다. + """ + autoPickupAt: DateTime + """ + 지금 노쇼로 처리할 수 있는지. 확정·제작 완료 상태이고 픽업 시각 ≤ 지금 < autoPickupAt일 때 true. + """ + canMarkNoShow: Boolean! + """ + 노쇼 처리 시각. 노쇼가 아니면 null. + """ + noShowAt: DateTime } """ @@ -235,7 +261,7 @@ BAD_USER_INPUT으로 거절된다. input SellerUpdateOrderStatusInput { orderId: ID! """ - 변경할 상태. 현재 상태에서 진입 가능한 값이어야 한다. + 변경할 상태. CONFIRMED·MADE·PICKED_UP·NO_SHOW 중 현재 상태에서 진입 가능한 값이어야 한다. """ toStatus: OrderStatusType! """ diff --git a/src/features/order/order.module.ts b/src/features/order/order.module.ts index ba7d5265..5af0468f 100644 --- a/src/features/order/order.module.ts +++ b/src/features/order/order.module.ts @@ -10,6 +10,7 @@ import { DepositRecordRepository } from '@/features/order/repositories/deposit-r import { OrderBookedRepository } from '@/features/order/repositories/order-booked.repository'; import { OrderCustomUploadRepository } from '@/features/order/repositories/order-custom-upload.repository'; import { OrderInquiryRepository } from '@/features/order/repositories/order-inquiry.repository'; +import { OrderLifecycleRepository } from '@/features/order/repositories/order-lifecycle.repository'; import { OrderStoreDailyLimitRepository } from '@/features/order/repositories/order-store-daily-limit.repository'; import { OrderTransitionRepository } from '@/features/order/repositories/order-transition.repository'; import { OrderWithdrawalBlockingRepository } from '@/features/order/repositories/order-withdrawal-blocking.repository'; @@ -42,6 +43,7 @@ import { OrderCustomUploadCleanupScheduler } from '@/features/order/services/ord import { OrderCustomizationService } from '@/features/order/services/order-customization.service'; import { AdminDepositService } from '@/features/order/services/order-deposit-admin.service'; import { OrderEventsService } from '@/features/order/services/order-events.service'; +import { OrderLifecycleScheduler } from '@/features/order/services/order-lifecycle.scheduler'; import { UserOrderService } from '@/features/order/services/order-my.service'; import { AdminPaymentService } from '@/features/order/services/order-payment-admin.service'; import { AdminRefundService } from '@/features/order/services/order-refund-admin.service'; @@ -99,6 +101,9 @@ import { StoreModule } from '@/features/store'; // 결제(입금 대기)와 상태 전이 잠금 단위, 관리자 입금 확인 PaymentRepository, OrderTransitionRepository, + // 자동 전이 크론(미입금 취소·확정 마감 알림·미확정 취소·자동 픽업 완료, worker) + OrderLifecycleRepository, + OrderLifecycleScheduler, AdminDepositService, AdminDepositQueryResolver, AdminDepositMutationResolver, diff --git a/src/features/order/order.types.graphql b/src/features/order/order.types.graphql index 6f9773dd..8efb7472 100644 --- a/src/features/order/order.types.graphql +++ b/src/features/order/order.types.graphql @@ -3,8 +3,10 @@ 흐름은 `PENDING_PAYMENT → SUBMITTED → CONFIRMED → MADE → PICKED_UP`이며 어떤 상태에서도 앞 단계로 되돌아갈 수 없다. 판매자가 sellerUpdateOrderStatus로 바꿀 수 있는 전이는 `SUBMITTED → CONFIRMED`, -`CONFIRMED → MADE`, `MADE → PICKED_UP`뿐이고, 취소는 주체별 취소 mutation(cancelMyOrder·sellerCancelOrder·adminCancelOrder)으로만 한다. -판매자에게는 입금이 확인된(접수된) 주문만 보인다. +`CONFIRMED → MADE`, `CONFIRMED·MADE → PICKED_UP·NO_SHOW`뿐이고, 취소는 주체별 취소 mutation(cancelMyOrder·sellerCancelOrder·adminCancelOrder)으로만 한다. +관리자도 adminCompleteOrderPickup으로 확정·제작 완료 주문을 픽업 완료할 수 있다. +시스템은 입금 기한(1시간)이 지난 입금 대기를 취소하고, 확정 마감이 지난 접수를 취소(전액 환불)하며, +픽업 시각 + 24시간이 지난 확정·제작 완료를 픽업 완료로 바꾼다. 판매자에게는 입금이 확인된(접수된) 주문만 보인다. """ enum OrderStatusType { """입금 대기. 주문 직후 계좌이체 입금을 기다리는 상태이고, 판매자에게 보이지 않는다.""" diff --git a/src/features/order/policies/order-lifecycle.policy.spec.ts b/src/features/order/policies/order-lifecycle.policy.spec.ts new file mode 100644 index 00000000..acc18272 --- /dev/null +++ b/src/features/order/policies/order-lifecycle.policy.spec.ts @@ -0,0 +1,115 @@ +import { HOUR_MS } from '@/common/utils/kst-time'; +import { + isConfirmReminderDue, + isConfirmTimedOut, + isPaymentExpired, + type OrderLockedState, +} from '@/features/order/policies/order-lifecycle.policy'; +import type { OrderStatus } from '@/generated/prisma/client'; + +const NOW = new Date('2026-11-19T05:00:00.000Z'); +const DAY = 24 * HOUR_MS; +const at = (offsetMs: number) => new Date(NOW.getTime() + offsetMs); + +function state(overrides: Partial = {}): OrderLockedState { + return { + status: 'PENDING_PAYMENT', + pickupAt: at(DAY), + confirmDeadlineAt: null, + payment: { status: 'PENDING', expires_at: NOW, buyer_claimed_at: null }, + ...overrides, + }; +} + +describe('order-lifecycle.policy', () => { + describe('isPaymentExpired', () => { + it.each([ + ['기한 정각', state(), true], + [ + '기한 1ms 전', + state({ + payment: { + status: 'PENDING', + expires_at: at(1), + buyer_claimed_at: null, + }, + }), + false, + ], + [ + "'입금했어요'를 누름", + state({ + payment: { + status: 'PENDING', + expires_at: at(-1), + buyer_claimed_at: at(-HOUR_MS), + }, + }), + false, + ], + [ + '결제 확인됨', + state({ + payment: { + status: 'CONFIRMED', + expires_at: at(-1), + buyer_claimed_at: null, + }, + }), + false, + ], + ['주문이 이미 접수', state({ status: 'SUBMITTED' }), false], + ['결제 없음(도입 전)', state({ payment: null }), false], + ])('%s → %s', (_label, s, expected) => { + expect(isPaymentExpired(s, NOW)).toBe(expected); + }); + }); + + describe('isConfirmTimedOut', () => { + it.each<[string, OrderStatus, Date | null, boolean]>([ + ['마감 정각', 'SUBMITTED', NOW, true], + ['마감 1ms 전', 'SUBMITTED', at(1), false], + ['마감 없음(결제 도입 전)', 'SUBMITTED', null, false], + ['이미 확정', 'CONFIRMED', at(-1), false], + ])('%s → %s', (_label, status, deadline, expected) => { + expect( + isConfirmTimedOut(state({ status, confirmDeadlineAt: deadline }), NOW), + ).toBe(expected); + }); + }); + + describe('isConfirmReminderDue(마감 − 2h ≤ now < 마감, 마감 − 2h > 접수)', () => { + const due = ( + deadline: Date | null, + submittedAt: Date | null, + overrides: { status?: OrderStatus; sentAt?: Date | null } = {}, + ) => + isConfirmReminderDue( + { + status: overrides.status ?? 'SUBMITTED', + submittedAt, + confirmDeadlineAt: deadline, + confirmReminderSentAt: overrides.sentAt ?? null, + }, + NOW, + ); + + it.each<[string, Date | null, Date | null, boolean]>([ + ['마감 2시간 전 정각', at(2 * HOUR_MS), at(-DAY), true], + ['마감 2시간 + 1ms 전', at(2 * HOUR_MS + 1), at(-DAY), false], + ['마감 1ms 전', at(1), at(-DAY), true], + ['마감 정각', NOW, at(-DAY), false], + ['마감 − 2h = 접수', at(HOUR_MS), at(-HOUR_MS), false], + ['마감 − 2h = 접수 + 1ms', at(HOUR_MS + 1), at(-HOUR_MS), true], + ['마감 없음', null, at(-DAY), false], + ['접수 시각 없음', at(HOUR_MS), null, false], + ])('%s → %s', (_label, deadline, submittedAt, expected) => { + expect(due(deadline, submittedAt)).toBe(expected); + }); + + it('이미 보냈거나 접수 상태가 아니면 보내지 않는다', () => { + expect(due(at(HOUR_MS), at(-DAY), { sentAt: at(-1) })).toBe(false); + expect(due(at(HOUR_MS), at(-DAY), { status: 'CONFIRMED' })).toBe(false); + }); + }); +}); diff --git a/src/features/order/policies/order-lifecycle.policy.ts b/src/features/order/policies/order-lifecycle.policy.ts new file mode 100644 index 00000000..4a7ad3b2 --- /dev/null +++ b/src/features/order/policies/order-lifecycle.policy.ts @@ -0,0 +1,66 @@ +import { HOUR_MS } from '@/common/utils/kst-time'; +import { + OrderStatus, + PaymentStatus, + type Payment, +} from '@/generated/prisma/client'; + +/** 확정 마감 이만큼 전에 판매자에게 미리 알린다. */ +export const CONFIRM_REMINDER_LEAD_MS = 2 * HOUR_MS; + +/** 잠금 읽기로 다시 본 주문·결제(크론 대상 재검사 재료). */ +export interface OrderLockedState { + status: OrderStatus; + pickupAt: Date; + confirmDeadlineAt: Date | null; + payment: Pick | null; +} + +export interface ConfirmReminderState { + status: OrderStatus; + submittedAt: Date | null; + confirmDeadlineAt: Date | null; + confirmReminderSentAt: Date | null; +} + +/** 미입금 취소 대상: 유예 없이 입금 기한 정각부터, '입금했어요'를 누른 주문은 관리자 확인을 기다린다. */ +export function isPaymentExpired(state: OrderLockedState, now: Date): boolean { + const { payment } = state; + return ( + state.status === OrderStatus.PENDING_PAYMENT && + payment?.status === PaymentStatus.PENDING && + payment.buyer_claimed_at === null && + payment.expires_at <= now + ); +} + +/** 미확정 취소 대상: 확정 마감이 지난 접수. 결제 도입 전 접수는 마감이 없어 빠진다. */ +export function isConfirmTimedOut(state: OrderLockedState, now: Date): boolean { + return ( + state.status === OrderStatus.SUBMITTED && + state.confirmDeadlineAt !== null && + state.confirmDeadlineAt <= now + ); +} + +/** 마감 2시간 전 구간의 미발송 접수. 접수 시점에 이미 그 구간이었으면(새 주문 푸시가 마감을 실었다) 보내지 않는다. */ +export function isConfirmReminderDue( + state: ConfirmReminderState, + now: Date, +): boolean { + const { confirmDeadlineAt: deadline, submittedAt } = state; + if ( + state.status !== OrderStatus.SUBMITTED || + state.confirmReminderSentAt !== null || + !deadline || + !submittedAt + ) { + return false; + } + const remindAt = deadline.getTime() - CONFIRM_REMINDER_LEAD_MS; + return ( + remindAt <= now.getTime() && + now < deadline && + remindAt > submittedAt.getTime() + ); +} diff --git a/src/features/order/policies/order-status-transition.policy.spec.ts b/src/features/order/policies/order-status-transition.policy.spec.ts index 99d70b06..98f69d3f 100644 --- a/src/features/order/policies/order-status-transition.policy.spec.ts +++ b/src/features/order/policies/order-status-transition.policy.spec.ts @@ -1,21 +1,62 @@ -import { OrderStatusTransitionPolicy } from '@/features/order/policies/order-status-transition.policy'; -import { OrderStatus } from '@/generated/prisma/client'; +import { HOUR_MS } from '@/common/utils/kst-time'; +import { OrderCancelPolicy } from '@/features/order/policies/order-cancel.policy'; +import { + autoPickupAt, + isInNoShowWindow, + OrderStatusTransitionPolicy, +} from '@/features/order/policies/order-status-transition.policy'; +import { OrderActor, OrderStatus } from '@/generated/prisma/client'; const STATUSES = Object.values(OrderStatus); +const ACTORS = Object.values(OrderActor); -/** 판매자 전이 허용 목록. 이 밖은 전부 거절이다(기본 거절). 취소는 sellerCancelOrder로만 한다. */ +const PICKUP_AT = new Date('2026-11-20T05:00:00.000Z'); +const IN_NO_SHOW_WINDOW = new Date(PICKUP_AT.getTime() + HOUR_MS); +const AFTER_AUTO_PICKUP = autoPickupAt(PICKUP_AT); + +/** 허용 전이 정본(actor:from>to). 이 밖은 전부 거절이다(기본 거절). */ const ALLOWED = new Set([ - 'SUBMITTED>CONFIRMED', - 'CONFIRMED>MADE', - 'MADE>PICKED_UP', + 'ADMIN:PENDING_PAYMENT>SUBMITTED', + 'BUYER:PENDING_PAYMENT>CANCELED', + 'ADMIN:PENDING_PAYMENT>CANCELED', + 'SYSTEM:PENDING_PAYMENT>CANCELED', + 'SELLER:SUBMITTED>CONFIRMED', + 'BUYER:SUBMITTED>CANCELED', + 'SELLER:SUBMITTED>CANCELED', + 'ADMIN:SUBMITTED>CANCELED', + 'SYSTEM:SUBMITTED>CANCELED', + 'SELLER:CONFIRMED>MADE', + 'SELLER:CONFIRMED>PICKED_UP', + 'ADMIN:CONFIRMED>PICKED_UP', + 'SYSTEM:CONFIRMED>PICKED_UP', + 'SELLER:CONFIRMED>NO_SHOW', + 'SELLER:CONFIRMED>CANCELED', + 'ADMIN:CONFIRMED>CANCELED', + 'SELLER:MADE>PICKED_UP', + 'ADMIN:MADE>PICKED_UP', + 'SYSTEM:MADE>PICKED_UP', + 'SELLER:MADE>NO_SHOW', + 'SELLER:MADE>CANCELED', + 'ADMIN:MADE>CANCELED', ]); -function expectedCode(from: OrderStatus, to: OrderStatus): string | null { +function expectedCode( + actor: OrderActor, + from: OrderStatus, + to: OrderStatus, +): string | null { if (from === to) return 'ORDER_STATUS_UNCHANGED'; - if (ALLOWED.has(`${from}>${to}`)) return null; + if (ALLOWED.has(`${actor}:${from}>${to}`)) return null; return 'INVALID_ORDER_STATUS_TRANSITION'; } +/** 시각 조건이 있는 전이는 그 조건을 채우는 시각으로 표를 본다(경계는 아래 describe). */ +function nowFor(actor: OrderActor, to: OrderStatus): Date { + return to === OrderStatus.PICKED_UP && actor === OrderActor.SYSTEM + ? AFTER_AUTO_PICKUP + : IN_NO_SHOW_WINDOW; +} + describe('OrderStatusTransitionPolicy', () => { const policy = new OrderStatusTransitionPolicy(); @@ -32,20 +73,108 @@ describe('OrderStatusTransitionPolicy', () => { }); }); - describe('assertSellerTransition', () => { - const cases = STATUSES.flatMap((from) => - STATUSES.map((to) => [from, to, expectedCode(from, to)] as const), + describe('assertTransition 전수(주체 4 × from 7 × to 7)', () => { + const cases = ACTORS.flatMap((actor) => + STATUSES.flatMap((from) => + STATUSES.map( + (to) => [actor, from, to, expectedCode(actor, from, to)] as const, + ), + ), ); - it('표는 상태 전 조합(7×7)을 덮고 허용 전이는 3개다(CANCELED로 가는 전이는 없다)', () => { - expect(cases).toHaveLength(49); - expect(cases.filter(([, , code]) => code === null)).toHaveLength(3); + it('표는 196 조합을 덮고 허용 전이는 22개다(종료 상태에서 나가는 전이는 없다)', () => { + expect(cases).toHaveLength(4 * 7 * 7); + expect(cases.filter(([, , , code]) => code === null)).toHaveLength(22); + for (const terminal of ['PICKED_UP', 'NO_SHOW', 'CANCELED']) { + expect( + cases.filter(([, from, , code]) => from === terminal && !code), + ).toHaveLength(0); + } }); - it.each(cases)('%s → %s: %s', (from, to, code) => { - const run = () => policy.assertSellerTransition(from, to); + it.each(cases)('%s: %s → %s = %s', (actor, from, to, code) => { + const request = { + actor, + from, + to, + now: nowFor(actor, to), + pickupAt: PICKUP_AT, + }; + expect(policy.canTransition(request)).toBe(code === null); + const run = () => policy.assertTransition(request); if (code === null) expect(run).not.toThrow(); else expect(run).toThrowDomain(code); }); + + it.each( + ACTORS.flatMap((actor) => STATUSES.map((s) => [actor, s] as const)), + )('%s의 %s 취소 허용은 OrderCancelPolicy와 같다', (actor, status) => { + const allowed = policy.canTransition({ + actor, + from: status, + to: OrderStatus.CANCELED, + now: IN_NO_SHOW_WINDOW, + pickupAt: PICKUP_AT, + }); + expect(allowed).toBe(new OrderCancelPolicy().canCancel(actor, status)); + }); + }); + + describe('노쇼 구간(pickupAt ≤ now < pickupAt + 24h)', () => { + const at = (offsetMs: number) => new Date(PICKUP_AT.getTime() + offsetMs); + + it.each([ + ['pickupAt − 1ms', at(-1), false], + ['pickupAt', at(0), true], + ['pickupAt + 24h − 1ms', at(24 * HOUR_MS - 1), true], + ['pickupAt + 24h', at(24 * HOUR_MS), false], + ])('%s: 허용 %s', (_label, now, allowed) => { + expect(isInNoShowWindow(PICKUP_AT, now)).toBe(allowed); + for (const from of [OrderStatus.CONFIRMED, OrderStatus.MADE]) { + const run = () => + policy.assertTransition({ + actor: OrderActor.SELLER, + from, + to: OrderStatus.NO_SHOW, + now, + pickupAt: PICKUP_AT, + }); + if (allowed) expect(run).not.toThrow(); + else expect(run).toThrowDomain('NO_SHOW_NOT_ALLOWED'); + } + }); + }); + + describe('픽업 완료 시각 조건은 시스템만 pickupAt + 24h부터', () => { + it.each([ + [-1, false], + [0, true], + ])('pickupAt + 24h %+dms: 허용 %s', (offset, allowed) => { + const request = { + actor: OrderActor.SYSTEM, + from: OrderStatus.MADE, + to: OrderStatus.PICKED_UP, + now: new Date(AFTER_AUTO_PICKUP.getTime() + offset), + pickupAt: PICKUP_AT, + }; + expect(policy.canTransition(request)).toBe(allowed); + }); + + it.each([OrderActor.SELLER, OrderActor.ADMIN])( + '%s 픽업 완료에는 시각 조건이 없다(픽업 시각 전에도 된다)', + (actor) => { + for (const from of [OrderStatus.CONFIRMED, OrderStatus.MADE]) { + expect( + policy.canTransition({ + actor, + from, + to: OrderStatus.PICKED_UP, + now: new Date(PICKUP_AT.getTime() - HOUR_MS), + pickupAt: PICKUP_AT, + }), + ).toBe(true); + } + }, + ); }); }); diff --git a/src/features/order/policies/order-status-transition.policy.ts b/src/features/order/policies/order-status-transition.policy.ts index a18e7e7e..adf26712 100644 --- a/src/features/order/policies/order-status-transition.policy.ts +++ b/src/features/order/policies/order-status-transition.policy.ts @@ -1,20 +1,78 @@ import { Injectable } from '@nestjs/common'; -import { DomainException } from '@/common/errors/error-catalog'; -import { OrderStatus } from '@/generated/prisma/client'; +import { DomainException, type ErrorCode } from '@/common/errors/error-catalog'; +import { DAY_MS } from '@/common/utils/kst-time'; +import { OrderActor, OrderStatus } from '@/generated/prisma/client'; const ORDER_STATUS_VALUES: readonly string[] = Object.values(OrderStatus); +const { BUYER, SELLER, ADMIN, SYSTEM } = OrderActor; + /** - * 판매자가 만들 수 있는 전이(to → 허용 from). 표에 없는 to는 거절한다 — 새 상태가 조용히 열리지 않게. - * 취소는 사유·사정·환불액이 필요해 sellerCancelOrder(OrderCancelPolicy)로만 한다. + * from → to → 그 전이를 할 수 있는 주체. 표에 없는 조합은 거절한다(기본 거절) — 새 상태가 조용히 열리지 않게. + * 취소의 사유·사정·환불액은 OrderCancelPolicy가 따로 판정한다. */ -const SELLER_TRANSITIONS: Partial> = - { - CONFIRMED: [OrderStatus.SUBMITTED], - MADE: [OrderStatus.CONFIRMED], - PICKED_UP: [OrderStatus.MADE], - }; +const TRANSITIONS: Partial< + Record>> +> = { + PENDING_PAYMENT: { SUBMITTED: [ADMIN], CANCELED: [BUYER, ADMIN, SYSTEM] }, + SUBMITTED: { CONFIRMED: [SELLER], CANCELED: [BUYER, SELLER, ADMIN, SYSTEM] }, + CONFIRMED: { + MADE: [SELLER], + PICKED_UP: [SELLER, ADMIN, SYSTEM], + NO_SHOW: [SELLER], + CANCELED: [SELLER, ADMIN], + }, + MADE: { + PICKED_UP: [SELLER, ADMIN, SYSTEM], + NO_SHOW: [SELLER], + CANCELED: [SELLER, ADMIN], + }, +}; + +/** 픽업 시각에서 이만큼 지나면 자동 픽업 완료되고, 노쇼는 그 전까지만 처리할 수 있다. */ +export const AUTO_PICKUP_DELAY_MS = DAY_MS; + +export interface OrderTransitionRequest { + actor: OrderActor; + from: OrderStatus; + to: OrderStatus; + now: Date; + pickupAt: Date; +} + +export function autoPickupAt(pickupAt: Date): Date { + return new Date(pickupAt.getTime() + AUTO_PICKUP_DELAY_MS); +} + +/** 노쇼 처리 구간: 픽업 시각 ≤ now < 자동 픽업 완료 시각. */ +export function isInNoShowWindow(pickupAt: Date, now: Date): boolean { + return pickupAt <= now && now < autoPickupAt(pickupAt); +} + +function violationOf({ + actor, + from, + to, + now, + pickupAt, +}: OrderTransitionRequest): ErrorCode | null { + if (from === to) return 'ORDER_STATUS_UNCHANGED'; + if (!TRANSITIONS[from]?.[to]?.includes(actor)) { + return 'INVALID_ORDER_STATUS_TRANSITION'; + } + if (to === OrderStatus.NO_SHOW && !isInNoShowWindow(pickupAt, now)) { + return 'NO_SHOW_NOT_ALLOWED'; + } + if ( + to === OrderStatus.PICKED_UP && + actor === SYSTEM && + now < autoPickupAt(pickupAt) + ) { + return 'INVALID_ORDER_STATUS_TRANSITION'; + } + return null; +} @Injectable() export class OrderStatusTransitionPolicy { @@ -23,11 +81,13 @@ export class OrderStatusTransitionPolicy { throw new DomainException('INVALID_ORDER_STATUS'); } - assertSellerTransition(from: OrderStatus, to: OrderStatus): void { - if (from === to) { - throw new DomainException('ORDER_STATUS_UNCHANGED'); - } - if (SELLER_TRANSITIONS[to]?.includes(from)) return; - throw new DomainException('INVALID_ORDER_STATUS_TRANSITION'); + /** 주체·상태·시각만 본다. 잠금 뒤 상태로 다시 부른다. */ + assertTransition(request: OrderTransitionRequest): void { + const code = violationOf(request); + if (code) throw new DomainException(code); + } + + canTransition(request: OrderTransitionRequest): boolean { + return violationOf(request) === null; } } diff --git a/src/features/order/repositories/order-lifecycle.repository.ts b/src/features/order/repositories/order-lifecycle.repository.ts new file mode 100644 index 00000000..f824b5f9 --- /dev/null +++ b/src/features/order/repositories/order-lifecycle.repository.ts @@ -0,0 +1,180 @@ +import { Injectable } from '@nestjs/common'; + +import { orderConfirmReminderDueEvent } from '@/features/order/events/order-confirm-reminder-due.event'; +import { + CONFIRM_REMINDER_LEAD_MS, + type ConfirmReminderState, +} from '@/features/order/policies/order-lifecycle.policy'; +import { AUTO_PICKUP_DELAY_MS } from '@/features/order/policies/order-status-transition.policy'; +import { OutboxPublisher } from '@/features/outbox'; +import { OrderStatus, PaymentStatus, Prisma } from '@/generated/prisma/client'; +import { activeWhere, PrismaService } from '@/prisma'; + +/** 키셋 한 페이지(id 오름차순). afterId 다음부터 limit건. */ +export interface CandidatePage { + now: Date; + afterId?: bigint; + limit: number; +} + +function afterIdWhere(page: CandidatePage) { + return page.afterId !== undefined ? { id: { gt: page.afterId } } : {}; +} + +function keysetPage(page: CandidatePage) { + return { + select: { id: true }, + orderBy: { id: 'asc' as const }, + take: page.limit, + }; +} + +/** + * 자동 전이 크론의 대상 고르기와 미리 알림 기록. 전이 자체는 OrderTransitionRepository가 건마다 잠근 뒤 다시 판정한다 — + * 여기 조건은 후보를 좁히는 용도라 잠금 없이 읽는다. + */ +@Injectable() +export class OrderLifecycleRepository { + constructor( + private readonly prisma: PrismaService, + private readonly outbox: OutboxPublisher, + ) {} + + /** 입금 기한이 지났고 '입금했어요'를 누르지 않은 입금 대기. */ + async findPaymentExpiredIds(page: CandidatePage): Promise { + const rows = await this.prisma.order.findMany({ + where: { + status: OrderStatus.PENDING_PAYMENT, + payment: { + status: PaymentStatus.PENDING, + buyer_claimed_at: null, + expires_at: { lte: page.now }, + }, + ...afterIdWhere(page), + }, + ...keysetPage(page), + }); + return rows.map((row) => row.id); + } + + /** 확정 마감이 지난 접수. 결제 도입 전 접수는 마감이 없어 빠진다. */ + async findConfirmTimedOutIds(page: CandidatePage): Promise { + const rows = await this.prisma.order.findMany({ + where: { + status: OrderStatus.SUBMITTED, + confirm_deadline_at: { lte: page.now }, + ...afterIdWhere(page), + }, + ...keysetPage(page), + }); + return rows.map((row) => row.id); + } + + /** 픽업 + 24시간이 지난 확정·제작 완료. 숨긴 매장의 주문은 관리자가 건별로 처리하므로 뺀다. */ + async findAutoPickupIds( + page: CandidatePage & { excludeStoreIds: bigint[] }, + ): Promise { + const rows = await this.prisma.order.findMany({ + where: { + status: { in: [OrderStatus.CONFIRMED, OrderStatus.MADE] }, + pickup_at: { + lte: new Date(page.now.getTime() - AUTO_PICKUP_DELAY_MS), + }, + ...(page.excludeStoreIds.length > 0 + ? { + items: { + none: { + store_id: { in: page.excludeStoreIds }, + ...activeWhere, + }, + }, + } + : {}), + ...afterIdWhere(page), + }, + ...keysetPage(page), + }); + return rows.map((row) => row.id); + } + + /** 마감 2시간 전 구간의 미발송 접수. 접수 시점 조건은 열 비교라 raw다. */ + async findConfirmReminderDueIds(page: CandidatePage): Promise { + const remindBefore = new Date( + page.now.getTime() + CONFIRM_REMINDER_LEAD_MS, + ); + const rows = await this.prisma.$queryRaw<{ id: bigint }[]>` + SELECT o.id FROM \`order\` o + WHERE o.status = 'SUBMITTED' + AND o.deleted_at IS NULL + AND o.confirm_reminder_sent_at IS NULL + AND o.confirm_deadline_at > ${page.now} + AND o.confirm_deadline_at <= ${remindBefore} + AND o.confirm_deadline_at - INTERVAL ${CONFIRM_REMINDER_LEAD_MS / 1000} SECOND > o.submitted_at + ${page.afterId !== undefined ? Prisma.sql`AND o.id > ${page.afterId}` : Prisma.empty} + ORDER BY o.id + LIMIT ${page.limit}`; + return rows.map((row) => row.id); + } + + /** + * 미리 알림 1회: 잠금 뒤 isDue로 다시 판정하고 발송 표시와 판매자 푸시 이벤트를 같은 tx에 남긴다. + * 대상이 아니게 됐으면(확정·취소·이미 발송) false. + */ + async markConfirmReminderSent(args: { + orderId: bigint; + now: Date; + isDue: (state: ConfirmReminderState) => boolean; + }): Promise { + const { orderId, now } = args; + return this.prisma.$transaction(async (tx) => { + const [locked] = await tx.$queryRaw< + { + id: bigint; + order_number: string; + status: OrderStatus; + submitted_at: Date | null; + confirm_deadline_at: Date | null; + confirm_reminder_sent_at: Date | null; + }[] + >` + SELECT id, order_number, status, submitted_at, confirm_deadline_at, confirm_reminder_sent_at + FROM \`order\` WHERE id = ${orderId} AND deleted_at IS NULL + FOR UPDATE`; + if ( + !locked?.confirm_deadline_at || + !args.isDue({ + status: locked.status, + submittedAt: locked.submitted_at, + confirmDeadlineAt: locked.confirm_deadline_at, + confirmReminderSentAt: locked.confirm_reminder_sent_at, + }) + ) { + return false; + } + const firstItem = await tx.orderItem.findFirst({ + where: { order_id: locked.id, ...activeWhere }, + orderBy: { id: 'asc' }, + select: { store_id: true, product_name_snapshot: true }, + }); + await tx.order.update({ + where: { id: locked.id }, + data: { confirm_reminder_sent_at: now }, + }); + // 품목이 없으면 매장을 몰라 보낼 곳이 없다 — 표시만 남겨 다시 고르지 않게 한다 + if (firstItem) { + await this.outbox.publish( + tx, + orderConfirmReminderDueEvent({ + orderId: locked.id, + orderNumber: locked.order_number, + storeId: firstItem.store_id, + productName: firstItem.product_name_snapshot, + confirmDeadlineAt: locked.confirm_deadline_at, + occurredAt: now, + }), + ); + } + return true; + }); + } +} diff --git a/src/features/order/repositories/order-settlement-finalizer.helper.ts b/src/features/order/repositories/order-settlement-finalizer.helper.ts index a1f49e55..5fb671f5 100644 --- a/src/features/order/repositories/order-settlement-finalizer.helper.ts +++ b/src/features/order/repositories/order-settlement-finalizer.helper.ts @@ -6,6 +6,8 @@ export interface LockedPayment { id: bigint; status: PaymentStatus; amount: number; + expires_at: Date; + buyer_claimed_at: Date | null; confirmed_at: Date | null; } @@ -15,13 +17,10 @@ export async function lockPayment( orderId: bigint, ): Promise { const [row] = await tx.$queryRaw< - { - id: bigint; - status: PaymentStatus; - amount: bigint; - confirmed_at: Date | null; - }[] - >`SELECT id, status, amount, confirmed_at FROM payment WHERE order_id = ${orderId} FOR UPDATE`; + (Omit & { amount: bigint })[] + >` + SELECT id, status, amount, expires_at, buyer_claimed_at, confirmed_at + FROM payment WHERE order_id = ${orderId} FOR UPDATE`; // raw는 INT UNSIGNED를 bigint로 돌려준다 return row ? { ...row, amount: Number(row.amount) } : null; } diff --git a/src/features/order/repositories/order-transition.repository.ts b/src/features/order/repositories/order-transition.repository.ts index 357793b2..f0e72717 100644 --- a/src/features/order/repositories/order-transition.repository.ts +++ b/src/features/order/repositories/order-transition.repository.ts @@ -12,10 +12,12 @@ import type { OrderCancelDecision, OrderCancelState, } from '@/features/order/policies/order-cancel.policy'; +import type { OrderLockedState } from '@/features/order/policies/order-lifecycle.policy'; import { confirmedPaidAmount, finalizeSettlementLocked, lockPayment, + type LockedPayment, } from '@/features/order/repositories/order-settlement-finalizer.helper'; import { adminOrderInclude, @@ -76,13 +78,88 @@ export interface CancelOrderArgs { /** 취소와 함께 받은 환불 계좌. 환불이 생기면 바로 송금 대기로 만들고, 환불이 없으면 버린다. */ refundAccount?: RefundAccountData | null; now: Date; + /** 크론 대상 조건을 잠금 뒤 다시 본다. false면 아무것도 바꾸지 않고 null이다(그사이 다른 전이·입금했어요). */ + eligible?: (state: OrderLockedState) => boolean; /** 잠금 시점 재료로 사유·사정·환불액을 정한다. 던지면 tx가 롤백되고 예외가 그대로 나간다. */ decide: (state: OrderCancelState) => OrderCancelDecision; } +export interface CompletePickupBySystemArgs { + orderId: bigint; + now: Date; + /** 잠금 뒤 상태·픽업 시각으로 다시 판정한다. false면 아무것도 바꾸지 않고 null이다. */ + eligible: (state: OrderLockedState) => boolean; +} + +export interface CompletePickupByAdminArgs { + orderId: bigint; + actorAccountId: bigint; + note: string | null; + now: Date; + /** 잠금 뒤 상태·픽업 시각으로 판정한다. 던지면 tx가 롤백되고 예외가 그대로 나간다. */ + assertTransition: (state: OrderLockedState) => void; +} + +/** 픽업 완료를 남기는 주체. 시스템 전이는 계정·메모가 없다. */ +interface PickupActor { + actor: OrderActor; + actorAccountId: bigint | null; + note: string | null; + now: Date; +} + /** 접수 뒤 판매자 확정 마감: 확인 + 24시간과 픽업 시각 중 이른 쪽. */ const CONFIRM_WINDOW_MS = DAY_MS; +interface LockedOrderRow { + id: bigint; + status: OrderStatus; + pickup_at: Date; + commission_rate_bps: number; + submitted_at: Date | null; + confirm_deadline_at: Date | null; +} + +async function lockOrder( + tx: Prisma.TransactionClient, + orderId: bigint, + scopeSql: Prisma.Sql = Prisma.empty, +): Promise { + const [row] = await tx.$queryRaw` + SELECT o.id, o.status, o.pickup_at, o.commission_rate_bps, o.submitted_at, o.confirm_deadline_at + FROM \`order\` o + WHERE o.id = ${orderId} AND o.deleted_at IS NULL ${scopeSql} + FOR UPDATE OF o`; + return row; +} + +function lockedState( + order: LockedOrderRow, + payment: LockedPayment | null, +): OrderLockedState { + return { + status: order.status, + pickupAt: order.pickup_at, + confirmDeadlineAt: order.confirm_deadline_at, + payment, + }; +} + +/** 이벤트 스냅샷용 첫 활성 품목(주문 1건 = 상품 1개). */ +function firstItemOf(tx: Prisma.TransactionClient, orderId: bigint) { + return tx.orderItem.findFirst({ + where: { order_id: orderId, ...activeWhere }, + orderBy: { id: 'asc' }, + select: { + store_id: true, + product_id: true, + product_name_snapshot: true, + store_name_snapshot: true, + quantity: true, + }, + }); +} + function cancelScopeSql(scope: OrderCancelScope): Prisma.Sql { switch (scope.kind) { case 'buyer': @@ -184,17 +261,7 @@ export class OrderTransitionRepository { }, }); - const firstItem = await tx.orderItem.findFirst({ - where: { order_id: locked.id, ...activeWhere }, - orderBy: { id: 'asc' }, - select: { - store_id: true, - product_id: true, - product_name_snapshot: true, - store_name_snapshot: true, - quantity: true, - }, - }); + const firstItem = await firstItemOf(tx, locked.id); await this.outbox.publish( tx, orderStatusChangedEvent({ @@ -265,19 +332,16 @@ export class OrderTransitionRepository { tx: Prisma.TransactionClient, args: CancelOrderArgs, ): Promise { - const [locked] = await tx.$queryRaw< - { - id: bigint; - status: OrderStatus; - commission_rate_bps: number; - submitted_at: Date | null; - }[] - >` - SELECT o.id, o.status, o.commission_rate_bps, o.submitted_at FROM \`order\` o - WHERE o.id = ${args.orderId} AND o.deleted_at IS NULL ${cancelScopeSql(args.scope)} - FOR UPDATE OF o`; + const locked = await lockOrder( + tx, + args.orderId, + cancelScopeSql(args.scope), + ); if (!locked) return null; const payment = await lockPayment(tx, locked.id); + if (args.eligible && !args.eligible(lockedState(locked, payment))) { + return null; + } const paidAmount = confirmedPaidAmount(payment); const decision = args.decide({ status: locked.status, paidAmount }); @@ -330,16 +394,7 @@ export class OrderTransitionRepository { }) : null; - const firstItem = await tx.orderItem.findFirst({ - where: { order_id: locked.id, ...activeWhere }, - orderBy: { id: 'asc' }, - select: { - store_id: true, - product_id: true, - product_name_snapshot: true, - store_name_snapshot: true, - }, - }); + const firstItem = await firstItemOf(tx, locked.id); const snapshot = { orderId: locked.id, orderNumber: updated.order_number, @@ -400,4 +455,110 @@ export class OrderTransitionRepository { } return updated; } + + /** + * 자동 픽업 완료(SYSTEM). 잠금 뒤 다시 판정해 그사이 판매자가 처리했거나 픽업이 바뀐 주문은 건너뛴다. + * 시스템 전이라 감사 기록은 없다. + */ + async completePickupBySystem( + args: CompletePickupBySystemArgs, + ): Promise { + return this.prisma.$transaction(async (tx) => { + const locked = await lockOrder(tx, args.orderId); + if (!locked) return null; + const payment = await lockPayment(tx, locked.id); + if (!args.eligible(lockedState(locked, payment))) return null; + return this.completePickupLocked(tx, locked, payment, { + actor: OrderActor.SYSTEM, + actorAccountId: null, + note: null, + now: args.now, + }); + }); + } + + /** 관리자 픽업 완료(매장 숨김과 무관). 없는 주문이면 null. */ + async completePickupByAdmin( + args: CompletePickupByAdminArgs, + ): Promise { + return this.prisma.$transaction(async (tx) => { + const locked = await lockOrder(tx, args.orderId); + if (!locked) return null; + const payment = await lockPayment(tx, locked.id); + args.assertTransition(lockedState(locked, payment)); + return this.completePickupLocked(tx, locked, payment, { + actor: OrderActor.ADMIN, + actorAccountId: args.actorAccountId, + note: args.note, + now: args.now, + }); + }); + } + + /** 픽업 완료와 정산 확정. 확인된 결제가 없는 주문(결제 도입 전)은 정산을 확정하지 않는다. */ + private async completePickupLocked( + tx: Prisma.TransactionClient, + locked: LockedOrderRow, + payment: LockedPayment | null, + by: PickupActor, + ): Promise { + const updated = await tx.order.update({ + where: { id: locked.id }, + data: { status: OrderStatus.PICKED_UP, picked_up_at: by.now }, + include: adminOrderInclude, + }); + await finalizeSettlementLocked( + tx, + locked, + confirmedPaidAmount(payment), + by.now, + ); + await tx.orderStatusHistory.create({ + data: { + order_id: locked.id, + from_status: locked.status, + to_status: OrderStatus.PICKED_UP, + changed_at: by.now, + actor_type: by.actor, + actor_account_id: by.actorAccountId, + note: by.note, + }, + }); + const firstItem = await firstItemOf(tx, locked.id); + await this.outbox.publish( + tx, + orderStatusChangedEvent({ + orderId: locked.id, + orderNumber: updated.order_number, + buyerAccountId: updated.account_id, + fromStatus: locked.status, + toStatus: OrderStatus.PICKED_UP, + storeId: firstItem?.store_id ?? null, + storeName: firstItem?.store_name_snapshot ?? null, + productId: firstItem?.product_id ?? null, + productName: firstItem?.product_name_snapshot ?? null, + actorType: by.actor, + pickupAt: updated.pickup_at, + occurredAt: by.now, + actorAccountId: by.actorAccountId, + }), + ); + if (by.actorAccountId !== null) { + await this.auditLogs.recordAudit(tx, { + actorAccountId: by.actorAccountId, + // 판매자에게 보인 주문만 매장 id를 붙인다(판매자 감사 로그 노출) + storeId: locked.submitted_at ? (firstItem?.store_id ?? null) : null, + targetType: AuditTargetType.ORDER, + targetId: locked.id, + action: AuditActionType.STATUS_CHANGE, + beforeJson: { status: locked.status }, + afterJson: { + status: OrderStatus.PICKED_UP, + actorType: by.actor, + note: by.note, + }, + }); + } + return updated; + } } diff --git a/src/features/order/repositories/order.repository.ts b/src/features/order/repositories/order.repository.ts index 5d8c98d0..09d6cb00 100644 --- a/src/features/order/repositories/order.repository.ts +++ b/src/features/order/repositories/order.repository.ts @@ -931,8 +931,8 @@ export class OrderRepository { /** * 판매자 상태 변경. 주문 행을 잠근(FOR UPDATE) 뒤 잠금 시점 상태로 전이를 다시 판정한다 — * 취소(OrderTransitionRepository.cancelLocked)와 같은 잠금을 쓰므로 둘이 교차해도 나중 쪽은 바뀐 - * 상태를 보고 거절된다(잠금 없이 읽으면 CANCELED 위에 CONFIRMED를 덮어쓴다). 픽업 완료는 정산을 함께 확정한다. - * assertTransition이 던지면 트랜잭션은 롤백되고 예외가 그대로 전파된다. + * 상태를 보고 거절된다(잠금 없이 읽으면 CANCELED 위에 CONFIRMED를 덮어쓴다). 픽업 완료·노쇼는 정산을 함께 확정한다. + * assertTransition은 잠금 시점 상태·픽업 시각으로 부르고, 던지면 트랜잭션은 롤백되고 예외가 그대로 전파된다. */ async updateOrderStatusBySeller(args: { orderId: bigint; @@ -941,15 +941,20 @@ export class OrderRepository { toStatus: OrderStatus; note: string | null; now: Date; - assertTransition: (fromStatus: OrderStatus) => void; + assertTransition: (fromStatus: OrderStatus, pickupAt: Date) => void; ipAddress?: string; userAgent?: string; }) { return this.prisma.$transaction(async (tx) => { const locked = await tx.$queryRaw< - { id: bigint; status: OrderStatus; commission_rate_bps: number }[] + { + id: bigint; + status: OrderStatus; + pickup_at: Date; + commission_rate_bps: number; + }[] >` - SELECT o.id, o.status, o.commission_rate_bps FROM \`order\` o + SELECT o.id, o.status, o.pickup_at, o.commission_rate_bps FROM \`order\` o WHERE o.id = ${args.orderId} AND o.deleted_at IS NULL AND o.submitted_at IS NOT NULL AND EXISTS ( @@ -964,7 +969,7 @@ export class OrderRepository { } const fromStatus = order.status; - args.assertTransition(fromStatus); + args.assertTransition(fromStatus, order.pickup_at); const updatedOrder = await tx.order.update({ where: { @@ -979,10 +984,16 @@ export class OrderRepository { ...(args.toStatus === OrderStatus.PICKED_UP ? { picked_up_at: args.now } : {}), + ...(args.toStatus === OrderStatus.NO_SHOW + ? { no_show_at: args.now } + : {}), }, include: sellerOrderSummaryInclude(args.storeId), }); - if (args.toStatus === OrderStatus.PICKED_UP) { + if ( + args.toStatus === OrderStatus.PICKED_UP || + args.toStatus === OrderStatus.NO_SHOW + ) { const payment = await lockPayment(tx, order.id); await finalizeSettlementLocked( tx, diff --git a/src/features/order/resolvers/order-admin-mutation.resolver.ts b/src/features/order/resolvers/order-admin-mutation.resolver.ts index 48528424..b78d220e 100644 --- a/src/features/order/resolvers/order-admin-mutation.resolver.ts +++ b/src/features/order/resolvers/order-admin-mutation.resolver.ts @@ -2,6 +2,7 @@ import { UseGuards } from '@nestjs/common'; import { Args, Mutation, Resolver } from '@nestjs/graphql'; import { AdminCancelOrderInput } from '@/features/order/dto/inputs/admin-cancel-order.input'; +import { AdminCompleteOrderPickupInput } from '@/features/order/dto/inputs/admin-complete-order-pickup.input'; import { AdminOrderService } from '@/features/order/services/order-admin.service'; import type { AdminOrderSummaryOutput } from '@/features/order/types/order-admin-output.type'; import { @@ -26,4 +27,15 @@ export class AdminOrderMutationResolver { ): Promise { return this.orderService.adminCancelOrder(parseAccountId(user), input); } + + @Mutation('adminCompleteOrderPickup') + adminCompleteOrderPickup( + @CurrentUser() user: JwtUser, + @Args('input') input: AdminCompleteOrderPickupInput, + ): Promise { + return this.orderService.adminCompleteOrderPickup( + parseAccountId(user), + input, + ); + } } diff --git a/src/features/order/resolvers/order-admin.resolver.spec.ts b/src/features/order/resolvers/order-admin.resolver.spec.ts index 20a4777d..7746adef 100644 --- a/src/features/order/resolvers/order-admin.resolver.spec.ts +++ b/src/features/order/resolvers/order-admin.resolver.spec.ts @@ -19,6 +19,7 @@ import { disconnectTestPrismaClient } from '@/test/db/prisma-test-client'; import { closeTruncateConnection, truncateAll } from '@/test/db/truncate'; import { createAccount, + createOrder, createOrderItem, createUserProfile, } from '@/test/factories'; @@ -97,6 +98,30 @@ describe('Admin Order Resolvers (real DB)', () => { expect(canceled.status).toBe('CANCELED'); }); + it('확정 주문 픽업 완료 경로', async () => { + const actor = await createAccount(prisma, { account_type: 'ADMIN' }); + const user = { + accountId: actor.id.toString(), + accountType: 'ADMIN' as const, + }; + const order = await createOrder(prisma, { status: 'CONFIRMED' }); + await createOrderItem(prisma, { order_id: order.id }); + await createUserProfile(prisma, { account_id: order.account_id }); + + const result = await mutationResolver.adminCompleteOrderPickup(user, { + orderId: order.id.toString(), + note: '매장 인도 확인', + }); + + expect(result.status).toBe('PICKED_UP'); + const detail = await queryResolver.adminOrder(user, order.id.toString()); + expect(detail.statusHistories[0]).toMatchObject({ + toStatus: 'PICKED_UP', + actorType: 'ADMIN', + }); + expect(detail.autoPickupAt).toBeNull(); + }); + it('매장 진행 주문 요약 경로', async () => { const actor = await createAccount(prisma, { account_type: 'ADMIN' }); const item = await createOrderItem(prisma); diff --git a/src/features/order/services/order-admin-mappers.helper.ts b/src/features/order/services/order-admin-mappers.helper.ts index c709b692..ae52e9e0 100644 --- a/src/features/order/services/order-admin-mappers.helper.ts +++ b/src/features/order/services/order-admin-mappers.helper.ts @@ -4,6 +4,7 @@ import type { AdminOrderRow, } from '@/features/order/repositories/order.repository'; import { + toOrderAutoTransitionTimes, toOrderCancellation, toOrderItemDetail, toOrderRefund, @@ -75,5 +76,6 @@ export function toAdminOrderDetailOutput( refunds: row.refunds.map(toOrderRefund), cancellation: toOrderCancellation(row), cancelOptions, + ...toOrderAutoTransitionTimes(row), }; } diff --git a/src/features/order/services/order-admin.service.spec.ts b/src/features/order/services/order-admin.service.spec.ts index fdb40610..08183ef4 100644 --- a/src/features/order/services/order-admin.service.spec.ts +++ b/src/features/order/services/order-admin.service.spec.ts @@ -1,6 +1,7 @@ import { BadRequestException } from '@nestjs/common'; import { PubSub } from 'graphql-subscriptions'; +import { ClockService } from '@/common/providers/clock.service'; import { AUDIT_LOG_REPOSITORY } from '@/features/audit-log'; import { AuditLogRepository } from '@/features/audit-log/repositories/audit-log.repository'; import { AccountAdminRepository } from '@/features/auth/repositories/account-admin.repository'; @@ -8,6 +9,7 @@ import { NotificationAdminRepository } from '@/features/notification/repositorie import { NotificationRepository } from '@/features/notification/repositories/notification.repository'; import { NotificationOutboxConsumer } from '@/features/notification/services/notification-outbox.consumer'; import type { AdminCancelOrderInput } from '@/features/order/dto/inputs/admin-cancel-order.input'; +import type { AdminCompleteOrderPickupInput } from '@/features/order/dto/inputs/admin-complete-order-pickup.input'; import { OrderCancelPolicy } from '@/features/order/policies/order-cancel.policy'; import { OrderStatusTransitionPolicy } from '@/features/order/policies/order-status-transition.policy'; import { OrderTransitionRepository } from '@/features/order/repositories/order-transition.repository'; @@ -42,6 +44,7 @@ describe('AdminOrderService (real DB)', () => { let prisma: PrismaClient; let dispatcher: OutboxDispatcherService; let pubSub: PubSub; + let clock: ClockService; beforeAll(async () => { const { module, prisma: p } = await createTestingModuleWithRealDb({ @@ -67,6 +70,7 @@ describe('AdminOrderService (real DB)', () => { orderRepo = module.get(OrderRepository); dispatcher = module.get(OutboxDispatcherService); pubSub = module.get(PUB_SUB); + clock = module.get(ClockService); prisma = p; }); @@ -79,6 +83,10 @@ describe('AdminOrderService (real DB)', () => { await truncateAll(); }); + afterEach(() => { + jest.restoreAllMocks(); + }); + async function admin(): Promise { return (await createAccount(prisma, { account_type: 'ADMIN' })).id; } @@ -449,6 +457,37 @@ describe('AdminOrderService (real DB)', () => { expect(result.cancellation).toBeNull(); }); + it.each([ + ['SUBMITTED', true, false], + ['MADE', false, true], + ['NO_SHOW', false, false], + ] as const)( + '%s: 확정 마감은 접수만, 자동 픽업 완료는 확정·제작 완료만, 노쇼 시각은 그대로 준다', + async (status, hasDeadline, hasAutoPickup) => { + const { order } = await orderWithItem({ status }); + const deadline = new Date('2026-11-19T06:00:00.000Z'); + const noShowAt = new Date('2026-11-19T07:00:00.000Z'); + await prisma.order.update({ + where: { id: order.id }, + data: { + pickup_at: new Date('2026-11-19T04:00:00.000Z'), + confirm_deadline_at: deadline, + no_show_at: status === 'NO_SHOW' ? noShowAt : null, + }, + }); + + const result = await service.adminOrder(await admin(), order.id); + + expect(result).toMatchObject({ + confirmDeadlineAt: hasDeadline ? deadline : null, + autoPickupAt: hasAutoPickup + ? new Date('2026-11-20T04:00:00.000Z') + : null, + noShowAt: status === 'NO_SHOW' ? noShowAt : null, + }); + }, + ); + it('결제와 입금 확인 처리자·메모를 준다', async () => { const { order } = await orderWithItem(); const confirmedAt = new Date('2026-09-16T07:00:00.000Z'); @@ -874,6 +913,263 @@ describe('AdminOrderService (real DB)', () => { }); }); + describe('adminCompleteOrderPickup', () => { + const NOW = new Date('2026-11-19T03:00:00.000Z'); + + beforeEach(() => { + jest.spyOn(clock, 'now').mockReturnValue(NOW); + }); + + function pickupInput( + orderId: bigint, + note?: string | null, + ): AdminCompleteOrderPickupInput { + return { orderId: orderId.toString(), note }; + } + + it.each(['CONFIRMED', 'MADE'] as const)( + '%s 주문을 픽업 완료하고 픽업 시각·정산 확정·이력(주체 ADMIN·메모)·픽업 완료 알림·감사·판매자 구독을 남긴다', + async (status) => { + const actor = await admin(); + const { order, buyer, storeId } = await orderWithItem({ + status, + paid: true, + }); + await prisma.order.update({ + where: { id: order.id }, + data: { commission_rate_bps: 333 }, + }); + const topic = await collectTopic(pubSub, `order.seller.${storeId}`); + + const result = await service.adminCompleteOrderPickup( + actor, + pickupInput(order.id, ' 매장 인도 확인 '), + ); + + expect(result).toMatchObject({ + id: order.id.toString(), + status: 'PICKED_UP', + storeId: storeId.toString(), + }); + await expect( + prisma.order.findUniqueOrThrow({ where: { id: order.id } }), + ).resolves.toMatchObject({ + status: 'PICKED_UP', + picked_up_at: NOW, + settlement_base_amount: 10_000, + commission_amount: 333, + settlement_finalized_at: NOW, + }); + await expect( + prisma.orderStatusHistory.findMany({ where: { order_id: order.id } }), + ).resolves.toEqual([ + expect.objectContaining({ + from_status: status, + to_status: 'PICKED_UP', + changed_at: NOW, + actor_type: 'ADMIN', + actor_account_id: actor, + note: '매장 인도 확인', + }), + ]); + await expect( + prisma.auditLog.findMany({ + where: { target_type: 'ORDER', target_id: order.id }, + }), + ).resolves.toEqual([ + expect.objectContaining({ + actor_account_id: actor, + store_id: storeId, + action: 'STATUS_CHANGE', + before_json: { status }, + after_json: { + status: 'PICKED_UP', + actorType: 'ADMIN', + note: '매장 인도 확인', + }, + }), + ]); + await drainOutbox(dispatcher); + await expect( + prisma.notification.findMany({ where: { order_id: order.id } }), + ).resolves.toEqual([ + expect.objectContaining({ + account_id: buyer.id, + event: 'ORDER_PICKED_UP', + body: `${order.order_number} 케이크 픽업이 완료되었어요.`, + }), + ]); + expect(topic.received).toEqual([ + expect.objectContaining({ + kind: 'STATUS_CHANGED', + orderId: order.id.toString(), + status: 'PICKED_UP', + }), + ]); + topic.stop(); + }, + ); + + it('숨긴 매장의 주문도 픽업 시각 전에 처리한다(자동 픽업 완료가 건너뛰는 주문)', async () => { + const hidden = await createStore(prisma, { is_active: false }); + const { order } = await orderWithItem({ + status: 'MADE', + storeId: hidden.id, + paid: true, + }); + await prisma.order.update({ + where: { id: order.id }, + data: { pickup_at: new Date(NOW.getTime() + 3 * 60 * 60_000) }, + }); + + const result = await service.adminCompleteOrderPickup( + await admin(), + pickupInput(order.id), + ); + + expect(result.status).toBe('PICKED_UP'); + await expect( + prisma.order.findUniqueOrThrow({ where: { id: order.id } }), + ).resolves.toMatchObject({ + picked_up_at: NOW, + settlement_finalized_at: NOW, + }); + }); + + it('확인된 결제가 없는 주문(결제 도입 전)은 픽업 완료만 하고 정산은 건너뛴다', async () => { + const { order } = await orderWithItem({ status: 'CONFIRMED' }); + + await service.adminCompleteOrderPickup( + await admin(), + pickupInput(order.id), + ); + + await expect( + prisma.order.findUniqueOrThrow({ where: { id: order.id } }), + ).resolves.toMatchObject({ + status: 'PICKED_UP', + picked_up_at: NOW, + settlement_base_amount: null, + settlement_finalized_at: null, + }); + }); + + it.each([ + ['PENDING_PAYMENT', 'INVALID_ORDER_STATUS_TRANSITION'], + ['SUBMITTED', 'INVALID_ORDER_STATUS_TRANSITION'], + ['NO_SHOW', 'INVALID_ORDER_STATUS_TRANSITION'], + ['CANCELED', 'INVALID_ORDER_STATUS_TRANSITION'], + ['PICKED_UP', 'ORDER_STATUS_UNCHANGED'], + ] as const)( + '%s 주문은 %s로 거절하고 아무것도 바꾸지 않는다', + async (status, code) => { + const { order, storeId } = await orderWithItem({ status, paid: true }); + const topic = await collectTopic(pubSub, `order.seller.${storeId}`); + + await expect( + service.adminCompleteOrderPickup( + await admin(), + pickupInput(order.id), + ), + ).rejects.toThrowDomain(code); + + await expect( + prisma.order.findUniqueOrThrow({ where: { id: order.id } }), + ).resolves.toMatchObject({ + status, + picked_up_at: null, + settlement_finalized_at: null, + }); + expect(await prisma.orderStatusHistory.count()).toBe(0); + expect(await prisma.outbox.count()).toBe(0); + expect(await prisma.auditLog.count()).toBe(0); + expect(topic.received).toHaveLength(0); + topic.stop(); + }, + ); + + it('메모는 선택(공백은 null)이고 500자를 넘으면 TEXT_TOO_LONG, 없거나 삭제된 주문은 404', async () => { + const { order } = await orderWithItem({ status: 'CONFIRMED' }); + const other = await orderWithItem({ status: 'MADE' }); + await expect( + service.adminCompleteOrderPickup( + await admin(), + pickupInput(order.id, 'x'.repeat(501)), + ), + ).rejects.toThrowDomain('TEXT_TOO_LONG'); + + await service.adminCompleteOrderPickup( + await admin(), + pickupInput(order.id, 'x'.repeat(500)), + ); + await service.adminCompleteOrderPickup( + await admin(), + pickupInput(other.order.id, ' '), + ); + const histories = await prisma.orderStatusHistory.findMany({ + orderBy: { id: 'asc' }, + }); + expect(histories.map((h) => h.note)).toEqual(['x'.repeat(500), null]); + + const deleted = await createOrder(prisma, { + status: 'CONFIRMED', + deleted_at: new Date(), + }); + for (const orderId of [deleted.id, 999_999n]) { + await expect( + service.adminCompleteOrderPickup(await admin(), pickupInput(orderId)), + ).rejects.toThrowDomain(404); + } + }); + + it('관리자가 아니면 403', async () => { + const { order } = await orderWithItem({ status: 'CONFIRMED' }); + const user = await createAccount(prisma, { account_type: 'USER' }); + await expect( + service.adminCompleteOrderPickup(user.id, pickupInput(order.id)), + ).rejects.toThrowDomain(403); + }); + + it('두 관리자가 동시에 처리해도 전이·감사·알림·구독은 1건씩이고 늦은 쪽은 잠금 뒤 상태로 ORDER_STATUS_UNCHANGED', async () => { + const { order, storeId } = await orderWithItem({ + status: 'MADE', + paid: true, + }); + const topic = await collectTopic(pubSub, `order.seller.${storeId}`); + const [a, b] = [await admin(), await admin()]; + + const results = await Promise.allSettled([ + service.adminCompleteOrderPickup(a, pickupInput(order.id, 'a')), + service.adminCompleteOrderPickup(b, pickupInput(order.id, 'b')), + ]); + + expect(results.map((r) => r.status).sort()).toEqual([ + 'fulfilled', + 'rejected', + ]); + const rejected = results.find((r) => r.status === 'rejected'); + expect((rejected as PromiseRejectedResult).reason).toThrowDomain( + 'ORDER_STATUS_UNCHANGED', + ); + expect( + await prisma.orderStatusHistory.count({ + where: { order_id: order.id }, + }), + ).toBe(1); + expect( + await prisma.auditLog.count({ + where: { target_type: 'ORDER', target_id: order.id }, + }), + ).toBe(1); + await drainOutbox(dispatcher); + expect( + await prisma.notification.count({ where: { order_id: order.id } }), + ).toBe(1); + expect(topic.received).toHaveLength(1); + topic.stop(); + }); + }); + describe('sellerOrderUpdated 발행', () => { it('관리자 취소는 첫 품목 매장 토픽에 1건 — 취소된 주문 행의 스냅샷을 싣는다', async () => { const { order, storeId } = await orderWithItem({ status: 'CONFIRMED' }); diff --git a/src/features/order/services/order-admin.service.ts b/src/features/order/services/order-admin.service.ts index b73bbb37..87604717 100644 --- a/src/features/order/services/order-admin.service.ts +++ b/src/features/order/services/order-admin.service.ts @@ -17,6 +17,7 @@ import { } from '@/features/audit-log'; import { AccountAdminRepository, AdminBaseService } from '@/features/auth'; import type { AdminCancelOrderInput } from '@/features/order/dto/inputs/admin-cancel-order.input'; +import type { AdminCompleteOrderPickupInput } from '@/features/order/dto/inputs/admin-complete-order-pickup.input'; import type { AdminOrderListInput } from '@/features/order/dto/inputs/admin-order-list.input'; import { OrderCancelPolicy } from '@/features/order/policies/order-cancel.policy'; import { OrderStatusTransitionPolicy } from '@/features/order/policies/order-status-transition.policy'; @@ -37,7 +38,7 @@ import type { AdminOrderSummaryOutput, AdminStoreInProgressOrderSummaryOutput, } from '@/features/order/types/order-admin-output.type'; -import { OrderActor } from '@/generated/prisma/client'; +import { OrderActor, OrderStatus } from '@/generated/prisma/client'; /** 취소 규칙은 OrderCancelPolicy가 단일 소스이고, 저장·이력·환불·알림·감사는 OrderTransitionRepository가 한 트랜잭션에서 처리한다. */ @Injectable() @@ -154,4 +155,33 @@ export class AdminOrderService extends AdminBaseService { await this.events.publishSellerStatusChanged(updated); return toAdminOrderSummaryOutput(updated); } + + /** + * 확정·제작 완료 주문을 픽업 완료로 바꾸고 정산을 확정한다. 숨긴 매장 주문처럼 자동 픽업 완료가 건너뛰는 주문을 + * 관리자가 건별로 닫는 경로라 매장 숨김은 보지 않는다. 판정은 잠금 읽기 결과로 한다. + */ + async adminCompleteOrderPickup( + accountId: bigint, + input: AdminCompleteOrderPickupInput, + ): Promise { + const ctx = await this.requireAdminContext(accountId); + const now = this.clock.now(); + const updated = await this.transitions.completePickupByAdmin({ + orderId: parseId(input.orderId), + actorAccountId: ctx.accountId, + note: cleanNullableText(input.note, MAX_REASON_LENGTH), + now, + assertTransition: (state) => + this.statusPolicy.assertTransition({ + actor: OrderActor.ADMIN, + from: state.status, + to: OrderStatus.PICKED_UP, + now, + pickupAt: state.pickupAt, + }), + }); + if (!updated) throw new DomainException('ORDER_NOT_FOUND'); + await this.events.publishSellerStatusChanged(updated); + return toAdminOrderSummaryOutput(updated); + } } diff --git a/src/features/order/services/order-lifecycle.scheduler.spec.ts b/src/features/order/services/order-lifecycle.scheduler.spec.ts new file mode 100644 index 00000000..b7aa1245 --- /dev/null +++ b/src/features/order/services/order-lifecycle.scheduler.spec.ts @@ -0,0 +1,625 @@ +import { Logger } from '@nestjs/common'; +import { PubSub } from 'graphql-subscriptions'; + +import { ClockService } from '@/common/providers/clock.service'; +import { HOUR_MS } from '@/common/utils/kst-time'; +import { AUDIT_LOG_REPOSITORY } from '@/features/audit-log'; +import { AuditLogRepository } from '@/features/audit-log/repositories/audit-log.repository'; +import { OrderCancelPolicy } from '@/features/order/policies/order-cancel.policy'; +import { isPaymentExpired } from '@/features/order/policies/order-lifecycle.policy'; +import { OrderStatusTransitionPolicy } from '@/features/order/policies/order-status-transition.policy'; +import { OrderLifecycleRepository } from '@/features/order/repositories/order-lifecycle.repository'; +import { OrderTransitionRepository } from '@/features/order/repositories/order-transition.repository'; +import { OrderEventsService } from '@/features/order/services/order-events.service'; +import { + LIFECYCLE_BATCH_SIZE, + LIFECYCLE_MAX_PER_TICK, + OrderLifecycleScheduler, +} from '@/features/order/services/order-lifecycle.scheduler'; +import { StoreAdminRepository } from '@/features/store/repositories/store-admin.repository'; +import type { + OrderStatus, + PaymentStatus, + PrismaClient, +} from '@/generated/prisma/client'; +import { AlertService } from '@/global/alerting'; +import { PUB_SUB } from '@/global/pubsub'; +import { disconnectTestPrismaClient } from '@/test/db/prisma-test-client'; +import { closeTruncateConnection, truncateAll } from '@/test/db/truncate'; +import { + createOrder, + createOrderItem, + createPayment, + createStore, +} from '@/test/factories'; +import { createTestingModuleWithRealDb } from '@/test/modules/testing-module.builder'; +import { outboxPublisherProviders } from '@/test/outbox'; +import { collectTopic } from '@/test/pubsub'; + +const NOW = new Date('2026-11-19T05:00:00.000Z'); +const at = (offsetMs: number) => new Date(NOW.getTime() + offsetMs); + +describe('OrderLifecycleScheduler (real DB)', () => { + let scheduler: OrderLifecycleScheduler; + let lifecycle: OrderLifecycleRepository; + let transitions: OrderTransitionRepository; + let prisma: PrismaClient; + let pubSub: PubSub; + const alerts = { notify: jest.fn().mockResolvedValue('sent') }; + const savedRole = process.env.APP_ROLE; + + beforeAll(async () => { + const { module, prisma: p } = await createTestingModuleWithRealDb({ + providers: [ + OrderLifecycleScheduler, + OrderLifecycleRepository, + OrderTransitionRepository, + StoreAdminRepository, + OrderCancelPolicy, + OrderStatusTransitionPolicy, + OrderEventsService, + { provide: PUB_SUB, useValue: new PubSub() }, + { provide: AUDIT_LOG_REPOSITORY, useClass: AuditLogRepository }, + { provide: ClockService, useValue: { now: () => NOW } }, + { provide: AlertService, useValue: alerts }, + ...outboxPublisherProviders({ clock: true }), + ], + }); + scheduler = module.get(OrderLifecycleScheduler); + lifecycle = module.get(OrderLifecycleRepository); + transitions = module.get(OrderTransitionRepository); + pubSub = module.get(PUB_SUB); + 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'; + alerts.notify.mockClear(); + jest.spyOn(Logger.prototype, 'error').mockImplementation(() => undefined); + }); + + afterEach(() => jest.restoreAllMocks()); + + async function storeOrder(opts: { + status: OrderStatus; + storeId?: bigint; + pickupAt?: Date; + submittedAt?: Date | null; + confirmDeadlineAt?: Date | null; + confirmReminderSentAt?: Date | null; + payment?: { + status: PaymentStatus; + expiresAt?: Date; + claimedAt?: Date | null; + }; + commissionRateBps?: number; + }) { + const storeId = opts.storeId ?? (await createStore(prisma)).id; + const order = await createOrder(prisma, { + status: opts.status, + pickup_at: opts.pickupAt, + submitted_at: opts.submittedAt, + confirm_deadline_at: opts.confirmDeadlineAt, + confirm_reminder_sent_at: opts.confirmReminderSentAt, + commission_rate_bps: opts.commissionRateBps, + }); + await createOrderItem(prisma, { + order_id: order.id, + store_id: storeId, + product_name_snapshot: '레터링 케이크', + }); + if (opts.payment) { + await createPayment(prisma, { + order_id: order.id, + status: opts.payment.status, + expires_at: opts.payment.expiresAt, + buyer_claimed_at: opts.payment.claimedAt ?? null, + confirmed_at: opts.payment.status === 'CONFIRMED' ? at(-HOUR_MS) : null, + }); + } + return { order, storeId }; + } + + const orderRow = (id: bigint) => + prisma.order.findUniqueOrThrow({ where: { id } }); + const histories = (orderId: bigint) => + prisma.orderStatusHistory.findMany({ + where: { order_id: orderId }, + orderBy: { id: 'asc' }, + }); + const outboxTypes = (aggregateId: bigint) => + prisma.outbox + .findMany({ + where: { aggregate_id: aggregateId.toString() }, + orderBy: { id: 'asc' }, + }) + .then((rows) => rows.map((r) => r.event_type)); + + describe('① 미입금 취소', () => { + const pending = (expiresAt: Date, claimedAt: Date | null = null) => + storeOrder({ + status: 'PENDING_PAYMENT', + payment: { status: 'PENDING', expiresAt, claimedAt }, + }); + + it('입금 기한 정각이면 시스템이 미입금으로 취소하고 결제를 닫는다(환불 없음)', async () => { + const { order } = await pending(NOW); + + await scheduler.cancelExpiredPayments(); + + expect(await orderRow(order.id)).toMatchObject({ + status: 'CANCELED', + canceled_at: NOW, + }); + expect( + await prisma.payment.findUniqueOrThrow({ + where: { order_id: order.id }, + }), + ).toMatchObject({ status: 'CANCELED', canceled_at: NOW }); + expect(await histories(order.id)).toEqual([ + expect.objectContaining({ + from_status: 'PENDING_PAYMENT', + to_status: 'CANCELED', + actor_type: 'SYSTEM', + actor_account_id: null, + cancel_reason: 'PAYMENT_NOT_RECEIVED', + refund_amount: 0, + }), + ]); + expect(await prisma.refund.count()).toBe(0); + expect(await outboxTypes(order.id)).toEqual(['order.status_changed']); + }); + + it.each([ + ['기한 1ms 전', at(1), null], + ["'입금했어요'를 누른 주문", at(-1), at(-HOUR_MS / 2)], + ])('%s는 취소하지 않는다', async (_label, expiresAt, claimedAt) => { + const { order } = await pending(expiresAt, claimedAt); + + await scheduler.cancelExpiredPayments(); + + expect((await orderRow(order.id)).status).toBe('PENDING_PAYMENT'); + expect(await histories(order.id)).toHaveLength(0); + }); + + it('입금 대기라도 판매자 구독은 발행하지 않는다(판매자에게 보인 적 없음)', async () => { + const { order, storeId } = await pending(at(-1)); + const topic = await collectTopic(pubSub, `order.seller.${storeId}`); + + await scheduler.cancelExpiredPayments(); + + expect((await orderRow(order.id)).status).toBe('CANCELED'); + expect(topic.received).toHaveLength(0); + topic.stop(); + }); + }); + + describe('② 확정 마감 2시간 전 미리 알림', () => { + const submitted = ( + deadline: Date, + submittedAt: Date, + sentAt: Date | null = null, + ) => + storeOrder({ + status: 'SUBMITTED', + submittedAt, + confirmDeadlineAt: deadline, + confirmReminderSentAt: sentAt, + payment: { status: 'CONFIRMED' }, + }); + + it('마감 2시간 전 구간에 들면 한 번만 보낸다(다음 틱은 보내지 않음)', async () => { + const { order } = await submitted(at(2 * HOUR_MS), at(-20 * HOUR_MS)); + + await scheduler.remindConfirmDeadlines(); + await scheduler.remindConfirmDeadlines(); + + expect((await orderRow(order.id)).confirm_reminder_sent_at).toEqual(NOW); + expect(await outboxTypes(order.id)).toEqual([ + 'order.confirm_reminder_due', + ]); + const [event] = await prisma.outbox.findMany(); + expect(event.payload_json).toMatchObject({ + orderId: order.id.toString(), + productName: '레터링 케이크', + confirmDeadlineAt: at(2 * HOUR_MS).toISOString(), + }); + }); + + it.each([ + ['마감 2시간 전보다 이르다', at(2 * HOUR_MS + 1), at(-20 * HOUR_MS)], + ['마감이 지났다(미확정 취소 몫)', NOW, at(-20 * HOUR_MS)], + // 마감 − 2시간 ≤ 접수: 새 주문 푸시가 마감 시각을 실었다 + ['마감 2시간 미만으로 접수됐다', at(HOUR_MS), at(-HOUR_MS / 2)], + ['마감 정확히 2시간 전에 접수됐다', at(HOUR_MS), at(-HOUR_MS)], + ])('%s면 보내지 않는다', async (_label, deadline, submittedAt) => { + const { order } = await submitted(deadline, submittedAt); + + // 후보 조회(SQL)와 잠금 뒤 재판정이 같은 조건을 본다 + expect( + await lifecycle.findConfirmReminderDueIds({ now: NOW, limit: 10 }), + ).toEqual([]); + await scheduler.remindConfirmDeadlines(); + + expect((await orderRow(order.id)).confirm_reminder_sent_at).toBeNull(); + expect(await outboxTypes(order.id)).toEqual([]); + }); + + it('마감 − 2시간이 접수 시각보다 1ms 뒤면 보낸다(경계)', async () => { + const submittedAt = at(-HOUR_MS); + const deadline = new Date(submittedAt.getTime() + 2 * HOUR_MS + 1); + const { order } = await submitted(deadline, submittedAt); + + await scheduler.remindConfirmDeadlines(); + + expect(await outboxTypes(order.id)).toEqual([ + 'order.confirm_reminder_due', + ]); + }); + + it('품목이 없는 주문은 보낼 매장을 몰라 표시만 남기고 이벤트는 없다', async () => { + const order = await createOrder(prisma, { + status: 'SUBMITTED', + submitted_at: at(-20 * HOUR_MS), + confirm_deadline_at: at(HOUR_MS), + }); + + await scheduler.remindConfirmDeadlines(); + + expect((await orderRow(order.id)).confirm_reminder_sent_at).toEqual(NOW); + expect(await outboxTypes(order.id)).toEqual([]); + }); + + it('잠금 뒤 다시 보면 대상이 아닌 주문(그사이 확정)은 표시도 이벤트도 없다', async () => { + const { order } = await submitted(at(HOUR_MS), at(-20 * HOUR_MS)); + await prisma.order.update({ + where: { id: order.id }, + data: { status: 'CONFIRMED' }, + }); + + const sent = await lifecycle.markConfirmReminderSent({ + orderId: order.id, + now: NOW, + isDue: () => false, + }); + + expect(sent).toBe(false); + expect((await orderRow(order.id)).confirm_reminder_sent_at).toBeNull(); + }); + }); + + describe('③ 미확정 자동 취소', () => { + it('확정 마감 정각이면 미확정으로 취소하고 전액 환불을 만든다(판매자 구독 발행)', async () => { + const { order, storeId } = await storeOrder({ + status: 'SUBMITTED', + confirmDeadlineAt: NOW, + payment: { status: 'CONFIRMED' }, + }); + const topic = await collectTopic(pubSub, `order.seller.${storeId}`); + + await scheduler.cancelConfirmTimeouts(); + + expect((await orderRow(order.id)).status).toBe('CANCELED'); + expect(await histories(order.id)).toEqual([ + expect.objectContaining({ + actor_type: 'SYSTEM', + cancel_reason: 'CONFIRM_TIMEOUT', + refund_amount: 10_000, + }), + ]); + expect( + await prisma.refund.findFirstOrThrow({ where: { order_id: order.id } }), + ).toMatchObject({ + kind: 'CANCEL', + amount: 10_000, + status: 'AWAITING_ACCOUNT', + }); + expect(await outboxTypes(order.id)).toEqual([ + 'order.status_changed', + 'refund.requested', + ]); + expect(topic.received).toEqual([ + expect.objectContaining({ kind: 'STATUS_CHANGED', status: 'CANCELED' }), + ]); + topic.stop(); + }); + + it.each([ + ['마감 1ms 전', at(1)], + ['결제 도입 전 접수(마감 없음)', null], + ])('%s는 취소하지 않는다', async (_label, deadline) => { + const { order } = await storeOrder({ + status: 'SUBMITTED', + confirmDeadlineAt: deadline, + }); + + await scheduler.cancelConfirmTimeouts(); + + expect((await orderRow(order.id)).status).toBe('SUBMITTED'); + }); + + it('숨긴 매장의 주문도 미확정 취소는 그대로 한다', async () => { + const store = await createStore(prisma, { is_active: false }); + const { order } = await storeOrder({ + status: 'SUBMITTED', + storeId: store.id, + confirmDeadlineAt: at(-1), + payment: { status: 'CONFIRMED' }, + }); + + await scheduler.cancelConfirmTimeouts(); + + expect((await orderRow(order.id)).status).toBe('CANCELED'); + }); + }); + + describe('④ 자동 픽업 완료', () => { + const overdue = at(-24 * HOUR_MS); + + it.each(['CONFIRMED', 'MADE'] as const)( + '%s는 픽업 + 24시간 정각에 픽업 완료되고 확인된 결제액으로 정산을 확정한다', + async (status) => { + const { order } = await storeOrder({ + status, + pickupAt: overdue, + payment: { status: 'CONFIRMED' }, + commissionRateBps: 333, + }); + + await scheduler.completeOverduePickups(); + + expect(await orderRow(order.id)).toMatchObject({ + status: 'PICKED_UP', + picked_up_at: NOW, + settlement_base_amount: 10_000, + commission_amount: 333, + settlement_finalized_at: NOW, + }); + expect(await histories(order.id)).toEqual([ + expect.objectContaining({ + from_status: status, + to_status: 'PICKED_UP', + actor_type: 'SYSTEM', + actor_account_id: null, + }), + ]); + expect(await outboxTypes(order.id)).toEqual(['order.status_changed']); + expect(await prisma.auditLog.count()).toBe(0); + }, + ); + + it('픽업 + 24시간 1ms 전이면 바꾸지 않는다', async () => { + const { order } = await storeOrder({ + status: 'MADE', + pickupAt: at(-24 * HOUR_MS + 1), + }); + + await scheduler.completeOverduePickups(); + + expect((await orderRow(order.id)).status).toBe('MADE'); + }); + + it('확인된 결제가 없는 주문(결제 도입 전)은 픽업 완료만 하고 정산은 건너뛴다', async () => { + const { order } = await storeOrder({ status: 'MADE', pickupAt: overdue }); + + await scheduler.completeOverduePickups(); + + expect(await orderRow(order.id)).toMatchObject({ + status: 'PICKED_UP', + settlement_base_amount: null, + settlement_finalized_at: null, + }); + }); + + it('숨긴 매장의 주문은 건너뛰고(관리자 건별 처리) 활성 매장 주문만 바꾼다', async () => { + const hidden = await createStore(prisma, { is_active: false }); + const skipped = await storeOrder({ + status: 'MADE', + storeId: hidden.id, + pickupAt: overdue, + }); + const done = await storeOrder({ status: 'MADE', pickupAt: overdue }); + + await scheduler.completeOverduePickups(); + + expect((await orderRow(skipped.order.id)).status).toBe('MADE'); + expect((await orderRow(done.order.id)).status).toBe('PICKED_UP'); + + // 반증: 매장을 다시 보이면 다음 틱에 픽업 완료된다 + await prisma.store.update({ + where: { id: hidden.id }, + data: { is_active: true }, + }); + await scheduler.completeOverduePickups(); + expect((await orderRow(skipped.order.id)).status).toBe('PICKED_UP'); + }); + }); + + describe('동시 실행', () => { + it('같은 주문의 미입금 취소가 두 tx에서 겹쳐도 한 번만 전이한다', async () => { + const { order } = await storeOrder({ + status: 'PENDING_PAYMENT', + payment: { status: 'PENDING', expiresAt: at(-1) }, + }); + const cancel = () => + transitions.cancel({ + orderId: order.id, + actor: 'SYSTEM', + actorAccountId: null, + scope: { kind: 'any' }, + note: null, + now: NOW, + eligible: (s) => isPaymentExpired(s, NOW), + decide: (state) => + new OrderCancelPolicy().decide( + { actor: 'SYSTEM', reason: 'PAYMENT_NOT_RECEIVED' }, + state, + ), + }); + + const results = await Promise.all([cancel(), cancel()]); + + expect(results.filter((r) => r !== null)).toHaveLength(1); + expect(await histories(order.id)).toHaveLength(1); + }); + + it('같은 주문의 자동 픽업 완료가 두 tx에서 겹쳐도 한 번만 전이한다', async () => { + const { order } = await storeOrder({ + status: 'MADE', + pickupAt: at(-24 * HOUR_MS), + payment: { status: 'CONFIRMED' }, + }); + const policy = new OrderStatusTransitionPolicy(); + const complete = () => + transitions.completePickupBySystem({ + orderId: order.id, + now: NOW, + eligible: (s) => + policy.canTransition({ + actor: 'SYSTEM', + from: s.status, + to: 'PICKED_UP', + now: NOW, + pickupAt: s.pickupAt, + }), + }); + + const results = await Promise.all([complete(), complete()]); + + expect(results.filter((r) => r !== null)).toHaveLength(1); + expect(await histories(order.id)).toHaveLength(1); + expect(await outboxTypes(order.id)).toEqual(['order.status_changed']); + }); + + it('잠금 뒤 판매자가 먼저 노쇼로 바꿨으면 자동 픽업 완료는 건너뛴다', async () => { + const { order } = await storeOrder({ + status: 'MADE', + pickupAt: at(-24 * HOUR_MS), + }); + await prisma.order.update({ + where: { id: order.id }, + data: { status: 'NO_SHOW' }, + }); + + const result = await transitions.completePickupBySystem({ + orderId: order.id, + now: NOW, + eligible: (s) => s.status === 'MADE', + }); + + expect(result).toBeNull(); + expect((await orderRow(order.id)).status).toBe('NO_SHOW'); + }); + + it('같은 작업의 틱이 겹치면 뒤 틱은 건너뛴다', async () => { + let release!: () => void; + const spy = jest + .spyOn(lifecycle, 'findPaymentExpiredIds') + .mockImplementation( + () => new Promise((resolve) => (release = () => resolve([]))), + ); + + const first = scheduler.cancelExpiredPayments(); + await scheduler.cancelExpiredPayments(); + release(); + await first; + + expect(spy).toHaveBeenCalledTimes(1); + }); + }); + + describe('배치·실패·역할', () => { + it(`후보를 ${LIFECYCLE_BATCH_SIZE}건씩 id 키셋으로 넘기고 한 틱에 ${LIFECYCLE_MAX_PER_TICK}건에서 멈춘다`, async () => { + const page = Array.from({ length: LIFECYCLE_BATCH_SIZE }, (_, i) => + BigInt(i + 1), + ); + const find = jest + .spyOn(lifecycle, 'findConfirmTimedOutIds') + .mockResolvedValue(page); + jest.spyOn(transitions, 'cancel').mockResolvedValue(null); + + await scheduler.cancelConfirmTimeouts(); + + expect(find).toHaveBeenCalledTimes( + LIFECYCLE_MAX_PER_TICK / LIFECYCLE_BATCH_SIZE, + ); + expect(find.mock.calls[0][0]).toMatchObject({ afterId: undefined }); + expect(find.mock.calls[1][0]).toMatchObject({ + afterId: BigInt(LIFECYCLE_BATCH_SIZE), + limit: LIFECYCLE_BATCH_SIZE, + }); + }); + + it('한 건이 실패하면 경보를 남기고 다음 건을 처리한다', async () => { + const first = await storeOrder({ + status: 'MADE', + pickupAt: at(-25 * HOUR_MS), + }); + const second = await storeOrder({ + status: 'MADE', + pickupAt: at(-25 * HOUR_MS), + }); + const original = transitions.completePickupBySystem.bind(transitions); + jest + .spyOn(transitions, 'completePickupBySystem') + .mockImplementation((args) => + args.orderId === first.order.id + ? Promise.reject(new Error('잠금 대기 시간 초과')) + : original(args), + ); + + await scheduler.completeOverduePickups(); + + expect((await orderRow(first.order.id)).status).toBe('MADE'); + expect((await orderRow(second.order.id)).status).toBe('PICKED_UP'); + expect(alerts.notify).toHaveBeenCalledWith( + expect.objectContaining({ + level: 'warn', + key: 'order-cron:auto-pickup', + detail: `주문 ${first.order.id}: 잠금 대기 시간 초과`, + }), + ); + }); + + it('후보 조회가 던지면 그 틱을 접고 경보한다', async () => { + jest + .spyOn(lifecycle, 'findConfirmReminderDueIds') + .mockRejectedValue(new Error('db down')); + + await expect(scheduler.remindConfirmDeadlines()).resolves.toBeUndefined(); + + expect(alerts.notify).toHaveBeenCalledWith( + expect.objectContaining({ + key: 'order-cron:confirm-reminder', + detail: 'db down', + }), + ); + }); + + it.each(['api', 'ws'])( + '%s 역할에서는 아무것도 하지 않는다', + async (role) => { + process.env.APP_ROLE = role; + const { order } = await storeOrder({ + status: 'PENDING_PAYMENT', + payment: { status: 'PENDING', expiresAt: at(-1) }, + }); + + await scheduler.cancelExpiredPayments(); + await scheduler.remindConfirmDeadlines(); + await scheduler.cancelConfirmTimeouts(); + await scheduler.completeOverduePickups(); + + expect((await orderRow(order.id)).status).toBe('PENDING_PAYMENT'); + }, + ); + }); +}); diff --git a/src/features/order/services/order-lifecycle.scheduler.ts b/src/features/order/services/order-lifecycle.scheduler.ts new file mode 100644 index 00000000..cc0fe3e4 --- /dev/null +++ b/src/features/order/services/order-lifecycle.scheduler.ts @@ -0,0 +1,218 @@ +import { Injectable, Logger } from '@nestjs/common'; +import { Cron } from '@nestjs/schedule'; + +import { ClockService } from '@/common/providers/clock.service'; +import { resolveAppRole, runsBackgroundJobs } from '@/config/app.config'; +import { OrderCancelPolicy } from '@/features/order/policies/order-cancel.policy'; +import { + isConfirmReminderDue, + isConfirmTimedOut, + isPaymentExpired, +} from '@/features/order/policies/order-lifecycle.policy'; +import { OrderStatusTransitionPolicy } from '@/features/order/policies/order-status-transition.policy'; +import { + OrderLifecycleRepository, + type CandidatePage, +} from '@/features/order/repositories/order-lifecycle.repository'; +import { + OrderTransitionRepository, + type CancelOrderArgs, +} from '@/features/order/repositories/order-transition.repository'; +import type { AdminOrderRow } from '@/features/order/repositories/order.repository'; +import { OrderEventsService } from '@/features/order/services/order-events.service'; +import { StoreAdminRepository } from '@/features/store'; +import { + OrderActor, + OrderCancelReason, + OrderStatus, +} from '@/generated/prisma/client'; +import { AlertService } from '@/global/alerting'; + +/** 후보는 id 순 100건씩, 한 틱에 최대 1000건까지 본다(밀린 양은 다음 틱으로). */ +export const LIFECYCLE_BATCH_SIZE = 100; +export const LIFECYCLE_MAX_PER_TICK = 1000; + +type LifecycleJob = + 'payment-expired' | 'confirm-reminder' | 'confirm-timeout' | 'auto-pickup'; + +/** + * 주문 자동 전이(worker 크론). 후보 id만 고른 뒤 건마다 repository가 연 tx에서 잠그고 이 정책으로 다시 판정한다 — + * 그사이 다른 전이·'입금했어요'가 끼면 건너뛴다. 건별 실패는 로그와 경보를 남기고 다음 건으로 넘어간다. + */ +@Injectable() +export class OrderLifecycleScheduler { + private readonly logger = new Logger(OrderLifecycleScheduler.name); + private readonly running = new Set(); + + constructor( + private readonly lifecycle: OrderLifecycleRepository, + private readonly transitions: OrderTransitionRepository, + private readonly stores: StoreAdminRepository, + private readonly cancelPolicy: OrderCancelPolicy, + private readonly statusPolicy: OrderStatusTransitionPolicy, + private readonly events: OrderEventsService, + private readonly clock: ClockService, + private readonly alerts: AlertService, + ) {} + + /** ① 입금 기한(주문 + 1시간)이 지난 미클레임 입금 대기를 취소한다(환불 없음). */ + @Cron('0 * * * * *') + cancelExpiredPayments(): Promise { + return this.tick('payment-expired', async (now) => { + await this.forEachCandidate( + 'payment-expired', + (page) => this.lifecycle.findPaymentExpiredIds({ ...page, now }), + (orderId) => + this.systemCancel( + orderId, + now, + OrderCancelReason.PAYMENT_NOT_RECEIVED, + (s) => isPaymentExpired(s, now), + ), + ); + }); + } + + /** ② 확정 마감 2시간 전 판매자 미리 알림(주문당 1회). */ + @Cron('30 * * * * *') + remindConfirmDeadlines(): Promise { + return this.tick('confirm-reminder', async (now) => { + await this.forEachCandidate( + 'confirm-reminder', + (page) => this.lifecycle.findConfirmReminderDueIds({ ...page, now }), + async (orderId) => { + await this.lifecycle.markConfirmReminderSent({ + orderId, + now, + isDue: (state) => isConfirmReminderDue(state, now), + }); + }, + ); + }); + } + + /** ③ 확정 마감이 지난 접수를 취소한다(전액 환불). 숨긴 매장 주문도 구매자에게 돈을 돌려주는 쪽이라 그대로 적용한다. */ + @Cron('15 * * * * *') + cancelConfirmTimeouts(): Promise { + return this.tick('confirm-timeout', async (now) => { + await this.forEachCandidate( + 'confirm-timeout', + (page) => this.lifecycle.findConfirmTimedOutIds({ ...page, now }), + (orderId) => + this.systemCancel( + orderId, + now, + OrderCancelReason.CONFIRM_TIMEOUT, + (s) => isConfirmTimedOut(s, now), + ), + ); + }); + } + + /** ④ 픽업 + 24시간이 지난 확정·제작 완료를 픽업 완료로 바꾸고 정산을 확정한다. 숨긴 매장 주문은 관리자가 건별로 처리한다. */ + @Cron('0 */5 * * * *') + completeOverduePickups(): Promise { + return this.tick('auto-pickup', async (now) => { + const excludeStoreIds = await this.stores.findInactiveStoreIds(); + await this.forEachCandidate( + 'auto-pickup', + (page) => + this.lifecycle.findAutoPickupIds({ ...page, now, excludeStoreIds }), + async (orderId) => { + const updated = await this.transitions.completePickupBySystem({ + orderId, + now, + eligible: (s) => + this.statusPolicy.canTransition({ + actor: OrderActor.SYSTEM, + from: s.status, + to: OrderStatus.PICKED_UP, + now, + pickupAt: s.pickupAt, + }), + }); + await this.afterTransition(updated); + }, + ); + }); + } + + private async systemCancel( + orderId: bigint, + now: Date, + reason: OrderCancelReason, + eligible: NonNullable, + ): Promise { + const updated = await this.transitions.cancel({ + orderId, + actor: OrderActor.SYSTEM, + actorAccountId: null, + scope: { kind: 'any' }, + note: null, + now, + eligible, + decide: (state) => + this.cancelPolicy.decide({ actor: OrderActor.SYSTEM, reason }, state), + }); + await this.afterTransition(updated); + } + + /** 커밋 뒤 판매자 구독(입금 전 주문은 발행하지 않는다). 건너뛴 건은 null이다. */ + private async afterTransition(updated: AdminOrderRow | null): Promise { + if (updated) await this.events.publishSellerStatusChanged(updated); + } + + /** 크론(ScheduleModule)은 worker에만 실리지만 역할도 함께 본다. 같은 작업의 틱이 겹치면 뒤 틱은 건너뛴다. */ + private async tick( + job: LifecycleJob, + run: (now: Date) => Promise, + ): Promise { + if (!runsBackgroundJobs(resolveAppRole()) || this.running.has(job)) return; + this.running.add(job); + try { + await run(this.clock.now()); + } catch (error) { + await this.report(job, error); + } finally { + this.running.delete(job); + } + } + + private async forEachCandidate( + job: LifecycleJob, + findIds: (page: Omit) => Promise, + handle: (orderId: bigint) => Promise, + ): Promise { + let afterId: bigint | undefined; + for (let seen = 0; seen < LIFECYCLE_MAX_PER_TICK;) { + const ids = await findIds({ afterId, limit: LIFECYCLE_BATCH_SIZE }); + for (const orderId of ids) { + try { + await handle(orderId); + } catch (error) { + await this.report(job, error, orderId); + } + } + seen += ids.length; + if (ids.length < LIFECYCLE_BATCH_SIZE) return; + afterId = ids[ids.length - 1]; + } + } + + private async report( + job: LifecycleJob, + error: unknown, + orderId?: bigint, + ): Promise { + const detail = `${orderId === undefined ? '' : `주문 ${orderId}: `}${ + error instanceof Error ? error.message : String(error) + }`; + this.logger.error(`주문 자동 전이(${job}) 실패 — ${detail}`); + await this.alerts.notify({ + level: 'warn', + title: '주문 자동 전이 실패', + key: `order-cron:${job}`, + detail, + }); + } +} diff --git a/src/features/order/services/order-output-mappers.helper.ts b/src/features/order/services/order-output-mappers.helper.ts index b6720cd9..1fc09405 100644 --- a/src/features/order/services/order-output-mappers.helper.ts +++ b/src/features/order/services/order-output-mappers.helper.ts @@ -1,10 +1,12 @@ import { ORDER_CANCEL_REASON_LABELS } from '@/features/order/constants/order-cancel-reasons'; +import { autoPickupAt } from '@/features/order/policies/order-status-transition.policy'; import { maskAccountNumber, toBank, } from '@/features/order/services/order-bank-account.helper'; import { readStoredThreeDDesign } from '@/features/order/services/order-custom-design.helper'; import type { + OrderAutoTransitionTimes, OrderCancellationOutput, OrderItemDetailOutput, OrderItemFreeEditOutput, @@ -189,6 +191,23 @@ export function toOrderStatusHistory( }; } +/** 자동 전이 예정 시각. 확정 마감은 접수 상태에서만, 자동 픽업 완료는 확정·제작 완료 상태에서만 있다. */ +export function toOrderAutoTransitionTimes(row: { + status: OrderStatus; + pickup_at: Date; + confirm_deadline_at: Date | null; + no_show_at: Date | null; +}): OrderAutoTransitionTimes { + const awaitingPickup = + row.status === OrderStatus.CONFIRMED || row.status === OrderStatus.MADE; + return { + confirmDeadlineAt: + row.status === OrderStatus.SUBMITTED ? row.confirm_deadline_at : null, + autoPickupAt: awaitingPickup ? autoPickupAt(row.pickup_at) : null, + noShowAt: row.no_show_at, + }; +} + /** 취소된 주문의 취소 이력과 취소 환불. 취소되지 않았거나 취소 이력이 없으면 null. */ export function toOrderCancellation(row: { status: OrderStatus; diff --git a/src/features/order/services/order-seller.service.spec.ts b/src/features/order/services/order-seller.service.spec.ts index 3b845e41..ffb09013 100644 --- a/src/features/order/services/order-seller.service.spec.ts +++ b/src/features/order/services/order-seller.service.spec.ts @@ -83,6 +83,8 @@ describe('SellerOrderService (real DB)', () => { /** 확인된 결제를 함께 만든다 */ paid?: boolean; commissionRateBps?: number; + pickupAt?: Date; + confirmDeadlineAt?: Date; } = {}, ) { const buyerId = @@ -92,6 +94,8 @@ describe('SellerOrderService (real DB)', () => { account_id: buyerId, status: opts.status ?? 'SUBMITTED', commission_rate_bps: opts.commissionRateBps, + pickup_at: opts.pickupAt, + confirm_deadline_at: opts.confirmDeadlineAt, }); await createOrderItem(prisma, { order_id: order.id, @@ -397,6 +401,59 @@ describe('SellerOrderService (real DB)', () => { expect(result.cancellation).toBeNull(); }); + describe('자동 전이 예정·노쇼', () => { + const NOW = new Date('2026-11-19T05:00:00.000Z'); + const PICKUP_AT = new Date('2026-11-19T04:00:00.000Z'); + const DEADLINE = new Date('2026-11-19T06:00:00.000Z'); + const AUTO_PICKUP = new Date('2026-11-20T04:00:00.000Z'); + + it.each([ + ['SUBMITTED', DEADLINE, null, false], + ['CONFIRMED', null, AUTO_PICKUP, true], + ['MADE', null, AUTO_PICKUP, true], + ['NO_SHOW', null, null, false], + ['CANCELED', null, null, false], + ] as const)( + '%s: 확정 마감 %p, 자동 픽업 %p, 노쇼 가능 %s', + async (status, confirmDeadlineAt, autoPickupAt, canMarkNoShow) => { + jest.spyOn(clock, 'now').mockReturnValue(NOW); + const { account, store } = await setupSellerWithStore(prisma); + // 확정 마감 값은 상태가 바뀌어도 남는다 — 접수 상태에서만 내려 준다 + const order = await createStoreOrder(store.id, { + status, + pickupAt: PICKUP_AT, + confirmDeadlineAt: DEADLINE, + }); + + const detail = await service.sellerOrder(account.id, order.id); + const [summary] = (await service.sellerOrderList(account.id)).items; + + expect(detail).toMatchObject({ + confirmDeadlineAt, + autoPickupAt, + canMarkNoShow, + noShowAt: null, + }); + expect(summary.confirmDeadlineAt).toEqual(confirmDeadlineAt); + }, + ); + + it('픽업 시각 전이면 노쇼로 처리할 수 없다', async () => { + jest + .spyOn(clock, 'now') + .mockReturnValue(new Date(PICKUP_AT.getTime() - 1)); + const { account, store } = await setupSellerWithStore(prisma); + const order = await createStoreOrder(store.id, { + status: 'MADE', + pickupAt: PICKUP_AT, + }); + + const detail = await service.sellerOrder(account.id, order.id); + + expect(detail.canMarkNoShow).toBe(false); + }); + }); + it('입금 반환 환불은 판매자 취소 정보에 섞이지 않는다', async () => { const { account, store } = await setupSellerWithStore(prisma); const order = await createStoreOrder(store.id, { status: 'CANCELED' }); @@ -621,9 +678,13 @@ describe('SellerOrderService (real DB)', () => { }); }); - it.each([OrderStatus.NO_SHOW, OrderStatus.PENDING_PAYMENT])( - '판매자는 %s로 바꿀 수 없다(400, 상태 불변)', - async (toStatus) => { + it.each([ + [OrderStatus.PENDING_PAYMENT, 'INVALID_ORDER_STATUS_TRANSITION'], + // 기본 픽업은 하루 뒤라 아직 노쇼 구간이 아니다 + [OrderStatus.NO_SHOW, 'NO_SHOW_NOT_ALLOWED'], + ] as const)( + '판매자는 %s로 바꿀 수 없다(%s, 상태 불변)', + async (toStatus, code) => { const { account, store } = await setupSellerWithStore(prisma); const order = await createStoreOrder(store.id, { status: 'MADE' }); @@ -632,7 +693,7 @@ describe('SellerOrderService (real DB)', () => { orderId: order.id.toString(), toStatus, }), - ).rejects.toThrowDomain('INVALID_ORDER_STATUS_TRANSITION'); + ).rejects.toThrowDomain(code); const row = await prisma.order.findUniqueOrThrow({ where: { id: order.id }, }); @@ -640,6 +701,103 @@ describe('SellerOrderService (real DB)', () => { }, ); + it.each(['CONFIRMED', 'MADE'] as const)( + '%s 주문을 픽업 시각 뒤 노쇼로 처리하면 노쇼 시각·정산을 남기고 환불은 없다', + async (status) => { + const now = new Date('2026-11-19T05:00:00.000Z'); + jest.spyOn(clock, 'now').mockReturnValue(now); + const { account, store } = await setupSellerWithStore(prisma); + const order = await createStoreOrder(store.id, { + status, + paid: true, + commissionRateBps: 1_000, + pickupAt: new Date(now.getTime() - 60 * 60_000), + }); + + const result = await service.sellerUpdateOrderStatus(account.id, { + orderId: order.id.toString(), + toStatus: 'NO_SHOW', + }); + + expect(result.status).toBe('NO_SHOW'); + await expect( + prisma.order.findUniqueOrThrow({ where: { id: order.id } }), + ).resolves.toMatchObject({ + status: 'NO_SHOW', + no_show_at: now, + settlement_base_amount: 10_000, + commission_amount: 1_000, + settlement_finalized_at: now, + }); + expect( + await prisma.orderStatusHistory.findMany({ + where: { order_id: order.id }, + }), + ).toEqual([ + expect.objectContaining({ + from_status: status, + to_status: 'NO_SHOW', + actor_type: 'SELLER', + }), + ]); + expect(await prisma.refund.count()).toBe(0); + const [event] = await prisma.outbox.findMany(); + expect(event.payload_json).toMatchObject({ + fromStatus: status, + toStatus: 'NO_SHOW', + actorType: 'SELLER', + }); + }, + ); + + it('사전 검사 뒤 픽업 일시가 미래로 바뀌면 잠금 시점 픽업 일시로 다시 판정해 노쇼를 거절한다', async () => { + const now = new Date('2026-11-19T05:00:00.000Z'); + jest.spyOn(clock, 'now').mockReturnValue(now); + const { account, store } = await setupSellerWithStore(prisma); + const order = await createStoreOrder(store.id, { + status: 'CONFIRMED', + pickupAt: new Date(now.getTime() - 60 * 60_000), + }); + const original = repo.findOrderDetailByStore.bind(repo); + jest + .spyOn(repo, 'findOrderDetailByStore') + .mockImplementationOnce(async (args) => { + const row = await original(args); + await prisma.order.update({ + where: { id: order.id }, + data: { pickup_at: new Date(now.getTime() + 24 * 60 * 60_000) }, + }); + return row; + }); + + await expect( + service.sellerUpdateOrderStatus(account.id, { + orderId: order.id.toString(), + toStatus: 'NO_SHOW', + }), + ).rejects.toThrowDomain('NO_SHOW_NOT_ALLOWED'); + await expect( + prisma.order.findUniqueOrThrow({ where: { id: order.id } }), + ).resolves.toMatchObject({ status: 'CONFIRMED', no_show_at: null }); + expect( + await prisma.orderStatusHistory.count({ + where: { order_id: order.id }, + }), + ).toBe(0); + }); + + it('확정 주문도 바로 픽업 완료할 수 있다', async () => { + const { account, store } = await setupSellerWithStore(prisma); + const order = await createStoreOrder(store.id, { status: 'CONFIRMED' }); + + const result = await service.sellerUpdateOrderStatus(account.id, { + orderId: order.id.toString(), + toStatus: 'PICKED_UP', + }); + + expect(result.status).toBe('PICKED_UP'); + }); + it('입금 대기 주문은 상태를 바꿀 수 없다(404)', async () => { const { account, store } = await setupSellerWithStore(prisma); const order = await createStoreOrder(store.id, { diff --git a/src/features/order/services/order-seller.service.ts b/src/features/order/services/order-seller.service.ts index c35276d1..1e315fe0 100644 --- a/src/features/order/services/order-seller.service.ts +++ b/src/features/order/services/order-seller.service.ts @@ -31,6 +31,7 @@ import { OrderEventsService } from '@/features/order/services/order-events.servi import { toOrderCancellation, toOrderItemDetail, + toOrderAutoTransitionTimes, toOrderListCustomBadge, toOrderStatusHistory, type OrderItemDetailRow, @@ -123,6 +124,10 @@ export class SellerOrderService extends SellerBaseService { const ctx = await this.requireSellerContext(accountId); const orderId = parseId(input.orderId); const toStatus = this.statusPolicy.parse(input.toStatus); + // 취소는 사유·사정·환불액이 필요해 sellerCancelOrder로만 한다 + if (toStatus === OrderStatus.CANCELED) { + throw new DomainException('INVALID_ORDER_STATUS_TRANSITION'); + } const current = await this.orderRepository.findOrderDetailByStore({ orderId, @@ -130,7 +135,16 @@ export class SellerOrderService extends SellerBaseService { }); if (!current) throw new DomainException('ORDER_NOT_FOUND'); - this.statusPolicy.assertSellerTransition(current.status, toStatus); + const now = this.clock.now(); + const assertTransition = (from: OrderStatus, pickupAt: Date) => + this.statusPolicy.assertTransition({ + actor: OrderActor.SELLER, + from, + to: toStatus, + now, + pickupAt, + }); + assertTransition(current.status, current.pickup_at); const updated = await this.orderRepository.updateOrderStatusBySeller({ orderId, @@ -138,10 +152,9 @@ export class SellerOrderService extends SellerBaseService { actorAccountId: ctx.accountId, toStatus, note: cleanNullableText(input.note, 500), - now: this.clock.now(), + now, // 잠금 뒤 현재 상태로 같은 규칙을 다시 적용한다(위 사전 검사는 빠른 거절용) - assertTransition: (from) => - this.statusPolicy.assertSellerTransition(from, toStatus), + assertTransition, }); if (!updated) throw new DomainException('ORDER_NOT_FOUND'); @@ -196,6 +209,7 @@ export class SellerOrderService extends SellerBaseService { firstItemName: row.items[0]?.product_name_snapshot ?? null, firstItemImageUrl: row.items[0]?.product_thumbnail_url_snapshot ?? null, ...toOrderListCustomBadge(row.items[0]), + confirmDeadlineAt: toOrderAutoTransitionTimes(row).confirmDeadlineAt, }; } @@ -217,6 +231,8 @@ export class SellerOrderService extends SellerBaseService { made_at: Date | null; picked_up_at: Date | null; canceled_at: Date | null; + confirm_deadline_at: Date | null; + no_show_at: Date | null; created_at: Date; updated_at: Date; status_histories: OrderStatusHistoryRow[]; @@ -253,6 +269,14 @@ export class SellerOrderService extends SellerBaseService { ), ), cancellation: toOrderCancellation(row), + ...toOrderAutoTransitionTimes(row), + canMarkNoShow: this.statusPolicy.canTransition({ + actor: OrderActor.SELLER, + from: row.status, + to: OrderStatus.NO_SHOW, + now: this.clock.now(), + pickupAt: row.pickup_at, + }), }; } } diff --git a/src/features/order/types/order-admin-output.type.ts b/src/features/order/types/order-admin-output.type.ts index 96f5be36..865ab9ec 100644 --- a/src/features/order/types/order-admin-output.type.ts +++ b/src/features/order/types/order-admin-output.type.ts @@ -1,5 +1,6 @@ import type { CancelRefundRule } from '@/features/order/policies/order-cancel.policy'; import type { + OrderAutoTransitionTimes, OrderCancellationOutput, OrderItemDetailOutput, OrderRefundOutput, @@ -36,7 +37,7 @@ export interface AdminStoreInProgressOrderSummaryOutput { byStatus: { status: OrderStatus; count: number }[]; } -export interface AdminOrderDetailOutput { +export interface AdminOrderDetailOutput extends OrderAutoTransitionTimes { id: string; orderNumber: string; buyer: { diff --git a/src/features/order/types/order-output.type.ts b/src/features/order/types/order-output.type.ts index cfba822c..3d4f0a14 100644 --- a/src/features/order/types/order-output.type.ts +++ b/src/features/order/types/order-output.type.ts @@ -135,3 +135,10 @@ export interface OrderRefundOutput { accountSubmittedAt: Date | null; completedAt: Date | null; } + +/** 자동 전이 예정·노쇼 시각(판매자·관리자 주문 상세). */ +export interface OrderAutoTransitionTimes { + confirmDeadlineAt: Date | null; + autoPickupAt: Date | null; + noShowAt: Date | null; +} diff --git a/src/features/order/types/order-seller-output.type.ts b/src/features/order/types/order-seller-output.type.ts index 6a013837..71ab8c7f 100644 --- a/src/features/order/types/order-seller-output.type.ts +++ b/src/features/order/types/order-seller-output.type.ts @@ -1,4 +1,5 @@ import type { + OrderAutoTransitionTimes, OrderCancellationOutput, OrderItemDetailOutput, OrderStatusHistoryOutput, @@ -18,9 +19,10 @@ export interface SellerOrderSummaryOutput { firstItemImageUrl: string | null; hasCustom: boolean; firstItemCustomImageUrl: string | null; + confirmDeadlineAt: Date | null; } -export interface SellerOrderDetailOutput { +export interface SellerOrderDetailOutput extends OrderAutoTransitionTimes { id: string; orderNumber: string; accountId: string; @@ -43,6 +45,7 @@ export interface SellerOrderDetailOutput { items: OrderItemDetailOutput[]; statusHistories: OrderStatusHistoryOutput[]; cancellation: OrderCancellationOutput | null; + canMarkNoShow: boolean; } /** SDL SellerOrderUpdateKind. PICKUP_RESCHEDULED는 판매자 픽업 일시 변경이 발행한다. */ diff --git a/src/features/store/repositories/store-admin.repository.ts b/src/features/store/repositories/store-admin.repository.ts index 562a25bb..546927b8 100644 --- a/src/features/store/repositories/store-admin.repository.ts +++ b/src/features/store/repositories/store-admin.repository.ts @@ -161,4 +161,13 @@ export class StoreAdminRepository { async countActiveStores(): Promise { return this.prisma.store.count({ where: { is_active: true } }); } + + /** 숨긴 매장 id(주문 자동 픽업 완료 제외용, order feature가 배럴로 소비). */ + async findInactiveStoreIds(): Promise { + const rows = await this.prisma.store.findMany({ + where: { is_active: false }, + select: { id: true }, + }); + return rows.map((row) => row.id); + } } diff --git a/src/test/factories/order.factory.ts b/src/test/factories/order.factory.ts index cc14a821..160deb58 100644 --- a/src/test/factories/order.factory.ts +++ b/src/test/factories/order.factory.ts @@ -37,6 +37,8 @@ export interface OrderOverrides { commission_rate_bps?: number; /** 미지정 시 PENDING_PAYMENT면 null, 그 밖의 상태는 생성 시각(입금 확인 = 판매자 노출) */ submitted_at?: Date | null; + confirm_deadline_at?: Date | null; + confirm_reminder_sent_at?: Date | null; } export async function createOrder( @@ -68,6 +70,8 @@ export async function createOrder( ...(overrides.commission_rate_bps !== undefined ? { commission_rate_bps: overrides.commission_rate_bps } : {}), + confirm_deadline_at: overrides.confirm_deadline_at ?? null, + confirm_reminder_sent_at: overrides.confirm_reminder_sent_at ?? null, submitted_at: overrides.submitted_at !== undefined ? overrides.submitted_at diff --git a/src/test/roles-coverage.spec.ts b/src/test/roles-coverage.spec.ts index 32c93561..cd0ea0dd 100644 --- a/src/test/roles-coverage.spec.ts +++ b/src/test/roles-coverage.spec.ts @@ -14,7 +14,7 @@ describe('접두 루트 필드 인가 커버리지', () => { describe.each([ ['seller', 'SELLER', 60], - ['admin', 'ADMIN', 74], + ['admin', 'ADMIN', 75], ] as const)('%s 접두 → @Roles(%s)', (prefix, role, count) => { const fields = collectRootFieldsWithPrefix(prefix);