backend-manager 5.0.84 → 5.0.86

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

@@ -3,8 +3,12 @@ const powertools = require('node-powertools');
 
 /**
  * POST /payments/webhook?processor=stripe&key=XXX
- * Receives payment provider webhooks, validates them, and saves to Firestore
+ * Receives payment processor webhooks, validates them, and saves to Firestore
  * The Firestore onWrite trigger handles async processing
+ *
+ * This handler is processor-agnostic. Each processor module defines:
+ *   - parseWebhook(req) — extracts { eventId, eventType, raw, uid }
+ *   - isSupported(eventType) — returns true for events we should process
  */
 module.exports = async ({ assistant, Manager, libraries }) => {
   const { admin } = libraries;
@@ -25,32 +29,41 @@ module.exports = async ({ assistant, Manager, libraries }) => {
     return assistant.respond('Invalid key', { code: 401 });
   }
 
-  // Load the provider
-  let provider;
+  // Load the processor module
+  let processorModule;
   try {
-    provider = require(path.resolve(__dirname, `providers/${processor}.js`));
+    processorModule = require(path.resolve(__dirname, `processors/${processor}.js`));
   } catch (e) {
     return assistant.respond(`Unknown processor: ${processor}`, { code: 400 });
   }
 
-  // Parse the webhook using the provider
+  // Parse the webhook using the processor
   let parsed;
   try {
-    parsed = provider.parseWebhook(assistant.ref.req);
+    parsed = processorModule.parseWebhook(assistant.ref.req);
   } catch (e) {
     return assistant.respond(`Failed to parse webhook: ${e.message}`, { code: 400 });
   }
 
   const { eventId, eventType, raw, uid } = parsed;
 
+  assistant.log(`Parsed webhook: eventId=${eventId}, eventType=${eventType}, uid=${uid || 'null'}`);
+
+  // Let the processor decide if this event type is relevant
+  if (processorModule.isSupported && !processorModule.isSupported(eventType)) {
+    assistant.log(`Ignoring event type: ${eventType}`);
+    return assistant.respond({ received: true, ignored: true });
+  }
+
   // Check for duplicate (skip if already processing/completed)
   const existingDoc = await admin.firestore().doc(`payments-webhooks/${eventId}`).get();
   if (existingDoc.exists) {
     const existingStatus = existingDoc.data()?.status;
     if (existingStatus !== 'failed') {
-      assistant.log(`Webhook ${eventId} already exists with status=${existingStatus}, skipping`);
+      assistant.log(`Duplicate webhook ${eventId}, existing status=${existingStatus}, skipping`);
       return assistant.respond({ received: true, duplicate: true });
     }
+    assistant.log(`Retrying previously failed webhook ${eventId}`);
   }
 
   // Build timestamps
@@ -80,7 +93,7 @@ module.exports = async ({ assistant, Manager, libraries }) => {
     },
   });
 
-  assistant.log(`Webhook ${eventId} saved (type=${eventType}, processor=${processor}, uid=${uid})`);
+  assistant.log(`Saved payments-webhooks/${eventId}: eventType=${eventType}, processor=${processor}, uid=${uid}`);
 
   // Return 200 immediately
   return assistant.respond({ received: true });

package/src/manager/routes/payments/webhook/{providers → processors}/stripe.js

@@ -1,8 +1,23 @@
 /**
- * Stripe webhook provider
+ * Stripe webhook processor
  * Extracts and validates webhook event data from Stripe
  */
