Comprehensive comparison for API Integration technology in Software Development applications

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

// Belvo API Configuration
const BELVO_API_URL = 'https://sandbox.belvo.com';
const BELVO_SECRET_ID = process.env.BELVO_SECRET_ID;
const BELVO_SECRET_PASSWORD = process.env.BELVO_SECRET_PASSWORD;

// Create Belvo API client with basic auth
const belvoClient = axios.create({
  baseURL: BELVO_API_URL,
  auth: {
    username: BELVO_SECRET_ID,
    password: BELVO_SECRET_PASSWORD
  },
  headers: {
    'Content-Type': 'application/json'
  }
});

app.use(express.json());

// Endpoint to register a new bank link for a user
app.post('/api/v1/users/:userId/bank-links', async (req, res) => {
  const { userId } = req.params;
  const { institution, username, password, token } = req.body;

  try {
    // Validate required fields
    if (!institution || !username || !password) {
      return res.status(400).json({
        error: 'Missing required fields: institution, username, password'
      });
    }

    // Register link with Belvo
    const linkResponse = await belvoClient.post('/api/links/', {
      institution,
      username,
      password,
      token,
      external_id: userId
    });

    const linkId = linkResponse.data.id;

    // Fetch accounts for the newly created link
    const accountsResponse = await belvoClient.post('/api/accounts/', {
      link: linkId,
      save_data: true
    });

    // Fetch recent transactions
    const transactionsResponse = await belvoClient.post('/api/transactions/', {
      link: linkId,
      date_from: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
      date_to: new Date().toISOString().split('T')[0],
      save_data: true
    });

    return res.status(201).json({
      success: true,
      data: {
        linkId: linkId,
        accounts: accountsResponse.data,
        transactions: transactionsResponse.data,
        message: 'Bank link created successfully'
      }
    });

  } catch (error) {
    console.error('Belvo API Error:', error.response?.data || error.message);

    // Handle specific Belvo error codes
    if (error.response?.status === 401) {
      return res.status(401).json({
        error: 'Invalid credentials provided for bank institution'
      });
    }

    if (error.response?.status === 428) {
      return res.status(428).json({
        error: 'MFA token required',
        session: error.response.data.session,
        token_generation: error.response.data.token_generation
      });
    }

    if (error.response?.status === 500) {
      return res.status(502).json({
        error: 'Bank institution temporarily unavailable'
      });
    }

    return res.status(500).json({
      error: 'Failed to create bank link',
      details: error.response?.data?.detail || error.message
    });
  }
});

// Endpoint to retrieve account balances
app.get('/api/v1/users/:userId/balances', async (req, res) => {
  const { userId } = req.params;

  try {
    // Retrieve all links for user
    const linksResponse = await belvoClient.get('/api/links/', {
      params: { external_id: userId }
    });

    if (linksResponse.data.results.length === 0) {
      return res.status(404).json({
        error: 'No bank links found for this user'
      });
    }

    // Fetch balances for all accounts
    const balancePromises = linksResponse.data.results.map(link =>
      belvoClient.post('/api/balances/', {
        link: link.id,
        save_data: true
      }).catch(err => ({ error: err.message, linkId: link.id }))
    );

    const balances = await Promise.all(balancePromises);

    return res.status(200).json({
      success: true,
      data: balances.map(b => b.data || b)
    });

  } catch (error) {
    console.error('Error fetching balances:', error.response?.data || error.message);
    return res.status(500).json({
      error: 'Failed to retrieve balances'
    });
  }
});

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