Receiving Webhooks

const jose = require('node-jose');

async function decryptWebhook(encryptedData, secretKey) {
  try {
    // Create keystore with your secret key
    const keystore = jose.JWK.createKeyStore();
    await keystore.add(secretKey, 'oct');

    // Decrypt JWE
    const result = await jose.JWE.createDecrypt(keystore).decrypt(encryptedData);

    // Parse decrypted payload
    const payload = JSON.parse(result.plaintext.toString());

    return payload;
  } catch (error) {
    console.error('Decryption failed:', error);
    throw new Error('Failed to decrypt webhook payload');
  }
}

// Usage
app.post('/webhooks/modulus', async (req, res) => {
  const { data } = req.body;
  const SECRET_KEY = process.env.MODULUS_SECRET_KEY;

  try {
    const payload = await decryptWebhook(data, SECRET_KEY);
    console.log('Decrypted payload:', payload);

    // Process the webhook
    await processWebhook(payload);

    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Webhook error:', error);
    res.status(500).json({ error: 'Processing failed' });
  }
});

async function processWebhook(payload) {
  const { action, referenceNumber, amount, status } = payload;

  // Check for duplicate webhooks
  const existing = await db.transactions.findOne({ referenceNumber });
  if (existing) {
    console.log(`Webhook already processed: ${referenceNumber}`);
    return;
  }

  switch (action) {
    case 'QRPH_SUCCESS':
      await handleSuccessfulPayment(payload);
      break;

    case 'QRPH_DECLINED':
      await handleDeclinedPayment(payload);
      break;

    default:
      console.warn(`Unknown webhook action: ${action}`);
  }
}

async function handleSuccessfulPayment(payload) {
  const { referenceNumber, amount, customerName } = payload;

  console.log(` Payment successful: ${referenceNumber}`);

  // Update order status in database
  await db.orders.updateOne(
    { referenceNumber },
    {
      $set: {
        status: 'paid',
        paidAmount: amount,
        paidAt: new Date(),
        customerName: customerName
      }
    }
  );

  // Send confirmation email
  await sendEmail({
    to: await getCustomerEmail(referenceNumber),
    subject: 'Payment Received',
    body: `Your payment of ₱${(amount / 100).toFixed(2)} has been confirmed.`
  });

  // Trigger order fulfillment
  await fulfillOrder(referenceNumber);

  // Log for audit trail
  await db.webhookLogs.insert({
    referenceNumber,
    action: 'QRPH_SUCCESS',
    processedAt: new Date(),
    status: 'completed'
  });
}

async function handleDeclinedPayment(payload) {
  const { referenceNumber, declineReason } = payload;

  console.log(` Payment declined: ${referenceNumber} - ${declineReason}`);

  // Update order status
  await db.orders.updateOne(
    { referenceNumber },
    {
      $set: {
        status: 'payment_failed',
        declineReason: declineReason,
        declinedAt: new Date()
      }
    }
  );

  // Notify customer of failure
  await sendEmail({
    to: await getCustomerEmail(referenceNumber),
    subject: 'Payment Failed',
    body: `Your payment was declined: ${declineReason}. Please try again or use a different payment method.`
  });

  // Log for audit trail
  await db.webhookLogs.insert({
    referenceNumber,
    action: 'QRPH_DECLINED',
    processedAt: new Date(),
    reason: declineReason
  });
}

const Queue = require('bull');
const webhookQueue = new Queue('webhooks');

app.post('/webhooks/modulus', async (req, res) => {
  // Add to queue
  await webhookQueue.add({
    data: req.body,
    receivedAt: new Date()
  });

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

// Process queue in background
webhookQueue.process(async (job) => {
  const { data } = job.data;
  const payload = await decryptWebhook(data.data, SECRET_KEY);
  await processWebhook(payload);
});