+
+// Stripe event types we process — add new ones here as needed
+const SUPPORTED_EVENTS = new Set([
+  'customer.subscription.created',
+  'customer.subscription.updated',
+  'customer.subscription.deleted',
+]);
+
 module.exports = {
+  /**
+   * Returns true if this event type should be saved and processed
+   */
+  isSupported(eventType) {
+    return SUPPORTED_EVENTS.has(eventType);
+  },
+
   /**
    * Parse a Stripe webhook request
    * Extracts the event data, event type, and resolves the UID from metadata

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

@@ -0,0 +1,15 @@
+/**
+ * Test webhook processor
+ * Delegates to Stripe's parser since test processor generates Stripe-shaped event payloads
+ */
+const stripeProcessor = require('./stripe.js');
+
+module.exports = {
+  isSupported(eventType) {
+    return stripeProcessor.isSupported(eventType);
+  },
+
+  parseWebhook(req) {
+    return stripeProcessor.parseWebhook(req);
+  },
+};

package/src/manager/routes/user/subscription/get.js

@@ -49,7 +49,7 @@ module.exports = async ({ assistant, user, settings, libraries }) => {
         timestampUNIX: userData?.subscription?.expires?.timestampUNIX || oldDateUNIX,
       },
       trial: {
-        activated: userData?.subscription?.trial?.activated ?? false,
+        claimed: userData?.subscription?.trial?.claimed ?? false,
         expires: {
           timestamp: userData?.subscription?.trial?.expires?.timestamp || oldDate,
           timestampUNIX: userData?.subscription?.trial?.expires?.timestampUNIX || oldDateUNIX,

package/src/manager/schemas/payments/webhook/post.js

@@ -1,6 +1,6 @@
 /**
  * Schema: POST /payments/webhook
- * Minimal schema - webhook payloads are validated by the provider, not the schema
+ * Minimal schema - webhook payloads are validated by the processor, not the schema
  * The processor and key come from query params, not the body
  */
 module.exports = () => ({});

package/src/test/test-accounts.js

@@ -130,37 +130,37 @@ const STATIC_ACCOUNTS = {
  * These accounts transition through states via webhook tests
  */
 const JOURNEY_ACCOUNTS = {
-  'journey-payment-upgrade': {
-    id: 'journey-payment-upgrade',
-    uid: '_test-journey-payment-upgrade',
-    email: '_test.journey-payment-upgrade@{domain}',
+  'journey-payments-upgrade': {
+    id: 'journey-payments-upgrade',
+    uid: '_test-journey-payments-upgrade',
+    email: '_test.journey-payments-upgrade@{domain}',
     properties: {
       roles: {},
       subscription: { product: { id: 'basic' }, status: 'active' }, // Starts as basic, upgraded via Stripe webhook
     },
   },
-  'journey-payment-cancel': {
-    id: 'journey-payment-cancel',
-    uid: '_test-journey-payment-cancel',
-    email: '_test.journey-payment-cancel@{domain}',
+  'journey-payments-cancel': {
+    id: 'journey-payments-cancel',
+    uid: '_test-journey-payments-cancel',
+    email: '_test.journey-payments-cancel@{domain}',
     properties: {
       roles: {},
-      subscription: { product: { id: 'premium' }, status: 'active', expires: getFutureExpires() }, // Starts as premium, cancelled via Stripe webhook
+      subscription: { product: { id: 'basic' }, status: 'active' }, // Test's first step overwrites with correct paid product from config
     },
   },
-  'journey-payment-suspend': {
-    id: 'journey-payment-suspend',
-    uid: '_test-journey-payment-suspend',
-    email: '_test.journey-payment-suspend@{domain}',
+  'journey-payments-suspend': {
+    id: 'journey-payments-suspend',
+    uid: '_test-journey-payments-suspend',
+    email: '_test.journey-payments-suspend@{domain}',
     properties: {
       roles: {},
-      subscription: { product: { id: 'premium' }, status: 'active', expires: getFutureExpires() }, // Starts as premium, suspended via failed payment webhook
+      subscription: { product: { id: 'basic' }, status: 'active' }, // Test's first step overwrites with correct paid product from config
     },
   },
-  'journey-payment-trial': {
-    id: 'journey-payment-trial',
-    uid: '_test-journey-payment-trial',
-    email: '_test.journey-payment-trial@{domain}',
+  'journey-payments-trial': {
+    id: 'journey-payments-trial',
+    uid: '_test-journey-payments-trial',
+    email: '_test.journey-payments-trial@{domain}',
     properties: {
       roles: {},
       subscription: { product: { id: 'basic' }, status: 'active' }, // Starts as basic, upgraded via trial webhook

package/templates/_.env

@@ -10,10 +10,8 @@ GITHUB_TOKEN=""
 OPENAI_API_KEY=""
 
 # Payment Processors
-PAYPAL_CLIENT_ID=""
 PAYPAL_CLIENT_SECRET=""
 STRIPE_SECRET_KEY=""
-CHARGEBEE_SITE=""
 CHARGEBEE_API_KEY=""
 COINBASE_API_KEY=""
 

package/templates/backend-manager-config.json

@@ -25,6 +25,56 @@
     secret: 'ABCx1234567890ABCDEFGH',
   },
   oauth2: {},
+  payment: {
+    processors: {
+      stripe: {
+        publishableKey: null,
+      },
+      paypal: {
+        clientId: null,
+      },
+      chargebee: {
+        site: null,
+      },
+      coinbase: {
+        enabled: false,
+      },
+    },
+    products: [
+      {
+        id: 'basic',
+        name: 'Basic',
+        type: 'subscription',
+        limits: {
+          requests: 100,
+        },
+      },
+      {
+        id: 'premium',
+        name: 'Premium',
+        type: 'subscription',
+        limits: {
+          requests: 1000,
+        },
+        trial: {
+          days: 14,
+        },
+        prices: {
+          monthly: {
+            amount: 4.99,
+            stripe: 'price_xxx',
+            paypal: 'P-xxx',
+          },
+          annually: {
+            amount: 49.99,
+            stripe: 'price_yyy',
+            paypal: 'P-yyy',
+          },
+        },
+      },
+      // Add more products/tiers here
+    ],
+  },
   firebaseConfig: {
     apiKey: '123-456',
     authDomain: 'PROJECT-ID.firebaseapp.com',
@@ -51,40 +101,6 @@
       // appUrl: 'https://api.otherapp.com', // Required if app is set (fetches /backend-manager/app)
     }
   ],
-  products: [
-    {
-      id: 'basic',
-      name: 'Basic',
-      type: 'subscription',
-      limits: {
-        requests: 100,
-      },
-    },
-    {
-      id: 'premium',
-      name: 'Premium',
-      type: 'subscription',
-      limits: {
-        requests: 1000,
-      },
-      trial: {
-        days: 14,
-      },
-      prices: {
-        monthly: {
-          amount: 4.99,
-          stripe: 'price_xxx',
-          paypal: 'P-xxx',
-        },
-        annually: {
-          amount: 49.99,
-          stripe: 'price_yyy',
-          paypal: 'P-yyy',
-        },
-      },
-    },
-    // Add more products/tiers here
-  ],
   reviews: {
     enabled: true,
     sites: [

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

@@ -0,0 +1,144 @@
+/**
+ * Test: Payment Journey - Cancel
+ * Simulates: paid active → pending cancel → cancelled
+ *
+ * Uses test intent for initial subscription, then manual webhooks for cancel flow
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+module.exports = {
+  description: 'Payment journey: paid → pending cancel → cancelled',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'setup-paid-subscription',
+      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+        const uid = accounts['journey-payments-cancel'].uid;
+
+        // Resolve first paid product from config
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        assert.ok(paidProduct, 'Config should have at least one paid product');
+
+        state.uid = uid;
+        state.paidProductId = paidProduct.id;
+        state.paidProductName = paidProduct.name;
+        state.paidPriceId = paidProduct.prices.monthly.stripe;
+
+        // Create subscription via test intent
+        const response = await http.as('journey-payments-cancel').post('payments/intent', {
+          processor: 'test',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+        assert.isSuccess(response, 'Intent should succeed');
+
+        // Wait for subscription to activate
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.product?.id === paidProduct.id;
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${uid}`);
+        assert.equal(userDoc.subscription?.product?.id, paidProduct.id, `Should start as ${paidProduct.id}`);
+        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+      },
+    },
+
+    {
+      name: 'send-pending-cancel-webhook',
+      async run({ http, assert, state, config }) {
+        const futureDate = new Date();
+        futureDate.setFullYear(futureDate.getFullYear() + 1);
+
+        state.eventId1 = `_test-evt-journey-cancel-pending-${Date.now()}`;
+
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          id: state.eventId1,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'active',
+              metadata: { uid: state.uid },
+              cancel_at_period_end: true,
+              cancel_at: Math.floor(futureDate.getTime() / 1000),
+              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.paidPriceId, interval: 'month' },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'pending-cancel-processed',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId1}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.status, 'active', 'Status should still be active');
+        assert.equal(userDoc.subscription.cancellation.pending, true, 'Cancellation should be pending');
+      },
+    },
+
+    {
+      name: 'send-cancelled-webhook',
+      async run({ http, assert, state, config }) {
+        state.eventId2 = `_test-evt-journey-cancel-final-${Date.now()}`;
+
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          id: state.eventId2,
+          type: 'customer.subscription.deleted',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'canceled',
+              metadata: { uid: state.uid },
+              cancel_at_period_end: false,
+              canceled_at: Math.floor(Date.now() / 1000),
+              current_period_end: Math.floor(Date.now() / 1000),
+              current_period_start: Math.floor(Date.now() / 1000) - 86400 * 30,
+              start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
+              trial_start: null,
+              trial_end: null,
+              plan: { id: state.paidPriceId, interval: 'month' },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'subscription-cancelled',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.status, 'cancelled', 'Status should be cancelled');
+        assert.equal(userDoc.subscription.cancellation.pending, false, 'Cancellation should not be pending');
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,143 @@
+/**
+ * Test: Payment Journey - Suspend & Recover
+ * Simulates: paid active → payment fails → suspended → payment succeeds → active again
+ *
+ * Uses test intent for initial subscription, then manual webhooks for suspend/recover
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+module.exports = {
+  description: 'Payment journey: paid → suspended → recovered via test processor',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'setup-paid-subscription',
+      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+        const uid = accounts['journey-payments-suspend'].uid;
+
+        // Resolve first paid product from config
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        assert.ok(paidProduct, 'Config should have at least one paid product');
+
+        state.uid = uid;
+        state.paidProductId = paidProduct.id;
+        state.paidProductName = paidProduct.name;
+        state.paidPriceId = paidProduct.prices.monthly.stripe;
+
+        // Create subscription via test intent
+        const response = await http.as('journey-payments-suspend').post('payments/intent', {
+          processor: 'test',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+        assert.isSuccess(response, 'Intent should succeed');
+
+        // Wait for subscription to activate
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.product?.id === paidProduct.id;
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${uid}`);
+        assert.equal(userDoc.subscription?.product?.id, paidProduct.id, `Should start as ${paidProduct.id}`);
+        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+      },
+    },
+
+    {
+      name: 'send-past-due-webhook',
+      async run({ http, assert, state, config }) {
+        state.eventId1 = `_test-evt-journey-suspend-fail-${Date.now()}`;
+
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          id: state.eventId1,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'past_due',
+              metadata: { uid: state.uid },
+              cancel_at_period_end: false,
+              canceled_at: null,
+              current_period_end: Math.floor(Date.now() / 1000) + 86400,
+              current_period_start: Math.floor(Date.now() / 1000) - 86400 * 29,
+              start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
+              trial_start: null,
+              trial_end: null,
+              plan: { id: state.paidPriceId, interval: 'month' },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'subscription-suspended',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId1}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.status, 'suspended', 'Status should be suspended');
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should still be ${state.paidProductId}`);
+      },
+    },
+
+    {
+      name: 'send-recovery-webhook',
+      async run({ http, assert, state, config }) {
+        const futureDate = new Date();
+        futureDate.setMonth(futureDate.getMonth() + 1);
+
+        state.eventId2 = `_test-evt-journey-suspend-recover-${Date.now()}`;
+
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          id: state.eventId2,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'active',
+              metadata: { uid: state.uid },
+              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 * 60,
+              trial_start: null,
+              trial_end: null,
+              plan: { id: state.paidPriceId, interval: 'month' },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'subscription-recovered',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.status, 'active', 'Status should be active again');
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should still be ${state.paidProductId}`);
+      },
+    },
+  ],
+};