Architecture Patterns

const express = require('express');
const AWS = require('aws-sdk');

const app = express();
const sqs = new AWS.SQS();

app.post('/webhooks/smartcar', async (req, res) => {
  try {
    // 1. Get the raw payload
    const payload = req.body;
    
    // 2. Queue for processing
    await sqs.sendMessage({
      QueueUrl: process.env.WEBHOOK_QUEUE_URL,
      MessageBody: JSON.stringify(payload)
    }).promise();
    
    // 3. Return immediately
    res.status(200).json({ status: 'received' });
  } catch (error) {
    console.error('Failed to queue webhook:', error);
    res.status(500).json({ error: 'Internal error' });
  }
});

// Separate worker processes the queue
async function processWebhook(payload) {
  const { eventType } = payload;
  
  if (eventType === 'VEHICLE_STATE') {
    await updateVehicleState(payload);
  } else if (eventType === 'VEHICLE_ERROR') {
    await handleVehicleError(payload);
  }
}

from flask import Flask, request
from rq import Queue
from redis import Redis

app = Flask(__name__)
redis_conn = Redis()
queue = Queue(connection=redis_conn)

@app.post("/webhooks/smartcar")
def webhook_handler():
    # 1. Get the raw payload
    payload = request.get_json()
    
    # 2. Queue for processing
    queue.enqueue(process_webhook, payload)
    
    # 3. Return immediately
    return {"status": "received"}, 200

def process_webhook(payload):
    # This runs asynchronously in a worker
    event_type = payload.get("eventType")
    
    if event_type == "VEHICLE_STATE":
        update_vehicle_state(payload)
    elif event_type == "VEHICLE_ERROR":
        handle_vehicle_error(payload)

@RestController
public class WebhookController {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @PostMapping("/webhooks/smartcar")
    public ResponseEntity<Map<String, String>> handleWebhook(
        @RequestBody String payload
    ) {
        // 1. Queue for processing
        rabbitTemplate.convertAndSend(
            "webhook-queue", 
            payload
        );
        
        // 2. Return immediately
        return ResponseEntity.ok(
            Map.of("status", "received")
        );
    }
}

@Component
public class WebhookProcessor {
    
    @RabbitListener(queues = "webhook-queue")
    public void processWebhook(String payload) {
        // This runs asynchronously
        JsonNode json = objectMapper.readTree(payload);
        String eventType = json.get("eventType").asText();
        
        if ("VEHICLE_STATE".equals(eventType)) {
            updateVehicleState(json);
        } else if ("VEHICLE_ERROR".equals(eventType)) {
            handleVehicleError(json);
        }
    }
}