@automattic/jetpack-connection 0.29.8

package/state/actions.jsx

@@ -0,0 +1,166 @@
+import restApi from '@automattic/jetpack-api';
+
+const SET_CONNECTION_STATUS = 'SET_CONNECTION_STATUS';
+const SET_CONNECTION_STATUS_IS_FETCHING = 'SET_CONNECTION_STATUS_IS_FETCHING';
+const FETCH_CONNECTION_STATUS = 'FETCH_CONNECTION_STATUS';
+const SET_SITE_IS_REGISTERING = 'SET_SITE_IS_REGISTERING';
+const SET_USER_IS_CONNECTING = 'SET_USER_IS_CONNECTING';
+const SET_REGISTRATION_ERROR = 'SET_REGISTRATION_ERROR';
+const CLEAR_REGISTRATION_ERROR = 'CLEAR_REGISTRATION_ERROR';
+const REGISTER_SITE = 'REGISTER_SITE';
+const SET_AUTHORIZATION_URL = 'SET_AUTHORIZATION_URL';
+const CONNECT_USER = 'CONNECT_USER';
+const DISCONNECT_USER_SUCCESS = 'DISCONNECT_USER_SUCCESS';
+const FETCH_AUTHORIZATION_URL = 'FETCH_AUTHORIZATION_URL';
+const SET_CONNECTED_PLUGINS = 'SET_CONNECTED_PLUGINS';
+const REFRESH_CONNECTED_PLUGINS = 'REFRESH_CONNECTED_PLUGINS';
+const SET_CONNECTION_ERRORS = 'SET_CONNECTION_ERRORS';
+const SET_IS_OFFLINE_MODE = 'SET_IS_OFFLINE_MODE';
+
+const setConnectionStatus = connectionStatus => {
+	return { type: SET_CONNECTION_STATUS, connectionStatus };
+};
+
+const setConnectionStatusIsFetching = isFetching => {
+	return { type: SET_CONNECTION_STATUS_IS_FETCHING, isFetching };
+};
+
+const fetchConnectionStatus = () => {
+	return { type: FETCH_CONNECTION_STATUS };
+};
+
+const setSiteIsRegistering = isRegistering => {
+	return { type: SET_SITE_IS_REGISTERING, isRegistering };
+};
+
+const setUserIsConnecting = isConnecting => {
+	return { type: SET_USER_IS_CONNECTING, isConnecting };
+};
+
+const disconnectUserSuccess = () => {
+	return { type: DISCONNECT_USER_SUCCESS };
+};
+
+const setRegistrationError = registrationError => {
+	return { type: SET_REGISTRATION_ERROR, registrationError };
+};
+
+const clearRegistrationError = () => {
+	return { type: CLEAR_REGISTRATION_ERROR };
+};
+
+const setAuthorizationUrl = authorizationUrl => {
+	return { type: SET_AUTHORIZATION_URL, authorizationUrl };
+};
+
+const fetchAuthorizationUrl = redirectUri => {
+	return { type: FETCH_AUTHORIZATION_URL, redirectUri };
+};
+
+const setConnectedPlugins = connectedPlugins => {
+	return { type: SET_CONNECTED_PLUGINS, connectedPlugins };
+};
+
+const setConnectionErrors = connectionErrors => {
+	return { type: SET_CONNECTION_ERRORS, connectionErrors };
+};
+
+const setIsOfflineMode = isOfflineMode => {
+	return { type: SET_IS_OFFLINE_MODE, isOfflineMode };
+};
+
+/**
+ * Connect site with wp.com user
+ *
+ * @param {object} Object - contains from and redirectFunc
+ * @param {string} Object.from - Value that represents the redirect origin
+ * @param {Function} Object.redirectFunc - A function to handle the redirect, defaults to location.assign
+ * @param {string} [Object.redirectUri] - A URI that the user will be redirected to
+ * @yields {object} Action object that will be yielded
+ */
+function* connectUser( { from, redirectFunc, redirectUri } = {} ) {
+	yield setUserIsConnecting( true );
+	yield { type: CONNECT_USER, from, redirectFunc, redirectUri };
+}
+
+/**
+ *
+ * Register an site into jetpack
+ *
+ * @param {object} Object - contains registrationNonce and redirectUri
+ * @param {string} Object.registrationNonce - Registration nonce
+ * @param {string} Object.redirectUri - URI that user will be redirected
+ * @yields {object} Action object that will be yielded
+ * @returns {Promise} Resolved or rejected value of registerSite
+ */
+function* registerSite( { registrationNonce, redirectUri } ) {
+	yield clearRegistrationError();
+	yield setSiteIsRegistering( true );
+
+	try {
+		const response = yield { type: REGISTER_SITE, registrationNonce, redirectUri };
+		yield setConnectionStatus( { isRegistered: true } );
+		yield setAuthorizationUrl( response.authorizeUrl );
+		yield setSiteIsRegistering( false );
+		return Promise.resolve( response );
+	} catch ( error ) {
+		yield setRegistrationError( error );
+		yield setSiteIsRegistering( false );
+		return Promise.reject( error );
+	}
+}
+
+/**
+ * Side effect action which will fetch a new list of connectedPlugins from the server
+ *
+ * @returns {Promise} - Promise which resolves when the product status is activated.
+ */
+const refreshConnectedPlugins =
+	() =>
+	async ( { dispatch } ) => {
+		return await new Promise( resolve => {
+			return restApi.fetchConnectedPlugins().then( data => {
+				dispatch( setConnectedPlugins( data ) );
+				resolve( data );
+			} );
+		} );
+	};
+
+const actions = {
+	setConnectionStatus,
+	setConnectionStatusIsFetching,
+	fetchConnectionStatus,
+	fetchAuthorizationUrl,
+	setSiteIsRegistering,
+	setUserIsConnecting,
+	setRegistrationError,
+	clearRegistrationError,
+	setAuthorizationUrl,
+	registerSite,
+	connectUser,
+	disconnectUserSuccess,
+	setConnectedPlugins,
+	refreshConnectedPlugins,
+	setConnectionErrors,
+	setIsOfflineMode,
+};
+
+export {
+	SET_CONNECTION_STATUS,
+	SET_CONNECTION_STATUS_IS_FETCHING,
+	FETCH_CONNECTION_STATUS,
+	FETCH_AUTHORIZATION_URL,
+	SET_SITE_IS_REGISTERING,
+	SET_USER_IS_CONNECTING,
+	SET_REGISTRATION_ERROR,
+	CLEAR_REGISTRATION_ERROR,
+	REGISTER_SITE,
+	SET_AUTHORIZATION_URL,
+	CONNECT_USER,
+	DISCONNECT_USER_SUCCESS,
+	SET_CONNECTED_PLUGINS,
+	REFRESH_CONNECTED_PLUGINS,
+	SET_CONNECTION_ERRORS,
+	SET_IS_OFFLINE_MODE,
+	actions as default,
+};

