Comprehensive comparison for Payment Processing technology in Software Development applications

const express = require('express');
const axios = require('axios');
const crypto = require('crypto');

const app = express();
app.use(express.json());

// Affirm Configuration
const AFFIRM_PUBLIC_KEY = process.env.AFFIRM_PUBLIC_KEY;
const AFFIRM_PRIVATE_KEY = process.env.AFFIRM_PRIVATE_KEY;
const AFFIRM_API_URL = process.env.AFFIRM_ENV === 'production' 
  ? 'https://api.affirm.com/api/v2'
  : 'https://sandbox.affirm.com/api/v2';

// Create Affirm checkout session
app.post('/api/checkout/affirm/create', async (req, res) => {
  try {
    const { cartItems, customer, shippingAddress, billingAddress } = req.body;

    // Validate required fields
    if (!cartItems || !customer || !shippingAddress) {
      return res.status(400).json({ error: 'Missing required checkout data' });
    }

    // Calculate total amount in cents
    const totalAmount = cartItems.reduce((sum, item) => {
      return sum + (item.price * item.quantity);
    }, 0);

    // Build Affirm checkout payload
    const checkoutPayload = {
      merchant: {
        user_confirmation_url: `${process.env.BASE_URL}/checkout/confirm`,
        user_cancel_url: `${process.env.BASE_URL}/checkout/cancel`,
        user_confirmation_url_action: 'POST'
      },
      items: cartItems.map(item => ({
        display_name: item.name,
        sku: item.sku,
        unit_price: item.price,
        qty: item.quantity,
        item_image_url: item.imageUrl,
        item_url: `${process.env.BASE_URL}/products/${item.id}`
      })),
      billing: {
        name: {
          first: billingAddress.firstName,
          last: billingAddress.lastName
        },
        address: {
          line1: billingAddress.street,
          line2: billingAddress.apartment || '',
          city: billingAddress.city,
          state: billingAddress.state,
          zipcode: billingAddress.zipCode,
          country: billingAddress.country || 'USA'
        },
        phone_number: customer.phone,
        email: customer.email
      },
      shipping: {
        name: {
          first: shippingAddress.firstName,
          last: shippingAddress.lastName
        },
        address: {
          line1: shippingAddress.street,
          line2: shippingAddress.apartment || '',
          city: shippingAddress.city,
          state: shippingAddress.state,
          zipcode: shippingAddress.zipCode,
          country: shippingAddress.country || 'USA'
        },
        phone_number: customer.phone,
        email: customer.email
      },
      currency: 'USD',
      tax_amount: Math.round(totalAmount * 0.08),
      shipping_amount: 0,
      total: totalAmount,
      metadata: {
        order_id: crypto.randomUUID(),
        platform: 'web'
      }
    };

    // Create checkout with Affirm API
    const response = await axios.post(
      `${AFFIRM_API_URL}/checkout`,
      checkoutPayload,
      {
        auth: {
          username: AFFIRM_PUBLIC_KEY,
          password: AFFIRM_PRIVATE_KEY
        },
        headers: {
          'Content-Type': 'application/json'
        }
      }
    );

    return res.json({
      checkout_token: response.data.checkout_token,
      redirect_url: response.data.redirect_url
    });

  } catch (error) {
    console.error('Affirm checkout creation failed:', error.response?.data || error.message);
    return res.status(500).json({
      error: 'Failed to create Affirm checkout',
      details: error.response?.data?.message || error.message
    });
  }
});

// Authorize and capture Affirm charge
app.post('/api/checkout/affirm/authorize', async (req, res) => {
  try {
    const { checkout_token, order_id } = req.body;

    if (!checkout_token) {
      return res.status(400).json({ error: 'Missing checkout_token' });
    }

    // Authorize the charge
    const authResponse = await axios.post(
      `${AFFIRM_API_URL}/charges`,
      { checkout_token },
      {
        auth: {
          username: AFFIRM_PUBLIC_KEY,
          password: AFFIRM_PRIVATE_KEY
        }
      }
    );

    const chargeId = authResponse.data.id;

    // Immediately capture the charge
    const captureResponse = await axios.post(
      `${AFFIRM_API_URL}/charges/${chargeId}/capture`,
      {
        order_id: order_id,
        shipping_carrier: 'USPS',
        shipping_confirmation: null
      },
      {
        auth: {
          username: AFFIRM_PUBLIC_KEY,
          password: AFFIRM_PRIVATE_KEY
        }
      }
    );

    return res.json({
      success: true,
      charge_id: chargeId,
      amount: captureResponse.data.amount,
      status: captureResponse.data.status
    });

  } catch (error) {
    console.error('Affirm authorization failed:', error.response?.data || error.message);
    return res.status(500).json({
      error: 'Failed to authorize Affirm payment',
      details: error.response?.data?.message || error.message
    });
  }
});

// Refund Affirm charge
app.post('/api/checkout/affirm/refund', async (req, res) => {
  try {
    const { charge_id, amount } = req.body;

    if (!charge_id) {
      return res.status(400).json({ error: 'Missing charge_id' });
    }

    const refundPayload = amount ? { amount } : {};

    const response = await axios.post(
      `${AFFIRM_API_URL}/charges/${charge_id}/refund`,
      refundPayload,
      {
        auth: {
          username: AFFIRM_PUBLIC_KEY,
          password: AFFIRM_PRIVATE_KEY
        }
      }
    );

    return res.json({
      success: true,
      refund_id: response.data.id,
      amount: response.data.amount
    });

  } catch (error) {
    console.error('Affirm refund failed:', error.response?.data || error.message);
    return res.status(500).json({
      error: 'Failed to process Affirm refund',
      details: error.response?.data?.message || error.message
    });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Affirm payment server running on port ${PORT}`);
});