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

package/src/site/reducer.ts

@@ -0,0 +1,386 @@
+import { combineReducers } from '@wordpress/data';
+import {
+	NewSiteBlogDetails,
+	NewSiteErrorResponse,
+	SiteDetails,
+	Domain,
+	SiteLaunchState,
+	SiteLaunchStatus,
+	SiteSettings,
+	AtomicTransferStatus,
+	LatestAtomicTransferStatus,
+} from './types';
+import {
+	AtomicTransferState,
+	LatestAtomicTransferState,
+	AtomicSoftwareStatusState,
+	AtomicSoftwareInstallState,
+	AtomicSoftwareInstallStatus,
+} from '.';
+import type { Action } from './actions';
+import type { Reducer } from 'redux';
+
+export const newSiteData: Reducer< NewSiteBlogDetails | undefined, Action > = ( state, action ) => {
+	if ( action.type === 'RECEIVE_NEW_SITE' ) {
+		const { response } = action;
+		return response.blog_details;
+	} else if ( action.type === 'RECEIVE_NEW_SITE_FAILED' ) {
+		return undefined;
+	} else if ( action.type === 'RESET_SITE_STORE' ) {
+		return undefined;
+	}
+	return state;
+};
+
+export const newSiteError: Reducer< NewSiteErrorResponse | undefined, Action > = (
+	state,
+	action
+) => {
+	switch ( action.type ) {
+		case 'FETCH_NEW_SITE':
+		case 'RECEIVE_NEW_SITE':
+		case 'RESET_SITE_STORE':
+		case 'RESET_RECEIVE_NEW_SITE_FAILED':
+			return undefined;
+		case 'RECEIVE_NEW_SITE_FAILED':
+			return {
+				error: action.error.error,
+				status: action.error.status,
+				statusCode: action.error.statusCode,
+				name: action.error.name,
+				message: action.error.message,
+			};
+	}
+	return state;
+};
+
+export const isFetchingSite: Reducer< boolean | undefined, Action > = ( state = false, action ) => {
+	switch ( action.type ) {
+		case 'FETCH_NEW_SITE':
+			return true;
+		case 'RECEIVE_NEW_SITE':
+		case 'RECEIVE_NEW_SITE_FAILED':
+		case 'RESET_SITE_STORE':
+		case 'RESET_RECEIVE_NEW_SITE_FAILED':
+			return false;
+	}
+	return state;
+};
+
+export const isFetchingSiteDetails: Reducer< boolean | undefined, Action > = (
+	state = false,
+	action
+) => {
+	switch ( action.type ) {
+		case 'FETCH_SITE':
+			return true;
+		case 'RECEIVE_SITE':
+		case 'RECEIVE_SITE_FAILED':
+			return false;
+	}
+	return state;
+};
+
+export const sites: Reducer< { [ key: number | string ]: SiteDetails | undefined }, Action > = (
+	state = {},
+	action
+) => {
+	if ( action.type === 'RECEIVE_SITE' ) {
+		if ( action.response ) {
+			return { ...state, [ action.response.ID ]: action.response };
+		}
+		return state;
+	} else if ( action.type === 'RECEIVE_SITE_FAILED' ) {
+		const { [ action.siteId ]: idToBeRemoved, ...remainingState } = state;
+		return { ...remainingState };
+	} else if ( action.type === 'RESET_SITE_STORE' ) {
+		return {};
+	} else if ( action.type === 'RECEIVE_SITE_TITLE' ) {
+		return {
+			...state,
+			[ action.siteId ]: { ...( state[ action.siteId ] as SiteDetails ), name: action.name },
+		};
+	} else if ( action.type === 'RECEIVE_SITE_TAGLINE' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				...( state[ action.siteId ] as SiteDetails ),
+				description: action.tagline ?? '',
+			},
+		};
+	} else if ( action.type === 'RECEIVE_SITE_VERTICAL_ID' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				...( state[ action.siteId ] as SiteDetails ),
+				options: {
+					...state[ action.siteId ]?.options,
+					site_vertical_id: action.verticalId,
+				},
+			},
+		};
+	}
+	return state;
+};
+
+export const sitesDomains: Reducer< { [ key: number ]: Domain[] }, Action > = (
+	state = {},
+	action
+) => {
+	if ( action.type === 'RECEIVE_SITE_DOMAINS' ) {
+		return { ...state, [ action.siteId ]: action.domains };
+	}
+	return state;
+};
+
+export const sitesSettings: Reducer< { [ key: number ]: SiteSettings }, Action > = (
+	state = {},
+	action
+) => {
+	if ( action.type === 'RECEIVE_SITE_SETTINGS' ) {
+		return { ...state, [ action.siteId ]: action.settings };
+	}
+	if ( action.type === 'UPDATE_SITE_SETTINGS' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				...state?.[ action.siteId ],
+				...action.settings,
+			},
+		};
+	}
+	return state;
+};
+
+export const launchStatus: Reducer< { [ key: number ]: SiteLaunchState }, Action > = (
+	state = {},
+	action
+) => {
+	if ( action.type === 'LAUNCH_SITE_START' ) {
+		return {
+			...state,
+			[ action.siteId ]: { status: SiteLaunchStatus.IN_PROGRESS, errorCode: undefined },
+		};
+	}
+	if ( action.type === 'LAUNCH_SITE_SUCCESS' ) {
+		return {
+			...state,
+			[ action.siteId ]: { status: SiteLaunchStatus.SUCCESS, errorCode: undefined },
+		};
+	}
+	if ( action.type === 'LAUNCH_SITE_FAILURE' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				status: SiteLaunchStatus.FAILURE,
+				errorCode: action.error,
+			},
+		};
+	}
+	return state;
+};
+
+export const siteSetupErrors: Reducer<
+	{
+		error?: string;
+		message?: string;
+	},
+	{
+		type: string;
+		error?: string;
+		message?: string;
+	}
+> = ( state = {}, action ) => {
+	if ( action.type === 'SET_SITE_SETUP_ERROR' ) {
+		const { error, message } = action;
+
+		return {
+			error,
+			message,
+		};
+	}
+
+	if ( action.type === 'CLEAR_SITE_SETUP_ERROR' ) {
+		return {};
+	}
+
+	return state;
+};
+
+export const atomicTransferStatus: Reducer< { [ key: number ]: AtomicTransferState }, Action > = (
+	state = {},
+	action
+) => {
+	if ( action.type === 'ATOMIC_TRANSFER_START' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				status: AtomicTransferStatus.IN_PROGRESS,
+				softwareSet: action.softwareSet,
+				errorCode: undefined,
+			},
+		};
+	}
+	if ( action.type === 'ATOMIC_TRANSFER_SUCCESS' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				status: AtomicTransferStatus.SUCCESS,
+				softwareSet: action.softwareSet,
+				errorCode: undefined,
+			},
+		};
+	}
+	if ( action.type === 'ATOMIC_TRANSFER_FAILURE' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				status: AtomicTransferStatus.FAILURE,
+				softwareSet: action.softwareSet,
+				errorCode: action.error,
+			},
+		};
+	}
+	return state;
+};
+
+export const latestAtomicTransferStatus: Reducer<
+	{ [ key: number ]: LatestAtomicTransferState },
+	Action
+> = ( state = {}, action ) => {
+	if ( action.type === 'LATEST_ATOMIC_TRANSFER_START' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				status: LatestAtomicTransferStatus.IN_PROGRESS,
+				transfer: undefined,
+				errorCode: undefined,
+			},
+		};
+	}
+	if ( action.type === 'LATEST_ATOMIC_TRANSFER_SUCCESS' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				status: LatestAtomicTransferStatus.SUCCESS,
+				transfer: action.transfer,
+				errorCode: undefined,
+			},
+		};
+	}
+	if ( action.type === 'LATEST_ATOMIC_TRANSFER_FAILURE' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				status: LatestAtomicTransferStatus.FAILURE,
+				transfer: undefined,
+				errorCode: action.error,
+			},
+		};
+	}
+	return state;
+};
+
+export const atomicSoftwareStatus: Reducer<
+	{ [ key: number ]: AtomicSoftwareStatusState },
+	Action
+> = ( state = {}, action ) => {
+	if ( action.type === 'ATOMIC_SOFTWARE_STATUS_START' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				[ action.softwareSet ]: {
+					status: undefined,
+					error: undefined,
+				},
+			},
+		};
+	}
+	if ( action.type === 'ATOMIC_SOFTWARE_STATUS_SUCCESS' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				[ action.softwareSet ]: {
+					status: action.status,
+					error: undefined,
+				},
+			},
+		};
+	}
+	if ( action.type === 'ATOMIC_SOFTWARE_STATUS_FAILURE' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				[ action.softwareSet ]: {
+					status: undefined,
+					error: action.error,
+				},
+			},
+		};
+	}
+	return state;
+};
+
+export const atomicSoftwareInstallStatus: Reducer<
+	{ [ key: number ]: AtomicSoftwareInstallState },
+	Action
+> = ( state = {}, action ) => {
+	if ( action.type === 'ATOMIC_SOFTWARE_INSTALL_START' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				[ action.softwareSet ]: {
+					status: AtomicSoftwareInstallStatus.IN_PROGRESS,
+					error: undefined,
+				},
+			},
+		};
+	}
+	if ( action.type === 'ATOMIC_SOFTWARE_INSTALL_SUCCESS' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				[ action.softwareSet ]: {
+					status: AtomicSoftwareInstallStatus.SUCCESS,
+					error: undefined,
+				},
+			},
+		};
+	}
+	if ( action.type === 'ATOMIC_SOFTWARE_INSTALL_FAILURE' ) {
+		return {
+			...state,
+			[ action.siteId ]: {
+				[ action.softwareSet ]: {
+					status: AtomicSoftwareInstallStatus.FAILURE,
+					error: action.error,
+				},
+			},
+		};
+	}
+	return state;
+};
+
+const newSite = combineReducers( {
+	data: newSiteData,
+	error: newSiteError,
+	isFetching: isFetchingSite,
+} );
+
+const reducer = combineReducers( {
+	isFetchingSiteDetails,
+	newSite,
+	sites,
+	launchStatus,
+	sitesDomains,
+	sitesSettings,
+	siteSetupErrors,
+	atomicTransferStatus,
+	latestAtomicTransferStatus,
+	atomicSoftwareStatus,
+	atomicSoftwareInstallStatus,
+} );
+
+export type State = ReturnType< typeof reducer >;
+
+export default reducer;

