PayPal Services & Payment Gateway Engineering

import { Client, Environment, OrdersController } from '@paypal/paypal-server-sdk';
const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: process.env.PAYPAL_CLIENT_ID!,
    oAuthClientSecret: process.env.PAYPAL_CLIENT_SECRET!,
  },
  environment: Environment.Production,
});
export async function createHostingOrder(planId: string, domain: string, amount: number) {
  const ordersController = new OrdersController(client);
  const idempotencyKey = `order_${domain}_${Date.now()}`;
  const response = await ordersController.createOrder({
    paypalRequestId: idempotencyKey,
    body: {
      intent: 'CAPTURE',
      purchaseUnits: [
        {
          referenceId: `host_${domain}`,
          description: `Unlimited Web Hosting Plan (${planId}) for ${domain}`,
          amount: {
            currencyCode: 'USD',
            value: amount.toFixed(2),
          },
        },
      ],
      applicationContext: {
        brandName: 'WinWinHost',
        landingPage: 'NO_PREFERENCE',
        userAction: 'PAY_NOW',
        returnUrl: 'https://winwinhost.com/checkout/success',
        cancelUrl: 'https://winwinhost.com/checkout/cancel',
      },
    },
  });
  return response.result;
}

import { OrdersController } from '@paypal/paypal-server-sdk';
import { db } from '../../utils/db';
export async function captureHostingOrder(orderId: string) {
  const ordersController = new OrdersController(client);
  // 1. Authorize & Capture payment from PayPal
  const { result } = await ordersController.captureOrder({
    id: orderId,
    prefer: 'return=representation',
  });
  if (result.status === 'COMPLETED') {
    const capture = result.purchaseUnits?.[0]?.payments?.captures?.[0];
    // 2. Provision hosting environment in MongoDB
    await db.collection('orders').insertOne({
      orderId: result.id,
      captureId: capture?.id,
      amount: capture?.amount?.value,
      currency: capture?.amount?.currencyCode,
      status: 'PAID',
      provisioned: true,
      paidAt: new Date(),
    });
    return { success: true, transactionId: capture?.id };
  }
  throw new Error(`Payment capture failed with status: ${result.status}`);
}

import express from 'express';
import crypto from 'crypto';
import { provisionHostingServer } from '../../services/hostingProvisioner';
export const paypalWebhookRouter = express.Router();
paypalWebhookRouter.post('/api/webhooks/paypal', async (req, res) => {
  const webhookEvent = req.body;
  const eventType = webhookEvent.event_type;
  // 1. Verify PayPal Cryptographic Signature
  const isValid = await verifyPayPalSignature(req);
  if (!isValid) {
    return res.status(401).json({ error: 'Invalid Webhook Signature' });
  }
  // 2. Handle specific subscription & checkout lifecycles
  switch (eventType) {
    case 'PAYMENT.CAPTURE.COMPLETED':
      await handleCaptureCompleted(webhookEvent.resource);
      break;
    case 'BILLING.SUBSCRIPTION.ACTIVATED':
      await provisionHostingServer(webhookEvent.resource.custom_id);
      break;
    case 'BILLING.SUBSCRIPTION.CANCELLED':
      await handleSubscriptionSuspension(webhookEvent.resource.id);
      break;
    default:
      console.log(`[PayPal Webhook] Unhandled event: ${eventType}`);
  }
  return res.status(200).json({ received: true });
});