backend-manager 5.0.85 → 5.0.87

package/src/manager/libraries/payment-processors/test.js

@@ -0,0 +1,141 @@
+const Stripe = require('./stripe.js');
+
+/**
+ * Test processor library
+ * Delegates to Stripe's transformers since test processor generates Stripe-shaped data
+ * Stamps processor as 'test' to distinguish from real Stripe data
+ */
+const Test = {
+  /**
+   * No-op init — test processor doesn't need an external SDK
+   */
+  init() {
+    return null;
+  },
+
+  /**
+   * Fetch resource — test processor has no real API
+   *
+   * When the requested resourceType doesn't match the fallback (e.g., requesting a subscription
+   * but the fallback is an invoice from invoice.payment_failed), look up the existing resource
+   * from Firestore instead of returning mismatched data.
+   */
+  async fetchResource(resourceType, resourceId, rawFallback, context) {
+    // If the fallback matches the requested type, return it directly
+    if (rawFallback?.object === resourceType) {
+      return rawFallback;
+    }
+
+    // Fallback doesn't match — try to look up the resource from Firestore
+    const admin = context?.admin;
+    if (admin && resourceId) {
+      const collection = resourceType === 'subscription' ? 'payments-subscriptions' : 'payments-one-time';
+      const doc = await admin.firestore().doc(`${collection}/${resourceId}`).get();
+
+      if (doc.exists) {
+        const data = doc.data();
+        // payments-subscriptions stores the unified subscription inside .subscription
+        // Reconstruct a Stripe-shaped object from the unified data for toUnifiedSubscription()
+        if (resourceType === 'subscription' && data.subscription) {
+          return buildStripeSubscriptionFromUnified(data.subscription, resourceId, context?.eventType, context?.config);
+        }
+      }
+    }
+
+    // Last resort: return the raw fallback
+    return rawFallback;
+  },
+
+  /**
+   * Transform raw subscription into unified shape
+   * Delegates to Stripe's toUnifiedSubscription (same data shape), stamps processor as 'test'
+   */
+  toUnifiedSubscription(rawSubscription, options) {
+    const unified = Stripe.toUnifiedSubscription(rawSubscription, options);
+    unified.payment.processor = 'test';
+    return unified;
+  },
+
+  /**
+   * Transform raw one-time payment into unified shape
+   * Delegates to Stripe's toUnifiedOneTime, stamps processor as 'test'
+   */
+  toUnifiedOneTime(rawResource, options) {
+    const unified = Stripe.toUnifiedOneTime(rawResource, options);
+    unified.processor = 'test';
+    return unified;
+  },
+};
+
+module.exports = Test;
+
+/**
+ * Reconstruct a Stripe-shaped subscription from the unified subscription stored in Firestore
+ * This is only needed for the test processor when the webhook fallback doesn't match the resource type
+ * (e.g., invoice.payment_failed sends invoice data but we need the subscription)
+ *
+ * The unified → Stripe mapping must produce data that toUnifiedSubscription() can process correctly.
+ * For payment failure events, we override the status to past_due so it maps to 'suspended'.
+ */
+function buildStripeSubscriptionFromUnified(unified, resourceId, eventType, config) {
+  // Map unified status back to a Stripe status
+  const STATUS_MAP = {
+    active: 'active',
+    suspended: 'past_due',
+    cancelled: 'canceled',
+  };
+
+  // Map unified frequency back to Stripe interval
+  const INTERVAL_MAP = {
+    monthly: 'month',
+    annually: 'year',
+    weekly: 'week',
+    daily: 'day',
+  };
+
+  // Determine status: for payment failure events, force past_due regardless of current state
+  // In production, Stripe would have already updated the subscription status
+  let status = STATUS_MAP[unified.status] || 'active';
+  if (eventType === 'invoice.payment_failed') {
+    status = 'past_due';
+  }
+
+  // Resolve the Stripe price ID from product + frequency via config
+  // This is needed for resolveProduct() in toUnifiedSubscription() to match the correct product
+  const frequency = unified.payment?.frequency;
+  const productId = unified.product?.id;
+  const priceId = resolvePriceId(productId, frequency, config);
+
+  return {
+    id: resourceId,
+    object: 'subscription',
+    status: status,
+    metadata: {},
+    plan: {
+      id: priceId,
+      interval: INTERVAL_MAP[frequency] || 'month',
+    },
+    current_period_end: unified.expires?.timestampUNIX || 0,
+    current_period_start: unified.payment?.startDate?.timestampUNIX || 0,
+    start_date: unified.payment?.startDate?.timestampUNIX || 0,
+    cancel_at_period_end: unified.cancellation?.pending || false,
+    cancel_at: unified.cancellation?.pending ? unified.cancellation?.date?.timestampUNIX : null,
+    canceled_at: null,
+    trial_start: unified.trial?.claimed ? (unified.payment?.startDate?.timestampUNIX || 0) : null,
+    trial_end: unified.trial?.claimed ? (unified.trial?.expires?.timestampUNIX || 0) : null,
+  };
+}
+
+/**
+ * Look up the Stripe price ID from config given a product ID and frequency
+ * e.g., ('plus', 'monthly') → 'price_plus_monthly'
+ */
+function resolvePriceId(productId, frequency, config) {
+  if (!productId || !frequency || !config?.payment?.products) {
+    return null;
+  }
+
+  const product = config.payment.products.find(p => p.id === productId);
+
+  return product?.prices?.[frequency]?.stripe || null;
+}

