Integration Guide

const express = require('express');
const router = express.Router();

const KYC_API_KEY = process.env.KYC_API_KEY;

router.post('/kyc/create-session', async (req, res) => {
  const { type } = req.body; // 'individual' or 'business'

  const endpoint = type === 'business' ? 'business' : 'individual';
  const url = `https://api.kyc.predicate.io/api/v1/register/${endpoint}`;

  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${KYC_API_KEY}`
      }
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message || `API error: ${response.status}`);
    }

    const data = await response.json();
    res.json(data);
  } catch (error) {
    console.error('Session creation error:', error);
    res.status(500).json({ error: 'Failed to create verification session' });
  }
});

module.exports = router;

router.get('/kyc/stream/:type/:sessionId', async (req, res) => {
  const { type, sessionId } = req.params;

  if (type !== 'individual' && type !== 'business') {
    return res.status(400).json({ error: 'Type must be individual or business' });
  }

  // Validate UUID format
  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
  if (!uuidRegex.test(sessionId)) {
    return res.status(400).json({ error: 'Invalid session ID format' });
  }

  // Set SSE headers
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');
  res.setHeader('X-Accel-Buffering', 'no');

  const kycUrl = `https://api.kyc.predicate.io/api/v1/status/realtime/${type}/${sessionId}`;

  try {
    const response = await fetch(kycUrl, {
      headers: { 'Authorization': `Bearer ${KYC_API_KEY}` }
    });

    if (!response.ok) {
      throw new Error(`KYC API error: ${response.status}`);
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();

    req.on('close', () => reader.cancel());

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      res.write(decoder.decode(value, { stream: true }));
    }
  } catch (error) {
    console.error('SSE streaming error:', error);
    res.write(`event: error\ndata: ${JSON.stringify({ error: 'Stream failed' })}\n\n`);
  }
});

class VerificationMonitor {
  constructor(sessionId, type) {
    this.sessionId = sessionId;
    this.type = type;
    this.eventSource = null;
  }

  start(onStatusUpdate, onError) {
    // Connect to YOUR backend, not directly to KYC API
    const url = `/kyc/stream/${this.type}/${this.sessionId}`;
    this.eventSource = new EventSource(url);

    this.eventSource.onmessage = (event) => {
      const status = JSON.parse(event.data);
      onStatusUpdate(status);

      if (status.status === 'completed' || status.status === 'failed') {
        this.stop();
      }
    };

    this.eventSource.onerror = () => {
      onError('Connection lost');
      this.stop();
    };
  }

  stop() {
    if (this.eventSource) {
      this.eventSource.close();
      this.eventSource = null;
    }
  }
}

function startMonitoring(sessionId, type) {
  const monitor = new VerificationMonitor(sessionId, type);
  monitor.start(
    (status) => updateVerificationUI(status),
    (error) => console.error('Monitoring error:', error)
  );
  return monitor;
}

router.get('/kyc/status/:type/:sessionId', async (req, res) => {
  const { type, sessionId } = req.params;

  if (type !== 'individual' && type !== 'business') {
    return res.status(400).json({ error: 'Type must be individual or business' });
  }

  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
  if (!uuidRegex.test(sessionId)) {
    return res.status(400).json({ error: 'Invalid session ID format' });
  }

  const kycUrl = `https://api.kyc.predicate.io/api/v1/status/${type}/${sessionId}`;

  try {
    const response = await fetch(kycUrl, {
      headers: { 'Authorization': `Bearer ${KYC_API_KEY}` }
    });

    if (!response.ok) {
      throw new Error(`KYC API error: ${response.status}`);
    }

    const data = await response.json();
    res.json(data);
  } catch (error) {
    console.error('Status check error:', error);
    res.status(500).json({ error: 'Failed to check verification status' });
  }
});

class VerificationPoller {
  constructor(sessionId, type, interval = 3000) {
    this.sessionId = sessionId;
    this.type = type;
    this.interval = interval;
    this.isPolling = false;
  }

  start(onStatusUpdate, onError) {
    this.onStatusUpdate = onStatusUpdate;
    this.onError = onError;
    this.isPolling = true;
    this.poll();
  }

  async poll() {
    if (!this.isPolling) return;

    try {
      const response = await fetch(`/kyc/status/${this.type}/${this.sessionId}`);
      const status = await response.json();
      this.onStatusUpdate(status);

      if (status.status === 'completed' || status.status === 'failed') {
        this.stop();
        return;
      }

      this.pollTimer = setTimeout(() => this.poll(), this.interval);
    } catch (error) {
      this.onError(error);
      this.pollTimer = setTimeout(() => this.poll(), this.interval);
    }
  }

  stop() {
    this.isPolling = false;
    if (this.pollTimer) clearTimeout(this.pollTimer);
  }
}