@automattic/data-stores 2.0.1 → 3.0.0

package/src/site/actions.ts

@@ -1,6 +1,13 @@
-/**
- * Internal dependencies
- */
+import { Design } from '@automattic/design-picker/src/types';
+import { wpcomRequest } from '../wpcom-request-controls';
+import {
+	SiteLaunchError,
+	AtomicTransferError,
+	LatestAtomicTransferError,
+	AtomicSoftwareStatusError,
+	AtomicSoftwareInstallError,
+} from './types';
+import type { WpcomClientCredentials } from '../shared-types';
 import type {
 	CreateSiteParams,
 	NewSiteErrorResponse,
@@ -9,11 +16,15 @@ import type {
 	SiteError,
 	Cart,
 	Domain,
+	LatestAtomicTransfer,
 	SiteLaunchError as SiteLaunchErrorType,
+	AtomicTransferError as AtomicTransferErrorType,
+	LatestAtomicTransferError as LatestAtomicTransferErrorType,
+	AtomicSoftwareStatusError as AtomicSoftwareStatusErrorType,
+	AtomicSoftwareInstallError as AtomicSoftwareInstallErrorType,
+	AtomicSoftwareStatus,
+	SiteSettings,
 } from './types';
-import type { WpcomClientCredentials } from '../shared-types';
-import { wpcomRequest } from '../wpcom-request-controls';
-import { SiteLaunchError } from './types';
 
 export function createActions( clientCreds: WpcomClientCredentials ) {
 	const fetchSite = () => ( {
@@ -55,7 +66,7 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 				validate: false,
 			};
 
-			const newSite = yield wpcomRequest( {
+			const newSite: NewSiteSuccessResponse = yield wpcomRequest( {
 				path: '/sites/new',
 				apiVersion: '1.1',
 				method: 'post',
@@ -66,7 +77,7 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 			yield receiveNewSite( newSite );
 			return true;
 		} catch ( err ) {
-			yield receiveNewSiteFailed( err );
+			yield receiveNewSiteFailed( err as NewSiteErrorResponse );
 			return false;
 		}
 	}
@@ -77,10 +88,22 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 		response,
 	} );
 
-	const receiveSiteTitle = ( siteId: number, title: string | undefined ) => ( {
+	const receiveSiteTitle = ( siteId: number, name: string | undefined ) => ( {
 		type: 'RECEIVE_SITE_TITLE' as const,
 		siteId,
-		title,
+		name,
+	} );
+
+	const receiveSiteTagline = ( siteId: number, tagline: string | undefined ) => ( {
+		type: 'RECEIVE_SITE_TAGLINE' as const,
+		siteId,
+		tagline,
+	} );
+
+	const receiveSiteVerticalId = ( siteId: number, verticalId: string | undefined ) => ( {
+		type: 'RECEIVE_SITE_VERTICAL_ID' as const,
+		siteId,
+		verticalId,
 	} );
 
 	const receiveSiteFailed = ( siteId: number, response: SiteError | undefined ) => ( {
@@ -129,7 +152,7 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 
 	// TODO: move getCart and setCart to a 'cart' data-store
 	function* getCart( siteId: number ) {
-		const success = yield wpcomRequest( {
+		const success: Cart = yield wpcomRequest( {
 			path: '/me/shopping-cart/' + siteId,
 			apiVersion: '1.1',
 			method: 'GET',
@@ -143,8 +166,20 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 		domains,
 	} );
 
+	const receiveSiteSettings = ( siteId: number, settings: SiteSettings ) => ( {
+		type: 'RECEIVE_SITE_SETTINGS' as const,
+		siteId,
+		settings,
+	} );
+
+	const updateSiteSettings = ( siteId: number, settings: SiteSettings ) => ( {
+		type: 'UPDATE_SITE_SETTINGS' as const,
+		siteId,
+		settings,
+	} );
+
 	function* setCart( siteId: number, cartData: Cart ) {
-		const success = yield wpcomRequest( {
+		const success: Cart = yield wpcomRequest( {
 			path: '/me/shopping-cart/' + siteId,
 			apiVersion: '1.1',
 			method: 'POST',
@@ -153,31 +188,291 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 		return success;
 	}
 
-	function* saveSiteTitle( siteId: number, title: string | undefined ) {
+	function* saveSiteSettings(
+		siteId: number,
+		settings: {
+			blogname?: string;
+			blogdescription?: string;
+			site_vertical_id?: string;
+			woocommerce_store_address?: string;
+			woocommerce_store_address_2?: string;
+			woocommerce_store_city?: string;
+			woocommerce_store_postcode?: string;
+			woocommerce_defaut_country?: string;
+			woocommerce_onboarding_profile?: { [ key: string ]: any };
+		}
+	) {
 		try {
 			// extract this into its own function as a generic settings setter
 			yield wpcomRequest( {
 				path: `/sites/${ encodeURIComponent( siteId ) }/settings`,
 				apiVersion: '1.4',
-				body: { blogname: title },
+				body: settings,
 				method: 'POST',
 			} );
-			yield receiveSiteTitle( siteId, title );
+			if ( 'blogname' in settings ) {
+				yield receiveSiteTitle( siteId, settings.blogname );
+			}
+			if ( 'blogdescription' in settings ) {
+				yield receiveSiteTagline( siteId, settings.blogdescription );
+			}
+			if ( 'site_vertical_id' in settings ) {
+				yield receiveSiteVerticalId( siteId, settings.site_vertical_id );
+			}
+			yield updateSiteSettings( siteId, settings );
 		} catch ( e ) {}
 	}
 
+	function* setIntentOnSite( siteSlug: string, intent: string ) {
+		try {
+			yield wpcomRequest( {
+				path: `/sites/${ encodeURIComponent( siteSlug ) }/site-intent`,
+				apiNamespace: 'wpcom/v2',
+				body: { site_intent: intent },
+				method: 'POST',
+			} );
+		} catch ( e ) {}
+	}
+
+	function* saveSiteTitle( siteId: number, blogname: string | undefined ) {
+		yield saveSiteSettings( siteId, { blogname } );
+	}
+
+	function* saveSiteTagline( siteId: number, blogdescription: string | undefined ) {
+		yield saveSiteSettings( siteId, { blogdescription } );
+	}
+
+	function* setDesignOnSite( siteSlug: string, selectedDesign: Design, siteVerticalId: string ) {
+		const { theme, recipe } = selectedDesign;
+
+		yield wpcomRequest( {
+			path: `/sites/${ siteSlug }/themes/mine`,
+			apiVersion: '1.1',
+			body: { theme: recipe?.stylesheet?.split( '/' )[ 1 ] || theme, dont_change_homepage: true },
+			method: 'POST',
+		} );
+
+		/*
+		 * Anchor themes are set up directly via Headstart on the server side
+		 * so exclude them from theme setup.
+		 */
+		const anchorDesigns = [ 'hannah', 'gilbert', 'riley' ];
+		if ( anchorDesigns.indexOf( selectedDesign.template ) < 0 ) {
+			yield wpcomRequest( {
+				path: `/sites/${ encodeURIComponent( siteSlug ) }/theme-setup`,
+				apiNamespace: 'wpcom/v2',
+				body: {
+					trim_content: true,
+					pattern_ids: recipe?.pattern_ids,
+					vertical_id: siteVerticalId || undefined,
+				},
+				method: 'POST',
+			} );
+		}
+
+		const data: { is_fse_active: boolean } = yield wpcomRequest( {
+			path: `/sites/${ siteSlug }/block-editor`,
+			apiNamespace: 'wpcom/v2',
+			method: 'GET',
+		} );
+
+		return data?.is_fse_active ?? false;
+	}
+
+	const setSiteSetupError = ( error: string, message: string ) => ( {
+		type: 'SET_SITE_SETUP_ERROR',
+		error,
+		message,
+	} );
+
+	const clearSiteSetupError = ( siteId: number ) => ( {
+		type: 'CLEAR_SITE_SETUP_ERROR',
+		siteId,
+	} );
+
+	const atomicTransferStart = ( siteId: number, softwareSet: string | undefined ) => ( {
+		type: 'ATOMIC_TRANSFER_START' as const,
+		siteId,
+		softwareSet,
+	} );
+
+	const atomicTransferSuccess = ( siteId: number, softwareSet: string | undefined ) => ( {
+		type: 'ATOMIC_TRANSFER_SUCCESS' as const,
+		siteId,
+		softwareSet,
+	} );
+
+	const atomicTransferFailure = (
+		siteId: number,
+		softwareSet: string | undefined,
+		error: AtomicTransferErrorType
+	) => ( {
+		type: 'ATOMIC_TRANSFER_FAILURE' as const,
+		siteId,
+		softwareSet,
+		error,
+	} );
+
+	function* initiateAtomicTransfer( siteId: number, softwareSet: string | undefined ) {
+		yield atomicTransferStart( siteId, softwareSet );
+		try {
+			yield wpcomRequest( {
+				path: `/sites/${ encodeURIComponent( siteId ) }/atomic/transfers`,
+				apiNamespace: 'wpcom/v2',
+				method: 'POST',
+				...( softwareSet
+					? {
+							body: {
+								software_set: encodeURIComponent( softwareSet ),
+							},
+					  }
+					: {} ),
+			} );
+			yield atomicTransferSuccess( siteId, softwareSet );
+		} catch ( _ ) {
+			yield atomicTransferFailure( siteId, softwareSet, AtomicTransferError.INTERNAL );
+		}
+	}
+
+	const latestAtomicTransferStart = ( siteId: number ) => ( {
+		type: 'LATEST_ATOMIC_TRANSFER_START' as const,
+		siteId,
+	} );
+
+	const latestAtomicTransferSuccess = ( siteId: number, transfer: LatestAtomicTransfer ) => ( {
+		type: 'LATEST_ATOMIC_TRANSFER_SUCCESS' as const,
+		siteId,
+		transfer,
+	} );
+
+	const latestAtomicTransferFailure = (
+		siteId: number,
+		error: LatestAtomicTransferErrorType
+	) => ( {
+		type: 'LATEST_ATOMIC_TRANSFER_FAILURE' as const,
+		siteId,
+		error,
+	} );
+
+	function* requestLatestAtomicTransfer( siteId: number ) {
+		yield latestAtomicTransferStart( siteId );
+
+		try {
+			const transfer: LatestAtomicTransfer = yield wpcomRequest( {
+				path: `/sites/${ encodeURIComponent( siteId ) }/atomic/transfers/latest`,
+				apiNamespace: 'wpcom/v2',
+				method: 'GET',
+			} );
+			yield latestAtomicTransferSuccess( siteId, transfer );
+		} catch ( err ) {
+			yield latestAtomicTransferFailure( siteId, err as LatestAtomicTransferError );
+		}
+	}
+
+	const atomicSoftwareStatusStart = ( siteId: number, softwareSet: string ) => ( {
+		type: 'ATOMIC_SOFTWARE_STATUS_START' as const,
+		siteId,
+		softwareSet,
+	} );
+
+	const atomicSoftwareStatusSuccess = (
+		siteId: number,
+		softwareSet: string,
+		status: AtomicSoftwareStatus
+	) => ( {
+		type: 'ATOMIC_SOFTWARE_STATUS_SUCCESS' as const,
+		siteId,
+		softwareSet,
+		status,
+	} );
+
+	const atomicSoftwareStatusFailure = (
+		siteId: number,
+		softwareSet: string,
+		error: AtomicSoftwareStatusErrorType
+	) => ( {
+		type: 'ATOMIC_SOFTWARE_STATUS_FAILURE' as const,
+		siteId,
+		softwareSet,
+		error,
+	} );
+
+	function* requestAtomicSoftwareStatus( siteId: number, softwareSet: string ) {
+		yield atomicSoftwareStatusStart( siteId, softwareSet );
+		try {
+			const status: AtomicSoftwareStatus = yield wpcomRequest( {
+				path: `/sites/${ encodeURIComponent( siteId ) }/atomic/software/${ encodeURIComponent(
+					softwareSet
+				) }`,
+				apiNamespace: 'wpcom/v2',
+				method: 'GET',
+			} );
+			yield atomicSoftwareStatusSuccess( siteId, softwareSet, status );
+		} catch ( err ) {
+			yield atomicSoftwareStatusFailure( siteId, softwareSet, err as AtomicSoftwareStatusError );
+		}
+	}
+
+	const atomicSoftwareInstallStart = ( siteId: number, softwareSet: string ) => ( {
+		type: 'ATOMIC_SOFTWARE_INSTALL_START' as const,
+		siteId,
+		softwareSet,
+	} );
+
+	const atomicSoftwareInstallSuccess = ( siteId: number, softwareSet: string ) => ( {
+		type: 'ATOMIC_SOFTWARE_INSTALL_SUCCESS' as const,
+		siteId,
+		softwareSet,
+	} );
+
+	const atomicSoftwareInstallFailure = (
+		siteId: number,
+		softwareSet: string,
+		error: AtomicSoftwareInstallErrorType
+	) => ( {
+		type: 'ATOMIC_SOFTWARE_INSTALL_FAILURE' as const,
+		siteId,
+		softwareSet,
+		error,
+	} );
+
+	function* initiateSoftwareInstall( siteId: number, softwareSet: string ) {
+		yield atomicSoftwareInstallStart( siteId, softwareSet );
+		try {
+			yield wpcomRequest( {
+				path: `/sites/${ encodeURIComponent( siteId ) }/atomic/software/${ encodeURIComponent(
+					softwareSet
+				) }`,
+				apiNamespace: 'wpcom/v2',
+				method: 'POST',
+				body: {},
+			} );
+			yield atomicSoftwareInstallSuccess( siteId, softwareSet );
+		} catch ( err ) {
+			yield atomicSoftwareInstallFailure( siteId, softwareSet, err as AtomicSoftwareInstallError );
+		}
+	}
+
 	return {
 		receiveSiteDomains,
+		receiveSiteSettings,
 		saveSiteTitle,
+		saveSiteSettings,
+		setIntentOnSite,
 		receiveSiteTitle,
 		fetchNewSite,
 		fetchSite,
 		receiveNewSite,
 		receiveNewSiteFailed,
 		resetNewSiteFailed,
+		setDesignOnSite,
 		createSite,
 		receiveSite,
 		receiveSiteFailed,
+		receiveSiteTagline,
+		receiveSiteVerticalId,
+		updateSiteSettings,
+		saveSiteTagline,
 		reset,
 		launchSite,
 		launchSiteStart,
@@ -185,6 +480,24 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 		launchSiteFailure,
 		getCart,
 		setCart,
+		setSiteSetupError,
+		clearSiteSetupError,
+		initiateAtomicTransfer,
+		atomicTransferStart,
+		atomicTransferSuccess,
+		atomicTransferFailure,
+		latestAtomicTransferStart,
+		latestAtomicTransferSuccess,
+		latestAtomicTransferFailure,
+		requestLatestAtomicTransfer,
+		atomicSoftwareStatusStart,
+		atomicSoftwareStatusSuccess,
+		atomicSoftwareStatusFailure,
+		requestAtomicSoftwareStatus,
+		initiateSoftwareInstall,
+		atomicSoftwareInstallStart,
+		atomicSoftwareInstallSuccess,
+		atomicSoftwareInstallFailure,
 	};
 }
 
@@ -195,16 +508,32 @@ export type Action =
 			| ActionCreators[ 'fetchNewSite' ]
 			| ActionCreators[ 'fetchSite' ]
 			| ActionCreators[ 'receiveSiteDomains' ]
+			| ActionCreators[ 'receiveSiteSettings' ]
 			| ActionCreators[ 'receiveNewSite' ]
 			| ActionCreators[ 'receiveSiteTitle' ]
 			| ActionCreators[ 'receiveNewSiteFailed' ]
+			| ActionCreators[ 'receiveSiteTagline' ]
+			| ActionCreators[ 'receiveSiteVerticalId' ]
 			| ActionCreators[ 'receiveSite' ]
 			| ActionCreators[ 'receiveSiteFailed' ]
+			| ActionCreators[ 'updateSiteSettings' ]
 			| ActionCreators[ 'reset' ]
 			| ActionCreators[ 'resetNewSiteFailed' ]
 			| ActionCreators[ 'launchSiteStart' ]
 			| ActionCreators[ 'launchSiteSuccess' ]
 			| ActionCreators[ 'launchSiteFailure' ]
+			| ActionCreators[ 'atomicTransferStart' ]
+			| ActionCreators[ 'atomicTransferSuccess' ]
+			| ActionCreators[ 'atomicTransferFailure' ]
+			| ActionCreators[ 'latestAtomicTransferStart' ]
+			| ActionCreators[ 'latestAtomicTransferSuccess' ]
+			| ActionCreators[ 'latestAtomicTransferFailure' ]
+			| ActionCreators[ 'atomicSoftwareStatusStart' ]
+			| ActionCreators[ 'atomicSoftwareStatusSuccess' ]
+			| ActionCreators[ 'atomicSoftwareStatusFailure' ]
+			| ActionCreators[ 'atomicSoftwareInstallStart' ]
+			| ActionCreators[ 'atomicSoftwareInstallSuccess' ]
+			| ActionCreators[ 'atomicSoftwareInstallFailure' ]
 	  >
 	// Type added so we can dispatch actions in tests, but has no runtime cost
 	| { type: 'TEST_ACTION' };

package/src/site/index.ts

@@ -1,22 +1,16 @@
-/**
- * External dependencies
- */
 import { registerStore } from '@wordpress/data';
-
-/**
- * Internal dependencies
- */
+import { controls } from '../wpcom-request-controls';
+import { createActions } from './actions';
 import { STORE_KEY } from './constants';
 import reducer, { State } from './reducer';
-import { createActions } from './actions';
 import * as resolvers from './resolvers';
 import * as selectors from './selectors';
 import type { DispatchFromMap, SelectFromMap } from '../mapped-types';
 import type { WpcomClientCredentials } from '../shared-types';
-import { controls } from '../wpcom-request-controls';
 
 export * from './types';
 export type { State };
+export { STORE_KEY };
 
 let isRegistered = false;
 export function register( clientCreds: WpcomClientCredentials ): typeof STORE_KEY {