backend-manager 5.0.89 → 5.0.92

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
@@ -13,8 +14,9 @@ const transitions = require('./transitions/index.js');
  * 4. Detects state transitions and dispatches handler files (non-blocking)
  * 5. Marks the webhook as completed
  */
-module.exports = async ({ Manager, assistant, change, context, libraries }) => {
-  const { admin } = libraries;
+module.exports = async ({ assistant, change, context }) => {
+  const Manager = assistant.Manager;
+  const admin = Manager.libraries.admin;
 
   const dataAfter = change.after.data();
 
@@ -73,17 +75,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, resourceType, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, assistant });
+
     // Mark webhook as completed (include transition name for auditing/testing)
     await webhookRef.set({
       status: 'completed',
@@ -111,13 +109,20 @@ 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, resourceType, uid, processor, eventType, eventId, resourceId, orderId, now, nowUNIX, webhookReceivedUNIX, assistant }) {
+  const Manager = assistant.Manager;
+  const admin = Manager.libraries.admin;
+  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 +135,122 @@ 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}`);
+  const before = isSubscription ? (userData.subscription || null) : null;
+
+  // Auto-fill user name from payment processor if not already set
+  if (!userData?.personal?.name?.first) {
+    const customerName = extractCustomerName(resource, resourceType);
+    if (customerName?.first) {
+      await admin.firestore().doc(`users/${uid}`).set({
+        personal: { name: customerName },
+      }, { merge: true });
+      assistant.log(`Auto-filled user name from ${resourceType}: ${customerName.first} ${customerName.last || ''}`);
     }
   }
 
-  // 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,
-          },
+  // 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, assistant,
       });
     } 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 });
+  }
+
+  // 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
+ * Extract customer name from a raw payment processor resource
  *
- * @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
+ * @param {object} resource - Raw processor resource (Stripe subscription, session, invoice)
+ * @param {string} resourceType - 'subscription' | 'session' | 'invoice'
+ * @returns {{ first: string, last: string }|null}
  */
-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);
-  }
-}
+function extractCustomerName(resource, resourceType) {
+  let fullName = null;
 
-/**
- * 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);
+  // Checkout sessions have customer_details.name
+  if (resourceType === 'session') {
+    fullName = resource.customer_details?.name;
   }
 
-  if (category === 'one-time') {
-    return resolveOneTimeEvent(transitionName, unified, config);
+  // Invoices have customer_name
+  if (resourceType === 'invoice') {
+    fullName = resource.customer_name;
   }
 
-  return null;
-}
+  // Subscriptions only have customer ID, no name
 
-/**
- * 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') {
+  if (!fullName) {
     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;
-
+  const { capitalize } = require('../../../libraries/infer-contact.js');
+  const parts = fullName.trim().split(/\s+/);
   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,
+    first: capitalize(parts[0]) || null,
+    last: capitalize(parts.slice(1).join(' ')) || null,
   };
 }

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

@@ -1,16 +1,25 @@
 /**
  * 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 }) {
+  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,
+    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 }) {
+  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,61 @@
+/**
+ * Shared email helper for payment transition handlers
+ * Sends transactional order emails directly via the shared email library (no HTTP round-trip)
+ */
+const moment = require('moment');
+
+/**
+ * Send an order email directly using the shared email library (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)
+ * @param {string} options.uid - User UID (resolved from Firestore for email + name)
+ * @param {object} options.assistant - Assistant instance
+ */
+function sendOrderEmail({ template, subject, categories, data, uid, assistant }) {
+  const email = assistant.Manager.Email(assistant);
+
+  const settings = {
+    to: `uid:${uid}`,
+    subject,
+    template,
+    categories,
+    copy: false,
+    data,
+  };
+
+  email.send(settings)
+    .then((result) => {
+      assistant.log(`sendOrderEmail(): Success template=${template}, uid=${uid}, status=${result.status}`);
+    })
+    .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,28 @@
 /**
  * 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 }) {
+  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,
+    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,30 @@
  * 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 }) {
   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,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+          ...(isTrial && after.trial?.expires?.timestamp && {
+            trialExpires: formatDate(after.trial.expires.timestamp),
+          }),
+        },
+      },
+    },
+  });
 };