Comprehensive comparison for API Integration technology in Software Development applications

const TokenIO = require('@token-io/tpp');
const express = require('express');
const app = express();

// Initialize Token.io client with credentials
const tokenClient = new TokenIO.TokenClient({
  env: 'production',
  developerKey: process.env.TOKEN_IO_DEVELOPER_KEY,
  keyDir: './keys'
});

let member;

// Initialize member on startup
async function initializeMember() {
  try {
    const alias = {
      type: 'DOMAIN',
      value: 'mycompany.com'
    };
    member = await tokenClient.createMember(alias);
    console.log('Member initialized:', member.memberId());
  } catch (error) {
    console.error('Failed to initialize member:', error);
    process.exit(1);
  }
}

app.use(express.json());

// Endpoint to create a payment token request
app.post('/api/payments/initiate', async (req, res) => {
  try {
    const { amount, currency, payeeAlias, description, redirectUrl } = req.body;

    // Validate required fields
    if (!amount || !currency || !payeeAlias) {
      return res.status(400).json({ error: 'Missing required fields' });
    }

    // Create token request for payment
    const tokenRequest = TokenIO.TokenRequest.create({
      transferDestinations: [{
        account: {
          token: {
            memberId: member.memberId(),
            accountId: process.env.ACCOUNT_ID
          }
        }
      }],
      amount: amount.toString(),
      currency: currency,
      description: description || 'Payment',
      callbackState: JSON.stringify({ orderId: req.body.orderId }),
      redirectUrl: redirectUrl || 'https://mycompany.com/payment/callback'
    });

    // Store token request
    const requestId = await member.storeTokenRequest(tokenRequest);

    // Generate authorization URL for customer
    const tokenRequestUrl = TokenIO.generateTokenRequestUrl(
      requestId,
      'production'
    );

    res.json({
      success: true,
      requestId: requestId,
      authorizationUrl: tokenRequestUrl,
      expiresAt: new Date(Date.now() + 3600000).toISOString()
    });

  } catch (error) {
    console.error('Payment initiation error:', error);
    res.status(500).json({
      error: 'Failed to initiate payment',
      message: error.message
    });
  }
});

// Endpoint to execute payment after token authorization
app.post('/api/payments/execute', async (req, res) => {
  try {
    const { tokenId } = req.body;

    if (!tokenId) {
      return res.status(400).json({ error: 'Token ID required' });
    }

    // Retrieve the token
    const token = await member.getToken(tokenId);

    // Create transfer using the token
    const transfer = await member.createTransfer({
      tokenId: tokenId,
      amount: token.payload.transfer.amount,
      currency: token.payload.transfer.currency,
      description: token.payload.description
    });

    res.json({
      success: true,
      transferId: transfer.id,
      status: transfer.status,
      amount: transfer.amount,
      currency: transfer.currency
    });

  } catch (error) {
    console.error('Payment execution error:', error);
    res.status(500).json({
      error: 'Failed to execute payment',
      message: error.message
    });
  }
});

// Endpoint to check transfer status
app.get('/api/payments/status/:transferId', async (req, res) => {
  try {
    const transfer = await member.getTransfer(req.params.transferId);
    
    res.json({
      transferId: transfer.id,
      status: transfer.status,
      amount: transfer.amount,
      currency: transfer.currency,
      createdAt: transfer.createdAtMs
    });

  } catch (error) {
    console.error('Status check error:', error);
    res.status(404).json({
      error: 'Transfer not found',
      message: error.message
    });
  }
});

// Start server after member initialization
initializeMember().then(() => {
  app.listen(3000, () => {
    console.log('Token.io payment API running on port 3000');
  });
});