Assinaturas e Pagamentos Recorrentes

import { Chargefy } from '@chargefy/sdk'

export const chargefy = new Chargefy({
  accessToken: process.env.CHARGEFY_ACCESS_TOKEN!,
  // Para sandbox:
  // server: 'sandbox'
})

import { Router, raw } from 'express'
import crypto from 'crypto'

export const webhooksRouter = Router()
webhooksRouter.use(raw({ type: 'application/json' }))

function verifySignature(payload: Buffer, signature: string, secret: string): boolean {
  const expected = crypto.createHmac('sha256', secret).update(payload).digest('hex')
  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))
}

webhooksRouter.post('/', (req, res) => {
  const signature = req.headers['webhook-signature'] as string
  const secret = process.env.CHARGEFY_WEBHOOK_SECRET!

  if (!signature || !verifySignature(req.body, signature, secret)) {
    return res.status(401).json({ error: 'Assinatura invalida' })
  }

  const event = JSON.parse(req.body.toString())

  // Responder imediatamente — processar async
  res.status(200).json({ received: true })

  // Processar evento
  handleSubscriptionEvent(event).catch(err => {
    console.error('Erro ao processar evento:', err)
  })
})

async function handleSubscriptionEvent(event: any) {
  const { type, data } = event

  switch (type) {
    case 'subscription.created':
      // Registrar assinatura no banco de dados
      await db.subscriptions.create({
        chargefy_id: data.id,
        customer_id: data.customer.id,
        product_id: data.product.id,
        status: 'pending',
        amount: data.amount,
        interval: data.recurringInterval,
        current_period_end: data.currentPeriodEnd,
      })
      console.log(`Assinatura ${data.id} criada para ${data.customer.email}`)
      break

    case 'subscription.active':
      // Liberar acesso ao servico
      await db.subscriptions.update(
        { chargefy_id: data.id },
        { status: 'active' }
      )
      await grantAccess(data.customer.id, data.product.id)
      await sendEmail(data.customer.email, 'welcome_subscription', {
        productName: data.product.name,
        amount: `R$ ${(data.amount / 100).toFixed(2)}`,
        nextBilling: data.currentPeriodEnd,
      })
      console.log(`Assinatura ${data.id} ativada`)
      break

    case 'subscription.updated':
      // Atualizar dados da assinatura (upgrade/downgrade)
      await db.subscriptions.update(
        { chargefy_id: data.id },
        {
          amount: data.amount,
          interval: data.recurringInterval,
          product_id: data.product.id,
          current_period_end: data.currentPeriodEnd,
        }
      )
      console.log(`Assinatura ${data.id} atualizada — novo valor: R$ ${(data.amount / 100).toFixed(2)}`)
      break

    case 'subscription.canceled':
      // Agendar revogacao de acesso
      await db.subscriptions.update(
        { chargefy_id: data.id },
        {
          status: 'canceled',
          cancel_at: data.cancelAtPeriodEnd ? data.currentPeriodEnd : new Date(),
        }
      )
      if (data.cancelAtPeriodEnd) {
        await sendEmail(data.customer.email, 'subscription_cancel_scheduled', {
          accessUntil: data.currentPeriodEnd,
        })
      }
      console.log(`Assinatura ${data.id} cancelada`)
      break

    case 'subscription.revoked':
      // Revogar acesso definitivamente
      await db.subscriptions.update(
        { chargefy_id: data.id },
        { status: 'revoked' }
      )
      await revokeAccess(data.customer.id, data.product.id)
      await sendEmail(data.customer.email, 'subscription_revoked', {
        productName: data.product.name,
      })
      console.log(`Assinatura ${data.id} revogada — acesso removido`)
      break
  }
}

import { Router } from 'express'
import { chargefy } from '../lib/chargefy.js'

export const subscriptionsRouter = Router()

// Listar planos disponiveis
subscriptionsRouter.get('/plans', async (_req, res) => {
  try {
    const products = await chargefy.products.list({
      isArchived: false,
      isRecurring: true,
    })

    const plans = products.items.map(product => ({
      id: product.id,
      name: product.name,
      description: product.description,
      prices: product.prices
        .filter(p => p.type === 'recurring')
        .map(p => ({
          id: p.id,
          amount: p.priceAmount,
          formatted: `R$ ${(p.priceAmount / 100).toFixed(2)}`,
          interval: p.recurringInterval,
          trialDays: p.trialPeriodDays || 0,
        })),
    }))

    res.json(plans)
  } catch (error) {
    res.status(500).json({ error: 'Falha ao listar planos' })
  }
})

