Comprehensive comparison for API Integration technology in Software Development applications

const axios = require('axios');
const crypto = require('crypto');

/**
 * Finicity API Integration Service
 * Handles customer account aggregation and financial data retrieval
 */
class FinicityService {
  constructor(partnerId, partnerSecret, appKey) {
    this.partnerId = partnerId;
    this.partnerSecret = partnerSecret;
    this.appKey = appKey;
    this.baseURL = 'https://api.finicity.com';
    this.token = null;
    this.tokenExpiry = null;
  }

  /**
   * Authenticate and get access token
   */
  async authenticate() {
    try {
      if (this.token && this.tokenExpiry && Date.now() < this.tokenExpiry) {
        return this.token;
      }

      const response = await axios.post(
        `${this.baseURL}/aggregation/v2/partners/authentication`,
        {
          partnerId: this.partnerId,
          partnerSecret: this.partnerSecret
        },
        {
          headers: {
            'Finicity-App-Key': this.appKey,
            'Content-Type': 'application/json'
          }
        }
      );

      this.token = response.data.token;
      this.tokenExpiry = Date.now() + (90 * 60 * 1000); // 90 minutes
      return this.token;
    } catch (error) {
      throw new Error(`Authentication failed: ${error.response?.data?.message || error.message}`);
    }
  }

  /**
   * Create a new customer in Finicity
   */
  async createCustomer(username, firstName, lastName) {
    try {
      const token = await this.authenticate();
      
      const response = await axios.post(
        `${this.baseURL}/aggregation/v2/customers/active`,
        {
          username: username,
          firstName: firstName,
          lastName: lastName
        },
        {
          headers: {
            'Finicity-App-Key': this.appKey,
            'Finicity-App-Token': token,
            'Content-Type': 'application/json'
          }
        }
      );

      return {
        customerId: response.data.id,
        username: response.data.username,
        createdDate: response.data.createdDate
      };
    } catch (error) {
      if (error.response?.status === 409) {
        throw new Error('Customer already exists');
      }
      throw new Error(`Failed to create customer: ${error.response?.data?.message || error.message}`);
    }
  }

  /**
   * Get all accounts for a customer
   */
  async getCustomerAccounts(customerId) {
    try {
      const token = await this.authenticate();
      
      const response = await axios.get(
        `${this.baseURL}/aggregation/v1/customers/${customerId}/accounts`,
        {
          headers: {
            'Finicity-App-Key': this.appKey,
            'Finicity-App-Token': token,
            'Accept': 'application/json'
          }
        }
      );

      return response.data.accounts.map(account => ({
        id: account.id,
        number: account.number,
        name: account.name,
        balance: account.balance,
        type: account.type,
        status: account.status,
        institutionId: account.institutionId
      }));
    } catch (error) {
      if (error.response?.status === 404) {
        throw new Error('Customer not found');
      }
      throw new Error(`Failed to retrieve accounts: ${error.response?.data?.message || error.message}`);
    }
  }

  /**
   * Generate Connect URL for account linking
   */
  async generateConnectUrl(customerId, redirectUri, webhookUrl) {
    try {
      const token = await this.authenticate();
      
      const response = await axios.post(
        `${this.baseURL}/connect/v2/generate`,
        {
          partnerId: this.partnerId,
          customerId: customerId,
          redirectUri: redirectUri,
          webhook: webhookUrl,
          webhookContentType: 'application/json',
          experience: 'default'
        },
        {
          headers: {
            'Finicity-App-Key': this.appKey,
            'Finicity-App-Token': token,
            'Content-Type': 'application/json'
          }
        }
      );

      return {
        link: response.data.link,
        sessionId: response.data.sessionId
      };
    } catch (error) {
      throw new Error(`Failed to generate Connect URL: ${error.response?.data?.message || error.message}`);
    }
  }

  /**
   * Refresh customer accounts data
   */
  async refreshAccounts(customerId) {
    try {
      const token = await this.authenticate();
      
      const response = await axios.post(
        `${this.baseURL}/aggregation/v1/customers/${customerId}/accounts`,
        {},
        {
          headers: {
            'Finicity-App-Key': this.appKey,
            'Finicity-App-Token': token,
            'Content-Type': 'application/json'
          }
        }
      );

      return {
        success: true,
        accountsDiscovered: response.data.accounts?.length || 0
      };
    } catch (error) {
      throw new Error(`Failed to refresh accounts: ${error.response?.data?.message || error.message}`);
    }
  }
}

// Example usage
const finicityService = new FinicityService(
  process.env.FINICITY_PARTNER_ID,
  process.env.FINICITY_PARTNER_SECRET,
  process.env.FINICITY_APP_KEY
);

// Express route example
const express = require('express');
const router = express.Router();

router.post('/api/customers/:customerId/connect', async (req, res) => {
  try {
    const { customerId } = req.params;
    const { redirectUri, webhookUrl } = req.body;

    const connectData = await finicityService.generateConnectUrl(
      customerId,
      redirectUri,
      webhookUrl
    );

    res.json({
      success: true,
      data: connectData
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

router.get('/api/customers/:customerId/accounts', async (req, res) => {
  try {
    const { customerId } = req.params;
    const accounts = await finicityService.getCustomerAccounts(customerId);

    res.json({
      success: true,
      data: accounts
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

module.exports = { FinicityService, router };