장바구니와 체크아웃 흐름

[비로그인]
- localStorage / cookie
- merge on login

[로그인]
- DB 저장
- 디바이스 간 동기화

CREATE TABLE carts (
  id UUID PRIMARY KEY,
  user_id UUID UNIQUE,    -- 로그인 사용자 (1인 1cart)
  session_id VARCHAR UNIQUE,  -- 비로그인 (cookie)
  expires_at TIMESTAMP,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE cart_items (
  id UUID PRIMARY KEY,
  cart_id UUID NOT NULL REFERENCES carts(id) ON DELETE CASCADE,
  variant_id UUID NOT NULL,
  quantity INT NOT NULL CHECK (quantity > 0),
  added_at TIMESTAMP DEFAULT NOW(),
  UNIQUE (cart_id, variant_id)
);

// POST /api/cart/items
async function addToCart(userId: string | null, sessionId: string | null, variantId: string, quantity: number) {
  const variant = await db.productVariant.findUnique({
    where: { id: variantId },
    include: { product: true },
  });
  if (!variant || variant.product.status !== 'active') {
    throw new NotFoundError('Product');
  }
  if (variant.stockQuantity < quantity) {
    throw new ConflictError('Insufficient stock');
  }

  // cart 찾거나 생성
  let cart = userId
    ? await db.cart.findUnique({ where: { userId } })
    : await db.cart.findUnique({ where: { sessionId: sessionId! } });

  if (!cart) {
    cart = await db.cart.create({
      data: userId ? { userId } : { sessionId: sessionId! },
    });
  }

  // 이미 있으면 quantity 증가
  return db.cartItem.upsert({
    where: { cartId_variantId: { cartId: cart.id, variantId } },
    create: { cartId: cart.id, variantId, quantity },
    update: { quantity: { increment: quantity } },
  });
}


// 로그인 시 merge
async function mergeGuestCart(userId: string, sessionId: string) {
  const guestCart = await db.cart.findUnique({
    where: { sessionId },
    include: { items: true },
  });
  if (!guestCart) return;

  let userCart = await db.cart.findUnique({ where: { userId } });
  if (!userCart) {
    userCart = await db.cart.create({ data: { userId } });
  }

  // 각 item을 user cart에 merge
  for (const item of guestCart.items) {
    await db.cartItem.upsert({
      where: { cartId_variantId: { cartId: userCart.id, variantId: item.variantId } },
      create: { cartId: userCart.id, variantId: item.variantId, quantity: item.quantity },
      update: { quantity: { increment: item.quantity } },
    });
  }

  await db.cart.delete({ where: { id: guestCart.id } });
}

1. 장바구니 (Cart) → 체크아웃 시작 (Checkout)

2. 배송지 입력 (or 저장된 주소 선택)
   - 주소 검색 API (Daum 우편번호 등)
   - 신규 입력 시 자동 저장

3. 배송 옵션 (일반/빠른배송) + 요청사항

4. 쿠폰·포인트 적용

5. 결제 수단 선택 + 결제

6. 주문 완료 → /orders/:id


[중요]
- 단계마다 URL 다름 (뒤로가기 가능)
- "주문서 없이 결제" — 비로그인 가능
- 진행 표시 (4/5)

'use client';

export default function CheckoutPage() {
  const [step, setStep] = useState<'shipping' | 'payment' | 'review'>('shipping');
  const [data, setData] = useState({
    address: null,
    shippingMethod: 'standard',
    couponCode: '',
    paymentMethod: 'card',
  });

  const cart = useQuery({ queryKey: ['cart'], queryFn: fetchCart });
  const summary = useMemo(() => calculateSummary(cart.data?.items ?? [], data), [cart, data]);

  const placeOrder = useMutation({
    mutationFn: () => fetch('/api/checkout/place-order', {
      method: 'POST',
      body: JSON.stringify({ ...data, items: cart.data?.items }),
    }).then(r => r.json()),
    onSuccess: (order) => {
      // PG 결제 페이지로
      window.location.href = order.paymentUrl;
    },
  });

  return (
    <div className="grid md:grid-cols-3 gap-8">
      <div className="md:col-span-2">
        <ProgressIndicator step={step} />

        {step === 'shipping' && <ShippingForm onNext={() => setStep('payment')} />}
        {step === 'payment' && <PaymentForm onNext={() => setStep('review')} />}
        {step === 'review' && (
          <OrderReview
            data={data}
            summary={summary}
            onConfirm={() => placeOrder.mutate()}
            isLoading={placeOrder.isPending}
          />
        )}
      </div>

      <aside className="sticky top-4">
        <OrderSummary cart={cart.data} summary={summary} />
      </aside>
    </div>
  );
}

// 결제 시작 시 재고 임시 차감 (15분)
async function reserveInventory(orderId: string, items: CartItem[]) {
  return db.$transaction(async (tx) => {
    for (const item of items) {
      await tx.inventoryReservation.create({
        data: {
          orderId,
          variantId: item.variantId,
          quantity: item.quantity,
          expiresAt: new Date(Date.now() + 15 * 60 * 1000),
        },
      });
    }
  });
}


// 가용 재고 = 실제 - 예약
async function getAvailableStock(variantId: string) {
  const variant = await db.productVariant.findUnique({ where: { id: variantId } });
  const reserved = await db.inventoryReservation.aggregate({
    where: { variantId, expiresAt: { gt: new Date() } },
    _sum: { quantity: true },
  });
  return variant!.stockQuantity - (reserved._sum.quantity ?? 0);
}


// 결제 성공 시 → 실제 차감 + 예약 해제
// 결제 실패/만료 시 → 예약만 해제