Comprehensive comparison for Authentication technology in Software Development applications

const express = require('express');
const { Onfido, Region } = require('@onfido/api');
const jwt = require('jsonwebtoken');

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

// Initialize Onfido client with API token
const onfido = new Onfido({
  apiToken: process.env.ONFIDO_API_TOKEN,
  region: Region.EU
});

// Middleware to verify JWT token from authenticated user
const authenticateUser = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) {
    return res.status(401).json({ error: 'No authentication token provided' });
  }
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.userId = decoded.userId;
    next();
  } catch (error) {
    return res.status(401).json({ error: 'Invalid authentication token' });
  }
};

// Create Onfido applicant and generate SDK token for identity verification
app.post('/api/identity/initiate', authenticateUser, async (req, res) => {
  try {
    const { firstName, lastName, email } = req.body;
    
    // Validate required fields
    if (!firstName || !lastName || !email) {
      return res.status(400).json({ 
        error: 'Missing required fields: firstName, lastName, email' 
      });
    }

    // Create applicant in Onfido
    const applicant = await onfido.applicant.create({
      firstName,
      lastName,
      email
    });

    // Generate SDK token for frontend integration
    const sdkToken = await onfido.sdkToken.generate({
      applicantId: applicant.id,
      referrer: process.env.ALLOWED_REFERRER || '*://*/*'
    });

    // Store applicant ID with user record in your database
    // await db.users.update(req.userId, { onfidoApplicantId: applicant.id });

    res.json({
      applicantId: applicant.id,
      sdkToken: sdkToken.token
    });

  } catch (error) {
    console.error('Onfido applicant creation error:', error);
    res.status(500).json({ 
      error: 'Failed to initiate identity verification',
      message: error.message 
    });
  }
});

// Create check after user completes document upload
app.post('/api/identity/check', authenticateUser, async (req, res) => {
  try {
    const { applicantId } = req.body;
    
    if (!applicantId) {
      return res.status(400).json({ error: 'Applicant ID is required' });
    }

    // Create a check with document and facial similarity reports
    const check = await onfido.check.create({
      applicantId,
      reportNames: ['document', 'facial_similarity_photo'],
      asynchronous: true
    });

    res.json({
      checkId: check.id,
      status: check.status,
      result: check.result
    });

  } catch (error) {
    console.error('Onfido check creation error:', error);
    res.status(500).json({ 
      error: 'Failed to create identity check',
      message: error.message 
    });
  }
});

// Webhook endpoint to receive verification results
app.post('/webhooks/onfido', express.raw({ type: 'application/json' }), async (req, res) => {
  try {
    const signature = req.headers['x-sha2-signature'];
    
    // Verify webhook signature for security
    // const isValid = verifyWebhookSignature(req.body, signature, process.env.ONFIDO_WEBHOOK_TOKEN);
    // if (!isValid) return res.status(401).json({ error: 'Invalid signature' });

    const event = JSON.parse(req.body.toString());
    
    if (event.payload.resource_type === 'check' && event.payload.action === 'check.completed') {
      const checkId = event.payload.object.id;
      
      // Retrieve full check details
      const check = await onfido.check.find(checkId);
      
      // Update user verification status based on result
      if (check.result === 'clear') {
        // await db.users.update({ onfidoCheckId: checkId }, { verified: true });
        console.log(`User verification successful for check ${checkId}`);
      } else {
        console.log(`User verification failed for check ${checkId}: ${check.result}`);
      }
    }

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

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

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