// Criar checkout de assinatura
subscriptionsRouter.post('/subscribe', async (req, res) => {
  try {
    const { priceId, customerEmail } = req.body

    const checkout = await chargefy.checkouts.create({
      productPriceId: priceId,
      customerEmail,
      successUrl: `${process.env.FRONTEND_URL}/dashboard/assinatura/sucesso`,
      metadata: { source: 'pricing_page' },
    })

    res.json({ checkoutUrl: checkout.url, clientSecret: checkout.clientSecret })
  } catch (error) {
    res.status(400).json({ error: 'Falha ao criar checkout' })
  }
})

// Obter assinatura ativa do usuario
subscriptionsRouter.get('/me', async (req, res) => {
  try {
    const customerId = req.user.chargefyCustomerId // do seu middleware de auth

    const subscriptions = await chargefy.subscriptions.list({
      customerId,
      active: true,
      limit: 1,
    })

    if (subscriptions.items.length === 0) {
      return res.json({ subscription: null })
    }

    const sub = subscriptions.items[0]
    res.json({
      subscription: {
        id: sub.id,
        status: sub.status,
        plan: sub.product.name,
        amount: `R$ ${(sub.amount / 100).toFixed(2)}`,
        interval: sub.recurringInterval,
        currentPeriodEnd: sub.currentPeriodEnd,
        cancelAtPeriodEnd: sub.cancelAtPeriodEnd,
      },
    })
  } catch (error) {
    res.status(500).json({ error: 'Falha ao buscar assinatura' })
  }
})

// Trocar plano (upgrade/downgrade)
subscriptionsRouter.post('/:id/change-plan', async (req, res) => {
  try {
    const { id } = req.params
    const { newPriceId } = req.body

    // Buscar assinatura atual para determinar se e upgrade ou downgrade
    const current = await chargefy.subscriptions.get(id)
    const newPrice = await chargefy.prices.get(newPriceId)

    const isUpgrade = newPrice.priceAmount > current.amount
    const updated = await chargefy.subscriptions.update(id, {
      productPriceId: newPriceId,
      proration: isUpgrade, // prorata apenas no upgrade
    })

    res.json({
      subscription: updated,
      changeType: isUpgrade ? 'upgrade' : 'downgrade',
      effectiveDate: isUpgrade ? 'imediato' : updated.currentPeriodEnd,
    })
  } catch (error) {
    res.status(400).json({ error: 'Falha ao trocar plano' })
  }
})

// Cancelar assinatura
subscriptionsRouter.post('/:id/cancel', async (req, res) => {
  try {
    const { id } = req.params
    const { immediate } = req.body

    const canceled = await chargefy.subscriptions.cancel(id, {
      cancelAtPeriodEnd: !immediate,
    })

    res.json({
      status: canceled.status,
      cancelAtPeriodEnd: canceled.cancelAtPeriodEnd,
      accessUntil: canceled.cancelAtPeriodEnd ? canceled.currentPeriodEnd : null,
    })
  } catch (error) {
    res.status(400).json({ error: 'Falha ao cancelar assinatura' })
  }
})

// Reverter cancelamento
subscriptionsRouter.post('/:id/reactivate', async (req, res) => {
  try {
    const { id } = req.params

    const reactivated = await chargefy.subscriptions.update(id, {
      cancelAtPeriodEnd: false,
    })

    res.json({
      status: reactivated.status,
      cancelAtPeriodEnd: reactivated.cancelAtPeriodEnd,
    })
  } catch (error) {
    res.status(400).json({ error: 'Falha ao reativar assinatura' })
  }
})

// Historico de faturas
subscriptionsRouter.get('/:id/invoices', async (req, res) => {
  try {
    const { id } = req.params
    const invoices = await chargefy.subscriptions.listInvoices(id, {
      page: 1,
      limit: 12,
    })

    res.json(invoices)
  } catch (error) {
    res.status(500).json({ error: 'Falha ao listar faturas' })
  }
})

import { useState, useEffect } from 'react'

interface Subscription {
  id: string
  status: string
  plan: string
  amount: string
  interval: string
  currentPeriodEnd: string
  cancelAtPeriodEnd: boolean
}

interface Plan {
  id: string
  name: string
  prices: { id: string; amount: number; formatted: string; interval: string }[]
}

