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 Basic Auth header for Affirm API
const getAffirmAuthHeader = () => {
  const credentials = Buffer.from(`${AFFIRM_PUBLIC_KEY}:${AFFIRM_PRIVATE_KEY}`).toString('base64');
  return `Basic ${credentials}`;
};

// Endpoint to create an Affirm checkout
app.post('/api/checkout/create', async (req, res) => {
  try {
    const { items, shippingAddress, billingAddress, metadata } = req.body;

    // Validate required fields
    if (!items || !Array.isArray(items) || items.length === 0) {
      return res.status(400).json({ error: 'Items array is required' });
    }

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

    // Construct Affirm checkout payload
    const checkoutPayload = {
      merchant: {
        user_confirmation_url: `${process.env.BASE_URL}/api/checkout/confirm`,
        user_cancel_url: `${process.env.BASE_URL}/checkout/cancel`,
        user_confirmation_url_action: 'POST'
      },
      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
      })),
      shipping: shippingAddress,
      billing: billingAddress,
      total: totalAmount,
      metadata: {
        order_id: metadata?.order_id || crypto.randomUUID(),
        customer_id: metadata?.customer_id
      }
    };

    // Create checkout with Affirm
    const affirmResponse = await axios.post(
      `${AFFIRM_API_URL}/checkout`,
      checkoutPayload,
      {
        headers: {
          'Authorization': getAffirmAuthHeader(),
          'Content-Type': 'application/json'
        }
      }
    );

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

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

// Endpoint to authorize and capture payment
app.post('/api/checkout/confirm', async (req, res) => {
  try {
    const { checkout_token } = req.body;

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

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

    const chargeId = authorizeResponse.data.id;
    const amount = authorizeResponse.data.amount;

    // Capture the charge immediately (or later for delayed capture)
    const captureResponse = await axios.post(
      `${AFFIRM_API_URL}/charges/${chargeId}/capture`,
      {},
      {
        headers: {
          'Authorization': getAffirmAuthHeader(),
          'Content-Type': 'application/json'
        }
      }
    );

    // Store transaction in database (pseudo-code)
    // await db.transactions.create({
    //   charge_id: chargeId,
    //   amount: amount,
    //   status: 'captured',
    //   created_at: new Date()
    // });

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

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

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

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

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

  } catch (error) {
    console.error('Affirm refund error:', error.response?.data || error.message);
    res.status(error.response?.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(`Server running on port ${PORT}`));