@automattic/data-stores 1.0.0-alpha.0 → 3.0.0

package/src/plans/selectors.ts

@@ -0,0 +1,161 @@
+import { select } from '@wordpress/data';
+import deprecate from '@wordpress/deprecated';
+import {
+	DEFAULT_PAID_PLAN,
+	TIMELESS_PLAN_ECOMMERCE,
+	TIMELESS_PLAN_FREE,
+	STORE_KEY,
+	FREE_PLAN_PRODUCT_ID,
+} from './constants';
+import type { State } from './reducer';
+import type {
+	Plan,
+	PlanFeature,
+	FeaturesByType,
+	PlanProduct,
+	PlanPath,
+	PlanSlug,
+	StorePlanSlug,
+} from './types';
+
+// Some of these selectors require unused parameters because those
+// params are used by the associated resolver.
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+export const getFeatures = ( state: State, locale: string ): Record< string, PlanFeature > =>
+	state.features[ locale ] ?? {};
+
+export const getFeaturesByType = ( state: State, locale: string ): Array< FeaturesByType > =>
+	state.featuresByType[ locale ] ?? [];
+
+export const getPlanByProductId = (
+	_state: State,
+	productId: number | undefined,
+	locale: string
+): Plan | undefined => {
+	if ( ! productId ) {
+		return undefined;
+	}
+
+	return select( STORE_KEY )
+		.getSupportedPlans( locale )
+		.find( ( plan ) => plan.productIds.indexOf( productId ) > -1 );
+};
+
+export const getPlanProductById = (
+	_state: State,
+	productId: number | undefined
+): PlanProduct | undefined => {
+	if ( ! productId ) {
+		return undefined;
+	}
+
+	return select( STORE_KEY )
+		.getPlansProducts()
+		.find( ( product ) => product.productId === productId );
+};
+
+export const getPlanByPeriodAgnosticSlug = (
+	_state: State,
+	slug: PlanSlug | undefined,
+	locale: string
+): Plan | undefined => {
+	if ( ! slug ) {
+		return undefined;
+	}
+	return select( STORE_KEY )
+		.getSupportedPlans( locale )
+		.find( ( plan ) => plan.periodAgnosticSlug === slug );
+};
+
+export const getDefaultPaidPlan = ( _: State, locale: string ): Plan | undefined => {
+	return select( STORE_KEY )
+		.getSupportedPlans( locale )
+		.find( ( plan ) => plan.periodAgnosticSlug === DEFAULT_PAID_PLAN );
+};
+
+export const getDefaultFreePlan = ( _: State, locale: string ): Plan | undefined => {
+	return select( STORE_KEY )
+		.getSupportedPlans( locale )
+		.find( ( plan ) => plan.periodAgnosticSlug === TIMELESS_PLAN_FREE );
+};
+
+export const getSupportedPlans = ( state: State, _locale: string ): Plan[] => {
+	return state.plans[ _locale ] ?? [];
+};
+
+export const getPlansProducts = ( state: State ): PlanProduct[] => {
+	return state.planProducts;
+};
+
+/**
+ * @deprecated  getPrices is deprecated, please use plan.price directly
+ *
+ * @param _state the state
+ * @param _locale the locale
+ */
+export const getPrices = ( _state: State, _locale: string ): Record< StorePlanSlug, string > => {
+	deprecate( 'getPrices', {
+		alternative: 'getPlanProduct().price',
+	} );
+	return select( STORE_KEY )
+		.getPlansProducts()
+		.reduce( ( prices, plan ) => {
+			prices[ plan.storeSlug ] = plan.price;
+			return prices;
+		}, {} as Record< StorePlanSlug, string > );
+};
+
+export const getPlanByPath = (
+	_state: State,
+	path: PlanPath | undefined,
+	locale: string
+): Plan | undefined => {
+	if ( ! path ) {
+		return undefined;
+	}
+
+	const planProduct = select( STORE_KEY )
+		.getPlansProducts()
+		.find( ( product ) => product.pathSlug === path );
+
+	if ( ! planProduct ) {
+		return undefined;
+	}
+
+	return select( STORE_KEY )
+		.getSupportedPlans( locale )
+		.find( ( plan ) => plan.periodAgnosticSlug === planProduct.periodAgnosticSlug );
+};
+
+export const getPlanProduct = (
+	_state: State,
+	periodAgnosticSlug: string | undefined,
+	billingPeriod: PlanProduct[ 'billingPeriod' ] | undefined
+): PlanProduct | undefined => {
+	if ( ! periodAgnosticSlug || ! billingPeriod ) {
+		return undefined;
+	}
+
+	return select( STORE_KEY )
+		.getPlansProducts()
+		.find( ( product ) => {
+			const matchesSlug = product.periodAgnosticSlug === periodAgnosticSlug;
+			// The billing period doesn't matter when dealing with free plan
+			const matchesBillingPeriod =
+				periodAgnosticSlug === TIMELESS_PLAN_FREE || product.billingPeriod === billingPeriod;
+
+			return matchesSlug && matchesBillingPeriod;
+		} );
+};
+
+export const isPlanEcommerce = ( _: State, planSlug?: PlanSlug ): boolean => {
+	return planSlug === TIMELESS_PLAN_ECOMMERCE;
+};
+
+export const isPlanFree = ( _: State, planSlug?: PlanSlug ): boolean => {
+	return planSlug === TIMELESS_PLAN_FREE;
+};
+
+export const isPlanProductFree = ( _: State, planProductId: number | undefined ): boolean =>
+	planProductId === FREE_PLAN_PRODUCT_ID;

