Webhook Events and Scenarios

const handleSubscriptionCancelled = async ({ user, subscription }) => {
  // Always record the per-subscription fact
  await markSubscriptionCanceled(subscription.id);
 
  // Revoke access only if nothing else is keeping the user alive.
  // `undefined` means we could not compute it — fall back to the API
  // rather than assuming the user has nothing.
  if (user.has_active_subscription === false) {
    await revokeAccess(user.id);
  }
};

const handleWebhookEvent = async (event) => {
  const { type, data } = event;
 
  switch (type) {
    case 'payment.completed':
      await handlePaymentCompleted(data);
      break;
 
    case 'subscription.created':
      await handleSubscriptionCreated(data);
      break;
 
    case 'subscription.updated':
      await handleSubscriptionUpdated(data);
      break;
 
    case 'subscription.cancelled':
      await handleSubscriptionCancelled(data);
      break;
 
    case 'refund.created':
      await handleRefundCreated(data);
      break;
 
    default:
      console.log(`Unhandled event type: ${type}`);
  }
};
 
// Handler implementations
const handlePaymentCompleted = async (data) => {
  const { payment, price, user, customer } = data;
 
  if (price.interval === 'lifetime') {
    // Grant lifetime access
    await grantLifetimeAccess(user.id);
    console.log(`Lifetime access granted to user ${user.id}`);
  } else {
    // Handle one-time payment
    await processOneTimePayment(payment.id, user.id);
  }
 
  // Send confirmation email
  await sendPaymentConfirmation(customer.email, price.unit_amount);
};
 
const handleSubscriptionCreated = async (data) => {
  const { subscription, user, customer } = data;
 
  if (subscription.status === 'trialing') {
    // Start trial period
    await startTrialPeriod(user.id, subscription.trial_period_end);
    console.log(`Trial started for user ${user.id}`);
  } else if (subscription.status === 'active') {
    // Activate subscription immediately
    await activateSubscription(user.id, subscription.id);
    console.log(`Subscription activated for user ${user.id}`);
  }
 
  // Send welcome email
  await sendWelcomeEmail(customer.email, subscription.status);
};

const eventTime = (event) => new Date(event.occurred_at || event.created_at);
 
const handleEventWithOrder = async (event) => {
  const key = event.data.subscription?.id || event.data.payment?.id;
  const lastProcessedTime = await getLastProcessedTime(key);
 
  if (eventTime(event) < lastProcessedTime) {
    console.log('Out of order event, skipping stale status update...');
    // Handle out-of-order event logic
    return;
  }
 
  await processEvent(event);
  await updateLastProcessedTime(key, eventTime(event));
};

const processedEvents = new Set();
 
const handleIdempotentEvent = async (event) => {
  if (processedEvents.has(event.id)) {
    console.log(`Event ${event.id} already processed`);
    return;
  }
 
  await processEvent(event);
  processedEvents.add(event.id);
};