Webhooks

const Queue = require('bull');
const webhookQueue = new Queue('webhook processing');

// Add webhook to queue instead of processing immediately
app.post('/webhooks/drip', (req, res) => {
  // Verify signature first
  if (!verifySignature(req.body, req.headers['x-drip-signature'])) {
    return res.status(401).send('Unauthorized');
  }
  
  // Add to queue for processing
  webhookQueue.add('process-webhook', req.body, {
    attempts: 3,
    backoff: 'exponential'
  });
  
  res.status(200).send('OK');
});

// Process webhooks from queue
webhookQueue.process('process-webhook', async (job) => {
  const event = job.data;
  
  try {
    await handleWebhookEvent(event);
    console.log(`✅ Processed webhook: ${event.type}`);
  } catch (error) {
    console.error(`❌ Failed to process webhook: ${error.message}`);
    throw error; // Will trigger retry
  }
});

const processedEvents = new Set();

function isEventProcessed(eventId) {
  return processedEvents.has(eventId);
}

function markEventProcessed(eventId) {
  processedEvents.add(eventId);
  
  // Clean up old event IDs (keep last 10,000)
  if (processedEvents.size > 10000) {
    const oldestEvents = Array.from(processedEvents).slice(0, 1000);
    oldestEvents.forEach(id => processedEvents.delete(id));
  }
}

async function handleWebhookEvent(event) {
  const eventId = event.id || `${event.type}-${event.timestamp}`;
  
  if (isEventProcessed(eventId)) {
    console.log(`⏭️  Skipping duplicate event: ${eventId}`);
    return;
  }
  
  // Process the event
  await processEvent(event);
  
  // Mark as processed
  markEventProcessed(eventId);
}

class WebhookProcessor {
  constructor() {
    this.maxRetries = 3;
    this.retryDelay = 1000; // 1 second
  }
  
  async processWithRetry(event, attempt = 1) {
    try {
      await this.processEvent(event);
      console.log(`✅ Processed webhook on attempt ${attempt}`);
    } catch (error) {
      console.error(`❌ Attempt ${attempt} failed: ${error.message}`);
      
      if (attempt < this.maxRetries) {
        const delay = this.retryDelay * Math.pow(2, attempt - 1); // Exponential backoff
        console.log(`⏳ Retrying in ${delay}ms...`);
        
        setTimeout(() => {
          this.processWithRetry(event, attempt + 1);
        }, delay);
      } else {
        console.error(`💀 Failed after ${this.maxRetries} attempts`);
        await this.handleFailedWebhook(event, error);
      }
    }
  }
  
  async handleFailedWebhook(event, error) {
    // Log to error tracking service
    console.error('Webhook processing failed permanently:', {
      event: event.type,
      error: error.message,
      timestamp: event.timestamp
    });
    
    // Maybe store in database for manual review
    await this.storeFailedWebhook(event, error);
  }
}

# Install ngrok
npm install -g ngrok

# Expose your local server
ngrok http 3000

# Use the ngrok URL for webhook registration
# https://abc123.ngrok.io/webhooks/drip

// test-webhook.js
const express = require('express');
const app = express();

app.use(express.json());

app.post('/webhooks/drip', (req, res) => {
  console.log('📦 Received webhook:');
  console.log('Type:', req.body.type);
  console.log('Timestamp:', req.body.timestamp);
  console.log('Data:', JSON.stringify(req.body.data, null, 2));
  console.log('---');
  
  res.status(200).send('OK');
});

app.listen(3000, () => {
  console.log('🔍 Webhook test server running on http://localhost:3000');
  console.log('📝 Register webhook URL: http://localhost:3000/webhooks/drip');
});

# Test your webhook endpoint
curl -X POST "http://localhost:3000/webhooks/drip" \
  -H "Content-Type: application/json" \
  -H "X-Drip-Signature: sha256=test" \
  -d '{
    "type": "member.points.awarded",
    "timestamp": "2024-01-20T15:30:00Z",
    "realmId": "test-realm",
    "data": {
      "member": {
        "id": "test-member",
        "username": "testuser"
      },
      "points": {
        "amount": 100,
        "realmPoint": {
          "name": "XP",
          "emoji": "⭐"
        }
      },
      "reason": "Test webhook",
      "newBalance": 1000
    }
  }'

async function listWebhooks(client) {
  const webhooks = await client.request('GET', 
    `/realm/${client.realmId}/webhooks`
  );
  
  console.log('Registered webhooks:');
  webhooks.data.forEach(webhook => {
    console.log(`- ${webhook.id}: ${webhook.url}`);
    console.log(`  Events: ${webhook.events.join(', ')}`);
    console.log(`  Active: ${webhook.active}`);
  });
  
  return webhooks.data;
}

async function updateWebhook(client, webhookId, updates) {
  const result = await client.request('PATCH',
    `/realm/${client.realmId}/webhooks/${webhookId}`,
    updates
  );
  
  console.log('Webhook updated:', result);
  return result;
}

// Example: Add new events to existing webhook
await updateWebhook(client, 'webhook-id', {
  events: ['member.joined', 'member.points.awarded', 'quest.completed', 'store.purchase.completed']
});

async function deleteWebhook(client, webhookId) {
  await client.request('DELETE',
    `/realm/${client.realmId}/webhooks/${webhookId}`
  );
  
  console.log('Webhook deleted:', webhookId);
}