feat(payments-next): Enable non-charge payments with stripe

Because:

* Stripe payments for a free purchase or for a reimbursement do not generate a payment intent as part of the payment process. The existing code throws an error for payments missing a payment intent

This commit:

* Adds in a special case for payments with a total amount of 0. Both "negative" payments (e.g. an upgrade to a lower price) and free purchases result in invoices with a total of 0, and a 'paid' status. Stripe automatically handles the application of negative purchase amounts towards the customer's account as a credit.

Closes #FXA-11413

Author: david1alvarez

libs/payments/cart/src/lib/cart.error.ts

@@ -209,3 +209,14 @@ export class CartSubscriptionNotFoundError extends CartError {
     Object.setPrototypeOf(this, CartSubscriptionNotFoundError.prototype);
   }
 }
+
+export class PaidInvoiceOnFailedCartError extends CartError {
+  constructor(cartId: string, args?: Record<string, any>) {
+    super('Paid invoice found on failed cart', {
+      cartId,
+      ...args,
+    });
+    this.name = 'PaidInvoiceOnFailedCartError';
+    Object.setPrototypeOf(this, PaidInvoiceOnFailedCartError.prototype);
+  }
+}

libs/payments/cart/src/lib/cart.service.ts

@@ -60,6 +60,7 @@ import {
   CartInvalidStateForActionError,
   CartStateProcessingError,
   CartSubscriptionNotFoundError,
+  PaidInvoiceOnFailedCartError,
 } from './cart.error';
 import { CartManager } from './cart.manager';
 import type {
@@ -178,11 +179,26 @@ export class CartService {
                 await this.invoiceManager.void(invoice.id);
                 break;
               case 'paid':
-                throw new CartError('Paid invoice found on failed cart', {
+                const paidInvoiceError = new PaidInvoiceOnFailedCartError(
                   cartId,
-                  stripeCustomerId: cart.stripeCustomerId,
-                  invoiceId: invoice.id,
-                });
+                  {
+                    error,
+                    stripeCustomerId: cart.stripeCustomerId,
+                    invoiceId: invoice.id,
+                  }
+                );
+                this.log.error(paidInvoiceError);
+
+                // swallow the error to allow cancellation of the subscription only when payment total is 0
+                if (invoice.total !== 0) {
+                  this.statsd.increment('non_zero_paid_invoice_on_failed_cart');
+                  Sentry.captureException(paidInvoiceError, {
+                    extra: {
+                      cartId,
+                    },
+                  });
+                  throw paidInvoiceError;
+                }
             }
           }
 
