backend-manager 5.0.108 → 5.0.110

package/CHANGELOG.md

@@ -14,6 +14,15 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `Fixed` for any bug fixes.
 - `Security` in case of vulnerabilities.
 
+# [5.0.109] - 2026-03-04
+### Added
+- Immediate trial cancellation: cancelling during a free trial now terminates the subscription instantly instead of scheduling cancel at period end, preventing free premium access for the remainder of the trial.
+- Intent status tracking: `payments-intents/{orderId}` is now updated with `status: completed/failed` and completion timestamp after webhook processing.
+- `journey-payments-trial-cancel` test suite covering the full trial → cancel → immediate cancellation flow.
+
+### Changed
+- Stripe and test cancel processors now detect trialing state and dispatch immediate cancel (`customer.subscription.deleted`) vs period-end cancel (`customer.subscription.updated`).
+
 # [5.0.106] - 2026-03-04
 ### Added
 - `GET /payments/trial-eligibility`: returns whether the authenticated user is eligible for a free trial (checks for any previous subscription orders in `payments-orders`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.108",
+  "version": "5.0.110",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {

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

@@ -31,6 +31,9 @@ module.exports = async ({ assistant, change, context }) => {
   // Set status to processing
   await webhookRef.set({ status: 'processing' }, { merge: true });
 
+  // Hoisted so orderId is available in catch block for audit trail
+  let orderId = null;
+
   try {
     const processor = dataAfter.processor;
     const uid = dataAfter.owner;
@@ -73,7 +76,7 @@ module.exports = async ({ assistant, change, context }) => {
     const webhookReceivedUNIX = dataAfter.metadata?.received?.timestampUNIX || nowUNIX;
 
     // Extract orderId from resource (processor-agnostic)
-    const orderId = library.getOrderId(resource);
+    orderId = library.getOrderId(resource);
 
     // Process the payment event (subscription or one-time)
     if (category !== 'subscription' && category !== 'one-time') {
@@ -100,11 +103,28 @@ module.exports = async ({ assistant, change, context }) => {
   } catch (e) {
     assistant.error(`Webhook ${eventId} failed: ${e.message}`, e);
 
+    const now = powertools.timestamp(new Date(), { output: 'string' });
+    const nowUNIX = powertools.timestamp(now, { output: 'unix' });
+
     // Mark as failed with error message
     await webhookRef.set({
       status: 'failed',
       error: e.message || String(e),
     }, { merge: true });
+
+    // Mark intent as failed if we resolved the orderId before the error
+    if (orderId) {
+      await admin.firestore().doc(`payments-intents/${orderId}`).set({
+        status: 'failed',
+        error: e.message || String(e),
+        metadata: {
+          completed: {
+            timestamp: now,
+            timestampUNIX: nowUNIX,
+          },
+        },
+      }, { merge: true });
+    }
   }
 };
 
@@ -216,10 +236,35 @@ async function processPaymentEvent({ category, library, resource, resourceType,
 
   // Write to payments-orders/{orderId}
   if (orderId) {
-    await admin.firestore().doc(`payments-orders/${orderId}`).set(order, { merge: true });
+    const orderRef = admin.firestore().doc(`payments-orders/${orderId}`);
+    const orderSnap = await orderRef.get();
+
+    // Initialize requests on first creation only (avoid overwriting cancel/refund data set by endpoints)
+    if (!orderSnap.exists) {
+      order.requests = {
+        cancellation: null,
+        refund: null,
+      };
+    }
+
+    await orderRef.set(order, { merge: true });
     assistant.log(`Updated payments-orders/${orderId}: type=${category}, uid=${uid}, eventType=${eventType}`);
   }
 
+  // Update payments-intents/{orderId} status to match webhook outcome
+  if (orderId) {
+    await admin.firestore().doc(`payments-intents/${orderId}`).set({
+      status: 'completed',
+      metadata: {
+        completed: {
+          timestamp: now,
+          timestampUNIX: nowUNIX,
+        },
+      },
+    }, { merge: true });
+    assistant.log(`Updated payments-intents/${orderId}: status=completed`);
+  }
+
   return transitionName;
 }
 

package/src/manager/routes/payments/cancel/post.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const powertools = require('node-powertools');
 
 /**
  * POST /payments/cancel
@@ -6,6 +7,7 @@ const path = require('path');
  * Delegates to the processor (e.g., Stripe) to set cancel_at_period_end=true.
  * The resulting webhook triggers the Firestore pipeline which updates subscription state
  * and fires the cancellation-requested transition handler.
+ * Stores the cancellation reason/feedback on payments-orders/{orderId}.requests.cancellation.
  * Requires authentication.
  */
 module.exports = async ({ assistant, user, settings }) => {
@@ -60,7 +62,31 @@ module.exports = async ({ assistant, user, settings }) => {
     return assistant.respond(`Failed to cancel subscription: ${e.message}`, { code: 500, sentry: true });
   }
 
-  assistant.log(`Cancel at period end scheduled: uid=${uid}, processor=${processor}, sub=${resourceId}, reason=${settings.reason}`);
+  // Store cancellation reason/feedback on the order doc
+  const orderId = subscription.payment?.orderId;
+
+  if (orderId) {
+    const admin = assistant.Manager.libraries.admin;
+    const now = powertools.timestamp(new Date(), { output: 'string' });
+    const nowUNIX = powertools.timestamp(now, { output: 'unix' });
+
+    await admin.firestore().doc(`payments-orders/${orderId}`).set({
+      requests: {
+        cancellation: {
+          reason: settings.reason || null,
+          feedback: settings.feedback || null,
+          date: {
+            timestamp: now,
+            timestampUNIX: nowUNIX,
+          },
+        },
+      },
+    }, { merge: true });
+
+    assistant.log(`Stored cancellation request on payments-orders/${orderId}: reason=${settings.reason}`);
+  }
+
+  assistant.log(`Cancel scheduled: uid=${uid}, processor=${processor}, sub=${resourceId}, reason=${settings.reason}`);
 
   return assistant.respond({ success: true });
 };

package/src/manager/routes/payments/cancel/processors/stripe.js

@@ -1,22 +1,35 @@
 /**
  * Stripe cancel processor
- * Sets a subscription to cancel at the end of the current billing period
+ * Cancels a subscription — immediately if trialing, at period end otherwise.
  */
 module.exports = {
   /**
-   * Cancel a Stripe subscription at period end
+   * Cancel a Stripe subscription
+   *
+   * If the subscription is currently trialing, cancel immediately to avoid
+   * giving free premium access for the remainder of the trial.
+   * Otherwise, cancel at the end of the current billing period.
    *
    * @param {object} options
    * @param {string} options.resourceId - Stripe subscription ID (e.g., 'sub_xxx')
    * @param {string} options.uid - User's UID (for logging)
+   * @param {object} options.subscription - User's current subscription object
    * @param {object} options.assistant - Assistant instance for logging
    */
-  async cancelAtPeriodEnd({ resourceId, uid, assistant }) {
+  async cancelAtPeriodEnd({ resourceId, uid, subscription, assistant }) {
     const StripeLib = require('../../../../libraries/payment/processors/stripe.js');
     const stripe = StripeLib.init();
 
-    await stripe.subscriptions.update(resourceId, { cancel_at_period_end: true });
+    const isTrialing = subscription?.trial?.claimed
+      && subscription?.status === 'active'
+      && subscription?.trial?.expires?.timestampUNIX === subscription?.expires?.timestampUNIX;
 
-    assistant.log(`Stripe cancel at period end: sub=${resourceId}, uid=${uid}`);
+    if (isTrialing) {
+      await stripe.subscriptions.cancel(resourceId);
+      assistant.log(`Stripe cancel immediate (trialing): sub=${resourceId}, uid=${uid}`);
+    } else {
+      await stripe.subscriptions.update(resourceId, { cancel_at_period_end: true });
+      assistant.log(`Stripe cancel at period end: sub=${resourceId}, uid=${uid}`);
+    }
   },
 };

package/src/manager/routes/payments/cancel/processors/test.js

@@ -2,9 +2,13 @@ const powertools = require('node-powertools');
 
 /**
  * Test cancel processor
- * Simulates the Stripe webhook that results from cancel_at_period_end=true
+ * Simulates the Stripe webhook that results from cancellation
  * by writing directly to payments-webhooks/{eventId} with status=pending.
  * The on-write trigger picks it up and runs the full pipeline.
+ *
+ * If the user is trialing, simulates immediate cancellation (customer.subscription.deleted).
+ * Otherwise, simulates cancel at period end (customer.subscription.updated with cancel_at_period_end=true).
+ *
  * Only available in non-production environments.
  */
 module.exports = {
@@ -16,7 +20,6 @@ module.exports = {
     const admin = assistant.Manager.libraries.admin;
 
     const timestamp = Date.now();
-    const eventId = `_test-evt-cancel-${timestamp}`;
     const now = Math.floor(timestamp / 1000);
     const periodEnd = now + (30 * 86400);
 
@@ -35,21 +38,31 @@ module.exports = {
       }
     }
 
-    // Build a Stripe-shaped customer.subscription.updated payload
-    // with cancel_at_period_end=true — mirrors what Stripe sends after cancellation
+    // Detect if user is on a trial
+    const isTrialing = subscription?.trial?.claimed
+      && subscription?.status === 'active'
+      && subscription?.trial?.expires?.timestampUNIX === subscription?.expires?.timestampUNIX;
+
+    // Trialing: immediate cancel (customer.subscription.deleted)
+    // Non-trialing: cancel at period end (customer.subscription.updated)
+    const eventType = isTrialing
+      ? 'customer.subscription.deleted'
+      : 'customer.subscription.updated';
+    const eventId = `_test-evt-cancel-${timestamp}`;
+
     const subscriptionObj = {
       id: resourceId,
       object: 'subscription',
-      status: 'active',
+      status: isTrialing ? 'canceled' : 'active',
       metadata: { uid, orderId },
-      cancel_at_period_end: true,
-      cancel_at: periodEnd,
-      canceled_at: null,
-      current_period_end: periodEnd,
+      cancel_at_period_end: !isTrialing,
+      cancel_at: isTrialing ? now : periodEnd,
+      canceled_at: isTrialing ? now : null,
+      current_period_end: isTrialing ? now : periodEnd,
       current_period_start: now - (30 * 86400),
       start_date: now - (30 * 86400),
-      trial_start: null,
-      trial_end: null,
+      trial_start: isTrialing ? (now - 86400) : null,
+      trial_end: isTrialing ? now : null,
       plan: { product: stripeProductId, interval: 'month' },
     };
 
@@ -64,11 +77,11 @@ module.exports = {
       owner: uid,
       raw: {
         id: eventId,
-        type: 'customer.subscription.updated',
+        type: eventType,
         data: { object: subscriptionObj },
       },
       event: {
-        type: 'customer.subscription.updated',
+        type: eventType,
         category: 'subscription',
         resourceType: 'subscription',
         resourceId: resourceId,
@@ -86,6 +99,6 @@ module.exports = {
       },
     });
 
-    assistant.log(`Test cancel processor: wrote payments-webhooks/${eventId} for sub=${resourceId}, uid=${uid}`);
+    assistant.log(`Test cancel processor: wrote payments-webhooks/${eventId} (${eventType}) for sub=${resourceId}, uid=${uid}, trialing=${isTrialing}`);
   },
 };

package/src/manager/routes/payments/refund/post.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const powertools = require('node-powertools');
 
 /**
  * POST /payments/refund
@@ -8,6 +9,7 @@ const path = require('path');
  * Delegates to the processor (e.g., Stripe) to issue the refund and cancel.
  * The resulting webhook triggers the Firestore pipeline which updates subscription state
  * and fires the subscription-cancelled transition handler.
+ * Stores the refund reason/feedback on payments-orders/{orderId}.requests.refund.
  * Requires authentication.
  */
 module.exports = async ({ assistant, user, settings }) => {
@@ -79,6 +81,32 @@ module.exports = async ({ assistant, user, settings }) => {
     return assistant.respond(`Failed to process refund: ${e.message}`, { code: 500, sentry: true });
   }
 
+  // Store refund reason/feedback on the order doc
+  const orderId = subscription.payment?.orderId;
+
+  if (orderId) {
+    const admin = assistant.Manager.libraries.admin;
+    const now = powertools.timestamp(new Date(), { output: 'string' });
+    const nowUNIX = powertools.timestamp(now, { output: 'unix' });
+
+    await admin.firestore().doc(`payments-orders/${orderId}`).set({
+      requests: {
+        refund: {
+          reason: settings.reason || null,
+          feedback: settings.feedback || null,
+          amount: refund.amount,
+          full: refund.full,
+          date: {
+            timestamp: now,
+            timestampUNIX: nowUNIX,
+          },
+        },
+      },
+    }, { merge: true });
+
+    assistant.log(`Stored refund request on payments-orders/${orderId}: reason=${settings.reason}, amount=${refund.amount}`);
+  }
+
   assistant.log(`Refund processed: uid=${uid}, processor=${processor}, sub=${resourceId}, amount=${refund.amount}, full=${refund.full}, reason=${settings.reason}`);
 
   return assistant.respond({ success: true, refund });

package/src/test/test-accounts.js

@@ -166,6 +166,15 @@ const JOURNEY_ACCOUNTS = {
       subscription: { product: { id: 'basic' }, status: 'active' }, // Starts as basic, upgraded via trial webhook
     },
   },
+  'journey-payments-trial-cancel': {
+    id: 'journey-payments-trial-cancel',
+    uid: '_test-journey-payments-trial-cancel',
+    email: '_test.journey-payments-trial-cancel@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' }, // Starts as basic, trial then immediate cancel
+    },
+  },
   'journey-payments-failure': {
     id: 'journey-payments-failure',
     uid: '_test-journey-payments-failure',

package/test/events/payments/journey-payments-cancel-endpoint.js

@@ -75,5 +75,20 @@ module.exports = {
         assert.ok(userDoc.subscription.cancellation.date.timestampUNIX > 0, 'Cancellation date should be set');
       },
     },
+
+    {
+      name: 'cancellation-request-stored',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.ok(orderDoc.requests, 'requests field should exist');
+        assert.ok(orderDoc.requests.cancellation, 'requests.cancellation should be populated');
+        assert.equal(orderDoc.requests.cancellation.reason, 'Too expensive', 'Cancellation reason should match');
+        assert.equal(orderDoc.requests.cancellation.feedback, 'Would return at a lower price', 'Cancellation feedback should match');
+        assert.ok(orderDoc.requests.cancellation.date.timestampUNIX > 0, 'Cancellation date should be set');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should still be null');
+      },
+    },
   ],
 };

package/test/events/payments/journey-payments-cancel.js

@@ -148,5 +148,31 @@ module.exports = {
         assert.equal(userDoc.subscription.cancellation.pending, false, 'Cancellation should not be pending');
       },
     },
