feat(payments-next): Error: No such subscription: 'sub_1SpH7cJNcmPzuWtRUU3vAbuz'

Because:

* A Delete subscription is causing a Not Found error when it should be handled gracefully.

This commit:

* Handles the error gracefully

Closes #PAY-3467

Author: elizabeth-ilina

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

@@ -554,6 +554,16 @@ export class PaidPaymentIntendOnFailedCartError extends CartError {
   }
 }
 
+export class CartSubscriptionDeletionFailedError extends CartError {
+  constructor(cartId: string, subscriptionId: string, cause: Error) {
+    super('Subscription deletion failed during cart cleanup', {
+      cartId,
+      subscriptionId,
+    }, cause);
+    this.name = 'CartSubscriptionDeletionFailedError';
+  }
+}
+
 export class SubscriptionPaymentIntentMissingCartError extends CartError {
   constructor(cartId: string, subscriptionId: string) {
     super('Subscription on cart has no payment intent', {

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

@@ -350,6 +350,49 @@ describe('CartService', () => {
       );
     });
 
+    it('gracefully handles subscription not found during cancel', async () => {
+      const mockCustomer = StripeResponseFactory(StripeCustomerFactory());
+      const mockSubscription = StripeResponseFactory(
+        StripeSubscriptionFactory({
+          customer: mockCustomer.id,
+          latest_invoice: null,
+        })
+      );
+      const mockCart = ResultCartFactory({
+        state: CartState.PROCESSING,
+        stripeSubscriptionId: mockSubscription.id,
+        stripeCustomerId: mockCustomer.id,
+        eligibilityStatus: CartEligibilityStatus.CREATE,
+      });
+
+      const stripeError = new Stripe.errors.StripeInvalidRequestError({
+        type: 'invalid_request_error',
+        message: `No such subscription: '${mockSubscription.id}'`,
+        code: 'resource_missing',
+      });
+
+      jest
+        .spyOn(cartManager, 'fetchCartById')
+        .mockRejectedValueOnce(new Error('test'))
+        .mockResolvedValue(mockCart);
+      jest.spyOn(cartManager, 'finishErrorCart').mockResolvedValue();
+      jest
+        .spyOn(subscriptionManager, 'retrieve')
+        .mockResolvedValue(mockSubscription);
+      jest
+        .spyOn(subscriptionManager, 'cancel')
+        .mockRejectedValue(stripeError);
+      jest
+        .spyOn(paymentIntentManager, 'retrieve')
+        .mockResolvedValue(mockPaymentIntent);
+
+      await expect(
+        cartService.finalizeProcessingCart(mockCart.id)
+      ).rejects.toThrow(Error);
+
+      expect(subscriptionManager.cancel).toHaveBeenCalled();
+    });
+
     it('cancels a created subscription with async local storage', async () => {
       const mockCustomer = StripeResponseFactory(StripeCustomerFactory());
       const mockSubscription = StripeResponseFactory(

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

@@ -84,6 +84,7 @@ import {
   SubmitNeedsInputCustomerIdMissingError,
   SubmitNeedsInputSubscriptionIdMissingError,
   SubmitNeedsInputUidMissingError,
+  CartSubscriptionDeletionFailedError,
 } from './cart.error';
 import { CartManager } from './cart.manager';
 import type {
@@ -278,11 +279,37 @@ export class CartService {
           }
 
           if (cart.eligibilityStatus === CartEligibilityStatus.CREATE) {
-            await this.subscriptionManager.cancel(subscriptionId, {
-              cancellation_details: {
-                comment: 'Automatic Cancellation: Cart checkout failed.',
-              },
-            });
+            try {
+              await this.subscriptionManager.cancel(subscriptionId, {
+                cancellation_details: {
+                  comment: 'Automatic Cancellation: Cart checkout failed.',
+                },
+              });
+            } catch (e) {
+              if (
+                e.code === 'resource_missing' ||
+                  e.message?.startsWith('No such subscription')
+              ) {
+                this.log.log(
+                  'cartService.wrapWithCartCatch.subscriptionNotFound',
+                  {
+                    subscriptionId,
+                    eligibilityStatus: cart.eligibilityStatus,
+                    offeringId: cart.offeringConfigId,
+                    interval: cart.interval,
+                  }
+                );
+                this.statsd.increment(
+                  'subscription_deletion_failed_not_found'
+                );
+              } else {
+                throw new CartSubscriptionDeletionFailedError(
+                  cartId,
+                  subscriptionId,
+                  e
+                );
+              }
+            }
           } else {
             this.statsd.increment(
               'checkout_failure_subscription_not_cancelled'