@@ -201,6 +217,7 @@ export class CartService {
             }
           } catch (e) {
             // swallow the error to allow cancellation of the subscription
+            this.log.error(e);
             Sentry.captureException(e, {
               extra: {
                 cartId,

libs/payments/cart/src/lib/checkout.service.spec.ts

@@ -688,6 +688,50 @@ describe('CheckoutService', () => {
         });
       });
 
+      it('handles free payments for customers with default payment method', async () => {
+        const freeInvoice = StripeResponseFactory(
+          StripeInvoiceFactory({
+            payment_intent: mockPaymentIntent.id,
+            amount_due: 0,
+            status: 'paid',
+          })
+        );
+        const existingPayentMethod = StripeResponseFactory(
+          StripePaymentMethodFactory()
+        );
+        jest.spyOn(invoiceManager, 'retrieve').mockResolvedValue(freeInvoice);
+        jest
+          .spyOn(customerManager, 'getDefaultPaymentMethod')
+          .mockResolvedValue(existingPayentMethod);
+        await expect(
+          checkoutService.payWithStripe(
+            mockCart,
+            mockConfirmationToken.id,
+            mockCustomerData
+          )
+        ).resolves;
+      });
+      it('rejects free payments for customers without default payment method', async () => {
+        const freeInvoice = StripeResponseFactory(
+          StripeInvoiceFactory({
+            payment_intent: mockPaymentIntent.id,
+            amount_due: 0,
+            status: 'paid',
+          })
+        );
+        jest.spyOn(invoiceManager, 'retrieve').mockResolvedValue(freeInvoice);
+        jest
+          .spyOn(customerManager, 'getDefaultPaymentMethod')
+          .mockResolvedValue(undefined);
+        await expect(
+          checkoutService.payWithStripe(
+            mockCart,
+            mockConfirmationToken.id,
+            mockCustomerData
+          )
+        ).rejects.toThrow();
+      });
+
       describe('upgrade', () => {
         const mockEligibilityResult =
           SubscriptionEligibilityUpgradeDowngradeResultFactory({

libs/payments/cart/src/lib/checkout.service.ts

@@ -347,47 +347,62 @@ export class CheckoutService {
       subscription.latest_invoice
     );
 
-    assert(
-      invoice.payment_intent,
-      'payment_intent does not exist on subscription'
-    );
-    // Confirm intent with collected payment method
-    const paymentIntent = await this.paymentIntentManager.confirm(
-      invoice.payment_intent,
-      {
-        confirmation_token: confirmationTokenId,
-        off_session: false,
-      }
-    );
+    if (invoice.amount_due === 0) {
+      // invoices without charge do not generate a payent intent
+      assert(
+        invoice.status === 'paid',
+        'Zero-charge stripe invoice expected to be in a paid status'
+      );
+      const paymentMethod = await this.customerManager.getDefaultPaymentMethod(
+        customer.id
+      );
+      assert(
+        !!paymentMethod,
+        'Payment method expected on customer for stripe zero-charge payment processing'
+      );
+    } else {
+      assert(
+        invoice.payment_intent,
+        'payment_intent does not exist on subscription'
+      );
+      // Confirm intent with collected payment method
+      const paymentIntent = await this.paymentIntentManager.confirm(
+        invoice.payment_intent,
+        {
+          confirmation_token: confirmationTokenId,
+          off_session: false,
+        }
+      );
 
-    if (paymentIntent.status === 'requires_action') {
-      await this.cartManager.setNeedsInputCart(cart.id);
-      return;
-    } else if (paymentIntent.status === 'succeeded') {
-      if (paymentIntent.payment_method) {
-        await this.customerManager.update(customer.id, {
-          invoice_settings: {
-            default_payment_method: paymentIntent.payment_method,
-          },
-        });
+      if (paymentIntent.status === 'requires_action') {
+        await this.cartManager.setNeedsInputCart(cart.id);
+        return;
+      } else if (paymentIntent.status === 'succeeded') {
+        if (paymentIntent.payment_method) {
+          await this.customerManager.update(customer.id, {
+            invoice_settings: {
+              default_payment_method: paymentIntent.payment_method,
+            },
+          });
+        } else {
+          throw new CartError(
+            'Failed to update customer default payment method',
+            { cartId: cart.id }
+          );
+        }
       } else {
-        throw new CartError(
-          'Failed to update customer default payment method',
-          { cartId: cart.id }
+        throw new CheckoutPaymentError(
+          `Expected payment intent status to be one of [requires_action, succeeded], instead found: ${paymentIntent.status}`
         );
       }
-      await this.postPaySteps({
-        cart,
-        version: updatedVersion,
-        subscription,
-        uid,
-        paymentProvider: 'stripe',
-      });
-    } else {
-      throw new CheckoutPaymentError(
-        `Expected payment intent status to be one of [requires_action, succeeded], instead found: ${paymentIntent.status}`
-      );
     }
+    await this.postPaySteps({
+      cart,
+      version: updatedVersion,
+      subscription,
+      uid,
+      paymentProvider: 'stripe',
+    });
   }
 
   async payWithPaypal(

libs/payments/customer/src/lib/customer.manager.ts

@@ -105,4 +105,8 @@ export class CustomerManager {
   isTaxEligible(customer: StripeCustomer) {
     return isCustomerTaxEligible(customer);
   }
+
+  async getDefaultPaymentMethod(customerId: string) {
+    return this.stripeClient.customerDefaultPaymentMethodRetrieve(customerId);
+  }
 }

libs/payments/stripe/src/lib/stripe.client.ts

@@ -325,6 +325,16 @@ export class StripeClient {
     return result as StripeResponse<StripePaymentMethod>;
   }
 
+  @CaptureTimingWithStatsD()
+  async customerDefaultPaymentMethodRetrieve(customerId: string) {
+    const result = await this.stripe.customers.retrieve(customerId, {
+      expand: ['invoice_settings.default_payment_method'],
+    });
+    if (result.deleted) return undefined;
+    return result.invoice_settings
+      .default_payment_method as StripeResponse<StripePaymentMethod>;
+  }
+
   @Cacheable({
     cacheKey: (args: any) =>
       cacheKeyForClient('pricesRetrieve', args[0], args[1]),