package/src/plans/test/actions.ts

@@ -0,0 +1,71 @@
+import * as Actions from '../actions';
+import * as MockData from '../mock';
+import { buildPlanFeaturesDict } from '../test-utils';
+
+const MOCK_LOCALE = 'test-locale';
+
+describe( 'Plans action creators', () => {
+	describe( 'setFeatures', () => {
+		it( 'should create the correct action object', () => {
+			const mockFeatures = buildPlanFeaturesDict( [
+				MockData.STORE_PLAN_FEATURE_CUSTOM_DOMAIN,
+				MockData.STORE_PLAN_FEATURE_LIVE_SUPPORT,
+				MockData.STORE_PLAN_FEATURE_WORDADS,
+			] );
+
+			expect( Actions.setFeatures( mockFeatures, MOCK_LOCALE ) ).toEqual( {
+				type: 'SET_FEATURES',
+				features: mockFeatures,
+				locale: MOCK_LOCALE,
+			} );
+		} );
+	} );
+
+	describe( 'setFeaturesByType', () => {
+		it( 'should create the correct action object', () => {
+			const features = [
+				MockData.API_FEATURES_BY_TYPE_GENERAL,
+				MockData.API_FEATURES_BY_TYPE_COMMERCE,
+				MockData.API_FEATURES_BY_TYPE_MARKETING,
+			];
+			expect( Actions.setFeaturesByType( features, MOCK_LOCALE ) ).toEqual( {
+				type: 'SET_FEATURES_BY_TYPE',
+				featuresByType: features,
+				locale: MOCK_LOCALE,
+			} );
+		} );
+	} );
+
+	describe( 'setPlans', () => {
+		it( 'should create the correct action object', () => {
+			const plans = [ MockData.STORE_PLAN_FREE, MockData.STORE_PLAN_PREMIUM ];
+			expect( Actions.setPlans( plans, MOCK_LOCALE ) ).toEqual( {
+				type: 'SET_PLANS',
+				plans,
+				locale: MOCK_LOCALE,
+			} );
+		} );
+	} );
+
+	describe( 'setPlanProducts', () => {
+		it( 'should create the correct action object', () => {
+			const planProducts = [
+				MockData.STORE_PRODUCT_FREE,
+				MockData.STORE_PRODUCT_PREMIUM_ANNUALLY,
+				MockData.STORE_PRODUCT_PREMIUM_MONTHLY,
+			];
+			expect( Actions.setPlanProducts( planProducts ) ).toEqual( {
+				type: 'SET_PLAN_PRODUCTS',
+				products: planProducts,
+			} );
+		} );
+	} );
+
+	describe( 'resetPlan', () => {
+		it( 'should create the correct action object', () => {
+			expect( Actions.resetPlan() ).toEqual( {
+				type: 'RESET_PLAN',
+			} );
+		} );
+	} );
+} );

package/src/plans/test/reducer.ts

