Merge pull request #18867 from mozilla/fxa-11605-upgrade-plan-info

feat(next): upgrade shows incorrect interval

Author: StaberindeZA

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

@@ -27,6 +27,7 @@ import {
   PaymentIntentManager,
   PaymentMethodManager,
   PriceManager,
+  PricingForCurrencyFactory,
   ProductManager,
   PromotionCodeManager,
   SubplatInterval,
@@ -47,6 +48,7 @@ import {
   StripeCustomerSessionFactory,
   StripeApiListFactory,
   StripeInvoiceFactory,
+  StripePriceRecurringFactory,
 } from '@fxa/payments/stripe';
 import {
   MockProfileClientConfigProvider,
@@ -144,6 +146,7 @@ describe('CartService', () => {
   let productConfigurationManager: ProductConfigurationManager;
   let subscriptionManager: SubscriptionManager;
   let paymentMethodManager: PaymentMethodManager;
+  let priceManager: PriceManager;
 
   const mockLogger = {
     error: jest.fn(),
@@ -226,6 +229,7 @@ describe('CartService', () => {
     productConfigurationManager = moduleRef.get(ProductConfigurationManager);
     subscriptionManager = moduleRef.get(SubscriptionManager);
     paymentMethodManager = moduleRef.get(PaymentMethodManager);
+    priceManager = moduleRef.get(PriceManager);
   });
 
   describe('wrapCartWithCatch', () => {
@@ -1452,10 +1456,13 @@ describe('CartService', () => {
         eligibilityStatus: CartEligibilityStatus.UPGRADE,
       });
       const mockCustomer = StripeResponseFactory(StripeCustomerFactory());
-      const mockPrice = StripePriceFactory();
+      const mockPrice = StripePriceFactory({ currency: mockCart.currency });
       const mockInvoicePreview = InvoicePreviewFactory();
       const mockFromOfferingId = faker.string.uuid();
-      const mockFromPrice = StripePriceFactory();
+      const mockFromPrice = StripePriceFactory({
+        recurring: StripePriceRecurringFactory({ interval: 'month' })
+      });
+      const mockPricingForCurrency = PricingForCurrencyFactory({ price: mockFromPrice })
       const mockSubscription = StripeSubscriptionFactory();
 
       jest.spyOn(cartManager, 'fetchCartById').mockResolvedValue(mockCart);
@@ -1474,6 +1481,7 @@ describe('CartService', () => {
       jest
         .spyOn(subscriptionManager, 'retrieveForCustomerAndPrice')
         .mockResolvedValue(mockSubscription);
+      jest.spyOn(priceManager, 'retrievePricingForCurrency').mockResolvedValue(mockPricingForCurrency);
 
       const result = await cartService.getCart(mockCart.id);
       expect(result).toEqual({
@@ -1488,9 +1496,9 @@ describe('CartService', () => {
         metricsOptedOut: false,
         fromOfferingConfigId: mockFromOfferingId,
         fromPrice: {
-          currency: mockFromPrice.currency,
-          interval: mockFromPrice.recurring?.interval,
-          listAmount: mockFromPrice.unit_amount,
+          currency: mockCart.currency,
+          interval: 'monthly',
+          unitAmount: mockFromPrice.unit_amount,
         },
         hasActiveSubscriptions: true,
       });

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

@@ -26,6 +26,8 @@ import {
   retrieveSubscriptionItem,
   PromotionCodeCouldNotBeAttachedError,
   TaxAddress,
+  PriceManager,
+  getSubplatInterval,
 } from '@fxa/payments/customer';
 import {
   EligibilityService,
@@ -95,16 +97,17 @@ export class CartService {
     private currencyManager: CurrencyManager,
     private customerManager: CustomerManager,
     private customerSessionManager: CustomerSessionManager,
-    private promotionCodeManager: PromotionCodeManager,
     private eligibilityService: EligibilityService,
     private invoiceManager: InvoiceManager,
     @Inject(LOGGER_PROVIDER) private log: LoggerService,
-    private productConfigurationManager: ProductConfigurationManager,
-    private subscriptionManager: SubscriptionManager,
     private paymentMethodManager: PaymentMethodManager,
     private paymentIntentManager: PaymentIntentManager,
-    @Inject(StatsDService) private statsd: StatsD
-  ) {}
+    private priceManager: PriceManager,
+    private productConfigurationManager: ProductConfigurationManager,
+    private promotionCodeManager: PromotionCodeManager,
+    private subscriptionManager: SubscriptionManager,
+    @Inject(StatsDService) private statsd: StatsD,
+  ) { }
 
   /**
    * Should be used to wrap any method that mutates an existing cart.
@@ -387,12 +390,12 @@ export class CartService {
 
       const accountCustomer = oldCart.uid
         ? await this.accountCustomerManager
-            .getAccountCustomerByUid(oldCart.uid)
-            .catch((error) => {
-              if (!(error instanceof AccountCustomerNotFoundError)) {
-                throw error;
-              }
-            })
+          .getAccountCustomerByUid(oldCart.uid)
+          .catch((error) => {
+            if (!(error instanceof AccountCustomerNotFoundError)) {
+              throw error;
+            }
+          })
         : undefined;
 
       if (!(oldCart.taxAddress && oldCart.currency)) {
@@ -766,12 +769,18 @@ export class CartService {
     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);
+
+      const { price: priceForCurrency, unitAmountForCurrency } = await this.priceManager.retrievePricingForCurrency(eligibility.fromPrice.id, cart.currency);
+      assertNotNull(unitAmountForCurrency);
+      assertNotNull(priceForCurrency.recurring);
+
+      const interval = getSubplatInterval(priceForCurrency.recurring.interval, priceForCurrency.recurring.interval_count);
+      assert(interval, 'Interval not found but is required');
+
       fromPrice = {
-        currency: eligibility.fromPrice.currency,
-        interval: eligibility.fromPrice.recurring.interval,
-        listAmount: eligibility.fromPrice.unit_amount,
+        currency: cart.currency,
+        interval,
+        unitAmount: unitAmountForCurrency,
       };
     }
 

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

@@ -2,14 +2,13 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-import { TaxAddress } from '@fxa/payments/customer';
+import { TaxAddress, type SubplatInterval } from '@fxa/payments/customer';
 import {
   Cart,
   CartEligibilityStatus,
   CartErrorReasonId,
   CartState,
 } from '@fxa/shared/db/mysql/account';
-import { StripePrice } from '@fxa/payments/stripe';
 import Stripe from 'stripe';
 
 export type CheckoutCustomerData = {
@@ -64,8 +63,8 @@ export type ResultCart = Readonly<Omit<Cart, 'id' | 'uid'>> & {
 
 export type FromPrice = {
   currency: string;
-  interval: NonNullable<StripePrice['recurring']>['interval'];
-  listAmount: number;
+  interval: SubplatInterval;
+  unitAmount: number;
 };
 
 export type BaseCartDTO = Omit<ResultCart, 'state'> & {

libs/payments/customer/src/index.ts

@@ -13,6 +13,7 @@ export * from './lib/product.manager';
 export * from './lib/promotionCode.manager';
 export * from './lib/subscription.manager';
 export * from './lib/types';
+export * from './lib/factories/pricing-for-currency.factory';
 export * from './lib/factories/tax-address.factory';
 export * from './lib/error';
 export * from './lib/util/stripeInvoiceToFirstInvoicePreviewDTO';

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

@@ -28,6 +28,12 @@ export class PlanIntervalMultiplePlansError extends PaymentsCustomerError {
   }
 }
 
+export class PriceForCurrencyNotFoundError extends PaymentsCustomerError {
+  constructor(priceId: string, currency: string) {
+    super('Price for currency not found', { info: { priceId, currency } });
+  }
+}
+
 export class PromotionCodeCouldNotBeAttachedError extends PaymentsCustomerError {
   customerId?: string;
   subscriptionId?: string;

libs/payments/customer/src/lib/factories/pricing-for-currency.factory.ts

@@ -0,0 +1,19 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { type PricingForCurrency } from '../types';
+import { StripePriceFactory } from '@fxa/payments/stripe';
+
+export const PricingForCurrencyFactory = (
+  override?: Partial<PricingForCurrency>
+): PricingForCurrency => {
+  const price = override?.price || StripePriceFactory();
+  return {
+    price,
+    unitAmountForCurrency: price.unit_amount,
+    currencyOptionForCurrency: price.currency_options[0],
+    ...override,
+  }
+};
+

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

@@ -11,10 +11,12 @@ import {
   StripePriceRecurringFactory,
   MockStripeConfigProvider,
 } from '@fxa/payments/stripe';
-import { PlanIntervalMultiplePlansError } from './error';
+import { PlanIntervalMultiplePlansError, PriceForCurrencyNotFoundError } from './error';
 import { PriceManager } from './price.manager';
 import { SubplatInterval } from './types';
 import { MockStatsDProvider } from '@fxa/shared/metrics/statsd';
+import { StripePriceCurrencyOptionFactory } from 'libs/payments/stripe/src/lib/factories/price.factory';
+import { faker } from '@faker-js/faker/.';
 
 describe('PriceManager', () => {
   let priceManager: PriceManager;
@@ -93,4 +95,59 @@ describe('PriceManager', () => {
       ).rejects.toBeInstanceOf(PlanIntervalMultiplePlansError);
     });
   });
+
+  describe('retrievePricingForCurrency', () => {
+    it('returns price data if currency matches default currency of price', async () => {
+      const mockPrice = StripeResponseFactory(
+        StripePriceFactory()
+      );
+
+      jest.spyOn(priceManager, 'retrieve').mockResolvedValue(mockPrice);
+
+      const result = await priceManager.retrievePricingForCurrency(mockPrice.id, mockPrice.currency)
+      expect(result).toEqual({
+        price: mockPrice,
+        unitAmountForCurrency: mockPrice.unit_amount,
+        currencyOptionForCurrency: mockPrice.currency_options[mockPrice.currency],
+      })
+    })
+
+    it('returns price currency options data if price does not match default currency of price', async () => {
+      const defaultCurrency = 'usd';
+      const currencyOption = 'eur';
+      const mockPrice = StripeResponseFactory(
+        StripePriceFactory({
+          currency_options: {
+            [defaultCurrency]: StripePriceCurrencyOptionFactory({
+              unit_amount: faker.number.int({ max: 1000 }),
+              unit_amount_decimal: faker.commerce.price({ min: 1000 }),
+            }),
+            [currencyOption]: StripePriceCurrencyOptionFactory({
+              unit_amount: faker.number.int({ max: 1000 }),
+              unit_amount_decimal: faker.commerce.price({ min: 1000 }),
+            }),
+          },
+        })
+      );
+
+      jest.spyOn(priceManager, 'retrieve').mockResolvedValue(mockPrice);
+
+      const result = await priceManager.retrievePricingForCurrency(mockPrice.id, currencyOption)
+      expect(result).toEqual({
+        price: mockPrice,
+        unitAmountForCurrency: mockPrice.currency_options[currencyOption].unit_amount,
+        currencyOptionForCurrency: mockPrice.currency_options[currencyOption],
+      })
+    })
+
+    it('throws an error if price does not have provided currency', async () => {
+      const mockPrice = StripeResponseFactory(
+        StripePriceFactory()
+      );
+
+      jest.spyOn(priceManager, 'retrieve').mockResolvedValue(mockPrice);
+
+      await expect(priceManager.retrievePricingForCurrency(mockPrice.id, 'invalid')).rejects.toBeInstanceOf(PriceForCurrencyNotFoundError)
+    })
+  })
 });

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

@@ -5,19 +5,39 @@
 import { Injectable } from '@nestjs/common';
 
 import { StripeClient, StripePrice } from '@fxa/payments/stripe';
-import { PlanIntervalMultiplePlansError } from './error';
-import { SubplatInterval } from './types';
+import { PlanIntervalMultiplePlansError, PriceForCurrencyNotFoundError } from './error';
+import { SubplatInterval, type PricingForCurrency } from './types';
 import { doesPriceMatchSubplatInterval } from './util/doesPriceMatchSubplatInterval';
+import { determinePriceUnitAmount } from './util/determinePriceUnitAmount';
 
 @Injectable()
 export class PriceManager {
-  constructor(private stripeClient: StripeClient) {}
+  constructor(private stripeClient: StripeClient) { }
 
   async retrieve(priceId: string) {
     const price = await this.stripeClient.pricesRetrieve(priceId);
     return price;
   }
 
+  async retrievePricingForCurrency(priceId: string, currency: string): Promise<PricingForCurrency> {
+    const stripeCurrency = currency.toLowerCase();
+    const price = await this.retrieve(priceId);
+
+    const currencyOptionForCurrency = price.currency_options[stripeCurrency];
+
+    if (!currencyOptionForCurrency) {
+      throw new PriceForCurrencyNotFoundError(priceId, currency);
+    }
+
+    const unitAmountForCurrency = determinePriceUnitAmount(currencyOptionForCurrency)
+
+    return {
+      price,
+      unitAmountForCurrency,
+      currencyOptionForCurrency,
+    }
+  }
+
   async retrieveByInterval(priceIds: string[], interval: SubplatInterval) {
     const prices: StripePrice[] = [];
     for (const priceId of priceIds) {

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

@@ -16,7 +16,7 @@ import { InvalidPaymentIntentError, PaymentIntentNotFoundError } from './error';
 
 @Injectable()
 export class SubscriptionManager {
-  constructor(private stripeClient: StripeClient) {}
+  constructor(private stripeClient: StripeClient) { }
 
   async cancel(
     subscriptionId: string,

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

@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 import { StripePrice } from '@fxa/payments/stripe';
+import { Stripe } from 'stripe';
 
 export type InvoicePreview = {
   currency: string;
@@ -24,6 +25,12 @@ export interface Interval {
   intervalCount: number;
 }
 
+export interface PricingForCurrency {
+  price: StripePrice,
+  unitAmountForCurrency: number | null;
+  currencyOptionForCurrency: Stripe.Price.CurrencyOptions;
+}
+
 export interface TaxAmount {
   title: string;
   inclusive: boolean;