Chat Application Backend Webhook API

// Pseudo-code
async function handleMessageNew(event) {
  // 1. Identify users to notify (thread participants)
  const subscription = await getSubscription(event.subscriptionId);
  const affectedBsn = subscription.bsn;

  // 2. Optional: Fetch full message details if needed
  const fullMessage = await matrixBridgeApi.getMessage(
    event.data.threadId,
    event.data.messageId,
    affectedBsn
  );

  // 3. Find connected WebSocket clients for this user
  const wsClients = getConnectedClients(affectedBsn);

  // 4. Push notification to clients
  wsClients.forEach(client => {
    client.send({
      type: 'message.new',
      threadId: event.data.threadId,
      message: fullMessage // or just use the preview
    });
  });

  // 5. Update unread counts, badges, etc.
  await incrementUnreadCount(affectedBsn, event.data.threadId);
}

async function handleMessageRead(event) {
  // 1. Get subscription details
  const subscription = await getSubscription(event.subscriptionId);

  // 2. Find connected clients for users in this thread
  const threadParticipants = await getThreadParticipants(event.data.threadId);

  // 3. Push read receipt to other participants
  threadParticipants.forEach(participantBsn => {
    if (participantBsn !== event.data.reader.bsn) {
      const wsClients = getConnectedClients(participantBsn);
      wsClients.forEach(client => {
        client.send({
          type: 'message.read',
          threadId: event.data.threadId,
          messageId: event.data.messageId,
          reader: event.data.reader
        });
      });
    }
  });
}

async function handleThreadNew(event) {
  // 1. Fetch full thread details
  const subscription = await getSubscription(event.subscriptionId);
  const thread = await matrixBridgeApi.getThread(
    event.data.threadId,
    subscription.bsn
  );

  // 2. Notify all participants
  event.data.participants.forEach(async userId => {
    const bsn = await resolveToBsn(userId);
    const wsClients = getConnectedClients(bsn);

    wsClients.forEach(client => {
      client.send({
        type: 'thread.new',
        careNetworkId: event.careNetworkId,
        thread: thread
      });
    });
  });
}

async function handleWebhook(event) {
  const eventKey = `${event.subscriptionId}:${event.eventType}:${event.data.messageId}:${event.timestamp}`;

  if (await isEventProcessed(eventKey)) {
    console.log('Duplicate event, ignoring');
    return { status: 'received' };
  }

  await processEvent(event);
  await markEventProcessed(eventKey);

  return { status: 'received' };
}

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

app.use(express.json());

// Webhook endpoint
app.post('/webhooks/matrix-events', async (req, res) => {
  const event = req.body;

  try {
    // Validate subscription exists
    const subscription = await getSubscription(event.subscriptionId);
    if (!subscription) {
      return res.status(404).json({ error: 'Subscription not found' });
    }

    // Return 200 immediately (process async)
    res.status(200).json({
      status: 'received',
      timestamp: new Date().toISOString()
    });

    // Process event asynchronously
    processEventAsync(event).catch(err => {
      console.error('Failed to process event:', err);
      // Log for manual investigation
    });

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

async function processEventAsync(event) {
  switch (event.eventType) {
    case 'message.new':
      await handleMessageNew(event);
      break;
    case 'message.read':
      await handleMessageRead(event);
      break;
    case 'thread.new':
      await handleThreadNew(event);
      break;
    case 'participant.joined':
    case 'participant.left':
      await handleParticipantChange(event);
      break;
    default:
      console.warn('Unknown event type:', event.eventType);
  }
}

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});

const crypto = require('crypto');

function verifyWebhookSignature(body, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(JSON.stringify(body))
    .digest('hex');

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

console.log({
  timestamp: new Date().toISOString(),
  subscriptionId: event.subscriptionId,
  eventType: event.eventType,
  careNetworkId: event.careNetworkId,
  processingTime: processingTimeMs,
  status: 'success' // or 'error'
});