package/state/controls.jsx

@@ -0,0 +1,40 @@
+import restApi from '@automattic/jetpack-api';
+import { createRegistryControl } from '@wordpress/data';
+import STORE_ID from './store-id';
+
+const REGISTER_SITE = ( { registrationNonce, redirectUri } ) =>
+	restApi.registerSite( registrationNonce, redirectUri );
+
+const CONNECT_USER = createRegistryControl(
+	( { resolveSelect } ) =>
+		( { from, redirectFunc, redirectUri } = {} ) => {
+			return new Promise( ( resolve, reject ) => {
+				resolveSelect( STORE_ID )
+					.getAuthorizationUrl( redirectUri )
+					.then( authorizationUrl => {
+						const redirect = redirectFunc || ( url => window.location.assign( url ) );
+
+						const url = new URL( authorizationUrl );
+
+						if ( from ) {
+							url.searchParams.set( 'from', encodeURIComponent( from ) );
+						}
+
+						const finalUrl = url.toString();
+						redirect( finalUrl );
+						resolve( finalUrl );
+					} )
+					.catch( error => {
+						reject( error );
+					} );
+			} );
+		}
+);
+
+const FETCH_AUTHORIZATION_URL = ( { redirectUri } ) => restApi.fetchAuthorizationUrl( redirectUri );
+
+export default {
+	FETCH_AUTHORIZATION_URL,
+	REGISTER_SITE,
+	CONNECT_USER,
+};