export function SubscriptionDashboard() {
  const [subscription, setSubscription] = useState<Subscription | null>(null)
  const [plans, setPlans] = useState<Plan[]>([])
  const [loading, setLoading] = useState(true)

  useEffect(() => {
    Promise.all([
      fetch('/api/subscriptions/me').then(r => r.json()),
      fetch('/api/subscriptions/plans').then(r => r.json()),
    ]).then(([subData, plansData]) => {
      setSubscription(subData.subscription)
      setPlans(plansData)
      setLoading(false)
    })
  }, [])

  async function handleCancel() {
    if (!subscription) return
    if (!confirm('Tem certeza que deseja cancelar sua assinatura?')) return

    const res = await fetch(`/api/subscriptions/${subscription.id}/cancel`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ immediate: false }),
    })

    const data = await res.json()
    setSubscription(prev => prev ? {
      ...prev,
      cancelAtPeriodEnd: data.cancelAtPeriodEnd,
    } : null)
  }

  async function handleReactivate() {
    if (!subscription) return

    const res = await fetch(`/api/subscriptions/${subscription.id}/reactivate`, {
      method: 'POST',
    })

    const data = await res.json()
    setSubscription(prev => prev ? {
      ...prev,
      cancelAtPeriodEnd: data.cancelAtPeriodEnd,
      status: data.status,
    } : null)
  }

  async function handleChangePlan(priceId: string) {
    if (!subscription) return

    const res = await fetch(`/api/subscriptions/${subscription.id}/change-plan`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ newPriceId: priceId }),
    })

    const data = await res.json()
    alert(`${data.changeType === 'upgrade' ? 'Upgrade' : 'Downgrade'} realizado!`)
    window.location.reload()
  }

  if (loading) return <div>Carregando...</div>

  if (!subscription) {
    return (
      <div>
        <h2>Escolha um plano</h2>
        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(250px, 1fr))', gap: '1rem' }}>
          {plans.map(plan => (
            <div key={plan.id} style={{ border: '1px solid #e5e7eb', borderRadius: '8px', padding: '1.5rem' }}>
              <h3>{plan.name}</h3>
              {plan.prices.map(price => (
                <div key={price.id} style={{ marginTop: '0.5rem' }}>
                  <p>{price.formatted}/{price.interval === 'month' ? 'mes' : 'ano'}</p>
                  <button onClick={async () => {
                    const res = await fetch('/api/subscriptions/subscribe', {
                      method: 'POST',
                      headers: { 'Content-Type': 'application/json' },
                      body: JSON.stringify({ priceId: price.id, customerEmail: '[email protected]' }),
                    })
                    const { checkoutUrl } = await res.json()
                    window.location.href = checkoutUrl
                  }}>
                    Assinar
                  </button>
                </div>
              ))}
            </div>
          ))}
        </div>
      </div>
    )
  }

  return (
    <div>
      <h2>Minha assinatura</h2>

      <div style={{ border: '1px solid #e5e7eb', borderRadius: '8px', padding: '1.5rem' }}>
        <p><strong>Plano:</strong> {subscription.plan}</p>
        <p><strong>Valor:</strong> {subscription.amount}/{subscription.interval === 'month' ? 'mes' : 'ano'}</p>
        <p><strong>Status:</strong> {subscription.status}</p>
        <p><strong>Proximo ciclo:</strong> {new Date(subscription.currentPeriodEnd).toLocaleDateString('pt-BR')}</p>

        {subscription.cancelAtPeriodEnd && (
          <div style={{ background: '#fef3c7', padding: '1rem', borderRadius: '4px', marginTop: '1rem' }}>
            <p>Sua assinatura sera cancelada em {new Date(subscription.currentPeriodEnd).toLocaleDateString('pt-BR')}.</p>
            <button onClick={handleReactivate}>Manter assinatura</button>
          </div>
        )}

        <div style={{ marginTop: '1rem', display: 'flex', gap: '0.5rem' }}>
          {!subscription.cancelAtPeriodEnd && (
            <button onClick={handleCancel} style={{ color: 'red' }}>
              Cancelar assinatura
            </button>
          )}
        </div>
      </div>

      <h3 style={{ marginTop: '2rem' }}>Trocar plano</h3>
      <div style={{ display: 'flex', gap: '1rem', flexWrap: 'wrap' }}>
        {plans.flatMap(plan =>
          plan.prices.map(price => (
            <button
              key={price.id}
              onClick={() => handleChangePlan(price.id)}
              style={{ padding: '0.5rem 1rem', border: '1px solid #e5e7eb', borderRadius: '4px' }}
            >
              {plan.name} — {price.formatted}/{price.interval === 'month' ? 'mes' : 'ano'}
            </button>
          ))
        )}
      </div>
    </div>
  )
}