backend-manager 5.0.89 → 5.0.91

package/src/manager/events/firestore/payments-webhooks/on-write.js

@@ -1,5 +1,6 @@
 const powertools = require('node-powertools');
 const transitions = require('./transitions/index.js');
+const { trackPayment } = require('./analytics.js');
 
 /**
  * Firestore trigger: payments-webhooks/{eventId} onWrite
@@ -73,17 +74,13 @@ module.exports = async ({ Manager, assistant, change, context, libraries }) => {
     // Extract orderId from resource metadata (set at intent creation)
     const orderId = resource.metadata?.orderId || null;
 
-    // Branch on category
-    let transitionName = null;
-
-    if (category === 'subscription') {
-      transitionName = await processSubscription({ library, resource, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, admin, assistant, Manager });
-    } else if (category === 'one-time') {
-      transitionName = await processOneTime({ library, resource, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, admin, assistant, Manager });
-    } else {
+    // Process the payment event (subscription or one-time)
+    if (category !== 'subscription' && category !== 'one-time') {
       throw new Error(`Unknown event category: ${category}`);
     }
 
+    const transitionName = await processPaymentEvent({ category, library, resource, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, admin, assistant, Manager });
+
     // Mark webhook as completed (include transition name for auditing/testing)
     await webhookRef.set({
       status: 'completed',
@@ -111,13 +108,18 @@ module.exports = async ({ Manager, assistant, change, context, libraries }) => {
 };
 
 /**
- * Process a subscription event
- * 1. Read current user subscription (before state)
- * 2. Transform raw resource → unified subscription (after state)
- * 3. Detect and dispatch transition handlers (non-blocking)
- * 4. Write to user doc + payments-orders
+ * Process a payment event (subscription or one-time)
+ * 1. Staleness check
+ * 2. Read user doc (for transition detection)
+ * 3. Transform raw resource → unified object
+ * 4. Build order object
+ * 5. Detect and dispatch transition handlers (non-blocking)
+ * 6. Track analytics (non-blocking)
+ * 7. Write to Firestore (user doc for subscriptions + payments-orders)
  */
