Tratamento de Erros e Casos de Borda

// lib/stripe-errors.ts
import type { StripeError } from "@stripe/stripe-js";
import type Stripe from "stripe";
 
export function getClientErrorMessage(error: StripeError): string {
  switch (error.type) {
    case "card_error":
      return getCardErrorMessage(error.code);
    case "validation_error":
      return "Por favor, verifique seus detalhes de pagamento e tente novamente.";
    case "invalid_request_error":
      return "Algo deu errado. Por favor, tente novamente.";
    case "api_error":
      return "Nosso processador de pagamento está temporariamente indisponível. Por favor, tente novamente em um momento.";
    case "api_connection_error":
      return "Erro de rede. Por favor, verifique sua conexão e tente novamente.";
    case "authentication_error":
      return "Falha na autenticação. Por favor, tente novamente.";
    case "rate_limit_error":
      return "Muitas solicitações. Por favor, aguarde um momento e tente novamente.";
    default:
      return "Ocorreu um erro inesperado. Por favor, tente novamente.";
  }
}
 
function getCardErrorMessage(code: string | undefined): string {
  switch (code) {
    case "card_declined":
      return "Seu cartão foi recusado. Por favor, use um cartão diferente.";
    case "insufficient_funds":
      return "Fundos insuficientes. Por favor, use um cartão diferente.";
    case "expired_card":
      return "Seu cartão expirou. Por favor, use um cartão diferente.";
    case "incorrect_cvc":
      return "CVC incorreto. Por favor, verifique e tente novamente.";
    case "incorrect_number":
      return "Número de cartão incorreto. Por favor, verifique e tente novamente.";
    case "processing_error":
      return "Ocorreu um erro ao processar seu cartão. Por favor, tente novamente.";
    default:
      return "Seu cartão foi recusado. Por favor, use um método de pagamento diferente.";
  }
}
 
export function getServerErrorMessage(error: Stripe.errors.StripeError): string {
  switch (error.type) {
    case "StripeCardError":
      return error.message ?? "Erro no cartão.";
    case "StripeInvalidRequestError":
      return "Solicitação inválida. Por favor, entre em contato com o suporte.";
    case "StripeAPIError":
      return "Serviço de pagamento temporariamente indisponível.";
    case "StripeConnectionError":
      return "Não foi possível conectar ao serviço de pagamento.";
    case "StripeAuthenticationError":
      return "Erro de configuração de pagamento. Por favor, entre em contato com o suporte.";
    case "StripeRateLimitError":
      return "Muitas solicitações. Por favor, tente novamente mais tarde.";
    default:
      return "Ocorreu um erro inesperado.";
  }
}

// lib/confirm-payment.ts
import type { Stripe, StripeElements } from "@stripe/stripe-js";
 
interface PaymentResult {
  success: boolean;
  error?: string;
  requiresAction?: boolean;
}
 
export async function confirmPaymentWithSCA(
  stripe: Stripe,
  elements: StripeElements,
  returnUrl: string
): Promise<PaymentResult> {
  const { error: submitError } = await elements.submit();
  if (submitError) {
    return { success: false, error: submitError.message };
  }
 
  const { error, paymentIntent } = await stripe.confirmPayment({
    elements,
    confirmParams: { return_url: returnUrl },
    redirect: "if_required",
  });
 
  if (error) {
    return { success: false, error: error.message };
  }
 
  switch (paymentIntent?.status) {
    case "succeeded":
      return { success: true };
    case "processing":
      return {
        success: false,
        error: "Seu pagamento está sendo processado. Você será notificado quando ele for concluído.",
      };
    case "requires_action":
      // 3D Secure foi acionado, mas não concluído
      return {
        success: false,
        requiresAction: true,
        error: "Autenticação adicional é necessária.",
      };
    default:
      return { success: false, error: "Status de pagamento inesperado." };
  }
}

// app/checkout/secure-checkout-form.tsx
"use client";
 
import { useState, type FormEvent } from "react";
import {
  PaymentElement,
  useStripe,
  useElements,
} from "@stripe/react-stripe-js";
import { getClientErrorMessage } from "@/lib/stripe-errors";
import type { StripeError } from "@stripe/stripe-js";
 
type FormStatus = "idle" | "validating" | "processing" | "succeeded" | "failed";
 