+
+    {
+      name: 'order-doc-verified',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null (cancel was via webhook, not endpoint)');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
+      },
+    },
+
+    {
+      name: 'intent-doc-completed',
+      async run({ firestore, assert, state }) {
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
+
+        assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
+      },
+    },
   ],
 };

package/test/events/payments/journey-payments-failure.js

@@ -112,5 +112,31 @@ module.exports = {
         assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should still be ${state.paidProductId}`);
       },
     },
+
+    {
+      name: 'order-doc-verified',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
+      },
+    },
+
+    {
+      name: 'intent-doc-completed',
+      async run({ firestore, assert, state }) {
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
+
+        assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after initial webhook processing');
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
+      },
+    },
   ],
 };

package/test/events/payments/journey-payments-one-time-failure.js

@@ -85,6 +85,9 @@ module.exports = {
         assert.equal(orderDoc.type, 'one-time', 'Type should be one-time');
         assert.equal(orderDoc.owner, state.uid, 'Owner should match');
         assert.equal(orderDoc.processor, 'test', 'Processor should be test');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
       },
     },
 

package/test/events/payments/journey-payments-one-time.js

@@ -88,6 +88,9 @@ module.exports = {
         assert.equal(orderDoc.unified.product.id, state.productId, `Product should be ${state.productId}`);
         assert.equal(orderDoc.unified.payment.processor, 'test', 'Unified processor should be test');
         assert.equal(orderDoc.unified.payment.orderId, state.orderId, 'Unified orderId should match');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
       },
     },
 
@@ -112,7 +115,7 @@ module.exports = {
     },
 
     {
-      name: 'intent-doc-created',
+      name: 'intent-doc-completed',
       async run({ firestore, assert, state }) {
         const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
 
@@ -121,7 +124,9 @@ module.exports = {
         assert.equal(intentDoc.intentId, state.intentId, 'Intent ID should match processor session ID');
         assert.equal(intentDoc.owner, state.uid, 'Owner should match');
         assert.equal(intentDoc.processor, 'test', 'Processor should be test');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
         assert.equal(intentDoc.productId, state.productId, `Product should be ${state.productId}`);
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
       },
     },
   ],

package/test/events/payments/journey-payments-plan-change.js

@@ -120,6 +120,21 @@ module.exports = {
         assert.ok(orderDoc, 'Order doc should exist');
         assert.equal(orderDoc.unified.product.id, state.productB.id, `Order product should be ${state.productB.id}`);
         assert.equal(orderDoc.unified.status, 'active', 'Order status should be active');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
+      },
+    },
+
+    {
+      name: 'intent-doc-completed',
+      async run({ firestore, assert, state }) {
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
+
+        assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
       },
     },
   ],

package/test/events/payments/journey-payments-suspend.js

@@ -147,5 +147,31 @@ module.exports = {
         assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should still be ${state.paidProductId}`);
       },
     },