@@ -0,0 +1,96 @@
+import { setPlans, setFeaturesByType, setFeatures, setPlanProducts } from '../actions';
+import * as MockData from '../mock';
+import reducer from '../reducer';
+import { buildPlanFeaturesDict } from '../test-utils';
+
+const MOCK_LOCALE = 'test-locale';
+
+describe( 'Plans reducer', () => {
+	describe( 'plans', () => {
+		it( 'should default to no plans info', () => {
+			const { plans } = reducer( undefined, { type: 'NOOP' } );
+			expect( plans ).toEqual( {} );
+		} );
+
+		it( 'should replace old plans with new plans', () => {
+			let state = reducer( undefined, setPlans( [ MockData.STORE_PLAN_FREE ], MOCK_LOCALE ) );
+
+			state = reducer(
+				state,
+				setPlanProducts( [
+					MockData.STORE_PRODUCT_FREE,
+					MockData.STORE_PRODUCT_PREMIUM_ANNUALLY,
+					MockData.STORE_PRODUCT_PREMIUM_MONTHLY,
+				] )
+			);
+
+			const newFreePlan = { ...MockData.STORE_PLAN_FREE, title: 'new free' };
+
+			const { plans } = reducer( state, setPlans( [ newFreePlan ], MOCK_LOCALE ) );
+
+			expect( plans[ MOCK_LOCALE ][ 0 ].title ).toBe( newFreePlan.title );
+			expect( plans[ MOCK_LOCALE ][ 1 ] ).toBeUndefined();
+		} );
+	} );
+
+	describe( 'featuresByType', () => {
+		it( 'should default to no featuresByType info', () => {
+			const { featuresByType } = reducer( undefined, { type: 'NOOP' } );
+			expect( featuresByType ).toEqual( {} );
+		} );
+
+		it( 'should replace old featuresByType info with new featuresByType info', () => {
+			const state = reducer(
+				undefined,
+				setFeaturesByType(
+					[ MockData.API_FEATURES_BY_TYPE_GENERAL, MockData.API_FEATURES_BY_TYPE_COMMERCE ],
+					MOCK_LOCALE
+				)
+			);
+
+			const { featuresByType } = reducer(
+				state,
+				setFeaturesByType( [ MockData.API_FEATURES_BY_TYPE_MARKETING ], MOCK_LOCALE )
+			);
+
+			expect( featuresByType[ MOCK_LOCALE ] ).toEqual( [
+				MockData.API_FEATURES_BY_TYPE_MARKETING,
+			] );
+		} );
+	} );
+
+	describe( 'features', () => {
+		it( 'should default to no feature info', () => {
+			const { features } = reducer( undefined, { type: 'NOOP' } );
+			expect( features ).toEqual( {} );
+		} );
+
+		it( 'should replace old features with new features', () => {
+			const state = reducer(
+				undefined,
+				setFeatures(
+					buildPlanFeaturesDict( [
+						MockData.STORE_PLAN_FEATURE_CUSTOM_DOMAIN,
+						MockData.STORE_PLAN_FEATURE_LIVE_SUPPORT,
+					] ),
+					MOCK_LOCALE
+				)
+			);
+
+			const { features } = reducer(
+				state,
+				setFeatures(
+					buildPlanFeaturesDict( [ MockData.STORE_PLAN_FEATURE_PRIORITY_SUPPORT ] ),
+					MOCK_LOCALE
+				)
+			);
+
+			expect(
+				features[ MOCK_LOCALE ][ MockData.STORE_PLAN_FEATURE_PRIORITY_SUPPORT.id ].name
+			).toBe( MockData.STORE_SIMPLIFIED_FEATURE_PRIORITY_SUPPORT.name );
+			expect(
+				features[ MOCK_LOCALE ][ MockData.STORE_PLAN_FEATURE_CUSTOM_DOMAIN.id ]
+			).toBeUndefined();
+		} );
+	} );
+} );

package/src/plans/test/resolvers.ts

