async getCart()

in libs/payments/cart/src/lib/cart.service.ts [632:788]
143 lines of code
15 McCabe index (conditional complexity)

  async getCart(cartId: string): Promise<CartDTO> {
    const cart = (await this.cartManager.fetchCartById(
      cartId
    )) as ResultCart & { taxAddress: TaxAddress; currency: string };

    assert(cart.taxAddress !== null, 'Cart must have a tax address');
    assert(cart.currency !== null, 'Cart must have a currency');

    const [price, metricsOptedOut] = await Promise.all([
      this.productConfigurationManager.retrieveStripePrice(
        cart.offeringConfigId,
        cart.interval as SubplatInterval
      ),
      this.metricsOptedOut(cart.uid),
    ]);

    let customer: StripeCustomer | undefined;
    let subscriptions: StripeSubscription[] = [];
    if (cart.stripeCustomerId) {
      [customer, subscriptions] = await Promise.all([
        this.customerManager.retrieve(cart.stripeCustomerId),
        this.subscriptionManager.listForCustomer(cart.stripeCustomerId),
      ]);
    }

    const eligibility = await this.eligibilityService.checkEligibility(
      cart.interval as SubplatInterval,
      cart.offeringConfigId,
      cart.uid,
      cart.stripeCustomerId
    );

    const cartEligibilityStatus =
      handleEligibilityStatusMap[eligibility.subscriptionEligibilityResult];

    let upcomingInvoicePreview: InvoicePreview | undefined;
    if (
      cartEligibilityStatus === CartEligibilityStatus.UPGRADE &&
      cart.state === CartState.START
    ) {
      assert(
        'fromPrice' in eligibility,
        'fromPrice not present for upgrade cart'
      );
      assert(customer, 'Customer is required for upgrade');
      const fromSubscription =
        await this.subscriptionManager.retrieveForCustomerAndPrice(
          customer.id,
          eligibility.fromPrice.id
        );
      assert(fromSubscription, 'Subscription required');
      const fromSubscriptionItem = retrieveSubscriptionItem(fromSubscription);
      upcomingInvoicePreview =
        await this.invoiceManager.previewUpcomingForUpgrade({
          priceId: price.id,
          customer,
          fromSubscriptionItem,
        });
    } else {
      upcomingInvoicePreview = await this.invoiceManager.previewUpcoming({
        priceId: price.id,
        currency: cart.currency,
        customer,
        taxAddress: cart.taxAddress,
        couponCode: cart.couponCode || undefined,
      });
    }

    let paymentInfo: PaymentInfo | undefined;
    const paymentMethodType = determinePaymentMethodType(
      customer,
      subscriptions
    );
    if (paymentMethodType?.type === 'stripe') {
      const paymentMethodPromise = this.paymentMethodManager.retrieve(
        paymentMethodType.paymentMethodId
      );
      const customerSessionPromise = cart.stripeCustomerId
        ? this.customerSessionManager.create(cart.stripeCustomerId)
        : undefined;
      const [paymentMethod, customerSession] = await Promise.all([
        paymentMethodPromise,
        customerSessionPromise,
      ]);
      paymentInfo = {
        type: paymentMethod.type,
        last4: paymentMethod.card?.last4,
        brand: paymentMethod.card?.brand,
        customerSessionClientSecret: customerSession?.client_secret,
      };
    } else if (paymentMethodType?.type === 'external_paypal') {
      paymentInfo = {
        type: 'external_paypal',
      };
    }

    // Cart latest invoice data
    let latestInvoicePreview: InvoicePreview | undefined;
    if (
      customer &&
      cart.stripeSubscriptionId &&
      cart.state !== CartState.FAIL
    ) {
      const subscription = subscriptions.find(
        (subscription) => subscription.id === cart.stripeSubscriptionId
      );
      // fetch latest payment info from subscription
      assert(subscription?.latest_invoice, 'Subscription not found');
      latestInvoicePreview = await this.invoiceManager.preview(
        subscription.latest_invoice
      );
    }

    if (cart.state === CartState.SUCCESS) {
      assert(
        latestInvoicePreview,
        'latestInvoicePreview not present for success cart'
      );
      assert(paymentInfo, 'paymentInfo not present for success cart');

      return {
        ...cart,
        state: CartState.SUCCESS,
        upcomingInvoicePreview,
        metricsOptedOut,
        latestInvoicePreview,
        paymentInfo,
      };
    }

    let fromPrice: FromPrice | undefined;
    if (cartEligibilityStatus === CartEligibilityStatus.UPGRADE) {
      assert('fromPrice' in eligibility, 'fromPrice not present for upgrade');
      assertNotNull(eligibility.fromPrice.unit_amount);
      assertNotNull(eligibility.fromPrice.recurring);
      fromPrice = {
        currency: eligibility.fromPrice.currency,
        interval: eligibility.fromPrice.recurring.interval,
        listAmount: eligibility.fromPrice.unit_amount,
      };
    }

    return {
      ...cart,
      state: cart.state,
      upcomingInvoicePreview,
      latestInvoicePreview,
      metricsOptedOut,
      paymentInfo,
      fromOfferingConfigId:
        'fromOfferingConfigId' in eligibility
          ? eligibility.fromOfferingConfigId
          : undefined,
      fromPrice: 'fromPrice' in eligibility ? fromPrice : undefined,
      hasActiveSubscriptions: !!subscriptions.length,
    };
  }