Webhooks Intro

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def handle_webhook():
    data = request.json
    
    # Validate webhook
    event_type = request.headers.get('X-Event-Type')
    signature = request.headers.get('X-Signature')
    
    print(f"Received webhook: {event_type}")
    print(f"Payload: {data}")
    
    # Process the event
    if event_type == 'order.created':
        process_order(data)
    elif event_type == 'payment.received':
        process_payment(data)
    
    # Acknowledge receipt
    return jsonify({"status": "received"}), 200

def process_order(data):
    order_id = data.get('id')
    customer = data.get('customer')
    # Process the order
    print(f"Processing order {order_id} for {customer}")

def process_payment(data):
    transaction_id = data.get('transaction_id')
    amount = data.get('amount')
    print(f"Processing payment {transaction_id}: ${amount}")

if __name__ == '__main__':
    app.run(port=8080)

const https = require('https');

async function sendWebhook(url, eventType, payload) {
  const data = JSON.stringify({
    event: eventType,
    timestamp: new Date().toISOString(),
    data: payload,
  });

  return new Promise((resolve, reject) => {
    const req = https.request(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(data),
        'X-Event-Type': eventType,
        'X-Signature': generateSignature(data),
        'X-Delivery-Attempt': '1',
      },
      timeout: 10000,
    }, (res) => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => {
        if (res.statusCode >= 200 && res.statusCode < 300) {
          resolve({ success: true, statusCode: res.statusCode });
        } else {
          resolve({ success: false, statusCode: res.statusCode, body });
        }
      });
    });

    req.on('error', reject);
    req.on('timeout', () => {
      req.destroy();
      reject(new Error('Request timeout'));
    });

    req.write(data);
    req.end();
  });
}

function generateSignature(payload) {
  const crypto = require('crypto');
  const secret = process.env.WEBHOOK_SECRET;
  return crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
}

// Usage
sendWebhook(
  'https://consumer.example.com/webhook',
  'user.created',
  { id: 123, email: 'user@example.com' }
).then(console.log).catch(console.error);

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

app.use(express.json());

// In-memory webhook subscriptions
const webhooks = [];

// Register webhook
app.post('/api/webhooks/register', (req, res) => {
  const { url, events, secret } = req.body;

  if (!url || !events || !Array.isArray(events)) {
    return res.status(400).json({ error: 'url and events required' });
  }

  const webhook = {
    id: generateId(),
    url,
    events,
    secret: secret || generateSecret(),
    status: 'active',
    createdAt: new Date().toISOString(),
    stats: { sent: 0, failed: 0, lastDelivery: null },
  };

  webhooks.push(webhook);
  
  // Send test webhook to verify
  sendTestWebhook(webhook);

  res.status(201).json({
    id: webhook.id,
    secret: webhook.secret, // Return once
    url: webhook.url,
    events: webhook.events,
  });
});

// List webhooks
app.get('/api/webhooks', (req, res) => {
  res.json(webhooks.map(w => ({
    id: w.id,
    url: w.url,
    events: w.events,
    status: w.status,
    stats: w.stats,
  })));
});

// Delete webhook
app.delete('/api/webhooks/:id', (req, res) => {
  const index = webhooks.findIndex(w => w.id === req.params.id);
  if (index === -1) return res.status(404).json({ error: 'Not found' });
  webhooks.splice(index, 1);
  res.status(204).end();
});

function generateId() {
  return Math.random().toString(36).substring(2, 15);
}

function generateSecret() {
  const crypto = require('crypto');
  return crypto.randomBytes(32).toString('hex');
}

app.listen(3000);