backend-manager 5.0.103 → 5.0.105

package/src/manager/libraries/{payment-processors → payment/processors}/stripe.js

@@ -71,6 +71,16 @@ const Stripe = {
     }
   },
 
+  /**
+   * Extract the internal orderId from a Stripe resource
+   *
+   * @param {object} resource - Raw Stripe resource (subscription, session, invoice)
+   * @returns {string|null}
+   */
+  getOrderId(resource) {
+    return resource.metadata?.orderId || null;
+  },
+
   /**
    * Transform a raw Stripe subscription object into the unified subscription shape
    * This produces the exact same object stored in users/{uid}.subscription
@@ -178,6 +188,69 @@ const Stripe = {
     return customer;
   },
 
+  /**
+   * Resolve the Stripe price ID by fetching active prices from the Stripe product
+   * and matching by interval + amount.
+   *
+   * @param {object} product - Product object from config (must have .prices and .stripe.productId)
+   * @param {string} productType - 'subscription' or 'one-time'
+   * @param {string} frequency - 'monthly', 'annually', etc. (subscriptions) — ignored for one-time
+   * @returns {Promise<string>} Stripe price ID
+   * @throws {Error} If product is archived, missing Stripe product ID, or no matching price found
+   */
+  async resolvePriceId(product, productType, frequency) {
+    if (product.archived) {
+      throw new Error(`Product ${product.id} is archived`);
+    }
+
+    const stripeProductId = product.stripe?.productId;
+
+    if (!stripeProductId) {
+      throw new Error(`No Stripe product ID for ${product.id}`);
+    }
+
+    const key = productType === 'subscription' ? frequency : 'once';
+    const expectedAmount = product.prices?.[key];
+
+    if (!expectedAmount) {
+      throw new Error(`No price configured for ${product.id}/${key}`);
+    }
+
+    const amountCents = Math.round(expectedAmount * 100);
+
+    // Fetch active prices from Stripe for this product
+    const stripe = this.init();
+
+    const prices = [];
+    for await (const price of stripe.prices.list({ product: stripeProductId, active: true, limit: 100 })) {
+      prices.push(price);
+    }
+
+    // Match by interval + amount
+    if (productType === 'subscription') {
+      const interval = frequency === 'annually' ? 'year' : 'month';
+      const match = prices.find(p =>
+        p.recurring?.interval === interval
+        && p.unit_amount === amountCents
+      );
+
+      if (!match) {
+        throw new Error(`No active Stripe price for ${product.id}/${frequency} at $${expectedAmount} (product: ${stripeProductId})`);
+      }
+
+      return match.id;
+    }
+
+    // One-time: match by amount, no recurring
+    const match = prices.find(p => !p.recurring && p.unit_amount === amountCents);
+
+    if (!match) {
+      throw new Error(`No active Stripe price for ${product.id}/once at $${expectedAmount} (product: ${stripeProductId})`);
+    }
+
+    return match.id;
+  },
+
   /**
    * Transform a raw Stripe one-time payment resource into a unified shape
    * Mirrors subscription structure: { product, status, payment: { ... } }
@@ -330,29 +403,28 @@ function resolveFrequency(raw) {
 }
 
 /**
- * Resolve product by matching the Stripe price ID against config products
+ * Resolve product by matching the Stripe product ID against config products
  * Returns { id, name } — falls back to basic if no match is found
  */
 function resolveProduct(raw, config) {
-  // Get the price ID from the subscription
-  const priceId = raw.plan?.id
-    || raw.items?.data?.[0]?.price?.id
+  // Get the Stripe product ID from the subscription
+  const stripeProductId = raw.items?.data?.[0]?.price?.product
+    || raw.plan?.product
     || null;
 
-  if (!priceId || !config.payment?.products) {
+  if (!stripeProductId || !config.payment?.products) {
     return { id: 'basic', name: 'Basic' };
   }
 
-  // Search through products for a matching price ID
   for (const product of config.payment.products) {
-    if (!product.prices) {
-      continue;
+    // Match current product ID
+    if (product.stripe?.productId === stripeProductId) {
+      return { id: product.id, name: product.name || product.id };
     }
 
-    for (const frequency of Object.keys(product.prices)) {
-      if (product.prices[frequency]?.stripe === priceId) {
-        return { id: product.id, name: product.name || product.id };
-      }
+    // Match legacy product IDs (pre-migration Stripe products)
+    if (product.stripe?.legacyProductIds?.includes(stripeProductId)) {
+      return { id: product.id, name: product.name || product.id };
     }
   }
 
@@ -426,15 +498,11 @@ function resolveStartDate(raw) {
 function resolvePrice(productId, frequency, config) {
   const product = config.payment?.products?.find(p => p.id === productId);
 
-  if (!product) {
+  if (!product || !product.prices) {
     return 0;
   }
 
-  if (frequency === 'once') {
-    return product.prices?.once?.amount || 0;
-  }
-
-  return product.prices?.[frequency]?.amount || 0;
+  return product.prices[frequency] || 0;
 }
 
 module.exports = Stripe;

package/src/manager/libraries/{payment-processors → payment/processors}/test.js

@@ -49,6 +49,13 @@ const Test = {
     return rawFallback;
   },
 
+  /**
+   * Extract orderId — delegates to Stripe (test processor uses Stripe-shaped data)
+   */
+  getOrderId(resource) {
+    return Stripe.getOrderId(resource);
+  },
+
   /**
    * Transform raw subscription into unified shape
    * Delegates to Stripe's toUnifiedSubscription (same data shape), stamps processor as 'test'
@@ -103,11 +110,11 @@ function buildStripeSubscriptionFromUnified(unified, resourceId, eventType, conf
     status = 'past_due';
   }
 
-  // Resolve the Stripe price ID from product + frequency via config
+  // Resolve the Stripe product ID from 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);
+  const stripeProductId = resolveStripeProductId(productId, config);
 
   return {
     id: resourceId,
@@ -115,7 +122,7 @@ function buildStripeSubscriptionFromUnified(unified, resourceId, eventType, conf
     status: status,
     metadata: { orderId: unified.payment?.orderId || null },
     plan: {
-      id: priceId,
+      product: stripeProductId,
       interval: INTERVAL_MAP[frequency] || 'month',
     },
     current_period_end: unified.expires?.timestampUNIX || 0,
@@ -130,15 +137,15 @@ function buildStripeSubscriptionFromUnified(unified, resourceId, eventType, conf
 }
 
 /**
- * Look up the Stripe price ID from config given a product ID and frequency
- * e.g., ('plus', 'monthly') → 'price_plus_monthly'
+ * Look up the Stripe product ID from config given a product ID
+ * e.g., ('plus') → 'prod_plus'
  */
-function resolvePriceId(productId, frequency, config) {
-  if (!productId || !frequency || !config?.payment?.products) {
+function resolveStripeProductId(productId, config) {
+  if (!productId || !config?.payment?.products) {
     return null;
   }
 
   const product = config.payment.products.find(p => p.id === productId);
 
-  return product?.prices?.[frequency]?.stripe || null;
+  return product?.stripe?.productId || null;
 }

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

@@ -0,0 +1,30 @@
+/**
+ * PayPal cancel processor
+ * Cancels a PayPal subscription
+ *
+ * Note: PayPal does not have "cancel at period end" like Stripe.
+ * Cancellation takes effect immediately, but the subscriber retains access
+ * until the end of the current billing period (PayPal's default behavior).
+ */
+module.exports = {
+  /**
+   * Cancel a PayPal subscription
+   *
+   * @param {object} options
+   * @param {string} options.resourceId - PayPal subscription ID (e.g., 'I-xxx')
+   * @param {string} options.uid - User's UID (for logging)
+   * @param {object} options.assistant - Assistant instance for logging
+   */
+  async cancelAtPeriodEnd({ resourceId, uid, assistant }) {
+    const PayPalLib = require('../../../../libraries/payment/processors/paypal.js');
+
+    await PayPalLib.request(`/v1/billing/subscriptions/${resourceId}/cancel`, {
+      method: 'POST',
+      body: JSON.stringify({
+        reason: 'Customer requested cancellation',
+      }),
+    });
+
+    assistant.log(`PayPal subscription cancelled: sub=${resourceId}, uid=${uid}`);
+  },
+};

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

@@ -12,7 +12,7 @@ module.exports = {
    * @param {object} options.assistant - Assistant instance for logging
    */
   async cancelAtPeriodEnd({ resourceId, uid, assistant }) {
-    const StripeLib = require('../../../../libraries/payment-processors/stripe.js');
+    const StripeLib = require('../../../../libraries/payment/processors/stripe.js');
     const stripe = StripeLib.init();
 
     await stripe.subscriptions.update(resourceId, { cancel_at_period_end: true });

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

@@ -20,20 +20,18 @@ module.exports = {
     const now = Math.floor(timestamp / 1000);
     const periodEnd = now + (30 * 86400);
 
-    // Look up the price ID from the existing order so toUnifiedSubscription can resolve the product
+    // Look up the Stripe product ID from the existing order so resolveProduct() can match
     const orderId = subscription?.payment?.orderId;
-    let priceId = null;
+    let stripeProductId = null;
 
     if (orderId) {
       const orderDoc = await admin.firestore().doc(`payments-orders/${orderId}`).get();
       if (orderDoc.exists) {
         const orderData = orderDoc.data();
-        // Find the matching price from config using frequency
-        const frequency = orderData.unified?.payment?.frequency;
         const productId = orderData.unified?.product?.id;
         const products = assistant.Manager.config.payment?.products || [];
         const product = products.find(p => p.id === productId);
-        priceId = product?.prices?.[frequency]?.stripe || null;
+        stripeProductId = product?.stripe?.productId || null;
       }
     }
 
@@ -52,7 +50,7 @@ module.exports = {
       start_date: now - (30 * 86400),
       trial_start: null,
       trial_end: null,
-      plan: { id: priceId, interval: 'month' },
+      plan: { product: stripeProductId, interval: 'month' },
     };
 
     const nowTs = powertools.timestamp(new Date(), { output: 'string' });

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

@@ -1,6 +1,6 @@
 const path = require('path');
 const powertools = require('node-powertools');
-const OrderId = require('../../../libraries/payment-processors/order-id.js');
+const OrderId = require('../../../libraries/payment/order-id.js');
 
 /**
  * POST /payments/intent
@@ -142,8 +142,8 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
  */
 function buildConfirmationUrl(baseUrl, { product, productId, productType, frequency, processor, trial, orderId }) {
   const amount = productType === 'subscription'
-    ? (product.prices?.[frequency]?.amount || 0)
-    : (product.prices?.once?.amount || 0);
+    ? (product.prices?.[frequency] || 0)
+    : (product.prices?.once || 0);
 
   const url = new URL('/payment/confirmation', baseUrl);
   url.searchParams.set('productId', productId);

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

@@ -0,0 +1,150 @@
+/**
+ * PayPal intent processor
+ * Creates PayPal subscriptions (Billing API) and one-time orders (Orders API v2)
+ */
+module.exports = {
+  /**
+   * Create a PayPal payment intent (subscription or one-time order)
+   *
+   * @param {object} options
+   * @param {string} options.uid - User's UID
+   * @param {string} options.orderId - Internal order ID
+   * @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' (subscriptions only)
+   * @param {boolean} options.trial - Whether to include a trial period
+   * @param {string} options.confirmationUrl - Success redirect URL
+   * @param {string} options.cancelUrl - Cancel redirect URL
+   * @param {object} options.assistant - Assistant instance for logging
+   * @returns {object} { id, url, raw }
+   */
+  async createIntent({ uid, orderId, product, productId, frequency, trial, confirmationUrl, cancelUrl, assistant }) {
+    const PayPalLib = require('../../../../libraries/payment/processors/paypal.js');
+
+    const productType = product.type || 'subscription';
+
+    if (productType === 'subscription') {
+      return createSubscriptionIntent({ uid, orderId, product, productId, frequency, trial, confirmationUrl, cancelUrl, assistant, PayPalLib });
+    }
+
+    return createOneTimeIntent({ uid, orderId, product, productId, confirmationUrl, cancelUrl, assistant, PayPalLib });
+  },
+};
+
+/**
+ * Create a PayPal subscription via the Billing Subscriptions API
+ */
+async function createSubscriptionIntent({ uid, orderId, product, productId, frequency, trial, confirmationUrl, cancelUrl, assistant, PayPalLib }) {
+  // Resolve the PayPal plan ID at runtime (fetches plans from product, matches by interval + amount)
+  const planId = await PayPalLib.resolvePlanId(product, frequency);
+
+  assistant.log(`PayPal subscription: planId=${planId}, uid=${uid}, trial=${trial}, trialDays=${product.trial?.days || 'none'}`);
+
+  // Build subscription request
+  const subscriptionParams = {
+    plan_id: planId,
+    custom_id: PayPalLib.buildCustomId(uid, orderId),
+    application_context: {
+      brand_name: product.name || productId,
+      return_url: confirmationUrl,
+      cancel_url: cancelUrl,
+      user_action: 'SUBSCRIBE_NOW',
+      shipping_preference: 'NO_SHIPPING',
+    },
+  };
+
+  // Add trial override if needed
+  // If trial is requested and product has trial days, override the plan's setup
+  // If trial is NOT requested but plan has trial, skip it by setting start_time to now
+  if (trial && product.trial?.days) {
+    // Let the plan's trial cycle handle it (if configured)
+    // PayPal trials are configured on the plan, not at subscription creation
+    assistant.log('PayPal trial: using plan trial cycle');
+  } else if (!trial) {
+    // Skip trial by starting billing immediately
+    const now = new Date();
+    now.setMinutes(now.getMinutes() + 5); // PayPal requires start_time in future
+    subscriptionParams.start_time = now.toISOString();
+  }
+
+  // Create the subscription
+  const subscription = await PayPalLib.request('/v1/billing/subscriptions', {
+    method: 'POST',
+    body: JSON.stringify(subscriptionParams),
+  });
+
+  // Extract approval URL
+  const approvalLink = subscription.links?.find(l => l.rel === 'approve');
+
+  if (!approvalLink) {
+    throw new Error('PayPal subscription created but no approval URL returned');
+  }
+
+  assistant.log(`PayPal subscription created: id=${subscription.id}, url=${approvalLink.href}`);
+
+  return {
+    id: subscription.id,
+    url: approvalLink.href,
+    raw: subscription,
+  };
+}
+
+/**
+ * Create a PayPal one-time order via the Orders API v2
+ */
+async function createOneTimeIntent({ uid, orderId, product, productId, confirmationUrl, cancelUrl, assistant, PayPalLib }) {
+  if (product.archived) {
+    throw new Error(`Product ${product.id} is archived`);
+  }
+
+  const amount = product.prices?.once;
+
+  if (!amount) {
+    throw new Error(`No one-time price configured for ${product.id}`);
+  }
+
+  const brandName = assistant.Manager?.config?.brand?.name || product.name || productId;
+
+  const orderParams = {
+    intent: 'CAPTURE',
+    purchase_units: [{
+      amount: {
+        currency_code: 'USD',
+        value: amount.toFixed(2),
+      },
+      description: product.name || productId,
+      custom_id: PayPalLib.buildCustomId(uid, orderId, productId),
+    }],
+    payment_source: {
+      paypal: {
+        experience_context: {
+          brand_name: brandName,
+          return_url: confirmationUrl,
+          cancel_url: cancelUrl,
+          user_action: 'PAY_NOW',
+          shipping_preference: 'NO_SHIPPING',
+        },
+      },
+    },
+  };
+
+  const order = await PayPalLib.request('/v2/checkout/orders', {
+    method: 'POST',
+    body: JSON.stringify(orderParams),
+  });
+
+  // Extract approval URL
+  const approvalLink = order.links?.find(l => l.rel === 'payer-action' || l.rel === 'approve');
+
+  if (!approvalLink) {
+    throw new Error('PayPal order created but no approval URL returned');
+  }
+
+  assistant.log(`PayPal order created: id=${order.id}, url=${approvalLink.href}`);
+
+  return {
+    id: order.id,
+    url: approvalLink.href,
+    raw: order,
+  };
+}

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

@@ -1,5 +1,3 @@
-const resolvePriceId = require('../../../../libraries/payment-processors/resolve-price-id.js');
-
 /**
  * Stripe intent processor
  * Creates Stripe Checkout Sessions for subscription and one-time purchases
@@ -20,13 +18,13 @@ module.exports = {
    */
   async createIntent({ uid, orderId, product, productId, frequency, trial, confirmationUrl, cancelUrl, assistant }) {
     // Initialize Stripe SDK
-    const StripeLib = require('../../../../libraries/payment-processors/stripe.js');
+    const StripeLib = require('../../../../libraries/payment/processors/stripe.js');
     const stripe = StripeLib.init();
 
     const productType = product.type || 'subscription';
 
-    // Resolve the Stripe price ID based on product type
-    const priceId = resolvePriceId(product, productType, frequency);
+    // Resolve the Stripe price ID at runtime (fetches active prices from Stripe product)
+    const priceId = await StripeLib.resolvePriceId(product, productType, frequency);
 
     // Resolve or create Stripe customer (keyed by uid in metadata)
     const email = assistant?.getUser()?.auth?.email || null;

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

@@ -1,5 +1,4 @@
 const fetch = require('wonderful-fetch');
-const resolvePriceId = require('../../../../libraries/payment-processors/resolve-price-id.js');
 
 /**
  * Test intent processor
@@ -43,9 +42,6 @@ module.exports = {
  * Generates Stripe-shaped subscription + customer.subscription.created event
  */
 async function createSubscriptionIntent({ uid, orderId, product, frequency, trial, confirmationUrl, assistant }) {
-  // Get the price ID for the requested frequency
-  const priceId = resolvePriceId(product, 'subscription', frequency);
-
   // Generate IDs
   const timestamp = Date.now();
   const sessionId = `_test-cs-${timestamp}`;
@@ -62,12 +58,13 @@ async function createSubscriptionIntent({ uid, orderId, product, frequency, tria
     : now + (30 * 86400);
 
   // Build Stripe-shaped subscription object
+  // Uses product's Stripe product ID so resolveProduct() can match it
   const subscription = {
     id: subscriptionId,
     object: 'subscription',
     status: trial && product.trial?.days ? 'trialing' : 'active',
     metadata: { uid, orderId },
-    plan: { id: priceId, interval },
+    plan: { product: product.stripe?.productId || null, interval },
     current_period_end: periodEnd,
     current_period_start: now,
     start_date: now,
@@ -109,8 +106,10 @@ async function createSubscriptionIntent({ uid, orderId, product, frequency, tria
  * Generates Stripe-shaped checkout session + checkout.session.completed event
  */
 async function createOneTimeIntent({ uid, orderId, product, productId, confirmationUrl, assistant }) {
-  // Validate that a price exists (resolvePriceId throws if not found)
-  resolvePriceId(product, 'one-time', null);
+  // Validate that a price exists
+  if (!product.prices?.once) {
+    throw new Error(`No one-time price configured for ${product.id}`);
+  }
 
   // Generate IDs
   const timestamp = Date.now();
@@ -125,7 +124,7 @@ async function createOneTimeIntent({ uid, orderId, product, productId, confirmat
     status: 'complete',
     payment_status: 'paid',
     metadata: { uid, orderId, productId },
-    amount_total: Math.round((product.prices?.once?.amount || 0) * 100),
+    amount_total: Math.round((product.prices.once || 0) * 100),
     currency: 'usd',
   };
 

package/src/manager/routes/payments/portal/processors/paypal.js

@@ -0,0 +1,24 @@
+/**
+ * PayPal portal processor
+ * PayPal does not have a hosted billing portal like Stripe.
+ * Returns a link to PayPal's subscription management page.
+ */
+module.exports = {
+  /**
+   * Get the PayPal subscription management URL
+   *
+   * @param {object} options
+   * @param {string} options.uid - User's UID
+   * @param {string|null} options.returnUrl - Not used for PayPal
+   * @param {object} options.assistant - Assistant instance for logging
+   * @returns {object} { url }
+   */
+  async createPortalSession({ uid, returnUrl, assistant }) {
+    // PayPal subscribers manage their subscription directly at PayPal
+    const url = 'https://www.paypal.com/myaccount/autopay/';
+
+    assistant.log(`PayPal portal redirect: uid=${uid}, url=${url}`);
+
+    return { url };
+  },
+};

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

@@ -19,7 +19,7 @@ module.exports = {
    * @returns {object} { url }
    */
   async createPortalSession({ uid, email, returnUrl, assistant }) {
-    const StripeLib = require('../../../../libraries/payment-processors/stripe.js');
+    const StripeLib = require('../../../../libraries/payment/processors/stripe.js');
     const stripe = StripeLib.init();
 
     // Resolve the Stripe customer for this user

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

@@ -0,0 +1,85 @@
+const path = require('path');
+
+/**
+ * POST /payments/refund
+ * Refunds the authenticated user's subscription and cancels it immediately.
+ * Requires the subscription to be cancelled or pending cancellation first.
+ *
+ * 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.
+ * Requires authentication.
+ */
+module.exports = async ({ assistant, user, settings }) => {
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  const uid = user.auth.uid;
+  const confirmed = settings.confirmed;
+
+  // Require explicit confirmation
+  if (!confirmed) {
+    return assistant.respond('Refund must be confirmed', { code: 400 });
+  }
+
+  const subscription = user.subscription;
+
+  // Require a paid subscription
+  if (!subscription || subscription.product?.id === 'basic') {
+    assistant.log(`Refund rejected: uid=${uid}, no paid subscription`);
+    return assistant.respond('No paid subscription found', { code: 400 });
+  }
+
+  // Require cancelled or pending cancellation — cannot refund an active subscription
+  const isCancelled = subscription.status === 'cancelled';
+  const isPendingCancel = subscription.cancellation?.pending === true;
+
+  if (!isCancelled && !isPendingCancel) {
+    assistant.log(`Refund rejected: uid=${uid}, status=${subscription.status}, pending=${subscription.cancellation?.pending}`);
+    return assistant.respond('Subscription must be cancelled or pending cancellation before requesting a refund', { code: 400 });
+  }
+
+  // Reject if the most recent payment is older than 6 months
+  const startDateUNIX = subscription.payment?.startDate?.timestampUNIX
+    || subscription.payment?.updatedBy?.date?.timestampUNIX;
+
+  if (startDateUNIX) {
+    const sixMonthsAgoUNIX = Math.floor(Date.now() / 1000) - (6 * 30 * 24 * 60 * 60);
+
+    if (startDateUNIX < sixMonthsAgoUNIX) {
+      assistant.log(`Refund rejected: uid=${uid}, payment too old (startDate=${new Date(startDateUNIX * 1000).toISOString()})`);
+      return assistant.respond('Payments older than 6 months are not eligible for refunds', { code: 400 });
+    }
+  }
+
+  const processor = subscription.payment?.processor;
+  const resourceId = subscription.payment?.resourceId;
+
+  if (!processor || !resourceId) {
+    assistant.log(`Refund rejected: uid=${uid}, missing processor=${processor} or resourceId=${resourceId}`);
+    return assistant.respond('Subscription payment details not found', { code: 400 });
+  }
+
+  // Load the processor module
+  let processorModule;
+  try {
+    processorModule = require(path.resolve(__dirname, `processors/${processor}.js`));
+  } catch (e) {
+    return assistant.respond(`Unknown processor: ${processor}`, { code: 400 });
+  }
+
+  // Process the refund via the processor
+  let refund;
+  try {
+    refund = await processorModule.processRefund({ resourceId, uid, subscription, assistant });
+  } catch (e) {
+    assistant.log(`Failed to process refund via ${processor}: ${e.message}`);
+    return assistant.respond(`Failed to process refund: ${e.message}`, { code: 500, sentry: true });
+  }
+
+  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 });
+};