Stripe 결제 통합

requires_payment_method → requires_confirmation → requires_action → processing → succeeded
                                                                                    ↘ canceled

import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

async function createPaymentIntent(amount: number, currency: string) {
  const intent = await stripe.paymentIntents.create({
    amount: convertToStripeAmount(amount, currency),
    currency: currency.toLowerCase(),
    payment_method_types: ['card'],
    metadata: { orderId: 'order-123' },
  });

  return {
    id: intent.id,
    clientSecret: intent.client_secret,
  };
}

import { loadStripe } from '@stripe/stripe-js';

const stripe = await loadStripe('pk_test_...');
const elements = stripe.elements();

// 카드 입력 UI 생성
const cardElement = elements.create('card');
cardElement.mount('#card-element');

// 결제 확인
async function handlePayment(clientSecret: string) {
  const { error, paymentIntent } = await stripe.confirmCardPayment(
    clientSecret,
    {
      payment_method: { card: cardElement },
    }
  );

  if (error) {
    console.error('결제 실패:', error.message);
  } else if (paymentIntent.status === 'succeeded') {
    console.log('결제 성공!');
  }
}

import { Elements, CardElement, useStripe, useElements } from '@stripe/react-stripe-js';

function CheckoutForm({ clientSecret }: { clientSecret: string }) {
  const stripe = useStripe();
  const elements = useElements();

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    if (!stripe || !elements) return;

    const { error } = await stripe.confirmCardPayment(clientSecret, {
      payment_method: { card: elements.getElement(CardElement)! },
    });

    if (error) {
      // 에러 표시
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <CardElement />
      <button type="submit" disabled={!stripe}>결제</button>
    </form>
  );
}

import { loadStripeTerminal } from '@stripe/terminal-js';

const StripeTerminal = await loadStripeTerminal();

const terminal = StripeTerminal.create({
  onFetchConnectionToken: async () => {
    // 서버에서 connection token을 받아온다
    const response = await fetch('/api/stripe/connection-token');
    const { secret } = await response.json();
    return secret;
  },
  onUnexpectedReaderDisconnect: () => {
    console.error('리더 연결이 끊어졌습니다');
  },
});

// 서버 사이드
async function createConnectionToken() {
  const token = await stripe.terminal.connectionTokens.create();
  return token.secret;
}

// 1. 리더 검색
const { discoveredReaders } = await terminal.discoverReaders({
  simulated: false,
  location: 'tml_location_id',  // Stripe 대시보드에서 등록한 위치
});

// 2. 리더 연결
await terminal.connectReader(discoveredReaders[0]);

// 3. 카드 수집 (고객이 카드를 대면)
const { paymentIntent } = await terminal.collectPaymentMethod(clientSecret);

// 4. 결제 처리
const { paymentIntent: processed } = await terminal.processPayment(paymentIntent);

if (processed.status === 'succeeded') {
  // 결제 완료 → 서버에 알림
}

// 시뮬레이터 테스트 카드 설정
terminal.setSimulatorConfiguration({
  testCardNumber: '4242424242424242',  // Visa 성공
});

const { discoveredReaders } = await terminal.discoverReaders({ simulated: true });
await terminal.connectReader(discoveredReaders[0]);

async function verifyPayment(paymentIntentId: string, expectedAmount: number) {
  const intent = await stripe.paymentIntents.retrieve(paymentIntentId);

  // 1. 상태 확인
  if (intent.status !== 'succeeded') {
    throw new Error(`결제 미완료: ${intent.status}`);
  }

  // 2. 금액 일치 확인
  if (intent.amount !== expectedAmount) {
    throw new Error('금액 불일치');
  }

  // 3. PaymentIntent ID가 우리가 생성한 것인지 확인
  // DB에 저장된 externalPaymentId와 대조
  return true;
}

import express from 'express';

const app = express();