@@ -0,0 +1,111 @@
+import * as MockData from '../mock';
+import { getSupportedPlans } from '../resolvers';
+import { buildPlanFeaturesDict } from '../test-utils';
+import type { PricedAPIPlan } from '../types';
+
+// Don't need to mock specific functions for any tests, but mocking
+// module because it accesses the `document` global.
+jest.mock( 'wpcom-proxy-request', () => ( {
+	__esModule: true,
+} ) );
+
+const MOCK_LOCALE = 'test-locale';
+
+beforeEach( () => {
+	jest.clearAllMocks();
+} );
+
+describe( 'Plans resolvers', () => {
+	describe( 'getSupportedPlans', () => {
+		it( 'should fetch APIs data and set features and plans data', () => {
+			const iter = getSupportedPlans( MOCK_LOCALE );
+
+			// Prepare stricter iterator types
+			type IteratorReturnType = ReturnType< typeof iter.next >;
+			type PlanPriceApiDataIterator = ( planPriceData: PricedAPIPlan[] ) => IteratorReturnType;
+			type PlanDetailsApiDataIterator = ( { body: DetailsAPIResponse } ) => IteratorReturnType;
+
+			// request to prices endpoint
+			expect( iter.next().value ).toEqual( {
+				request: {
+					apiVersion: '1.5',
+					path: '/plans',
+					query: `locale=${ MOCK_LOCALE }`,
+				},
+				type: 'WPCOM_REQUEST',
+			} );
+
+			// request to plan details/features endpoint
+			const planPriceApiData = [
+				MockData.API_PLAN_PRICE_FREE,
+				MockData.API_PLAN_PRICE_PREMIUM_ANNUALLY,
+				MockData.API_PLAN_PRICE_PREMIUM_MONTHLY,
+			];
+			expect( ( iter.next as PlanPriceApiDataIterator )( planPriceApiData ).value ).toEqual( {
+				type: 'FETCH_AND_PARSE',
+				resource: `https://public-api.wordpress.com/wpcom/v2/plans/details?locale=${ MOCK_LOCALE }`,
+				options: {
+					credentials: 'omit',
+					mode: 'cors',
+				},
+			} );
+
+			// setPlans call
+			const planDetailsApiData = {
+				body: MockData.API_PLAN_DETAILS,
+			};
+			expect( ( iter.next as PlanDetailsApiDataIterator )( planDetailsApiData ).value ).toEqual( {
+				locale: MOCK_LOCALE,
+				type: 'SET_PLANS',
+				plans: [ MockData.STORE_PLAN_FREE, MockData.STORE_PLAN_PREMIUM ],
+			} );
+
+			// setPlanProducts call
+			expect( iter.next().value ).toEqual( {
+				type: 'SET_PLAN_PRODUCTS',
+				products: [
+					MockData.STORE_PRODUCT_FREE,
+					MockData.STORE_PRODUCT_PREMIUM_ANNUALLY,
+					MockData.STORE_PRODUCT_PREMIUM_MONTHLY,
+				],
+			} );
+
+			expect( iter.next().value ).toEqual( {
+				locale: MOCK_LOCALE,
+				type: 'SET_FEATURES',
+				features: buildPlanFeaturesDict( [
+					MockData.STORE_PLAN_FEATURE_CUSTOM_DOMAIN,
+					MockData.STORE_PLAN_FEATURE_LIVE_SUPPORT,
+					MockData.STORE_PLAN_FEATURE_PRIORITY_SUPPORT,
+					MockData.STORE_PLAN_FEATURE_RECURRING_PAYMENTS,
+					MockData.STORE_PLAN_FEATURE_WORDADS,
+				] ),
+			} );
+
+			expect( iter.next().value ).toEqual( {
+				locale: MOCK_LOCALE,
+				type: 'SET_FEATURES_BY_TYPE',
+				featuresByType: [
+					MockData.API_FEATURES_BY_TYPE_GENERAL,
+					MockData.API_FEATURES_BY_TYPE_COMMERCE,
+					MockData.API_FEATURES_BY_TYPE_MARKETING,
+				],
+			} );
+		} );
+
+		it( 'should default to english locale', () => {
+			const englishLocale = 'en';
+			const iter = getSupportedPlans();
+
+			// request to prices endpoint
+			expect( iter.next().value ).toEqual( {
+				request: {
+					apiVersion: '1.5',
+					path: '/plans',
+					query: `locale=${ englishLocale }`,
+				},
+				type: 'WPCOM_REQUEST',
+			} );
+		} );
+	} );
+} );