-async function processSubscription({ library, resource, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, admin, assistant, Manager }) {
+async function processPaymentEvent({ category, library, resource, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, admin, assistant, Manager }) {
+  const isSubscription = category === 'subscription';
+
   // Staleness check: skip if a newer webhook already wrote to this order
   if (orderId) {
     const existingDoc = await admin.firestore().doc(`payments-orders/${orderId}`).get();
@@ -130,329 +132,77 @@ async function processSubscription({ library, resource, uid, processor, eventTyp
     }
   }
 
-  // Read current user doc BEFORE writing (for transition detection)
+  // Read current user doc (needed for transition detection + handler context)
   const userDoc = await admin.firestore().doc(`users/${uid}`).get();
   const userData = userDoc.exists ? userDoc.data() : {};
-  const before = userData.subscription || null;
-
-  // Transform to unified subscription (the "after" state)
-  const unified = library.toUnifiedSubscription(resource, {
-    config: Manager.config,
-    eventName: eventType,
-    eventId: eventId,
-  });
-
-  assistant.log(`Unified subscription: status=${unified.status}, product=${unified.product.id}, frequency=${unified.payment.frequency}, trial.claimed=${unified.trial.claimed}, cancellation.pending=${unified.cancellation.pending}`, unified);
-
-  // Detect and dispatch transition (non-blocking)
-  const shouldRunHandlers = !assistant.isTesting() || process.env.TEST_EXTENDED_MODE;
-  const transitionName = transitions.detectTransition('subscription', before, unified, eventType);
-
-  if (transitionName) {
-    assistant.log(`Transition detected: subscription/${transitionName} (before.status=${before?.status || 'null'}, after.status=${unified.status})`);
-
-    if (shouldRunHandlers) {
-      transitions.dispatch(transitionName, 'subscription', {
-        before, after: unified, uid, userDoc: userData, admin, assistant, Manager, eventType, eventId,
-      });
-    } else {
-      assistant.log(`Transition handler skipped (testing mode): subscription/${transitionName}`);
-    }
-  }
-
-  // Track payment analytics (non-blocking)
-  if (transitionName && shouldRunHandlers) {
-    trackPayment({ category: 'subscription', transitionName, unified, uid, processor, assistant, Manager });
-  }
-
-  // Write unified subscription to user doc
-  await admin.firestore().doc(`users/${uid}`).set({
-    subscription: unified,
-  }, { merge: true });
-
-  assistant.log(`Updated users/${uid}.subscription: status=${unified.status}, product=${unified.product.id}`);
-
-  // Write to payments-orders/{orderId}
-  if (orderId) {
-    await admin.firestore().doc(`payments-orders/${orderId}`).set({
-      id: orderId,
-      type: 'subscription',
-      owner: uid,
-      processor: processor,
-      resourceId: resourceId,
-      subscription: unified,
-      metadata: {
-        created: {
-          timestamp: now,
-          timestampUNIX: nowUNIX,
-        },
-        updated: {
-          timestamp: now,
-          timestampUNIX: nowUNIX,
-        },
-        updatedBy: {
-          event: {
-            name: eventType,
-            id: eventId,
-          },
+  const before = isSubscription ? (userData.subscription || null) : null;
+
+  // Transform raw resource → unified object
+  const transformOptions = { config: Manager.config, eventName: eventType, eventId: eventId };
+  const unified = isSubscription
+    ? library.toUnifiedSubscription(resource, transformOptions)
+    : library.toUnifiedOneTime(resource, transformOptions);
+
+  assistant.log(`Unified ${category}: product=${unified.product.id}, status=${unified.status}`, unified);
+
+  // Build the order object (single source of truth for handlers + Firestore)
+  const order = {
+    id: orderId,
+    type: category,
+    owner: uid,
+    processor: processor,
+    resourceId: resourceId,
+    unified: unified,
+    metadata: {
+      created: {
+        timestamp: now,
+        timestampUNIX: nowUNIX,
+      },
+      updated: {
+        timestamp: now,
+        timestampUNIX: nowUNIX,
+      },
+      updatedBy: {
+        event: {
+          name: eventType,
+          id: eventId,
         },
       },
-    }, { merge: true });
-
-    assistant.log(`Updated payments-orders/${orderId}: type=subscription, uid=${uid}, eventType=${eventType}`);
-  }
-
-  return transitionName;
-}
-
-/**
- * Process a one-time payment event
- * 1. Transform raw resource → unified one-time
- * 2. Detect and dispatch transition handlers (non-blocking)
- * 3. Write to payments-orders
- */
-async function processOneTime({ library, resource, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, admin, assistant, Manager }) {
-  // Staleness check: skip if a newer webhook already wrote to this order
-  if (orderId) {
-    const existingDoc = await admin.firestore().doc(`payments-orders/${orderId}`).get();
-    if (existingDoc.exists) {
-      const existingUpdatedUNIX = existingDoc.data()?.metadata?.updated?.timestampUNIX || 0;
-      if (webhookReceivedUNIX < existingUpdatedUNIX) {
-        assistant.log(`Stale webhook ${eventId}: received=${webhookReceivedUNIX}, existing updated=${existingUpdatedUNIX}, skipping`);
-        return null;
-      }
-    }
-  }
-
-  const unified = library.toUnifiedOneTime(resource, {
-    config: Manager.config,
-    eventName: eventType,
-    eventId: eventId,
-  });
-
-  assistant.log(`Unified one-time: id=${unified.id}, status=${unified.status}`, unified);
+    },
+  };
 
   // Detect and dispatch transition (non-blocking)
   const shouldRunHandlers = !assistant.isTesting() || process.env.TEST_EXTENDED_MODE;
-  const transitionName = transitions.detectTransition('one-time', null, unified, eventType);
+  const transitionName = transitions.detectTransition(category, before, unified, eventType);
 
   if (transitionName) {
-    assistant.log(`Transition detected: one-time/${transitionName}`);
+    assistant.log(`Transition detected: ${category}/${transitionName} (before.status=${before?.status || 'null'}, after.status=${unified.status})`);
 
     if (shouldRunHandlers) {
-      // Read user doc for handler context
-      const userDoc = await admin.firestore().doc(`users/${uid}`).get();
-      const userData = userDoc.exists ? userDoc.data() : {};
-
-      transitions.dispatch(transitionName, 'one-time', {
-        before: null, after: unified, uid, userDoc: userData, admin, assistant, Manager, eventType, eventId,
+      transitions.dispatch(transitionName, category, {
+        before, after: unified, order, uid, userDoc: userData, admin, assistant, Manager, eventType, eventId,
       });
     } else {
-      assistant.log(`Transition handler skipped (testing mode): one-time/${transitionName}`);
+      assistant.log(`Transition handler skipped (testing mode): ${category}/${transitionName}`);
     }
   }
 
   // Track payment analytics (non-blocking)
   if (transitionName && shouldRunHandlers) {
-    trackPayment({ category: 'one-time', transitionName, unified, uid, processor, assistant, Manager });
+    trackPayment({ category, transitionName, unified, uid, processor, assistant, Manager });
+  }
+
+  // Write unified subscription to user doc (subscriptions only)
+  if (isSubscription) {
+    await admin.firestore().doc(`users/${uid}`).set({ subscription: unified }, { merge: true });
+    assistant.log(`Updated users/${uid}.subscription: status=${unified.status}, product=${unified.product.id}`);
   }
 
   // Write to payments-orders/{orderId}
   if (orderId) {
-    await admin.firestore().doc(`payments-orders/${orderId}`).set({
-      id: orderId,
-      type: 'one-time',
-      owner: uid,
-      processor: processor,
-      resourceId: resourceId,
-      payment: unified,
-      metadata: {
-        created: {
-          timestamp: now,
-          timestampUNIX: nowUNIX,
-        },
-        updated: {
-          timestamp: now,
-          timestampUNIX: nowUNIX,
-        },
-        updatedBy: {
-          event: {
-            name: eventType,
-            id: eventId,
-          },
-        },
-      },
-    }, { merge: true });
-
-    assistant.log(`Updated payments-orders/${orderId}: type=one-time, uid=${uid}, eventType=${eventType}`);
+    await admin.firestore().doc(`payments-orders/${orderId}`).set(order, { merge: true });
+    assistant.log(`Updated payments-orders/${orderId}: type=${category}, uid=${uid}, eventType=${eventType}`);
   }
 
   return transitionName;
 }
-
-/**
- * Track payment events across analytics platforms (non-blocking)
- * Fires server-side events for GA4, Meta Conversions API, and TikTok Events API
- *
- * Maps transitions to standard platform events:
- *   new-subscription (no trial) → purchase / Purchase / CompletePayment
- *   new-subscription (trial)    → start_trial / StartTrial / Subscribe
- *   payment-recovered           → purchase / Subscribe / Subscribe (recurring)
- *   purchase-completed          → purchase / Purchase / CompletePayment
- *
- * @param {object} options
- * @param {string} options.category - 'subscription' or 'one-time'
- * @param {string} options.transitionName - Detected transition (e.g., 'new-subscription', 'purchase-completed')
- * @param {object} options.unified - Unified subscription or one-time object
- * @param {string} options.uid - User ID
- * @param {string} options.processor - Payment processor (e.g., 'stripe', 'paypal')
- * @param {object} options.assistant - Assistant instance
- * @param {object} options.Manager - Manager instance
- */
-function trackPayment({ category, transitionName, unified, uid, processor, assistant, Manager }) {
-  try {
-    // Resolve the analytics event to fire based on transition
-    const event = resolvePaymentEvent(category, transitionName, unified, Manager.config);
-
-    if (!event) {
-      return;
-    }
-
-    assistant.log(`trackPayment: event=${event.ga4}, value=${event.value}, currency=${event.currency}, product=${event.productId}, uid=${uid}`);
-
-    // GA4 via Measurement Protocol
-    Manager.Analytics({ assistant, uuid: uid }).event(event.ga4, {
-      transaction_id: event.transactionId,
-      value: event.value,
-      currency: event.currency,
-      items: [{
-        item_id: event.productId,
-        item_name: event.productName,
-        price: event.value,
-        quantity: 1,
-      }],
-      payment_processor: processor,
-      payment_frequency: event.frequency,
-      is_trial: event.isTrial,
-      is_recurring: event.isRecurring,
-    });
-
-    // TODO: Meta Conversions API
-    // Event name: event.meta (e.g., 'Purchase', 'StartTrial', 'Subscribe')
-    // https://developers.facebook.com/docs/marketing-api/conversions-api
-
-    // TODO: TikTok Events API
-    // Event name: event.tiktok (e.g., 'CompletePayment', 'Subscribe')
-    // https://business-api.tiktok.com/portal/docs?id=1771100865818625
-  } catch (e) {
-    assistant.error(`trackPayment failed: ${e.message}`, e);
-  }
-}
-
-/**
- * Resolve which analytics event to fire based on transition + unified data
- * Returns null if the transition doesn't warrant an analytics event
- */
-function resolvePaymentEvent(category, transitionName, unified, config) {
-  if (category === 'subscription') {
-    return resolveSubscriptionEvent(transitionName, unified, config);
-  }
-
-  if (category === 'one-time') {
-    return resolveOneTimeEvent(transitionName, unified, config);
-  }
-
-  return null;
-}
-
-/**
- * Map subscription transitions to analytics events
- */
-function resolveSubscriptionEvent(transitionName, unified, config) {
-  const productId = unified.product?.id;
-  const productName = unified.product?.name;
-  const frequency = unified.payment?.frequency;
-  const isTrial = unified.trial?.claimed === true;
-  const resourceId = unified.payment?.resourceId;
-
-  // Resolve price from config
-  const product = config.payment?.products?.find(p => p.id === productId);
-  const price = product?.prices?.[frequency]?.amount || 0;
-
-  if (transitionName === 'new-subscription' && isTrial) {
-    return {
-      ga4: 'start_trial',
-      meta: 'StartTrial',
-      tiktok: 'Subscribe',
-      value: 0,
-      currency: config.payment?.currency || 'USD',
-      productId,
-      productName,
-      frequency,
-      isTrial: true,
-      isRecurring: false,
-      transactionId: resourceId,
-    };
-  }
-
-  if (transitionName === 'new-subscription') {
-    return {
-      ga4: 'purchase',
-      meta: 'Purchase',
-      tiktok: 'CompletePayment',
-      value: price,
-      currency: config.payment?.currency || 'USD',
-      productId,
-      productName,
-      frequency,
-      isTrial: false,
-      isRecurring: false,
-      transactionId: resourceId,
-    };
-  }
-
-  if (transitionName === 'payment-recovered') {
-    return {
-      ga4: 'purchase',
-      meta: 'Subscribe',
-      tiktok: 'Subscribe',
-      value: price,
-      currency: config.payment?.currency || 'USD',
-      productId,
-      productName,
-      frequency,
-      isTrial: false,
-      isRecurring: true,
-      transactionId: resourceId,
-    };
-  }
-
-  return null;
-}
-
-/**
- * Map one-time transitions to analytics events
- */
-function resolveOneTimeEvent(transitionName, unified, config) {
-  if (transitionName !== 'purchase-completed') {
-    return null;
-  }
-
-  const productId = unified.metadata?.productId || unified.raw?.metadata?.productId;
-  const product = config.payment?.products?.find(p => p.id === productId);
-  const price = product?.prices?.once?.amount || 0;
-
-  return {
-    ga4: 'purchase',
-    meta: 'Purchase',
-    tiktok: 'CompletePayment',
-    value: price,
-    currency: config.payment?.currency || 'USD',
-    productId: productId || 'unknown',
-    productName: product?.name || 'Unknown',
-    frequency: null,
-    isTrial: false,
-    isRecurring: false,
-    transactionId: unified.id,
-  };
-}

package/src/manager/events/firestore/payments-webhooks/transitions/one-time/purchase-completed.js

@@ -1,16 +1,26 @@
 /**
  * Transition: purchase-completed
  * Triggered when a one-time payment checkout completes (checkout.session.completed with mode=payment)
- *
- * Use cases:
- * - Send purchase receipt/confirmation email
- * - Deliver digital goods or credits
- * - Fire analytics event for purchase
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
-  assistant.log(`Transition [one-time/purchase-completed]: uid=${uid}, resourceId=${after.id}`);
+const { sendOrderEmail, formatDate } = require('../send-email.js');
 
-  // TODO: Send purchase confirmation email
-  // TODO: Deliver digital goods
-  // TODO: Fire analytics event
+module.exports = async function ({ before, after, order, uid, assistant, Manager }) {
+  assistant.log(`Transition [one-time/purchase-completed]: uid=${uid}, resourceId=${after.payment.resourceId}`);
+
+  sendOrderEmail({
+    template: 'd-5371ac2b4e3b490bbce51bfc2922ece8',
+    subject: 'Your order is confirmed!',
+    categories: ['order/confirmation'],
+    uid,
+    assistant,
+    Manager,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+        },
+      },
+    },
+  });
 };

package/src/manager/events/firestore/payments-webhooks/transitions/one-time/purchase-failed.js

@@ -2,14 +2,10 @@
  * Transition: purchase-failed
  * Triggered when a one-time payment fails (invoice.payment_failed with billing_reason=manual)
  *
- * Use cases:
- * - Send payment failure notification
- * - Include retry link or alternative payment method
- * - Fire analytics event
+ * NOTE: No email template exists for this transition yet. Keeping as stub.
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
-  assistant.log(`Transition [one-time/purchase-failed]: uid=${uid}, resourceId=${after.id}`);
+module.exports = async function ({ before, after, order, uid, assistant, Manager }) {
+  assistant.log(`Transition [one-time/purchase-failed]: uid=${uid}, orderId=${order?.id}`);
 
-  // TODO: Send payment failure email with retry link
-  // TODO: Fire analytics event
+  // TODO: Send payment failure email once template is created
 };

package/src/manager/events/firestore/payments-webhooks/transitions/send-email.js

@@ -0,0 +1,67 @@
+/**
+ * Shared email helper for payment transition handlers
+ * Sends transactional order emails via POST /admin/email
+ */
+const moment = require('moment');
+
+/**
+ * Send an order email via the admin/email endpoint (fire-and-forget)
+ *
+ * @param {object} options
+ * @param {string} options.template - SendGrid dynamic template ID
+ * @param {string} options.subject - Email subject line
+ * @param {string[]} options.categories - SendGrid categories for filtering
+ * @param {object} options.data - Template data (passed as-is to the email API)
+ * @param {string} options.uid - User UID (endpoint resolves email from Firestore)
+ * @param {object} options.assistant - Assistant instance
+ * @param {object} options.Manager - Manager instance
+ */
+function sendOrderEmail({ template, subject, categories, data, uid, assistant, Manager }) {
+  const fetch = require('wonderful-fetch');
+
+  fetch(`${Manager.project.apiUrl}/backend-manager/admin/email`, {
+    method: 'POST',
+    response: 'json',
+    timeout: 30000,
+    body: {
+      backendManagerKey: process.env.BACKEND_MANAGER_KEY,
+      user: { auth: { uid } },
+      subject: subject,
+      template: template,
+      categories: categories,
+      copy: false,
+      ensureUnique: true,
+      data: data,
+    },
+  })
+  .then((json) => {
+    assistant.log(`sendOrderEmail(): Success template=${template}, uid=${uid}, status=${json?.data?.status || 'unknown'}`);
+  })
+  .catch((e) => {
+    assistant.error(`sendOrderEmail(): Failed template=${template}, uid=${uid}: ${e.message}`);
+  });
+}
+
+/**
+ * Format an ISO timestamp or Unix timestamp to display format
+ *
+ * @param {string|number} timestamp - ISO string or Unix timestamp (seconds)
+ * @returns {string} Formatted date (e.g., 'Feb 25, 2026')
+ */
+function formatDate(timestamp) {
+  if (!timestamp) {
+    return '';
+  }
+
+  // Unix timestamp (number or numeric string)
+  if (typeof timestamp === 'number' || /^\d+$/.test(timestamp)) {
+    return moment.unix(Number(timestamp)).utc().format('MMM D, YYYY');
+  }
+
+  return moment(timestamp).utc().format('MMM D, YYYY');
+}
+
+module.exports = {
+  sendOrderEmail,
+  formatDate,
+};

package/src/manager/events/firestore/payments-webhooks/transitions/subscription/cancellation-requested.js

@@ -1,15 +1,29 @@
 /**
  * Transition: cancellation-requested
  * Triggered when a user requests cancellation at period end (cancellation.pending flips to true)
- *
- * Use cases:
- * - Send cancellation confirmation email with period end date
- * - Include win-back offer or feedback survey link
- * - Fire analytics event for churn intent
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
-  assistant.log(`Transition [subscription/cancellation-requested]: uid=${uid}, product=${after.product.id}, cancelDate=${after.cancellation.date.timestamp}`);
+const { sendOrderEmail, formatDate } = require('../send-email.js');
 
-  // TODO: Send cancellation confirmation email with end date
-  // TODO: Fire analytics event
+module.exports = async function ({ before, after, order, uid, assistant, Manager }) {
+  assistant.log(`Transition [subscription/cancellation-requested]: uid=${uid}, product=${after.product.id}, cancelDate=${after.cancellation.date?.timestamp}`);
+
+  sendOrderEmail({
+    template: 'd-78074f3e8c844146bf263b86fc8d5ecf',
+    subject: 'Your subscription cancellation is confirmed',
+    categories: ['order/cancellation-requested'],
+    uid,
+    assistant,
+    Manager,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+          ...(after.cancellation?.date?.timestamp && {
+            cancellationDate: formatDate(after.cancellation.date.timestamp),
+          }),
+        },
+      },
+    },
+  });
 };

package/src/manager/events/firestore/payments-webhooks/transitions/subscription/new-subscription.js

@@ -2,17 +2,31 @@
  * Transition: new-subscription
  * Triggered when a user subscribes for the first time (basic/null → active paid)
  * Check after.trial.claimed to determine if this is a trial subscription
- *
- * Use cases:
- * - Send order confirmation email with plan details (include trial info if applicable)
- * - Fire analytics event for new subscriber
- * - Update marketing lists
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
+const { sendOrderEmail, formatDate } = require('../send-email.js');
+
+module.exports = async function ({ before, after, order, uid, assistant, Manager }) {
   const isTrial = after.trial?.claimed === true;
 
   assistant.log(`Transition [subscription/new-subscription]: uid=${uid}, product=${after.product.id}, frequency=${after.payment.frequency}, trial=${isTrial}`);
 
-  // TODO: Send order confirmation email (modify content if isTrial)
-  // TODO: Fire analytics event
+  sendOrderEmail({
+    template: 'd-5371ac2b4e3b490bbce51bfc2922ece8',
+    subject: isTrial ? 'Your free trial has started!' : 'Your subscription is confirmed!',
+    categories: ['order/confirmation'],
+    uid,
+    assistant,
+    Manager,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+          ...(isTrial && after.trial?.expires?.timestamp && {
+            trialExpires: formatDate(after.trial.expires.timestamp),
+          }),
+        },
+      },
+    },
+  });
 };

package/src/manager/events/firestore/payments-webhooks/transitions/subscription/payment-failed.js

@@ -1,15 +1,26 @@
 /**
  * Transition: payment-failed
  * Triggered when a subscription payment fails (active → suspended)
- *
- * Use cases:
- * - Send payment failure notification email
- * - Include link to update payment method
- * - Fire analytics event for churn risk
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
+const { sendOrderEmail, formatDate } = require('../send-email.js');
+
+module.exports = async function ({ before, after, order, uid, assistant, Manager }) {
   assistant.log(`Transition [subscription/payment-failed]: uid=${uid}, product=${after.product.id}, previousStatus=${before?.status}`);
 
-  // TODO: Send payment failure email with update-payment link
-  // TODO: Fire analytics event
+  sendOrderEmail({
+    template: 'd-e56af0ac62364bfb9e50af02854e2cd3',
+    subject: 'Your payment failed',
+    categories: ['order/payment-failed'],
+    uid,
+    assistant,
+    Manager,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+        },
+      },
+    },
+  });
 };