backend-manager 5.0.89 → 5.0.91

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

@@ -1,4 +1,5 @@
 const fetch = require('wonderful-fetch');
+const resolvePriceId = require('../../../../libraries/payment-processors/resolve-price-id.js');
 
 /**
  * Test intent processor
@@ -16,12 +17,13 @@ module.exports = {
    * @param {string} options.productId - Product ID from config
    * @param {string} options.frequency - 'monthly' or 'annually' (subscriptions only)
    * @param {boolean} options.trial - Whether to include a trial period (subscriptions only)
-   * @param {object} options.config - BEM config
+   * @param {string} options.confirmationUrl - Success redirect URL
+   * @param {string} options.cancelUrl - Cancel redirect URL
    * @param {object} options.Manager - Manager instance
    * @param {object} options.assistant - Assistant instance
    * @returns {object} { id, url, raw }
    */
-  async createIntent({ uid, orderId, product, productId, frequency, trial, config, Manager, assistant }) {
+  async createIntent({ uid, orderId, product, productId, frequency, trial, confirmationUrl, Manager, assistant }) {
     // Guard: test processor is not available in production
     if (assistant.isProduction()) {
       throw new Error('Test processor is not available in production');
@@ -30,10 +32,10 @@ module.exports = {
     const productType = product.type || 'subscription';
 
     if (productType === 'subscription') {
-      return createSubscriptionIntent({ uid, orderId, product, productId, frequency, trial, config, Manager, assistant });
+      return createSubscriptionIntent({ uid, orderId, product, frequency, trial, confirmationUrl, Manager, assistant });
     }
 
-    return createOneTimeIntent({ uid, orderId, product, productId, config, Manager, assistant });
+    return createOneTimeIntent({ uid, orderId, product, productId, confirmationUrl, Manager, assistant });
   },
 };
 
@@ -41,12 +43,9 @@ module.exports = {
  * Create a test subscription intent
  * Generates Stripe-shaped subscription + customer.subscription.created event
  */
-async function createSubscriptionIntent({ uid, orderId, product, productId, frequency, trial, config, Manager, assistant }) {
+async function createSubscriptionIntent({ uid, orderId, product, frequency, trial, confirmationUrl, Manager, assistant }) {
   // Get the price ID for the requested frequency
-  const priceId = product.prices?.[frequency]?.stripe;
-  if (!priceId) {
-    throw new Error(`No Stripe price found for ${productId}/${frequency}`);
-  }
+  const priceId = resolvePriceId(product, 'subscription', frequency);
 
   // Generate IDs
   const timestamp = Date.now();
@@ -94,14 +93,14 @@ async function createSubscriptionIntent({ uid, orderId, product, productId, freq
     data: { object: subscription },
   };
 
-  assistant?.log(`Test subscription intent: sessionId=${sessionId}, subscriptionId=${subscriptionId}, eventId=${eventId}, trial=${!!subscription.trial_start}`);
+  assistant.log(`Test subscription intent: sessionId=${sessionId}, subscriptionId=${subscriptionId}, eventId=${eventId}, trial=${!!subscription.trial_start}`);
 
   // Auto-fire webhook
   fireWebhook({ event, Manager, assistant });
 
   return {
     id: sessionId,
-    url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
+    url: confirmationUrl,
     raw: { id: sessionId, object: 'checkout.session', subscription: subscriptionId },
   };
 }
@@ -110,12 +109,9 @@ async function createSubscriptionIntent({ uid, orderId, product, productId, freq
  * Create a test one-time payment intent
  * Generates Stripe-shaped checkout session + checkout.session.completed event
  */
-async function createOneTimeIntent({ uid, orderId, product, productId, config, Manager, assistant }) {
-  // Get the price ID for one-time purchase
-  const priceId = product.prices?.once?.stripe;
-  if (!priceId) {
-    throw new Error(`No Stripe price found for ${productId}/once`);
-  }
+async function createOneTimeIntent({ uid, orderId, product, productId, confirmationUrl, Manager, assistant }) {
+  // Validate that a price exists (resolvePriceId throws if not found)
+  resolvePriceId(product, 'one-time', null);
 
   // Generate IDs
   const timestamp = Date.now();
@@ -141,14 +137,14 @@ async function createOneTimeIntent({ uid, orderId, product, productId, config, M
     data: { object: session },
   };
 
-  assistant?.log(`Test one-time intent: sessionId=${sessionId}, eventId=${eventId}, productId=${productId}`);
+  assistant.log(`Test one-time intent: sessionId=${sessionId}, eventId=${eventId}, productId=${productId}`);
 
   // Auto-fire webhook
   fireWebhook({ event, Manager, assistant });
 
   return {
     id: sessionId,
-    url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
+    url: confirmationUrl,
     raw: { id: sessionId, object: 'checkout.session', mode: 'payment' },
   };
 }
@@ -164,6 +160,6 @@ function fireWebhook({ event, Manager, assistant }) {
     body: event,
     timeout: 15000,
   }).catch((e) => {
-    assistant?.log(`Test processor auto-webhook failed: ${e.message}`);
+    assistant.log(`Test processor auto-webhook failed: ${e.message}`);
   });
 }

package/src/test/runner.js

@@ -1,3 +1,4 @@
+const os = require('os');
 const path = require('path');
 const jetpack = require('fs-jetpack');
 const chalk = require('chalk');
@@ -52,6 +53,16 @@ class TestRunner {
    * Main run method
    */
   async run() {
+    // Abort if BEM is running from the user's home directory (e.g., accidental ~/node_modules install)
+    const homeDir = os.homedir();
+    if (__dirname.startsWith(path.join(homeDir, 'node_modules'))) {
+      console.error(chalk.red('\n  ERROR: BEM is running from ~/node_modules (home directory install).'));
+      console.error(chalk.red('  This is likely an accidental global install that shadows local project copies.'));
+      console.error(chalk.red(`  Fix: rm -rf ${path.join(homeDir, 'node_modules')} ${path.join(homeDir, 'package.json')} ${path.join(homeDir, 'package-lock.json')}`));
+      console.error(chalk.red(`  Running from: ${__dirname}\n`));
+      process.exit(1);
+    }
+
     // Set testing flag to skip external API calls (emails, SendGrid)
     process.env.BEM_TESTING = 'true';
 

package/src/test/test-accounts.js

@@ -175,6 +175,24 @@ const JOURNEY_ACCOUNTS = {
       subscription: { product: { id: 'basic' }, status: 'active' }, // Test's first step overwrites with correct paid product from config
     },
   },
+  'journey-payments-plan-change': {
+    id: 'journey-payments-plan-change',
+    uid: '_test-journey-payments-plan-change',
+    email: '_test.journey-payments-plan-change@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' }, // Test's first step overwrites with correct paid product from config
+    },
+  },
+  'journey-payments-one-time': {
+    id: 'journey-payments-one-time',
+    uid: '_test-journey-payments-one-time',
+    email: '_test.journey-payments-one-time@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' },
+    },
+  },
 };
 
 /**

package/templates/backend-manager-config.json

@@ -72,18 +72,37 @@
           },
         },
       },
-      // Example one-time product:
-      // {
-      //   id: 'credits-100',
-      //   name: '100 Credits',
-      //   type: 'one-time',
-      //   prices: {
-      //     once: {
-      //       amount: 9.99,
-      //       stripe: null,
-      //     },
-      //   },
-      // },
+      {
+        id: 'ultimate',
+        name: 'Ultimate',
+        type: 'subscription',
+        limits: {
+          requests: 10000,
+        },
+        prices: {
+          monthly: {
+            amount: 19.99,
+            stripe: null,
+            paypal: null,
+          },
+          annually: {
+            amount: 199.99,
+            stripe: null,
+            paypal: null,
+          },
+        },
+      },
+      {
+        id: 'credits-100',
+        name: '100 Credits',
+        type: 'one-time',
+        prices: {
+          once: {
+            amount: 9.99,
+            stripe: null,
+          },
+        },
+      },
       // Add more products/tiers here
     ],
   },

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

@@ -0,0 +1,105 @@
+/**
+ * Test: Payment Journey - One-Time Payment Failure
+ * Simulates: invoice.payment_failed for a non-subscription invoice → purchase-failed transition
+ *
+ * This verifies the webhook routing for one-time invoice failures:
+ * invoice.payment_failed with no subscription billing_reason → category: 'one-time'
+ *
+ * Uses the journey-payments-one-time account (one-time events don't modify subscription state)
+ */
+module.exports = {
+  description: 'Payment journey: one-time invoice.payment_failed → purchase-failed',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'resolve-one-time-product',
+      async run({ accounts, assert, state, config }) {
+        const uid = accounts['journey-payments-one-time'].uid;
+
+        // Resolve first one-time product from config
+        const oneTimeProduct = config.payment.products.find(p => p.type === 'one-time' && p.prices?.once);
+        assert.ok(oneTimeProduct, 'Config should have at least one one-time product');
+
+        state.uid = uid;
+        state.productId = oneTimeProduct.id;
+      },
+    },
+
+    {
+      name: 'send-one-time-payment-failed',
+      async run({ http, assert, state, config }) {
+        state.eventId = `_test-evt-journey-onetime-fail-${Date.now()}`;
+        state.invoiceId = `_test-inv-onetime-fail-${Date.now()}`;
+        state.orderId = `0000-0000-0000`; // Fake orderId for test
+
+        // Send invoice.payment_failed with a non-subscription billing reason
+        // This routes to category: 'one-time' in the webhook parser
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          id: state.eventId,
+          type: 'invoice.payment_failed',
+          data: {
+            object: {
+              id: state.invoiceId,
+              object: 'invoice',
+              billing_reason: 'manual',
+              amount_due: 999,
+              amount_paid: 0,
+              status: 'open',
+              metadata: {
+                uid: state.uid,
+                orderId: state.orderId,
+                productId: state.productId,
+              },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'webhook-categorized-as-one-time',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'completed' || doc?.status === 'failed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.ok(webhookDoc, 'Webhook doc should exist');
+        assert.equal(webhookDoc.event?.category, 'one-time', 'Category should be one-time');
+        assert.equal(webhookDoc.event?.resourceType, 'invoice', 'Resource type should be invoice');
+        assert.equal(webhookDoc.transition, 'purchase-failed', 'Transition should be purchase-failed');
+      },
+    },
+
+    {
+      name: 'order-doc-created-with-failure',
+      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, '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');
+      },
+    },
+
+    {
+      name: 'subscription-unchanged',
+      async run({ firestore, assert, state }) {
+        // One-time payment failures must NOT modify subscription state
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(
+          userDoc.subscription?.product?.id,
+          'basic',
+          'Subscription should remain basic after one-time failure',
+        );
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,128 @@
+/**
+ * Test: Payment Journey - One-Time Purchase
+ * Simulates: user → test intent (one-time product) → auto-webhook → purchase-completed
+ *
+ * Uses the test processor to exercise the full intent→webhook→trigger pipeline
+ * for one-time payments. Unlike subscriptions, one-time payments only write to
+ * payments-orders/{orderId} — they do NOT modify users/{uid}.subscription.
+ *
+ * Requires at least one product with type: 'one-time' in config.payment.products
+ */
+module.exports = {
+  description: 'Payment journey: one-time purchase via test intent → purchase-completed',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'resolve-one-time-product',
+      async run({ accounts, firestore, assert, state, config }) {
+        const uid = accounts['journey-payments-one-time'].uid;
+        const userDoc = await firestore.get(`users/${uid}`);
+
+        assert.ok(userDoc, 'User doc should exist');
+
+        // Resolve first one-time product from config
+        const oneTimeProduct = config.payment.products.find(p => p.type === 'one-time' && p.prices?.once);
+        assert.ok(oneTimeProduct, 'Config should have at least one one-time product');
+
+        state.uid = uid;
+        state.productId = oneTimeProduct.id;
+        state.productName = oneTimeProduct.name;
+        state.price = oneTimeProduct.prices.once.amount;
+
+        // Snapshot subscription before purchase — should remain unchanged after
+        state.subscriptionBefore = userDoc.subscription || null;
+      },
+    },
+
+    {
+      name: 'create-one-time-intent',
+      async run({ http, assert, state }) {
+        const response = await http.as('journey-payments-one-time').post('payments/intent', {
+          processor: 'test',
+          productId: state.productId,
+        });
+
+        assert.isSuccess(response, 'Intent should succeed');
+        assert.ok(response.data.id, 'Should return intent ID');
+        assert.ok(response.data.orderId, 'Should return orderId');
+        assert.match(response.data.orderId, /^\d{4}-\d{4}-\d{4}$/, 'orderId should be XXXX-XXXX-XXXX format');
+        assert.ok(response.data.url, 'Should return URL');
+
+        state.intentId = response.data.id;
+        state.orderId = response.data.orderId;
+
+        // Derive webhook event ID from intent ID (same timestamp)
+        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
+      },
+    },
+
+    {
+      name: 'webhook-transition-purchase-completed',
+      async run({ firestore, assert, state, waitFor }) {
+        // Poll until the webhook is processed
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.ok(webhookDoc, 'Webhook doc should exist');
+        assert.equal(webhookDoc.transition, 'purchase-completed', 'Transition should be purchase-completed');
+        assert.equal(webhookDoc.orderId, state.orderId, 'Webhook doc orderId should match intent');
+        assert.equal(webhookDoc.event?.category, 'one-time', 'Category should be one-time');
+      },
+    },
+
+    {
+      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, '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.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');
+      },
+    },
+
+    {
+      name: 'subscription-unchanged',
+      async run({ firestore, assert, state }) {
+        // One-time payments must NOT modify users/{uid}.subscription
+        const userDoc = await firestore.get(`users/${state.uid}`);
+        const subAfter = userDoc.subscription || null;
+
+        assert.deepEqual(
+          subAfter?.product?.id,
+          state.subscriptionBefore?.product?.id,
+          'Subscription product should be unchanged after one-time purchase',
+        );
+        assert.deepEqual(
+          subAfter?.status,
+          state.subscriptionBefore?.status,
+          'Subscription status should be unchanged after one-time purchase',
+        );
+      },
+    },
+
+    {
+      name: 'intent-doc-created',
+      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.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.productId, state.productId, `Product should be ${state.productId}`);
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,126 @@
+/**
+ * Test: Payment Journey - Plan Change
+ * Simulates: basic → paid product A → plan-changed webhook → paid product B
+ *
+ * Uses test intent for initial subscription, then manual webhook to change plans.
+ * Requires at least two paid subscription products in config.
+ */
+module.exports = {
+  description: 'Payment journey: paid product A → plan-changed → paid product B',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'setup-paid-subscription',
+      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+        const uid = accounts['journey-payments-plan-change'].uid;
+
+        // Resolve two distinct paid subscription products from config
+        const paidProducts = config.payment.products.filter(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
+        assert.ok(paidProducts.length >= 2, 'Config should have at least two paid subscription products');
+
+        const productA = paidProducts[0];
+        const productB = paidProducts[1];
+
+        state.uid = uid;
+        state.productA = { id: productA.id, name: productA.name, priceId: productA.prices.monthly.stripe };
+        state.productB = { id: productB.id, name: productB.name, priceId: productB.prices.monthly.stripe };
+
+        // Create subscription via test intent (product A)
+        const response = await http.as('journey-payments-plan-change').post('payments/intent', {
+          processor: 'test',
+          productId: productA.id,
+          frequency: 'monthly',
+        });
+        assert.isSuccess(response, 'Intent should succeed');
+        state.orderId = response.data.orderId;
+
+        // Wait for subscription to activate
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.product?.id === productA.id;
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${uid}`);
+        assert.equal(userDoc.subscription?.product?.id, productA.id, `Should start as ${productA.id}`);
+        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+      },
+    },
+
+    {
+      name: 'send-plan-change-webhook',
+      async run({ http, assert, state, config }) {
+        const futureDate = new Date();
+        futureDate.setMonth(futureDate.getMonth() + 1);
+
+        state.eventId = `_test-evt-journey-plan-change-${Date.now()}`;
+
+        // Send subscription.updated with a different product's price ID
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          id: state.eventId,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'active',
+              metadata: { uid: state.uid, orderId: state.orderId },
+              cancel_at_period_end: false,
+              canceled_at: null,
+              current_period_end: Math.floor(futureDate.getTime() / 1000),
+              current_period_start: Math.floor(Date.now() / 1000),
+              start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
+              trial_start: null,
+              trial_end: null,
+              plan: { id: state.productB.priceId, interval: 'month' },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'plan-changed-transition-detected',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.ok(webhookDoc, 'Webhook doc should exist');
+        assert.equal(webhookDoc.transition, 'plan-changed', 'Transition should be plan-changed');
+      },
+    },
+
+    {
+      name: 'subscription-updated-to-product-b',
+      async run({ firestore, assert, state }) {
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.product.id, state.productB.id, `Product should be ${state.productB.id}`);
+        assert.equal(userDoc.subscription.product.name, state.productB.name, `Product name should be ${state.productB.name}`);
+        assert.equal(userDoc.subscription.status, 'active', 'Status should still be active');
+        assert.equal(userDoc.subscription.payment.processor, 'test', 'Processor should be test');
+        assert.equal(userDoc.subscription.payment.frequency, 'monthly', 'Frequency should be monthly');
+        assert.equal(userDoc.subscription.payment.resourceId, state.subscriptionId, 'Resource ID should be the same subscription');
+      },
+    },
+
+    {
+      name: 'order-doc-updated',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        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');
+      },
+    },
+  ],
+};

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

@@ -88,8 +88,8 @@ module.exports = {
         assert.equal(orderDoc.owner, state.uid, 'Owner should match');
         assert.equal(orderDoc.processor, 'test', 'Processor should be test');
         assert.equal(orderDoc.resourceId, state.subscriptionId, 'Resource ID should match');
-        assert.equal(orderDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(orderDoc.subscription.status, 'active', 'Status should be active');
+        assert.equal(orderDoc.unified.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
+        assert.equal(orderDoc.unified.status, 'active', 'Status should be active');
       },
     },