Traiter les webhooks

import express from 'express';
import crypto from 'crypto';

const app = express();

// Définir la fonction de traitement du webhook
async function handleWebhook(req: express.Request, res: express.Response) {
  const LOMI_WEBHOOK_SECRET = process.env.LOMI_WEBHOOK_SECRET;
  if (!LOMI_WEBHOOK_SECRET) {
    console.error('Webhook secret is not configured.');
    return res.status(500).send('Webhook configuration error');
  }

  // Vérifier la signature (implémentation ci-dessous)
  const signature = req.headers['x-lomi-signature'] as string;
  if (
    !signature ||
    !verifySignature(req.body, signature, LOMI_WEBHOOK_SECRET)
  ) {
    return res.status(400).send('Invalid signature');
  }

  // Répondre rapidement pour accuser réception
  res.status(200).json({ received: true });

  // Traiter l’événement de manière asynchrone
  const event = JSON.parse(req.body.toString());
  try {
    await processWebhookEvent(event);
  } catch (error) {
    console.error('Error processing webhook event:', error);
    // Journaliser l’erreur sans faire échouer la réponse à lomi.
  }
}

// Utiliser express.raw() pour accéder au corps brut (vérification de signature)
app.post(
  '/your-webhook-endpoint',
  express.raw({ type: 'application/json' }),
  handleWebhook,
);

// Fonction de vérification de signature (voir ci-dessous)
function verifySignature(
  payload: Buffer,
  signature: string,
  secret: string,
): boolean {
  // ... implementation ...
  return true; // Placeholder
}

// Logique de traitement de l’événement
async function processWebhookEvent(event: any): Promise<void> {
  console.log(`Processing event: ${event.id}, Type: ${event.event}`);
  // Ajouter votre logique métier selon event.event
}

// Démarrer le serveur...

import crypto from 'crypto';

function verifySignature(
  payload: Buffer, // Corps brut (Buffer)
  signatureHeader: string,
  secret: string,
): boolean {
  if (!payload || !signatureHeader || !secret) {
    return false;
  }

  try {
    const hmac = crypto
      .createHmac('sha256', secret)
      .update(payload)
      .digest('hex');

    // Comparaison à temps constant
    return crypto.timingSafeEqual(
      Buffer.from(signatureHeader),
      Buffer.from(hmac),
    );
  } catch (error) {
    console.error('Error during signature verification:', error);
    return false;
  }
}

interface LomiWebhookEvent {
  id: string; // UUID — idempotence / dédoublonnage
  event: string; // ex. 'PAYMENT_SUCCEEDED'
  timestamp: string;
  data: any; // Structure selon le type d’événement
  /** Reprend le `NODE_ENV` de l’hôte expéditeur (p. ex. `production`, `development`) — pas un drapeau bac à sable checkout */
  lomi_environment: string;
}

async function processWebhookEvent(event: LomiWebhookEvent): Promise<void> {
  // Facultatif : vérifier si l’identifiant a déjà été traité (idempotence)
  if (await hasEventBeenProcessed(event.id)) {
    console.log(`Event ${event.id} already processed. Skipping.`);
    return;
  }

  console.log(`Processing event: ${event.id}, Type: ${event.event}`);

  switch (event.event) {
    case 'PAYMENT_SUCCEEDED':
      const transaction = event.data; // Objet transaction
      console.log(
        `Payment succeeded for transaction: ${transaction.transaction_id}`,
      );
      // Ex. : livrer la commande, accorder l’accès, mettre à jour la base
      // await fulfillOrder(transaction.metadata?.order_id, transaction);
      break;

    case 'PAYMENT_FAILED':
      const failedTxn = event.data;
      console.log(
        `Payment failed for transaction: ${failedTxn.transaction_id}`,
      );
      // Ex. : notifier le client, passer la commande en échec
      // await handleFailedPayment(failedTxn.metadata?.order_id, failedTxn);
      break;

    case 'SUBSCRIPTION_CREATED':
      const subscription = event.data;
      console.log(`Subscription created: ${subscription.subscription_id}`);
      // Ex. : provisionner le service pour l’abonnement
      break;

    case 'SUBSCRIPTION_RENEWED':
      const renewed = event.data;
      console.log(`Subscription renewed: ${renewed.subscription_id}`);
      // Ex. : prolonger l’accès pour la nouvelle période
      break;

    case 'SUBSCRIPTION_CANCELLED':
      const cancelledSub = event.data;
      console.log(`Subscription cancelled: ${cancelledSub.subscription_id}`);
      // Ex. : révoquer l’accès immédiatement ou en fin de période
      break;

    // Ajouter d’autres cas pour les événements auxquels vous êtes abonné…

    default:
      console.warn(`Unhandled event type: ${event.event}`);
  }

  // Facultatif : marquer l’événement comme traité
  await markEventAsProcessed(event.id);
}

// Fonctions fictives pour l’idempotence (à implémenter avec votre BDD/cache)
async function hasEventBeenProcessed(eventId: string): Promise<boolean> {
  // Vérifier dans votre stockage si eventId existe
  return false; // Remplacer par la vérification réelle
}
async function markEventAsProcessed(eventId: string): Promise<void> {
  // Enregistrer eventId dans votre stockage
}

async function handleWebhook(req: express.Request, res: express.Response) {
  // ... (vérifier la signature) ...
  if (!isValidSignature) {
    return res.status(400).send('Invalid signature');
  }

  // Accuser réception tout de suite
  res.status(200).json({ received: true });

  // Ajouter l’événement à une file en arrière-plan
  const event = JSON.parse(req.body.toString());
  backgroundQueue.add('process-webhook', event);
}

async function processWebhookEvent(event: LomiWebhookEvent): Promise<void> {
  const isProcessed = await database.checkIfEventProcessed(event.id);
  if (isProcessed) {
    console.log(`Event ${event.id} is a duplicate, skipping.`);
    return;
  }

  // ... traiter l’événement ...

  await database.markEventAsProcessed(event.id);
}

async function handleWebhook(req: express.Request, res: express.Response) {
  const eventId = JSON.parse(req.body.toString())?.id || 'unknown';
  console.log(`Received webhook request for event ID (potential): ${eventId}`);

  // ... (vérifier la signature) ...
  if (!isValidSignature) {
    console.warn(`Invalid signature for event ID: ${eventId}`);
    return res.status(400).send('Invalid signature');
  }
  console.log(`Signature verified for event ID: ${eventId}`);

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

  // ... (traitement asynchrone) ...
}