package/state/reducers.jsx

@@ -0,0 +1,121 @@
+import { combineReducers } from '@wordpress/data';
+import {
+	SET_CONNECTION_STATUS,
+	SET_CONNECTION_STATUS_IS_FETCHING,
+	SET_SITE_IS_REGISTERING,
+	SET_USER_IS_CONNECTING,
+	DISCONNECT_USER_SUCCESS,
+	CLEAR_REGISTRATION_ERROR,
+	SET_REGISTRATION_ERROR,
+	SET_AUTHORIZATION_URL,
+	SET_CONNECTED_PLUGINS,
+	SET_CONNECTION_ERRORS,
+	SET_IS_OFFLINE_MODE,
+} from './actions';
+
+const connectionStatus = ( state = {}, action ) => {
+	switch ( action.type ) {
+		case SET_CONNECTION_STATUS:
+			return { ...state, ...action.connectionStatus };
+		case DISCONNECT_USER_SUCCESS:
+			return { ...state, isUserConnected: false };
+	}
+
+	return state;
+};
+
+const connectedPlugins = ( state = {}, action ) => {
+	switch ( action.type ) {
+		case SET_CONNECTED_PLUGINS:
+			return action.connectedPlugins;
+	}
+
+	return state;
+};
+
+const connectionStatusIsFetching = ( state = false, action ) => {
+	switch ( action.type ) {
+		case SET_CONNECTION_STATUS_IS_FETCHING:
+			return action.isFetching;
+	}
+
+	return state;
+};
+
+const siteIsRegistering = ( state = false, action ) => {
+	switch ( action.type ) {
+		case SET_SITE_IS_REGISTERING:
+			return action.isRegistering;
+	}
+
+	return state;
+};
+
+const userIsConnecting = ( state = false, action ) => {
+	switch ( action.type ) {
+		case SET_USER_IS_CONNECTING:
+			return action.isConnecting;
+	}
+
+	return state;
+};
+
+const registrationError = ( state, action ) => {
+	switch ( action.type ) {
+		case CLEAR_REGISTRATION_ERROR:
+			return false;
+		case SET_REGISTRATION_ERROR:
+			return action.registrationError;
+		default:
+			return state;
+	}
+};
+
+const authorizationUrl = ( state, action ) => {
+	switch ( action.type ) {
+		case SET_AUTHORIZATION_URL:
+			return action.authorizationUrl;
+		default:
+			return state;
+	}
+};
+
+const userConnectionData = ( state, action ) => {
+	switch ( action.type ) {
+		default:
+			return state;
+	}
+};
+
+const connectionErrors = ( state = {}, action ) => {
+	switch ( action.type ) {
+		case SET_CONNECTION_ERRORS:
+			return action.connectionErrors;
+	}
+
+	return state;
+};
+
+const isOfflineMode = ( state = false, action ) => {
+	switch ( action.type ) {
+		case SET_IS_OFFLINE_MODE:
+			return action.isConnecting;
+	}
+
+	return state;
+};
+
+const reducers = combineReducers( {
+	connectionStatus,
+	connectionStatusIsFetching,
+	siteIsRegistering,
+	userIsConnecting,
+	registrationError,
+	authorizationUrl,
+	userConnectionData,
+	connectedPlugins,
+	connectionErrors,
+	isOfflineMode,
+} );
+
+export default reducers;

package/state/resolvers.jsx