// 웹훅 엔드포인트는 raw body가 필요하다 (서명 검증용)
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['stripe-signature'] as string;
  const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET;

  let event: Stripe.Event;

  try {
    event = stripe.webhooks.constructEvent(req.body, sig, endpointSecret);
  } catch (err) {
    console.error('웹훅 서명 검증 실패:', err.message);
    return res.status(400).send('Webhook signature verification failed');
  }

  switch (event.type) {
    case 'payment_intent.succeeded':
      const paymentIntent = event.data.object as Stripe.PaymentIntent;
      // 주문 완료 처리
      handlePaymentSuccess(paymentIntent);
      break;

    case 'payment_intent.payment_failed':
      // 실패 처리, 사용자 알림
      break;
  }

  res.json({ received: true });
});

async function handlePaymentSuccess(paymentIntent: Stripe.PaymentIntent) {
  const order = await db.orders.findByPaymentIntentId(paymentIntent.id);

  // 이미 처리된 주문이면 무시
  if (order.status === 'completed') {
    return;
  }

  await db.orders.update(order.id, { status: 'completed' });
}

const zeroDecimalCurrencies = [
  'BIF', 'CLP', 'DJF', 'GNF', 'JPY', 'KMF', 'KRW',
  'MGA', 'PYG', 'RWF', 'UGX', 'VND', 'VUV',
  'XAF', 'XOF', 'XPF',
];

function convertToStripeAmount(amount: number, currency: string): number {
  if (zeroDecimalCurrencies.includes(currency.toUpperCase())) {
    return Math.round(amount);  // 변환 없이 그대로
  }
  return Math.round(amount * 100);  // 센트 단위로 변환
}

async function retryPayment(payment: Payment) {
  // 1. 이전 PaymentIntent 취소
  if (payment.externalPaymentId) {
    try {
      await stripe.paymentIntents.cancel(payment.externalPaymentId);
    } catch (error) {
      // 취소 실패해도 재시도는 진행 (이미 succeeded/canceled 상태일 수 있음)
      console.warn('이전 PaymentIntent 취소 실패:', error);
    }
  }

  // 2. 새 PaymentIntent 생성
  const newIntent = await stripe.paymentIntents.create({
    amount: payment.amount,
    currency: payment.currency,
    payment_method_types: ['card_present'],
  });

  // 3. DB 업데이트
  payment.externalPaymentId = newIntent.id;
  await payment.save();

  return { clientSecret: newIntent.client_secret };
}

// ❌ 위험: 클라이언트가 보낸 금액 사용
app.post('/create-payment', (req, res) => {
  const intent = await stripe.paymentIntents.create({
    amount: req.body.amount,  // 조작 가능!
    currency: 'krw',
  });
});

// ✅ 안전: 서버에서 금액 계산
app.post('/create-payment', (req, res) => {
  const order = await db.orders.findById(req.body.orderId);
  const amount = calculateTotalPrice(order);  // 서버 사이드 계산

  const intent = await stripe.paymentIntents.create({
    amount,
    currency: 'krw',
  });
});

// 클라이언트가 보낸 ID와 DB에 저장된 ID 대조
if (dto.paymentIntentId !== payment.externalPaymentId) {
  throw new BadRequestException('PaymentIntent ID mismatch');
}

┌──────────────┐     ① PaymentIntent 생성 요청     ┌──────────────┐
│              │ ──────────────────────────────────→ │              │
│   클라이언트   │     ② clientSecret 반환           │    서버       │
│   (브라우저/   │ ←────────────────────────────────── │   (NestJS/   │
│    키오스크)   │                                    │   Express)   │
│              │     ⑤ 결제 완료 알림 + 검증 요청    │              │
│              │ ──────────────────────────────────→ │              │
│              │     ⑥ 서버가 Stripe API로 직접 확인  │              │
└──────┬───────┘                                    └──────┬───────┘
       │                                                    │
       │ ③ clientSecret으로                                 │ ①② Stripe SDK로
       │   카드 정보 수집/확인                                │    PaymentIntent 생성
       │                                                    │
       │ ④ 카드 정보는 Stripe로                              │ ⑥ retrieve로
       │   직접 전송                                         │   상태 검증
       ↓                                                    ↓
┌─────────────────────────────────────────────────────────────┐
│                        Stripe API                           │
│   PaymentIntent 관리 / 카드 정보 처리 / 웹훅 발송            │
└─────────────────────────────────────────────────────────────┘