Merge pull request #19905 from mozilla/PAY-3469-add-churn-feature-flag

feat(payments-next): Add Churn Intervention feature flag

Author: elizabeth-ilina

apps/payments/next/.env

@@ -94,6 +94,7 @@ CURRENCY_CONFIG__CURRENCIES_TO_COUNTRIES={"USD":["AS","CA","GB","GU","MP","MY","
 
 # Churn Intervention Config
 CHURN_INTERVENTION_CONFIG__COLLECTION_NAME=churnInterventions
+CHURN_INTERVENTION_CONFIG__ENABLED=false
 
 # StatsD Config
 STATS_D_CONFIG__SAMPLE_RATE=

apps/payments/next/app/[locale]/[offeringId]/[interval]/[churnType]/loyalty-discount/terms/page.tsx

@@ -9,6 +9,7 @@ import { headers } from 'next/headers';
 import { URLSearchParams } from 'url';
 import { SubplatInterval } from '@fxa/payments/customer';
 import { notFound } from 'next/navigation';
+import { config } from 'apps/payments/next/config';
 
 export default async function ChurnTerms({
   params,
@@ -17,6 +18,10 @@ export default async function ChurnTerms({
   params: ChurnParams;
   searchParams: Record<string, string | string[]> | undefined;
 }) {
+  if (!config.churnInterventionConfig.enabled) {
+    notFound();
+  }
+
   const { locale, interval, churnType, offeringId } = params;
   const acceptLanguage = headers().get('accept-language');
   const l10n = getApp().getL10n(acceptLanguage, locale);

apps/payments/next/app/[locale]/subscriptions/[subscriptionId]/loyalty-discount/stay-subscribed/error/page.tsx

@@ -19,6 +19,11 @@ export default async function LoyaltyDiscountStaySubscribedErrorPage({
   searchParams: Record<string, string> | undefined;
 }) {
   const { locale, subscriptionId } = params;
+
+  if (!config.churnInterventionConfig.enabled) {
+    redirect(`/${locale}/subscriptions/${subscriptionId}/stay-subscribed`);
+  }
+
   const acceptLanguage = headers().get('accept-language');
 
   const session = await auth();

apps/payments/next/app/[locale]/subscriptions/[subscriptionId]/loyalty-discount/stay-subscribed/page.tsx

@@ -25,6 +25,11 @@ export default async function LoyaltyDiscountStaySubscribedPage({
   searchParams: Record<string, string> | undefined;
 }) {
   const { locale, subscriptionId } = params;
+
+  if (!config.churnInterventionConfig.enabled) {
+    redirect(`/${locale}/subscriptions/${subscriptionId}/stay-subscribed`);
+  }
+
   const acceptLanguage = headers().get('accept-language');
 
   const session = await auth();

libs/payments/cart/src/lib/churn-intervention.config.ts

@@ -4,15 +4,19 @@
 
 import { faker } from '@faker-js/faker';
 import { Provider } from '@nestjs/common';
-import { IsString } from 'class-validator';
+import { IsBoolean, IsString } from 'class-validator';
 
 export class ChurnInterventionConfig {
   @IsString()
   public readonly collectionName!: string;
+
+  @IsBoolean()
+  public readonly enabled: boolean = false;
 }
 
 export const MockChurnInterventionConfig = {
   collectionName: faker.string.uuid(),
+  enabled: true,
 } satisfies ChurnInterventionConfig;
 
 export const MockChurnInterventionConfigProvider = {

libs/payments/management/src/lib/churn-intervention.service.spec.ts

@@ -7,6 +7,7 @@ import { Logger } from '@nestjs/common';
 import { Test } from '@nestjs/testing';
 
 import {
+  ChurnInterventionConfig,
   ChurnInterventionManager,
   ChurnInterventionEntryFactory,
 } from '@fxa/payments/cart';
@@ -73,10 +74,19 @@ describe('ChurnInterventionService', () => {
     timing: jest.fn(),
   };
 
+  const mockChurnInterventionConfig = {
+    collectionName: 'churn-interventions',
+    enabled: true,
+  };
+
   beforeEach(async () => {
     const moduleRef = await Test.createTestingModule({
       providers: [
         ChurnInterventionService,
+        {
+          provide: ChurnInterventionConfig,
+          useValue: mockChurnInterventionConfig,
+        },
         {
           provide: EligibilityService,
           useValue: {
@@ -95,6 +105,7 @@ describe('ChurnInterventionService', () => {
           provide: ProductConfigurationManager,
           useValue: {
             getChurnInterventionBySubscription: jest.fn(),
+            getChurnIntervention: jest.fn(),
             getCancelInterstitialOffer: jest.fn(),
             getPageContentByPriceIds: jest.fn(),
             getSubplatIntervalBySubscription: jest.fn(),
@@ -1158,4 +1169,101 @@ describe('ChurnInterventionService', () => {
       });
     });
   });
+
+  describe('when feature is disabled', () => {
+    beforeEach(() => {
+      mockChurnInterventionConfig.enabled = false;
+      jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+      mockChurnInterventionConfig.enabled = true;
+    });
+
+    it('returns feature_disabled when determineStaySubscribedEligibility is called', async () => {
+      const result =
+        await churnInterventionService.determineStaySubscribedEligibility(
+          'uid_123',
+          'sub_123',
+          'en'
+        );
+
+      expect(result.isEligible).toBe(false);
+      expect(result.reason).toBe('feature_disabled');
+      expect(result.cmsChurnInterventionEntry).toBeNull();
+      expect(result.cmsOfferingContent).toBeNull();
+      expect(
+        productConfigurationManager.getChurnInterventionBySubscription
+      ).not.toHaveBeenCalled();
+    });
+
+    it('returns feature_disabled when redeemChurnCoupon is called', async () => {
+      const result = await churnInterventionService.redeemChurnCoupon(
+        'uid123',
+        'sub_123',
+        'en'
+      );
+
+      expect(result.redeemed).toBe(false);
+      expect(result.errorCode).toBe('feature_disabled');
+    });
+
+    it('determineCancellationIntervention returns none', async () => {
+      const result =
+        await churnInterventionService.determineCancellationIntervention({
+          uid: 'uid123',
+          subscriptionId: 'sub_123',
+        });
+
+      expect(result.cancelChurnInterventionType).toBe('none');
+      expect(result.cmsOfferContent).toBeNull();
+    });
+
+    it('returns feature_disabled when determineCancelChurnContentEligibility is called', async () => {
+      const result =
+        await churnInterventionService.determineCancelChurnContentEligibility({
+          uid: 'uid_123',
+          subscriptionId: 'sub_123',
+        });
+
+      expect(result.isEligible).toBe(false);
+      expect(result.reason).toBe('feature_disabled');
+      expect(result.cmsChurnInterventionEntry).toBeNull();
+      expect(
+        productConfigurationManager.getChurnInterventionBySubscription
+      ).not.toHaveBeenCalled();
+    });
+
+    it('returns feature_disabled when determineCancelInterstitialOfferEligibility is called', async () => {
+      const result =
+        await churnInterventionService.determineCancelInterstitialOfferEligibility(
+          {
+            uid: 'uid_123',
+            subscriptionId: 'sub_123',
+          }
+        );
+
+      expect(result.isEligible).toBe(false);
+      expect(result.reason).toBe('feature_disabled');
+      expect(result.cmsOfferContent).toBeNull();
+      expect(result.cmsOfferingContent).toBeNull();
+      expect(
+        productConfigurationManager.getSubplatIntervalBySubscription
+      ).not.toHaveBeenCalled();
+    });
+
+    it('returns empty array when getChurnInterventionForProduct is called', async () => {
+      const result =
+        await churnInterventionService.getChurnInterventionForProduct(
+          SubplatInterval.Monthly,
+          'cancel',
+          'prod_123'
+        );
+
+      expect(result.churnInterventions).toEqual([]);
+      expect(
+        productConfigurationManager.getChurnIntervention
+      ).not.toHaveBeenCalled();
+    });
+  });
 });

libs/payments/management/src/lib/churn-intervention.service.ts

@@ -3,7 +3,10 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 import { Inject, Injectable, Logger, type LoggerService } from '@nestjs/common';
-import { ChurnInterventionManager } from '@fxa/payments/cart';
+import {
+  ChurnInterventionConfig,
+  ChurnInterventionManager,
+} from '@fxa/payments/cart';
 import {
   ChurnInterventionByProductIdResultUtil,
   ProductConfigurationManager,
@@ -22,6 +25,18 @@ import {
   ChurnInterventionProductIdentifierMissingError,
   ChurnSubscriptionCustomerMismatchError,
 } from './churn-intervention.error';
+export enum Enum_Churnintervention_Churntype {
+  Cancel = 'cancel',
+  StaySubscribed = 'stay_subscribed'
+}
+
+export enum Enum_Churnintervention_Interval {
+  Daily = 'daily',
+  Halfyearly = 'halfyearly',
+  Monthly = 'monthly',
+  Weekly = 'weekly',
+  Yearly = 'yearly'
+}
 
 @Injectable()
 export class ChurnInterventionService {
@@ -34,9 +49,14 @@ export class ChurnInterventionService {
     private profileClient: ProfileClient,
     private subscriptionManager: SubscriptionManager,
     @Inject(StatsDService) private statsd: StatsD,
-    @Inject(Logger) private log: LoggerService
+    @Inject(Logger) private log: LoggerService,
+    private churnInterventionConfig: ChurnInterventionConfig
   ) {}
 
+  private isFeatureEnabled(): boolean {
+    return this.churnInterventionConfig.enabled ?? false;
+  }
+
   /**
    * Reload the customer data to reflect a change.
    * NOTE: This is currently duplicated in subscriptionManagement.service.ts
@@ -71,6 +91,10 @@ export class ChurnInterventionService {
     acceptLanguage?: string,
     selectedLanguage?: string
   ) {
+    if (!this.isFeatureEnabled()) {
+      return { churnInterventions: [] };
+    }
+
     let util: ChurnInterventionByProductIdResultUtil;
     if (stripeProductId) {
       util = await this.productConfigurationManager.getChurnIntervention(
@@ -105,6 +129,15 @@ export class ChurnInterventionService {
     acceptLanguage?: string | null,
     selectedLanguage?: string
   ) {
+    if (!this.isFeatureEnabled()) {
+      return {
+        isEligible: false,
+        reason: 'feature_disabled',
+        cmsChurnInterventionEntry: null,
+        cmsOfferingContent: null,
+      };
+    }
+
     try {
       const cmsChurnResult =
         await this.productConfigurationManager.getChurnInterventionBySubscription(
@@ -245,6 +278,13 @@ export class ChurnInterventionService {
     acceptLanguage?: string | null,
     selectedLanguage?: string
   ) {
+    if (!this.isFeatureEnabled()) {
+      return {
+        redeemed: false,
+        errorCode: 'feature_disabled',
+      };
+    }
+
     const eligibilityResult = await this.determineStaySubscribedEligibility(
       uid,
       subscriptionId,
@@ -330,6 +370,13 @@ export class ChurnInterventionService {
     acceptLanguage?: string | null;
     selectedLanguage?: string;
   }) {
+    if (!this.isFeatureEnabled()) {
+      return {
+        cancelChurnInterventionType: 'none',
+        cmsOfferContent: null,
+      };
+    }
+
     try {
       const accountCustomer =
         await this.accountCustomerManager.getAccountCustomerByUid(args.uid);
@@ -422,6 +469,15 @@ export class ChurnInterventionService {
     acceptLanguage?: string | null;
     selectedLanguage?: string;
   }) {
+    if (!this.isFeatureEnabled()) {
+      return {
+        isEligible: false,
+        reason: 'feature_disabled',
+        cmsOfferContent: null,
+        cmsOfferingContent: null,
+      };
+    }
+
     const upgradeInterval = SubplatInterval.Yearly;
     const subscription = await this.subscriptionManager.retrieve(
       args.subscriptionId
@@ -566,6 +622,14 @@ export class ChurnInterventionService {
     acceptLanguage?: string | null;
     selectedLanguage?: string;
   }) {
+    if (!this.isFeatureEnabled()) {
+      return {
+        isEligible: false,
+        reason: 'feature_disabled',
+        cmsChurnInterventionEntry: null,
+      };
+    }
+
     const cmsChurnResult =
       await this.productConfigurationManager.getChurnInterventionBySubscription(
         args.subscriptionId,

packages/fxa-auth-server/lib/payments/initSubplat.ts

@@ -149,8 +149,12 @@ export async function initSubplat({
   );
   const subscriptionManager = new SubscriptionManager(stripeClient);
   const customerManager = new CustomerManager(stripeClient);
+  const churnInterventionConfig = {
+    collectionName: 'churnCollection',
+    enabled: true,
+  };
   const churnInterventionManager = new ChurnInterventionManager(
-    { collectionName: 'churnCollection' },
+    churnInterventionConfig,
     firestore
   );
   const eligibilityManager = new EligibilityManager(
@@ -196,7 +200,8 @@ export async function initSubplat({
     profileClient,
     subscriptionManager,
     statsd,
-    logger
+    logger,
+    churnInterventionConfig
   );
 
   const subscriptionManagementService = new SubscriptionManagementService(