+
+    {
+      name: 'order-doc-verified',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
+      },
+    },
+
+    {
+      name: 'intent-doc-completed',
+      async run({ firestore, assert, state }) {
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
+
+        assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
+      },
+    },
   ],
 };

package/test/events/payments/journey-payments-trial-cancel.js

@@ -0,0 +1,124 @@
+/**
+ * Test: Payment Journey - Trial Cancel
+ * Simulates: basic user → trial activation → cancel during trial → immediate cancellation
+ *
+ * When a user cancels during a free trial, the subscription should be cancelled immediately
+ * (not scheduled for period end) to avoid giving free premium access for the remainder of the trial.
+ *
+ * Uses the test processor for initial trial, then cancel endpoint for cancellation.
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+module.exports = {
+  description: 'Payment journey: trial → cancel during trial → immediate cancellation',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'verify-starts-as-basic',
+      async run({ accounts, firestore, assert, state, config }) {
+        const uid = accounts['journey-payments-trial-cancel'].uid;
+        const userDoc = await firestore.get(`users/${uid}`);
+
+        assert.ok(userDoc, 'User doc should exist');
+        assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
+        assert.equal(userDoc.subscription?.trial?.claimed, false, 'Trial should not be claimed');
+
+        // Resolve first paid product with trial from config
+        const trialProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices && p.trial?.days);
+        assert.ok(trialProduct, 'Config should have at least one paid product with trial');
+
+        state.uid = uid;
+        state.paidProductId = trialProduct.id;
+        state.paidProductName = trialProduct.name;
+      },
+    },
+
+    {
+      name: 'create-trial-intent',
+      async run({ http, assert, state }) {
+        const response = await http.as('journey-payments-trial-cancel').post('payments/intent', {
+          processor: 'test',
+          productId: state.paidProductId,
+          frequency: 'monthly',
+          trial: true,
+        });
+
+        assert.isSuccess(response, 'Intent should succeed');
+        assert.ok(response.data.id, 'Should return intent ID');
+        assert.ok(response.data.orderId, 'Should return orderId');
+
+        state.intentId = response.data.id;
+        state.orderId = response.data.orderId;
+        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
+      },
+    },
+
+    {
+      name: 'trial-activated',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${state.uid}`);
+          return userDoc?.subscription?.trial?.claimed === true;
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
+        assert.equal(userDoc.subscription.status, 'active', 'Status should be active');
+        assert.equal(userDoc.subscription.trial.claimed, true, 'Trial should be claimed');
+        assert.equal(userDoc.subscription.trial.expires.timestampUNIX, userDoc.subscription.expires.timestampUNIX, 'Trial expires should match subscription expires (still in trial period)');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+      },
+    },
+
+    {
+      name: 'cancel-during-trial',
+      async run({ http, assert }) {
+        // Cancel via endpoint — test processor should detect trial and simulate immediate cancel
+        const response = await http.as('journey-payments-trial-cancel').post('payments/cancel', {
+          confirmed: true,
+          reason: 'Changed my mind during trial',
+          feedback: 'Testing trial cancellation',
+        });
+
+        assert.isSuccess(response, 'Cancel endpoint should succeed');
+        assert.equal(response.data.success, true, 'Should return { success: true }');
+      },
+    },
+
+    {
+      name: 'verify-immediate-cancellation',
+      async run({ firestore, assert, state, waitFor }) {
+        // Poll until subscription is cancelled (NOT just pending)
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${state.uid}`);
+          return userDoc?.subscription?.status === 'cancelled';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        // During trial cancel: subscription should be immediately cancelled, not pending
+        assert.equal(userDoc.subscription.status, 'cancelled', 'Status should be cancelled (not active with pending)');
+        assert.equal(userDoc.subscription.cancellation.pending, false, 'Should NOT be pending — should be fully cancelled');
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should still be ${state.paidProductId}`);
+      },
+    },
+
+    {
+      name: 'cancellation-request-stored',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.ok(orderDoc.requests, 'requests field should exist');
+        assert.ok(orderDoc.requests.cancellation, 'requests.cancellation should be populated');
+        assert.equal(orderDoc.requests.cancellation.reason, 'Changed my mind during trial', 'Cancellation reason should match');
+        assert.equal(orderDoc.requests.cancellation.feedback, 'Testing trial cancellation', 'Cancellation feedback should match');
+        assert.ok(orderDoc.requests.cancellation.date.timestampUNIX > 0, 'Cancellation date should be set');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should still be null');
+      },
+    },
+  ],
+};

package/test/events/payments/journey-payments-trial.js

@@ -79,6 +79,35 @@ module.exports = {
       },
     },
 
+    {
+      name: 'intent-doc-completed',
+      async run({ firestore, assert, state }) {
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
+
+        assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
+      },
+    },
+
+    {
+      name: 'order-doc-created',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.equal(orderDoc.unified.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
+        assert.equal(orderDoc.unified.trial.claimed, true, 'Trial should be claimed');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
+      },
+    },
+
     {
       name: 'send-trial-to-active-webhook',
       async run({ http, assert, state, config }) {

package/test/events/payments/journey-payments-upgrade.js

@@ -90,6 +90,9 @@ module.exports = {
         assert.equal(orderDoc.resourceId, state.subscriptionId, 'Resource ID should match');
         assert.equal(orderDoc.unified.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
         assert.equal(orderDoc.unified.status, 'active', 'Status should be active');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null initially');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null initially');
       },
     },
 
@@ -109,7 +112,7 @@ module.exports = {
     },
 
     {
-      name: 'intent-doc-created',
+      name: 'intent-doc-completed',
       async run({ firestore, assert, state }) {
         const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
 
@@ -118,8 +121,9 @@ module.exports = {
         assert.equal(intentDoc.intentId, state.intentId, 'Intent ID should match processor session ID');
         assert.equal(intentDoc.owner, state.uid, 'Owner should match');
         assert.equal(intentDoc.processor, 'test', 'Processor should be test');
-        assert.equal(intentDoc.status, 'pending', 'Intent status should be pending');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
         assert.equal(intentDoc.productId, state.paidProductId, `Product should be ${state.paidProductId}`);
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
       },
     },
   ],