Comprehensive comparison for Authentication technology in Software Development applications

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

app.use(express.json());

// Jumio API Configuration
const JUMIO_API_TOKEN = process.env.JUMIO_API_TOKEN;
const JUMIO_API_SECRET = process.env.JUMIO_API_SECRET;
const JUMIO_BASE_URL = 'https://netverify.com/api/v4';

// Generate Basic Auth header for Jumio API
function getJumioAuthHeader() {
  const credentials = Buffer.from(`${JUMIO_API_TOKEN}:${JUMIO_API_SECRET}`).toString('base64');
  return `Basic ${credentials}`;
}

// Initiate identity verification session
app.post('/api/auth/verify-identity', async (req, res) => {
  try {
    const { userId, userEmail, successUrl, errorUrl } = req.body;

    // Validate required fields
    if (!userId || !userEmail) {
      return res.status(400).json({ error: 'Missing required fields: userId and userEmail' });
    }

    // Create verification session with Jumio
    const jumioResponse = await axios.post(
      `${JUMIO_BASE_URL}/initiate`,
      {
        customerInternalReference: userId,
        userReference: userEmail,
        callbackUrl: `${process.env.APP_BASE_URL}/api/webhooks/jumio`,
        successUrl: successUrl || `${process.env.APP_BASE_URL}/verification/success`,
        errorUrl: errorUrl || `${process.env.APP_BASE_URL}/verification/error`,
        workflowId: process.env.JUMIO_WORKFLOW_ID || 200,
        locale: 'en-US'
      },
      {
        headers: {
          'Authorization': getJumioAuthHeader(),
          'Content-Type': 'application/json',
          'User-Agent': 'MyApp/1.0'
        },
        timeout: 10000
      }
    );

    // Store session reference in database (pseudo-code)
    // await db.verificationSessions.create({
    //   userId: userId,
    //   jumioTransactionReference: jumioResponse.data.transactionReference,
    //   status: 'PENDING',
    //   createdAt: new Date()
    // });

    return res.status(200).json({
      success: true,
      redirectUrl: jumioResponse.data.redirectUrl,
      transactionReference: jumioResponse.data.transactionReference
    });

  } catch (error) {
    console.error('Jumio verification initiation failed:', error.response?.data || error.message);
    
    if (error.response?.status === 401) {
      return res.status(500).json({ error: 'Authentication failed with Jumio service' });
    }
    
    if (error.response?.status === 400) {
      return res.status(400).json({ error: 'Invalid verification request parameters' });
    }

    return res.status(500).json({ error: 'Identity verification service unavailable' });
  }
});

// Webhook endpoint to receive Jumio verification results
app.post('/api/webhooks/jumio', async (req, res) => {
  try {
    const payload = req.body;
    const signature = req.headers['x-jumio-signature'];

    // Verify webhook signature (recommended for production)
    const computedSignature = crypto
      .createHmac('sha256', JUMIO_API_SECRET)
      .update(JSON.stringify(payload))
      .digest('hex');

    if (signature !== computedSignature) {
      console.warn('Invalid Jumio webhook signature');
      return res.status(401).json({ error: 'Invalid signature' });
    }

    const { transactionReference, status, verificationStatus, identityVerification } = payload;

    // Update verification status in database
    // await db.verificationSessions.update(
    //   { jumioTransactionReference: transactionReference },
    //   { 
    //     status: status,
    //     verificationStatus: verificationStatus,
    //     verificationData: identityVerification,
    //     completedAt: new Date()
    //   }
    // );

    // Handle successful verification
    if (status === 'DONE' && verificationStatus === 'APPROVED_VERIFIED') {
      // Grant user access or update account status
      console.log(`User verification approved: ${transactionReference}`);
      // await updateUserVerificationStatus(payload.customerInternalReference, 'VERIFIED');
    }

    // Handle failed verification
    if (verificationStatus === 'DENIED_FRAUD' || verificationStatus === 'DENIED_UNSUPPORTED_ID_TYPE') {
      console.log(`User verification denied: ${transactionReference}`);
      // await notifyUserOfVerificationFailure(payload.customerInternalReference);
    }

    return res.status(200).json({ received: true });

  } catch (error) {
    console.error('Webhook processing error:', error);
    return res.status(500).json({ error: 'Webhook processing failed' });
  }
});

// Retrieve verification status
app.get('/api/auth/verify-identity/:transactionReference', async (req, res) => {
  try {
    const { transactionReference } = req.params;

    const jumioResponse = await axios.get(
      `${JUMIO_BASE_URL}/accounts/${transactionReference}`,
      {
        headers: {
          'Authorization': getJumioAuthHeader(),
          'User-Agent': 'MyApp/1.0'
        },
        timeout: 10000
      }
    );

    return res.status(200).json({
      transactionReference: jumioResponse.data.transactionReference,
      status: jumioResponse.data.status,
      verificationStatus: jumioResponse.data.verificationStatus
    });

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

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