package/src/site/resolvers.ts

@@ -0,0 +1,57 @@
+// wpcomRequest is a temporary rename while we're working on migrating generators to thunks
+import wpcomRequest from 'wpcom-proxy-request';
+import type { SiteDetails, Domain, SiteSettings, Dispatch } from './types';
+
+/**
+ * Attempt to find a site based on its id, and if not return undefined.
+ * We are currently ignoring error messages and silently failing if we can't find a
+ * site. This could be extended in the future by retrieving the `error` and
+ * `message` strings returned by the API.
+ *
+ * @param siteId {number}	The site to look up
+ */
+export const getSite =
+	( siteId: number ) =>
+	async ( { dispatch }: Dispatch ) => {
+		dispatch.fetchSite();
+		try {
+			const existingSite: SiteDetails | undefined = await wpcomRequest( {
+				path: '/sites/' + encodeURIComponent( siteId ),
+				apiVersion: '1.1',
+			} );
+			dispatch.receiveSite( siteId, existingSite );
+		} catch ( err ) {
+			dispatch.receiveSiteFailed( siteId, undefined );
+		}
+	};
+
+/**
+ * Get all site domains
+ *
+ * @param siteId {number} The site id
+ */
+export const getSiteDomains =
+	( siteId: number ) =>
+	async ( { dispatch }: Dispatch ) => {
+		const result: { domains: Domain[] } = await wpcomRequest( {
+			path: '/sites/' + encodeURIComponent( siteId ) + '/domains',
+			apiVersion: '1.2',
+		} );
+		dispatch.receiveSiteDomains( siteId, result?.domains );
+	};
+
+/**
+ * Get all site settings
+ *
+ * @param siteId {number} The site id
+ */
+export const getSiteSettings =
+	( siteId: number ) =>
+	async ( { dispatch }: Dispatch ) => {
+		const result: { settings: SiteSettings } = await wpcomRequest( {
+			path: '/sites/' + encodeURIComponent( siteId ) + '/settings',
+			apiVersion: '1.4',
+		} );
+
+		dispatch.receiveSiteSettings( siteId, result?.settings );
+	};

