Payments API

1. User creates booking
        ↓
2. Frontend receives payment URL
        ↓
3. User redirected to Paystack checkout
        ↓
4. User completes payment
        ↓
5. Paystack sends webhook
        ↓
6. Backend confirms booking
        ↓
7. User redirected to confirmation page

POST /api/payments/initialize

{
  "bookingId": "clx789xyz...",
  "method": "MOBILE_MONEY",
  "callbackUrl": "https://y3nko.travel/dashboard/bookings/Y3K-ABC123"
}

{
  "data": {
    "authorizationUrl": "https://checkout.paystack.com/abc123xyz",
    "accessCode": "abc123xyz",
    "reference": "PAY-XYZ789"
  }
}

GET /api/payments/{reference}/status

{
  "data": {
    "payment": {
      "id": "clx999...",
      "status": "COMPLETED",
      "amount": "3123.75",
      "currency": "GHS",
      "method": "MOBILE_MONEY",
      "paystackRef": "PAY-XYZ789",
      "paidAt": "2024-02-20T10:35:00Z"
    },
    "booking": {
      "id": "clx789xyz...",
      "reference": "Y3K-ABC123",
      "status": "CONFIRMED"
    }
  }
}

POST /api/webhooks/paystack

{
  "received": true
}

// app/api/webhooks/paystack/route.ts
import { NextRequest, NextResponse } from 'next/server'
import crypto from 'crypto'
import { prisma } from '@/lib/db'
import { sendBookingConfirmation } from '@/lib/email'
 
export async function POST(req: NextRequest) {
  const body = await req.text()
  const signature = req.headers.get('x-paystack-signature')
 
  // Verify signature
  const hash = crypto
    .createHmac('sha512', process.env.PAYSTACK_WEBHOOK_SECRET!)
    .update(body)
    .digest('hex')
 
  if (hash !== signature) {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 })
  }
 
  const event = JSON.parse(body)
 
  switch (event.event) {
    case 'charge.success':
      await handleSuccessfulPayment(event.data)
      break
    case 'charge.failed':
      await handleFailedPayment(event.data)
      break
  }
 
  return NextResponse.json({ received: true })
}
 
async function handleSuccessfulPayment(data: any) {
  const { reference, metadata, channel, paid_at } = data
 
  // Update payment
  await prisma.payment.update({
    where: { paystackRef: reference },
    data: {
      status: 'COMPLETED',
      method: mapPaystackChannel(channel),
      paidAt: new Date(paid_at)
    }
  })
 
  // Update booking
  const booking = await prisma.booking.update({
    where: { id: metadata.bookingId },
    data: {
      status: 'CONFIRMED',
      confirmedAt: new Date()
    },
    include: { listing: true, user: true }
  })
 
  // Block dates
  await blockDates(booking.listingId, booking.checkIn, booking.checkOut)
 
  // Send email
  await sendBookingConfirmation(booking)
}

// lib/pricing.ts
const SERVICE_FEE_RATE = 0.10  // 10%
const TAX_RATE = 0.125         // 12.5% (VAT + Tourism Levy)
 
export function calculatePricing(input: {
  pricePerNight: number
  nights: number
  currency: 'GHS' | 'USD'
}) {
  const subtotal = input.pricePerNight * input.nights
  const serviceFee = Math.round(subtotal * SERVICE_FEE_RATE * 100) / 100
  const taxes = Math.round(subtotal * TAX_RATE * 100) / 100
  const total = Math.round((subtotal + serviceFee + taxes) * 100) / 100
 
  return {
    pricePerNight: input.pricePerNight,
    nights: input.nights,
    subtotal,
    serviceFee,
    taxes,
    total,
    currency: input.currency
  }
}

ngrok http 3000

https://abc123.ngrok.io/api/webhooks/paystack

// lib/refunds.ts
import Paystack from 'paystack-node'
 
const paystack = new Paystack(process.env.PAYSTACK_SECRET_KEY!)
 
export async function processRefund(bookingReference: string, reason: string) {
  const booking = await prisma.booking.findUnique({
    where: { reference: bookingReference },
    include: { payments: { where: { status: 'COMPLETED' } } }
  })
 
  const payment = booking.payments[0]
  if (!payment) throw new Error('No completed payment found')
 
  // Calculate refund amount based on policy
  const refundAmount = calculateRefundAmount(booking)
  if (refundAmount <= 0) {
    return { success: false, message: 'No refund applicable' }
  }
 
  // Process refund via Paystack
  const response = await paystack.refund.create({
    transaction: payment.paystackRef,
    amount: Math.round(refundAmount * 100) // pesewas
  })
 
  if (response.data.status === 'processed') {
    await prisma.payment.update({
      where: { id: payment.id },
      data: { status: 'REFUNDED' }
    })
 
    await prisma.booking.update({
      where: { id: booking.id },
      data: {
        status: 'CANCELLED',
        cancelledAt: new Date(),
        cancelReason: reason
      }
    })
 
    return { success: true, refundAmount }
  }
 
  return { success: false, message: response.data.message }
}