@@ -0,0 +1,32 @@
+import { dispatch, select } from '@wordpress/data';
+import actions from './actions';
+import STORE_ID from './store-id';
+
+const connectionResolvers = {
+	getAuthorizationUrl: {
+		isFulfilled: ( state, ...args ) => {
+			const hasAuthorization = Boolean( state.authorizationUrl );
+			const hasFinishedResolution = select( STORE_ID ).hasFinishedResolution(
+				'getAuthorizationUrl',
+				args
+			);
+
+			// we need to set finish resolution to fix a problem when using resolveSelect,
+			// since it looks for finishResolution to return the value
+			// ref: https://github.com/WordPress/gutenberg/blob/5dbf7ca8a285f5cab65ebf7ab87dafeb6118b6aa/packages/data/src/redux-store/index.js#L342
+			if ( hasAuthorization && ! hasFinishedResolution ) {
+				dispatch( STORE_ID ).finishResolution( 'getAuthorizationUrl', args );
+			}
+
+			return hasAuthorization;
+		},
+		*fulfill( redirectUri ) {
+			const response = yield actions.fetchAuthorizationUrl( redirectUri );
+			yield actions.setAuthorizationUrl( response.authorizeUrl );
+		},
+	},
+};
+
+export default {
+	...connectionResolvers,
+};

package/state/selectors.jsx

@@ -0,0 +1,35 @@
+const getWpcomUser = state => {
+	return state?.userConnectionData?.currentUser?.wpcomUser;
+};
+
+const getBlogId = state => {
+	return state?.userConnectionData?.currentUser?.blogId;
+};
+
+const connectionSelectors = {
+	getConnectionStatus: state => state.connectionStatus || {},
+	/**
+	 * Checks whether the store is fetching the connection status from the server
+	 *
+	 * @deprecated since 0.14.0
+	 * @returns {boolean} Is the store is fetching the connection status from the server?
+	 */
+	getConnectionStatusIsFetching: () => false,
+	getSiteIsRegistering: state => state.siteIsRegistering || false,
+	getUserIsConnecting: state => state.userIsConnecting || false,
+	getRegistrationError: state => state.registrationError || false,
+	getAuthorizationUrl: state => state.authorizationUrl || false,
+	getUserConnectionData: state => state.userConnectionData || false,
+	getConnectedPlugins: state => state.connectedPlugins || [],
+	getConnectionErrors: state => state.connectionErrors || [],
+	getIsOfflineMode: state => state.isOfflineMode || false,
+
+	getWpcomUser,
+	getBlogId,
+};
+
+const selectors = {
+	...connectionSelectors,
+};
+
+export default selectors;

package/state/store-holder.jsx

@@ -0,0 +1,14 @@
+import { createReduxStore, register } from '@wordpress/data';
+
+class storeHolder {
+	static store = null;
+
+	static mayBeInit( storeId, storeConfig ) {
+		if ( null === storeHolder.store ) {
+			storeHolder.store = createReduxStore( storeId, storeConfig );
+			register( storeHolder.store );
+		}
+	}
+}
+
+export default storeHolder;

package/state/store-id.jsx

@@ -0,0 +1,3 @@
+const STORE_ID = 'jetpack-connection';
+
+export default STORE_ID;

package/state/store.jsx

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+
+import actions from './actions';
+import controls from './controls';
+import reducer from './reducers';
+import resolvers from './resolvers';
+import selectors from './selectors';
+import storeHolder from './store-holder';
+import STORE_ID from './store-id';
+
+const initialState = window.JP_CONNECTION_INITIAL_STATE;
+
+if ( ! initialState ) {
+	console.error(
+		'Jetpack Connection package: Initial state is missing. Check documentation to see how to use the Connection composer package to set up the initial state.'
+	);
+}
+
+storeHolder.mayBeInit( STORE_ID, {
+	__experimentalUseThunks: true,
+	reducer,
+	actions,
+	selectors,
+	resolvers,
+	controls,
+	initialState: initialState || {},
+} );
+
+export { STORE_ID };