package/src/manager/routes/app/get.js

@@ -14,29 +14,12 @@ module.exports = async ({ assistant, Manager }) => {
  */
 function buildPublicConfig(config) {
   return {
-    id: config.app?.id,
-    name: config.brand?.name,
-    description: config.brand?.description,
-    url: config.brand?.url,
-    email: config.brand?.contact?.email,
-    images: config.brand?.images || {},
-    github: {
-      user: config.github?.user,
-      repo: (config.github?.repo_website || '').split('/').pop(),
-    },
-    reviews: config.reviews || {},
+    brand: config.brand || {},
+    github: config.github || {},
+    oauth2: config.oauth2 || {},
+    payment: config.payment || {},
     firebaseConfig: config.firebaseConfig || {},
-    payment: {
-      processors: config.payment?.processors || {},
-      products: (config.payment?.products || []).map(p => ({
-        id: p.id,
-        name: p.name,
-        type: p.type,
-        limits: p.limits || {},
-        trial: p.trial || {},
-        prices: p.prices || {},
-      })),
-    },
+    reviews: config.reviews || {},
   };
 }
 

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

@@ -3,7 +3,7 @@ const powertools = require('node-powertools');
 
 /**
  * POST /payments/intent
- * Creates a payment intent (e.g., Stripe Checkout Session) for subscription purchase
+ * Creates a payment intent (e.g., Stripe Checkout Session) for subscription or one-time purchase
  * Requires authentication
  */
 module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
@@ -22,26 +22,6 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
 
   assistant.log(`Intent request: uid=${uid}, processor=${processor}, product=${productId}, frequency=${frequency}, trial=${trial}`);
 
-  // Check if user already has an active non-basic subscription
-  if (user.subscription?.status === 'active' && user.subscription?.product?.id !== 'basic') {
-    assistant.log(`User ${uid} already has active subscription: product=${user.subscription.product.id}, status=${user.subscription.status}, resourceId=${user.subscription.payment?.resourceId}`);
-    return assistant.respond('User already has an active subscription', { code: 400 });
-  }
-
-  // Resolve trial eligibility: if requested but user has subscription history, silently downgrade
-  if (trial) {
-    const historySnapshot = await admin.firestore()
-      .collection('payments-subscriptions')
-      .where('uid', '==', uid)
-      .limit(1)
-      .get();
-
-    if (!historySnapshot.empty) {
-      assistant.log(`User ${uid} not eligible for trial (has subscription history), continuing without trial`);
-      trial = false;
-    }
-  }
-
   // Validate product exists in config
   const product = (Manager.config.payment?.products || []).find(p => p.id === productId);
   if (!product) {
@@ -49,7 +29,40 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
     return assistant.respond(`Product '${productId}' not found`, { code: 400 });
   }
 
-  assistant.log(`Product resolved: id=${product.id}, name=${product.name}, trialDays=${product.trial?.days || 'none'}`);
+  const productType = product.type || 'subscription';
+
+  assistant.log(`Product resolved: id=${product.id}, name=${product.name}, type=${productType}, trialDays=${product.trial?.days || 'none'}`);
+
+  // Subscription-specific guards
+  if (productType === 'subscription') {
+    // Require frequency for subscriptions
+    if (!frequency) {
+      return assistant.respond('Frequency is required for subscription products', { code: 400 });
+    }
+
+    // Check if user already has an active non-basic subscription
+    if (user.subscription?.status === 'active' && user.subscription?.product?.id !== 'basic') {
+      assistant.log(`User ${uid} already has active subscription: product=${user.subscription.product.id}, status=${user.subscription.status}, resourceId=${user.subscription.payment?.resourceId}`);
+      return assistant.respond('User already has an active subscription', { code: 400 });
+    }
+
+    // Resolve trial eligibility: if requested but user has subscription history, silently downgrade
+    if (trial) {
+      const historySnapshot = await admin.firestore()
+        .collection('payments-subscriptions')
+        .where('uid', '==', uid)
+        .limit(1)
+        .get();
+
+      if (!historySnapshot.empty) {
+        assistant.log(`User ${uid} not eligible for trial (has subscription history), continuing without trial`);
+        trial = false;
+      }
+    }
+  } else {
+    // One-time purchases don't use trial or frequency
+    trial = false;
+  }
 
   // Load the processor module
   let processorModule;
@@ -64,6 +77,7 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
   try {
     result = await processorModule.createIntent({
       uid,
+      product,
       productId,
       frequency,
       trial,
@@ -89,6 +103,7 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
     uid: uid,
     status: 'pending',
     productId: productId,
+    productType: productType,
     frequency: frequency,
     trial: trial,
     raw: result.raw,
@@ -100,7 +115,7 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
     },
   });
 
-  assistant.log(`Saved payments-intents/${result.id}: uid=${uid}, product=${productId}, frequency=${frequency}, trial=${trial}`);
+  assistant.log(`Saved payments-intents/${result.id}: uid=${uid}, product=${productId}, type=${productType}, frequency=${frequency}, trial=${trial}`);
 
   return assistant.respond({
     id: result.id,

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

@@ -1,75 +1,85 @@
 /**
  * Stripe intent processor
- * Creates Stripe Checkout Sessions for subscription purchases
+ * Creates Stripe Checkout Sessions for subscription and one-time purchases
  */
 module.exports = {
   /**
-   * Create a Stripe Checkout Session for a subscription
+   * Create a Stripe Checkout Session
    *
    * @param {object} options
    * @param {string} options.uid - User's UID
+   * @param {object} options.product - Full product object from config
    * @param {string} options.productId - Product ID from config (e.g., 'premium')
-   * @param {string} options.frequency - 'monthly' or 'annually'
-   * @param {boolean} options.trial - Whether to include a trial period
-   * @param {object} options.config - BEM config (must contain products array)
+   * @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 {object} options.Manager - Manager instance
    * @returns {object} { id, url, raw }
    */
-  async createIntent({ uid, productId, frequency, trial, config, Manager, assistant }) {
+  async createIntent({ uid, product, productId, frequency, trial, config, Manager, assistant }) {
     // Initialize Stripe SDK
-    const StripeLib = require('../../../../libraries/stripe.js');
+    const StripeLib = require('../../../../libraries/payment-processors/stripe.js');
     const stripe = StripeLib.init();
 
-    // Find the product in config
-    const product = (config.payment?.products || []).find(p => p.id === productId);
-    if (!product) {
-      throw new Error(`Product '${productId}' not found in config`);
-    }
+    const productType = product.type || 'subscription';
 
-    // Get the Stripe price ID for the requested frequency
-    const priceId = product.prices?.[frequency]?.stripe;
-    if (!priceId) {
-      throw new Error(`No Stripe price found for ${productId}/${frequency}`);
+    // Resolve the Stripe price ID based on product type
+    let priceId;
+    if (productType === 'subscription') {
+      priceId = product.prices?.[frequency]?.stripe;
+      if (!priceId) {
+        throw new Error(`No Stripe price found for ${productId}/${frequency}`);
+      }
+    } else {
+      priceId = product.prices?.once?.stripe;
+      if (!priceId) {
+        throw new Error(`No Stripe price found for ${productId}/once`);
+      }
     }
 
     // Resolve or create Stripe customer (keyed by uid in metadata)
     const email = assistant?.getUser()?.auth?.email || null;
     const customer = await resolveCustomer(stripe, uid, email, assistant);
 
-    assistant?.log(`Stripe checkout: priceId=${priceId}, uid=${uid}, customerId=${customer.id}, trial=${trial}, trialDays=${product.trial?.days || 'none'}`);
-
-    // Build session params
-    const sessionParams = {
-      mode: 'subscription',
-      customer: customer.id,
-      line_items: [{
-        price: priceId,
-        quantity: 1,
-      }],
-      subscription_data: {
-        metadata: {
-          uid: uid,
-        },
-      },
-      success_url: `${config.brand?.url || 'https://example.com'}/account/?payment=success`,
-      cancel_url: `${config.brand?.url || 'https://example.com'}/account/?payment=cancelled`,
-      metadata: {
-        uid: uid,
-        productId: productId,
-        frequency: frequency,
-      },
-    };
+    assistant?.log(`Stripe checkout: type=${productType}, priceId=${priceId}, uid=${uid}, customerId=${customer.id}, trial=${trial}, trialDays=${product.trial?.days || 'none'}`);
+
+    // Build confirmation redirect URL
+    const baseUrl = config.brand?.url;
+    const amount = productType === 'subscription'
+      ? (product.prices?.[frequency]?.amount || 0)
+      : (product.prices?.once?.amount || 0);
+
+    const confirmationUrl = new URL('/payment/confirmation', baseUrl);
+    confirmationUrl.searchParams.set('orderId', '{CHECKOUT_SESSION_ID}');
+    confirmationUrl.searchParams.set('productId', productId);
+    confirmationUrl.searchParams.set('productName', product.name || productId);
+    confirmationUrl.searchParams.set('amount', trial && product.trial?.days ? '0' : String(amount));
+    confirmationUrl.searchParams.set('currency', 'USD');
+    confirmationUrl.searchParams.set('frequency', frequency || 'once');
+    confirmationUrl.searchParams.set('paymentMethod', 'stripe');
+    confirmationUrl.searchParams.set('trial', String(!!trial && !!product.trial?.days));
+    confirmationUrl.searchParams.set('track', 'true');
 
-    // Add trial period if requested
-    if (trial && product.trial?.days) {
-      sessionParams.subscription_data.trial_period_days = product.trial.days;
-      assistant?.log(`Trial period added: ${product.trial.days} days`);
+    const cancelUrl = new URL('/payment/checkout', baseUrl);
+    cancelUrl.searchParams.set('product', productId);
+    if (frequency) {
+      cancelUrl.searchParams.set('frequency', frequency);
+    }
+    cancelUrl.searchParams.set('payment', 'cancelled');
+
+    // Build session params based on product type
+    let sessionParams;
+
+    if (productType === 'subscription') {
+      sessionParams = buildSubscriptionSession({ priceId, customer, uid, productId, frequency, trial, product, confirmationUrl, cancelUrl });
+    } else {
+      sessionParams = buildOneTimeSession({ priceId, customer, uid, productId, product, confirmationUrl, cancelUrl });
     }
 
     // Create the checkout session
     const session = await stripe.checkout.sessions.create(sessionParams);
 
-    assistant?.log(`Stripe session created: sessionId=${session.id}, url=${session.url}`);
+    assistant?.log(`Stripe session created: sessionId=${session.id}, mode=${sessionParams.mode}, url=${session.url}`);
 
     return {
       id: session.id,
@@ -79,6 +89,64 @@ module.exports = {
   },
 };
 
+/**
+ * Build Stripe Checkout Session params for a subscription
+ */
+function buildSubscriptionSession({ priceId, customer, uid, productId, frequency, trial, product, confirmationUrl, cancelUrl }) {
+  const sessionParams = {
+    mode: 'subscription',
+    customer: customer.id,
+    line_items: [{
+      price: priceId,
+      quantity: 1,
+    }],
+    subscription_data: {
+      metadata: {
+        uid: uid,
+      },
+    },
+    success_url: confirmationUrl.toString(),
+    cancel_url: cancelUrl.toString(),
+    metadata: {
+      uid: uid,
+      productId: productId,
+      frequency: frequency,
+    },
+  };
+
+  // Add trial period if requested
+  if (trial && product.trial?.days) {
+    sessionParams.subscription_data.trial_period_days = product.trial.days;
+  }
+
+  return sessionParams;
+}
+
+/**
+ * Build Stripe Checkout Session params for a one-time payment
+ */
+function buildOneTimeSession({ priceId, customer, uid, productId, product, confirmationUrl, cancelUrl }) {
+  return {
+    mode: 'payment',
+    customer: customer.id,
+    line_items: [{
+      price: priceId,
+      quantity: 1,
+    }],
+    payment_intent_data: {
+      metadata: {
+        uid: uid,
+      },
+    },
+    success_url: confirmationUrl.toString(),
+    cancel_url: cancelUrl.toString(),
+    metadata: {
+      uid: uid,
+      productId: productId,
+    },
+  };
+}
+
 /**
  * Find an existing Stripe customer by uid metadata, or create one
  */