Comprehensive comparison for Backend technology in Fintech applications

const express = require('express');
const router = express.Router();
const { body, validationResult } = require('express-validator');
const crypto = require('crypto');

// Mock database and services (replace with actual implementations)
const db = require('../database');
const paymentGateway = require('../services/paymentGateway');
const auditLogger = require('../services/auditLogger');

// Middleware for authentication
const authenticateUser = async (req, res, next) => {
  try {
    const token = req.headers.authorization?.split(' ')[1];
    if (!token) {
      return res.status(401).json({ error: 'Authentication required' });
    }
    // Verify JWT token (simplified)
    req.user = await verifyToken(token);
    next();
  } catch (error) {
    return res.status(401).json({ error: 'Invalid authentication token' });
  }
};

// POST /api/v1/transactions/transfer - Initiate money transfer
router.post(
  '/transfer',
  authenticateUser,
  [
    body('amount').isFloat({ min: 0.01, max: 1000000 }).withMessage('Invalid amount'),
    body('currency').isIn(['USD', 'EUR', 'GBP']).withMessage('Unsupported currency'),
    body('recipientAccountId').isUUID().withMessage('Invalid recipient account ID'),
    body('description').optional().isString().trim().isLength({ max: 200 })
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { amount, currency, recipientAccountId, description } = req.body;
    const transactionId = crypto.randomUUID();
    const idempotencyKey = req.headers['idempotency-key'];

    try {
      // Check for duplicate transaction using idempotency key
      if (idempotencyKey) {
        const existingTx = await db.findTransactionByIdempotencyKey(idempotencyKey);
        if (existingTx) {
          return res.status(200).json(existingTx);
        }
      }

      // Start database transaction
      await db.beginTransaction();

      // Verify sender has sufficient balance
      const senderAccount = await db.getAccountById(req.user.accountId);
      if (senderAccount.balance < amount) {
        await db.rollback();
        return res.status(400).json({ error: 'Insufficient funds' });
      }

      // Verify recipient account exists
      const recipientAccount = await db.getAccountById(recipientAccountId);
      if (!recipientAccount) {
        await db.rollback();
        return res.status(404).json({ error: 'Recipient account not found' });
      }

      // Debit sender account
      await db.updateAccountBalance(req.user.accountId, -amount);

      // Credit recipient account
      await db.updateAccountBalance(recipientAccountId, amount);

      // Create transaction record
      const transaction = await db.createTransaction({
        id: transactionId,
        senderId: req.user.accountId,
        recipientId: recipientAccountId,
        amount,
        currency,
        description,
        status: 'completed',
        idempotencyKey,
        createdAt: new Date()
      });

      // Commit database transaction
      await db.commit();

      // Log audit trail
      await auditLogger.log({
        action: 'TRANSFER',
        userId: req.user.id,
        transactionId,
        amount,
        currency,
        timestamp: new Date()
      });

      // Return success response
      res.status(201).json({
        transactionId,
        status: 'completed',
        amount,
        currency,
        recipientAccountId,
        timestamp: transaction.createdAt
      });

    } catch (error) {
      await db.rollback();
      console.error('Transfer error:', error);

      // Log error for monitoring
      await auditLogger.logError({
        action: 'TRANSFER_FAILED',
        userId: req.user.id,
        error: error.message,
        timestamp: new Date()
      });

      res.status(500).json({ error: 'Transaction failed. Please try again.' });
    }
  }
);

module.exports = router;