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 API 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_SANDBOX === 'true' 
  ? 'https://sandbox.affirm.com/api/v2' 
  : 'https://api.affirm.com/api/v2';

// Helper function to create Basic Auth header
function getAuthHeader() {
  const credentials = Buffer.from(`${AFFIRM_PUBLIC_KEY}:${AFFIRM_PRIVATE_KEY}`).toString('base64');
  return `Basic ${credentials}`;
}

// Endpoint to create checkout session
app.post('/api/checkout/create', async (req, res) => {
  try {
    const { items, customer, shipping, billing } = req.body;

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

    // Calculate total amount in cents
    const totalAmount = items.reduce((sum, item) => sum + (item.unit_price * item.qty), 0);

    // Create checkout object for Affirm
    const checkoutData = {
      merchant: {
        user_confirmation_url: `${process.env.BASE_URL}/checkout/confirm`,
        user_cancel_url: `${process.env.BASE_URL}/checkout/cancel`,
        user_confirmation_url_action: 'POST'
      },
      shipping: {
        name: {
          first: shipping.first_name,
          last: shipping.last_name
        },
        address: {
          line1: shipping.address_line1,
          line2: shipping.address_line2 || '',
          city: shipping.city,
          state: shipping.state,
          zipcode: shipping.zipcode,
          country: shipping.country || 'USA'
        },
        phone_number: shipping.phone,
        email: customer.email
      },
      billing: billing || shipping,
      items: items.map(item => ({
        display_name: item.name,
        sku: item.sku,
        unit_price: item.unit_price,
        qty: item.qty,
        item_image_url: item.image_url,
        item_url: item.product_url
      })),
      discounts: req.body.discounts || {},
      metadata: {
        order_id: crypto.randomUUID(),
        platform: 'ecommerce-api'
      },
      order_id: crypto.randomUUID(),
      shipping_amount: req.body.shipping_amount || 0,
      tax_amount: req.body.tax_amount || 0,
      total: totalAmount
    };

    // Send checkout request to Affirm
    const response = await axios.post(
      `${AFFIRM_API_URL}/checkout`,
      checkoutData,
      {
        headers: {
          'Authorization': getAuthHeader(),
          'Content-Type': 'application/json'
        }
      }
    );

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

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

// Endpoint to authorize charge after customer confirms
app.post('/api/checkout/confirm', async (req, res) => {
  try {
    const { checkout_token } = req.body;

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

    // Authorize the charge
    const response = await axios.post(
      `${AFFIRM_API_URL}/charges`,
      { checkout_token },
      {
        headers: {
          'Authorization': getAuthHeader(),
          'Content-Type': 'application/json'
        }
      }
    );

    const chargeId = response.data.id;

    // Store charge ID in your database here
    // await db.orders.update({ checkout_token }, { affirm_charge_id: chargeId });

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

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

// Endpoint to capture an authorized charge
app.post('/api/charges/:chargeId/capture', async (req, res) => {
  try {
    const { chargeId } = req.params;
    const { order_id, shipping_carrier, shipping_confirmation } = req.body;

    const captureData = {
      order_id,
      shipping_carrier,
      shipping_confirmation
    };

    const response = await axios.post(
      `${AFFIRM_API_URL}/charges/${chargeId}/capture`,
      captureData,
      {
        headers: {
          'Authorization': getAuthHeader(),
          'Content-Type': 'application/json'
        }
      }
    );

    res.json({
      success: true,
      transaction_id: response.data.transaction_id,
      amount: response.data.amount
    });

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

// Endpoint to refund a charge
app.post('/api/charges/:chargeId/refund', async (req, res) => {
  try {
    const { chargeId } = req.params;
    const { amount } = req.body;

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

    const response = await axios.post(
      `${AFFIRM_API_URL}/charges/${chargeId}/refund`,
      refundData,
      {
        headers: {
          'Authorization': getAuthHeader(),
          'Content-Type': 'application/json'
        }
      }
    );

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

  } catch (error) {
    console.error('Affirm refund error:', error.response?.data || error.message);
    res.status(500).json({ 
      error: 'Failed to process 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}`);
});