Comprehensive comparison for technology in applications

const express = require('express');
const { Configuration, PlaidApi, PlaidEnvironments, Products, CountryCode } = require('plaid');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

// Initialize Plaid client
const configuration = new Configuration({
  basePath: PlaidEnvironments.sandbox,
  baseOptions: {
    headers: {
      'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
      'PLAID-SECRET': process.env.PLAID_SECRET,
    },
  },
});

const plaidClient = new PlaidApi(configuration);

// Create Link Token endpoint
app.post('/api/create_link_token', async (req, res) => {
  try {
    const { userId } = req.body;
    
    if (!userId) {
      return res.status(400).json({ error: 'userId is required' });
    }

    const request = {
      user: {
        client_user_id: userId,
      },
      client_name: 'My Financial App',
      products: [Products.Transactions, Products.Auth],
      country_codes: [CountryCode.Us],
      language: 'en',
    };

    const response = await plaidClient.linkTokenCreate(request);
    res.json({ link_token: response.data.link_token });
  } catch (error) {
    console.error('Error creating link token:', error.response?.data || error.message);
    res.status(500).json({ error: 'Failed to create link token' });
  }
});

// Exchange public token for access token
app.post('/api/exchange_public_token', async (req, res) => {
  try {
    const { public_token, userId } = req.body;

    if (!public_token || !userId) {
      return res.status(400).json({ error: 'public_token and userId are required' });
    }

    const response = await plaidClient.itemPublicTokenExchange({
      public_token: public_token,
    });

    const accessToken = response.data.access_token;
    const itemId = response.data.item_id;

    // Store accessToken securely in your database associated with userId
    // await db.storeAccessToken(userId, accessToken, itemId);

    res.json({ success: true, item_id: itemId });
  } catch (error) {
    console.error('Error exchanging public token:', error.response?.data || error.message);
    res.status(500).json({ error: 'Failed to exchange public token' });
  }
});

// Get transactions endpoint
app.post('/api/transactions', async (req, res) => {
  try {
    const { accessToken, startDate, endDate } = req.body;

    if (!accessToken || !startDate || !endDate) {
      return res.status(400).json({ error: 'accessToken, startDate, and endDate are required' });
    }

    const request = {
      access_token: accessToken,
      start_date: startDate,
      end_date: endDate,
      options: {
        count: 100,
        offset: 0,
      },
    };

    const response = await plaidClient.transactionsGet(request);
    const transactions = response.data.transactions;
    const accounts = response.data.accounts;

    res.json({
      transactions: transactions,
      accounts: accounts,
      total_transactions: response.data.total_transactions,
    });
  } catch (error) {
    console.error('Error fetching transactions:', error.response?.data || error.message);
    
    if (error.response?.data?.error_code === 'ITEM_LOGIN_REQUIRED') {
      return res.status(401).json({ error: 'User needs to reconnect their account' });
    }
    
    res.status(500).json({ error: 'Failed to fetch transactions' });
  }
});

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