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' 
  : 'https://sandbox.affirm.com';

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

    // Validate required fields
    if (!items || !customer || !shippingAddress) {
      return res.status(400).json({ error: 'Missing required 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}/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_url: item.url,
        item_image_url: item.image_url
      })),
      shipping: {
        name: {
          first: shippingAddress.firstName,
          last: shippingAddress.lastName
        },
        address: {
          line1: shippingAddress.line1,
          line2: shippingAddress.line2 || '',
          city: shippingAddress.city,
          state: shippingAddress.state,
          zipcode: shippingAddress.zipcode,
          country: shippingAddress.country || 'USA'
        },
        phone_number: shippingAddress.phone,
        email: customer.email
      },
      billing: billingAddress || shippingAddress,
      discounts: {},
      metadata: {
        order_id: crypto.randomUUID(),
        customer_id: customer.id
      },
      order_id: crypto.randomUUID(),
      shipping_amount: req.body.shippingAmount || 0,
      tax_amount: req.body.taxAmount || 0,
      total: totalAmount
    };

    // Send checkout request to Affirm
    const response = await axios.post(
      `${AFFIRM_API_URL}/api/v2/checkout`,
      checkoutData,
      {
        auth: {
          username: AFFIRM_PUBLIC_KEY,
          password: AFFIRM_PRIVATE_KEY
        },
        headers: {
          'Content-Type': 'application/json'
        }
      }
    );

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

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

// Confirm Affirm payment
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 with Affirm
    const response = await axios.post(
      `${AFFIRM_API_URL}/api/v2/charges`,
      { checkout_token },
      {
        auth: {
          username: AFFIRM_PUBLIC_KEY,
          password: AFFIRM_PRIVATE_KEY
        },
        headers: {
          'Content-Type': 'application/json'
        }
      }
    );

    const chargeId = response.data.id;
    const transactionId = response.data.transaction_id;

    // Store charge information in database
    // await saveChargeToDatabase({ chargeId, transactionId, ...response.data });

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

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

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

    const captureData = {
      ...(amount && { amount }),
      order_id,
      shipping_carrier,
      shipping_confirmation
    };

    const response = await axios.post(
      `${AFFIRM_API_URL}/api/v2/charges/${chargeId}/capture`,
      captureData,
      {
        auth: {
          username: AFFIRM_PUBLIC_KEY,
          password: AFFIRM_PRIVATE_KEY
        }
      }
    );

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

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

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

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

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

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

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