package/src/site/selectors.ts

@@ -0,0 +1,141 @@
+import { select } from '@wordpress/data';
+import { STORE_KEY } from './constants';
+import { SiteLaunchStatus, SiteOption } from './types';
+import type { State } from './reducer';
+
+export const getState = ( state: State ) => state;
+export const getNewSite = ( state: State ) => state.newSite.data;
+export const getNewSiteError = ( state: State ) => state.newSite.error;
+export const isFetchingSite = ( state: State ) => state.newSite.isFetching;
+export const isFetchingSiteDetails = ( state: State ) => state.isFetchingSiteDetails;
+export const isNewSite = ( state: State ) => !! state.newSite.data;
+
+/**
+ * Get a site matched by id. This selector has a matching
+ * resolver that uses the `siteId` parameter to fetch an existing site. If the
+ * site cannot be found, invalidate the resolution cache.
+ *
+ * @param state {State}		state object
+ * @param siteId {number}	id of the site to look up
+ */
+export const getSite = ( state: State, siteId: number | string ) => {
+	return (
+		state.sites[ siteId ] ||
+		Object.values( state.sites ).find( ( site ) => site && new URL( site.URL ).host === siteId )
+	);
+};
+
+export const getSiteIdBySlug = ( _: State, slug: string ) => {
+	return select( STORE_KEY ).getSite( slug )?.ID;
+};
+
+export const getSiteTitle = ( _: State, siteId: number ) =>
+	select( STORE_KEY ).getSite( siteId )?.name;
+
+export const getSiteVerticalId = ( _: State, siteId: number ) =>
+	select( STORE_KEY ).getSite( siteId )?.options?.site_vertical_id;
+
+// @TODO: Return LaunchStatus instead of a boolean
+export const isSiteLaunched = ( state: State, siteId: number ) => {
+	return state.launchStatus[ siteId ]?.status === SiteLaunchStatus.SUCCESS;
+};
+
+// @TODO: Return LaunchStatus instead of a boolean
+export const isSiteLaunching = ( state: State, siteId: number ) => {
+	return state.launchStatus[ siteId ]?.status === SiteLaunchStatus.IN_PROGRESS;
+};
+
+export const isSiteAtomic = ( state: State, siteId: number | string ) => {
+	return select( STORE_KEY ).getSite( siteId )?.options.is_wpcom_atomic === true;
+};
+
+export const isSiteWPForTeams = ( state: State, siteId: number | string ) => {
+	return select( STORE_KEY ).getSite( siteId )?.options.is_wpforteams_site === true;
+};
+
+export const getSiteDomains = ( state: State, siteId: number ) => {
+	return state.sitesDomains[ siteId ];
+};
+
+export const getSiteSettings = ( state: State, siteId: number ) => {
+	return state.sitesSettings[ siteId ];
+};
+
+export const getSiteSetupError = ( state: State ) => {
+	return state.siteSetupErrors;
+};
+
+export const getSiteOptions = ( state: State, siteId: number ) => {
+	return state.sites[ siteId ]?.options;
+};
+
+export const getSiteOption = ( state: State, siteId: number, optionName: SiteOption ) => {
+	return state.sites[ siteId ]?.options?.[ optionName ];
+};
+
+export const getPrimarySiteDomain = ( _: State, siteId: number ) =>
+	select( STORE_KEY )
+		.getSiteDomains( siteId )
+		?.find( ( domain ) => domain.primary_domain );
+
+export const getSiteSubdomain = ( _: State, siteId: number ) =>
+	select( STORE_KEY )
+		.getSiteDomains( siteId )
+		?.find( ( domain ) => domain.is_subdomain );
+
+export const getSiteLatestAtomicTransfer = ( state: State, siteId: number ) => {
+	return state.latestAtomicTransferStatus[ siteId ]?.transfer;
+};
+
+export const getSiteLatestAtomicTransferError = ( state: State, siteId: number ) => {
+	return state.latestAtomicTransferStatus[ siteId ]?.errorCode;
+};
+
+export const getAtomicSoftwareStatus = ( state: State, siteId: number, softwareSet: string ) => {
+	return state.atomicSoftwareStatus[ siteId ]?.[ softwareSet ]?.status;
+};
+
+export const getAtomicSoftwareError = ( state: State, siteId: number, softwareSet: string ) => {
+	return state.atomicSoftwareStatus[ siteId ]?.[ softwareSet ]?.error;
+};
+
+export const getAtomicSoftwareInstallError = (
+	state: State,
+	siteId: number,
+	softwareSet: string
+) => {
+	return state.atomicSoftwareInstallStatus[ siteId ]?.[ softwareSet ]?.error;
+};
+
+export const siteHasFeature = (
+	_: State,
+	siteId: number | undefined,
+	featureKey: string
+): boolean => {
+	return Boolean(
+		siteId && select( STORE_KEY ).getSite( siteId )?.plan?.features.active.includes( featureKey )
+	);
+};
+
+export const requiresUpgrade = ( state: State, siteId: number | null ) => {
+	return siteId && ! select( STORE_KEY ).siteHasFeature( siteId, 'woop' );
+};
+
+export function isJetpackSite( state: State, siteId?: number ): boolean {
+	return Boolean( siteId && select( STORE_KEY ).getSite( siteId )?.jetpack );
+}
+
+export function isEligibleForProPlan( state: State, siteId?: number ): boolean {
+	if ( ! siteId ) {
+		return false;
+	}
+
+	if (
+		( isJetpackSite( state, siteId ) && ! isSiteAtomic( state, siteId ) ) ||
+		isSiteWPForTeams( state, siteId )
+	) {
+		return false;
+	}
+
+	return true;
+}