Generate an Express.js webhook handler for Stripe with:
- Signature verification using stripe.webhooks.constructEvent
- A switch statement handling: payment_intent.succeeded,
  payment_intent.payment_failed, customer.subscription.deleted
- Raw body parsing (required for Stripe signature verification)
- TypeScript types for the request handler

import express, { Request, Response } from 'express';
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET!;

// Important: Stripe needs the raw body for signature verification
app.post(
  '/webhooks/stripe',
  express.raw({ type: 'application/json' }),
  async (req: Request, res: Response) => {
    const sig = req.headers['stripe-signature'] as string;

    let event: Stripe.Event;
    try {
      event = stripe.webhooks.constructEvent(req.body, sig, endpointSecret);
    } catch (err) {
      console.error('Signature verification failed:', err);
      return res.status(400).send(`Webhook Error: ${(err as Error).message}`);
    }

    switch (event.type) {
      case 'payment_intent.succeeded':
        const paymentIntent = event.data.object as Stripe.PaymentIntent;
        await handlePaymentSuccess(paymentIntent);
        break;
      case 'payment_intent.payment_failed':
        const failedPayment = event.data.object as Stripe.PaymentIntent;
        await handlePaymentFailure(failedPayment);
        break;
      case 'customer.subscription.deleted':
        const subscription = event.data.object as Stripe.Subscription;
        await handleSubscriptionCancelled(subscription);
        break;
      default:
        console.log(`Unhandled event type: ${event.type}`);
    }

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

Review this webhook handler for idempotency issues. List every
scenario where duplicate processing could cause data corruption
or inconsistency:

[paste your webhook code here]

For each issue found, explain the failure scenario step by step
and suggest a fix.

Design a retry strategy for a webhook processing system with
these requirements:
- Webhook events are queued in a database table
- Failed events should retry with exponential backoff
- Max 5 retries over 24 hours
- After max retries, move to a dead letter queue for manual review
- Include the database schema and the worker process code
Use TypeScript and PostgreSQL.

// Database schema AI generates
interface WebhookEvent {
  id: string;
  event_type: string;
  payload: Record<string, unknown>;
  status: 'pending' | 'processing' | 'completed' | 'failed' | 'dead_letter';
  attempts: number;
  next_retry_at: Date | null;
  last_error: string | null;
  created_at: Date;
}

// Retry delay calculation
function getNextRetryDelay(attempt: number): number {
  // Exponential backoff: 1min, 5min, 25min, 2hr, 10hr
  const baseDelay = 60_000;
  return baseDelay * Math.pow(5, attempt);
}

// Worker that processes the queue
async function processWebhookQueue() {
  const event = await db.query(`
    UPDATE webhook_events
    SET status = 'processing'
    WHERE id = (
      SELECT id FROM webhook_events
      WHERE status = 'pending'
        AND (next_retry_at IS NULL OR next_retry_at <= NOW())
      ORDER BY created_at ASC
      LIMIT 1
      FOR UPDATE SKIP LOCKED
    )
    RETURNING *
  `);

  if (!event) return;

  try {
    await handleWebhookEvent(event);
    await db.query(
      `UPDATE webhook_events SET status = 'completed' WHERE id = CODE_BLOCK`,
      [event.id]
    );
  } catch (error) {
    const nextAttempt = event.attempts + 1;

    if (nextAttempt >= 5) {
      await db.query(
        `UPDATE webhook_events
         SET status = 'dead_letter', last_error = $2, attempts = $3
         WHERE id = CODE_BLOCK`,
        [event.id, (error as Error).message, nextAttempt]
      );
    } else {
      const retryAt = new Date(Date.now() + getNextRetryDelay(nextAttempt));
      await db.query(
        `UPDATE webhook_events
         SET status = 'pending', attempts = $2,
             next_retry_at = $3, last_error = $4
         WHERE id = CODE_BLOCK`,
        [event.id, nextAttempt, retryAt, (error as Error).message]
      );
    }
  }
}

// Example test AI might generate for your handler
describe('Stripe webhook handler', () => {
  it('should reject requests with invalid signatures', async () => {
    const res = await request(app)
      .post('/webhooks/stripe')
      .set('stripe-signature', 'invalid_sig')
      .send({ id: 'evt_123', type: 'payment_intent.succeeded' });

    expect(res.status).toBe(400);
  });

  it('should process duplicate events idempotently', async () => {
    const event = createTestEvent('payment_intent.succeeded');

    // First call: processes normally
    await request(app).post('/webhooks/stripe').send(event);
    // Second call: same event, should not duplicate
    await request(app).post('/webhooks/stripe').send(event);

    const orders = await db.orders.findAll({
      where: { paymentId: event.data.object.id }
    });
    expect(orders).toHaveLength(1); // Not 2!
  });

  it('should handle processing failures gracefully', async () => {
    mockPaymentService.rejectNext();

    const res = await request(app)
      .post('/webhooks/stripe')
      .send(createTestEvent('payment_intent.succeeded'));

    expect(res.status).toBe(200); // Still acknowledge receipt
    // Event should be queued for retry
    const pending = await db.webhookEvents.findPending();
    expect(pending).toHaveLength(1);
  });
});