export function SecureCheckoutForm() {
  const stripe = useStripe();
  const elements = useElements();
  const [status, setStatus] = useState<FormStatus>("idle");
  const [errorMessage, setErrorMessage] = useState<string | null>(null);
  const [retryCount, setRetryCount] = useState(0);
 
  function handleError(error: StripeError) {
    const message = getClientErrorMessage(error);
    setErrorMessage(message);
    setStatus("failed");
 
    // Permite retentativa para erros transitórios
    if (error.type === "api_error" || error.type === "api_connection_error") {
      setRetryCount((prev) => prev + 1);
    }
  }
 
  async function handleSubmit(e: FormEvent) {
    e.preventDefault();
    if (!stripe || !elements) return;
 
    setStatus("validating");
    setErrorMessage(null);
 
    // Passo 1: Validar o formulário
    const { error: submitError } = await elements.submit();
    if (submitError) {
      handleError(submitError);
      return;
    }
 
    setStatus("processing");
 
    // Passo 2: Confirmar o pagamento
    const { error: confirmError, paymentIntent } =
      await stripe.confirmPayment({
        elements,
        confirmParams: {
          return_url: `${window.location.origin}/success`,
        },
        redirect: "if_required",
      });
 
    if (confirmError) {
      handleError(confirmError);
      return;
    }
 
    // Passo 3: Lidar com o resultado
    switch (paymentIntent?.status) {
      case "succeeded":
        setStatus("succeeded");
        break;
      case "processing":
        setErrorMessage(
          "Seu pagamento está sendo processado. Notificaremos você quando ele for concluído."
        );
        setStatus("processing");
        break;
      case "requires_action":
        setErrorMessage(
          "Autenticação adicional necessária. Por favor, complete a verificação."
        );
        setStatus("failed");
        break;
      default:
        setErrorMessage("Algo deu errado. Por favor, tente novamente.");
        setStatus("failed");
    }
  }
 
  if (status === "succeeded") {
    return (
      <div className="text-center p-8">
        <div className="text-green-500 text-5xl mb-4">&#10003;</div>
        <h2 className="text-2xl font-bold">Pagamento bem-sucedido!</h2>
        <p className="text-gray-600 mt-2">
          Obrigado pela sua compra.
        </p>
      </div>
    );
  }
 
  return (
    <form onSubmit={handleSubmit} className="max-w-md mx-auto p-6 space-y-6">
      <PaymentElement />
 
      {errorMessage && (
        <div
          className={`rounded-lg p-4 ${
            status === "processing"
              ? "bg-yellow-50 border border-yellow-200"
              : "bg-red-50 border border-red-200"
          }`}
          role="alert"
        >
          <p
            className={`text-sm font-medium ${
              status === "processing" ? "text-yellow-800" : "text-red-800"
            }`}
          >
            {errorMessage}
          </p>
        </div>
      )}
 
      <button
        type="submit"
        disabled={
          !stripe || status === "validating" || status === "processing"
        }
        className="w-full bg-blue-600 text-white py-3 rounded-lg font-medium
                   hover:bg-blue-700 disabled:opacity-50 transition-colors"
      >
        {status === "validating" && "Validando..."}
        {status === "processing" && "Processando pagamento..."}
        {status === "idle" && "Pagar agora"}
        {status === "failed" && (retryCount > 0 ? `Tentar novamente (${retryCount})` : "Tentar novamente")}
      </button>
 
      {retryCount >= 3 && (
        <p className="text-sm text-gray-500 text-center">
          Com problemas?{" "}
          <a href="/support" className="text-blue-600 underline">
            Entre em contato com o suporte
          </a>
        </p>
      )}
    </form>
  );
}

// app/actions/safe-checkout.ts
"use server";
 
import { stripe } from "@/lib/stripe";
import { getServerErrorMessage } from "@/lib/stripe-errors";
import Stripe from "stripe";
 
export async function safeCreateCheckout(priceId: string) {
  try {
    const session = await stripe.checkout.sessions.create({
      mode: "payment",
      line_items: [{ price: priceId, quantity: 1 }],
      success_url: `${process.env.NEXT_PUBLIC_APP_URL}/success?session_id={CHECKOUT_SESSION_ID}`,
      cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/pricing`,
    });
 
    return { url: session.url };
  } catch (err) {
    if (err instanceof Stripe.errors.StripeError) {
      console.error(`Erro Stripe [${err.type}]: ${err.message}`);
      return { error: getServerErrorMessage(err) };
    }
    console.error("Erro inesperado:", err);
    return { error: "Ocorreu um erro inesperado." };
  }
}

async function withRetry<T>(
  fn: () => Promise<T>,
  maxRetries = 3
): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (err) {
      if (
        err instanceof Stripe.errors.StripeError &&
        (err.type === "StripeConnectionError" ||
          err.type === "StripeAPIError") &&
        attempt < maxRetries
      ) {
        const delay = Math.pow(2, attempt) * 1000;
        await new Promise((r) => setTimeout(r, delay));
        continue;
      }
      throw err;
    }
  }
  throw new Error("Max retries exceeded");
}
 
// Uso
const session = await withRetry(() =>
  stripe.checkout.sessions.create({ /* ... */ })
);

const paymentIntent = await stripe.paymentIntents.create(
  {
    amount: 2999,
    currency: "usd",
    automatic_payment_methods: { enabled: true },
  },
  {
    idempotencyKey: `pi_${userId}_${orderId}`,
  }
);

import type { StripeError } from "@stripe/stripe-js";
 
function isRetryable(error: StripeError): boolean {
  return (
    error.type === "api_error" || error.type === "api_connection_error"
  );
}