@automattic/data-stores 3.1.2 → 3.2.0

package/src/domain-suggestions/actions.ts

@@ -1,51 +0,0 @@
-import type {
-	DomainSuggestion,
-	DomainSuggestionQuery,
-	DomainCategory,
-	DomainAvailability,
-} from './types';
-
-export const receiveCategories = ( categories: DomainCategory[] ) =>
-	( {
-		type: 'RECEIVE_CATEGORIES',
-		categories,
-	} ) as const;
-
-export const fetchDomainSuggestions = () =>
-	( {
-		type: 'FETCH_DOMAIN_SUGGESTIONS',
-		timeStamp: Date.now(),
-	} ) as const;
-
-export const receiveDomainAvailability = ( domainName: string, availability: DomainAvailability ) =>
-	( {
-		type: 'RECEIVE_DOMAIN_AVAILABILITY',
-		domainName,
-		availability,
-	} ) as const;
-
-export const receiveDomainSuggestionsSuccess = (
-	queryObject: DomainSuggestionQuery,
-	suggestions: DomainSuggestion[] | undefined
-) =>
-	( {
-		type: 'RECEIVE_DOMAIN_SUGGESTIONS_SUCCESS',
-		queryObject,
-		suggestions,
-		timeStamp: Date.now(),
-	} ) as const;
-
-export const receiveDomainSuggestionsError = ( errorMessage: string ) =>
-	( {
-		type: 'RECEIVE_DOMAIN_SUGGESTIONS_ERROR',
-		errorMessage,
-		timeStamp: Date.now(),
-	} ) as const;
-
-export type Action = ReturnType<
-	| typeof receiveCategories
-	| typeof fetchDomainSuggestions
-	| typeof receiveDomainSuggestionsSuccess
-	| typeof receiveDomainSuggestionsError
-	| typeof receiveDomainAvailability
->;

package/src/domain-suggestions/constants.ts

@@ -1,8 +0,0 @@
-export const STORE_KEY = 'automattic/domains/suggestions';
-
-export enum DataStatus {
-	Failure = 'failure',
-	Pending = 'pending',
-	Success = 'success',
-	Uninitialized = 'uninitialized',
-}

package/src/domain-suggestions/index.ts

@@ -1,22 +0,0 @@
-import { register, createReduxStore } from '@wordpress/data';
-import { controls } from '../wpcom-request-controls';
-import * as actions from './actions';
-import { STORE_KEY } from './constants';
-import reducer, { State } from './reducer';
-import * as resolvers from './resolvers';
-import * as selectors from './selectors';
-
-export * from './types';
-export * from './constants';
-export * from './queries';
-export { getFormattedPrice } from './utils';
-export type { State };
-
-export const store = createReduxStore( STORE_KEY, {
-	actions,
-	controls,
-	reducer,
-	resolvers,
-	selectors,
-} );
-register( store );

package/src/domain-suggestions/queries.ts

@@ -1,85 +0,0 @@
-import { useQuery, useQueryClient } from '@tanstack/react-query';
-import { stringify } from 'qs';
-import wpcomProxyRequest from 'wpcom-proxy-request';
-import { getFormattedPrice, normalizeDomainSuggestionQuery } from './utils';
-import type { DomainSuggestion, DomainSuggestionSelectorOptions } from './types';
-
-const STALE_TIME = 1000 * 60 * 5; // 5 minutes
-
-export function useGetDomainSuggestions(
-	search?: string | null,
-	searchOptions: DomainSuggestionSelectorOptions = {},
-	queryOptions = {}
-) {
-	const queryClient = useQueryClient();
-	const result = useQuery( {
-		queryKey: [ 'domain-suggestions', search, searchOptions ],
-		queryFn: async () => {
-			if ( ! search ) {
-				return [];
-			}
-			const queryObject = normalizeDomainSuggestionQuery( search, searchOptions );
-
-			const suggestions: DomainSuggestion[] = await wpcomProxyRequest( {
-				apiVersion: '1.1',
-				path: '/domains/suggestions',
-				query: stringify( queryObject ),
-			} );
-			if ( ! Array.isArray( suggestions ) ) {
-				throw new Error( 'Invalid response from the server' );
-			}
-
-			const processedSuggestions = suggestions.map( ( suggestion: DomainSuggestion ) => {
-				if ( suggestion.unavailable ) {
-					return suggestion;
-				}
-				return {
-					...suggestion,
-					...( suggestion.raw_price &&
-						suggestion.currency_code && {
-							cost: getFormattedPrice( suggestion.raw_price, suggestion.currency_code ),
-						} ),
-				};
-			} );
-
-			return processedSuggestions;
-		},
-		enabled: !! search,
-		staleTime: STALE_TIME,
-		...queryOptions,
-	} );
-
-	return {
-		...result,
-		invalidateCache: () =>
-			queryClient.invalidateQueries( {
-				queryKey: [ 'domain-suggestions', search, searchOptions ],
-			} ),
-	};
-}
-
-/**
- * Returns the expected *.wordpress.com for a given domain name
- */
-export function useGetWordPressSubdomain( paidDomainName?: string | null ) {
-	return useGetDomainSuggestions( paidDomainName, {
-		quantity: 1,
-		include_wordpressdotcom: true,
-		include_dotblogsubdomain: false,
-		only_wordpressdotcom: false,
-		vendor: 'dot',
-	} );
-}
-
-/**
- * Returns a custom .com domain suggestion for a given query
- */
-export function useGetSingleCustomDotComDomainSuggestion( query?: string | null, locale?: string ) {
-	return useGetDomainSuggestions( query, {
-		quantity: 1,
-		include_wordpressdotcom: false,
-		include_dotblogsubdomain: false,
-		locale,
-		tlds: [ 'com' ],
-	} );
-}

package/src/domain-suggestions/reducer.ts

@@ -1,77 +0,0 @@
-import { combineReducers } from '@wordpress/data';
-import { DataStatus } from './constants';
-import { stringifyDomainQueryObject } from './utils';
-import type { Action } from './actions';
-import type { DomainCategory, DomainSuggestionState, DomainAvailabilities } from './types';
-import type { Reducer } from 'redux';
-
-const initialDomainSuggestionState: DomainSuggestionState = {
-	state: DataStatus.Uninitialized,
-	data: {},
-	errorMessage: null,
-	lastUpdated: -Infinity,
-	pendingSince: undefined,
-};
-
-export const domainSuggestions: Reducer< DomainSuggestionState, Action > = (
-	state = initialDomainSuggestionState,
-	action
-) => {
-	if ( action.type === 'FETCH_DOMAIN_SUGGESTIONS' ) {
-		return {
-			...state,
-			state: DataStatus.Pending,
-			errorMessage: null,
-			pendingSince: action.timeStamp,
-		};
-	}
-
-	if ( action.type === 'RECEIVE_DOMAIN_SUGGESTIONS_SUCCESS' ) {
-		return {
-			...state,
-			state: DataStatus.Success,
-			data: {
-				...state.data,
-				[ stringifyDomainQueryObject( action.queryObject ) ]: action.suggestions,
-			},
-			errorMessage: null,
-			lastUpdated: action.timeStamp,
-			pendingSince: undefined,
-		};
-	}
-
-	if ( action.type === 'RECEIVE_DOMAIN_SUGGESTIONS_ERROR' ) {
-		return {
-			...state,
-			state: DataStatus.Failure,
-			errorMessage: action.errorMessage,
-			lastUpdated: action.timeStamp,
-			pendingSince: undefined,
-		};
-	}
-
-	return state;
-};
-
-const categories: Reducer< DomainCategory[], Action > = ( state = [], action ) => {
-	if ( action.type === 'RECEIVE_CATEGORIES' ) {
-		return action.categories;
-	}
-	return state;
-};
-
-const availability: Reducer< DomainAvailabilities, Action > = ( state = {}, action ) => {
-	if ( action.type === 'RECEIVE_DOMAIN_AVAILABILITY' ) {
-		return {
-			...state,
-			[ action.domainName ]: action.availability,
-		};
-	}
-	return state;
-};
-
-const reducer = combineReducers( { categories, domainSuggestions, availability } );
-
-export type State = ReturnType< typeof reducer >;
-
-export default reducer;

package/src/domain-suggestions/resolvers.ts

@@ -1,110 +0,0 @@
-import { translate } from 'i18n-calypso';
-import { stringify } from 'qs';
-import validator from 'validator';
-import { fetchAndParse, wpcomRequest } from '../wpcom-request-controls';
-import {
-	receiveCategories,
-	receiveDomainSuggestionsSuccess,
-	receiveDomainSuggestionsError,
-	fetchDomainSuggestions,
-	receiveDomainAvailability,
-} from './actions';
-import { getFormattedPrice } from './utils';
-import type { DomainSuggestion, DomainSuggestionQuery } from './types';
-
-function getAvailabilityURL( domainName: string ) {
-	return `https://public-api.wordpress.com/rest/v1.3/domains/${ encodeURIComponent(
-		domainName
-	) }/is-available?is_cart_pre_check=true`;
-}
-
-function suggestionsLackThisFQDN( suggestions: DomainSuggestion[], domainName: string ) {
-	return (
-		validator.isFQDN( domainName ) &&
-		! suggestions.some( ( s ) => s.domain_name.toLowerCase() === domainName )
-	);
-}
-
-export const isAvailable = function* isAvailable( domainName: string ) {
-	const url = getAvailabilityURL( domainName );
-
-	try {
-		const { body } = yield fetchAndParse( url );
-		return receiveDomainAvailability( domainName, body );
-	} catch {
-		// the API returns a status of 'unknown' if it can not accurately determine
-		// availability, we will return the same status if the API request fails.
-		return receiveDomainAvailability( domainName, {
-			domain_name: domainName,
-			mappable: 'unknown',
-			status: 'unknown',
-			supports_privacy: false,
-		} );
-	}
-};
-
-export function* getCategories() {
-	const { body } = yield fetchAndParse(
-		'https://public-api.wordpress.com/wpcom/v2/onboarding/domains/categories'
-	);
-	return receiveCategories( body );
-}
-
-export function* __internalGetDomainSuggestions( queryObject: DomainSuggestionQuery ) {
-	// If normalized search string (`query`) contains no alphanumerics, endpoint 404s
-	if ( ! queryObject.query ) {
-		return receiveDomainSuggestionsError( 'Empty query' );
-	}
-
-	yield fetchDomainSuggestions();
-
-	try {
-		const suggestions: DomainSuggestion[] = yield wpcomRequest( {
-			apiVersion: '1.1',
-			path: '/domains/suggestions',
-			query: stringify( queryObject ),
-		} );
-
-		if ( ! Array.isArray( suggestions ) ) {
-			// Other internal server errors
-			return receiveDomainSuggestionsError(
-				translate( 'Invalid response from the server' ) as string
-			);
-		}
-
-		// if the query is a FQDN and the results don't have it,
-		// this implies that the user is searching for an unavailable domain name
-		// TODO: query the availability endpoint to find the exact reason why it's unavailable
-		// all the possible responses can be found here https://github.com/Automattic/wp-calypso/blob/trunk/client/lib/domains/registration/availability-messages.js#L40-L390
-		if ( suggestionsLackThisFQDN( suggestions, queryObject.query ) ) {
-			const unavailableSuggestion: DomainSuggestion = {
-				domain_name: queryObject.query,
-				unavailable: true,
-				cost: '',
-				raw_price: 0,
-				currency_code: '',
-			};
-			suggestions.unshift( unavailableSuggestion );
-		}
-
-		const processedSuggestions = suggestions.map( ( suggestion: DomainSuggestion ) => {
-			if ( suggestion.unavailable ) {
-				return suggestion;
-			}
-			return {
-				...suggestion,
-				...( suggestion.raw_price &&
-					suggestion.currency_code && {
-						cost: getFormattedPrice( suggestion.raw_price, suggestion.currency_code ),
-					} ),
-			};
-		} );
-
-		return receiveDomainSuggestionsSuccess( queryObject, processedSuggestions );
-	} catch ( e ) {
-		// e.g. no connection, or JSON parsing error
-		return receiveDomainSuggestionsError(
-			( e as Error ).message || ( translate( 'Error while fetching server response' ) as string )
-		);
-	}
-}

package/src/domain-suggestions/selectors.ts

@@ -1,86 +0,0 @@
-import { select } from '@wordpress/data';
-import { STORE_KEY, DataStatus } from './constants';
-import { stringifyDomainQueryObject, normalizeDomainSuggestionQuery } from './utils';
-import type { State } from './reducer';
-import type {
-	DomainAvailability,
-	DomainAvailabilities,
-	DomainCategory,
-	DomainSuggestion,
-	DomainSuggestionQuery,
-	DomainSuggestionSelectorOptions,
-} from './types';
-
-export const getCategories = ( state: State ): DomainCategory[] => {
-	// Sort domain categories by tier, then by title.
-	return [
-		...state.categories
-			.filter( ( { tier } ) => tier !== null )
-			.sort( ( a, b ) => ( a > b ? 1 : -1 ) ),
-		...state.categories
-			.filter( ( { tier } ) => tier === null )
-			.sort( ( a, b ) => a.title.localeCompare( b.title ) ),
-	];
-};
-
-export const getDomainSuggestions = (
-	_state: State,
-	search: string,
-	options: DomainSuggestionSelectorOptions = {}
-): DomainSuggestion[] | undefined => {
-	const normalizedQuery = normalizeDomainSuggestionQuery( search, options );
-
-	// We need to go through the `select` store to get the resolver action
-	return (
-		select( STORE_KEY ) as {
-			__internalGetDomainSuggestions: (
-				queryObject: DomainSuggestionQuery
-			) => DomainSuggestion[] | undefined;
-		}
-	 ).__internalGetDomainSuggestions( normalizedQuery );
-};
-
-export const getDomainState = ( state: State ): DataStatus => {
-	return state.domainSuggestions.state;
-};
-
-export const getDomainErrorMessage = ( state: State ): string | null => {
-	return state.domainSuggestions.errorMessage;
-};
-
-// TODO: reconcile this function with "Pending" status?
-// It doesn't seem to be used
-export const isLoadingDomainSuggestions = (
-	_state: State,
-	search: string,
-	options: DomainSuggestionSelectorOptions = {}
-): boolean => {
-	const normalizedQuery = normalizeDomainSuggestionQuery( search, options );
-
-	return (
-		select( 'core/data' ) as {
-			isResolving: ( storeKey: string, resolverName: string, args: unknown[] ) => boolean;
-		}
-	 ).isResolving( STORE_KEY, '__internalGetDomainSuggestions', [ normalizedQuery ] );
-};
-
-/**
- * Do not use this selector. It is for internal use.
- * @param state Store state
- * @param queryObject Normalized object representing the query
- * @returns suggestions
- */
-export const __internalGetDomainSuggestions = (
-	state: State,
-	queryObject: DomainSuggestionQuery
-): DomainSuggestion[] | undefined => {
-	return state.domainSuggestions.data[ stringifyDomainQueryObject( queryObject ) ];
-};
-
-export const isAvailable = ( state: State, domainName: string ): DomainAvailability | undefined => {
-	return state.availability[ domainName ];
-};
-
-export const getDomainAvailabilities = ( state: State ): DomainAvailabilities => {
-	return state.availability;
-};

package/src/domain-suggestions/test/reducer.ts

@@ -1,105 +0,0 @@
-import { DataStatus } from '../constants';
-import { domainSuggestions } from '../reducer';
-import type { DomainSuggestionState, DomainSuggestion } from '../types';
-
-describe( 'domainSuggestions', () => {
-	const initialTimeStamp = Date.now();
-	const initialState: DomainSuggestionState = {
-		state: DataStatus.Uninitialized,
-		data: undefined,
-		errorMessage: null,
-		lastUpdated: initialTimeStamp,
-		pendingSince: undefined,
-	};
-
-	it( 'goes into a state of pending when fetching results', () => {
-		const now = Date.now();
-		const state = domainSuggestions( initialState, {
-			type: 'FETCH_DOMAIN_SUGGESTIONS',
-			timeStamp: now,
-		} );
-
-		const expectedState: DomainSuggestionState = {
-			state: DataStatus.Pending,
-			data: undefined,
-			errorMessage: null,
-			lastUpdated: initialTimeStamp,
-			pendingSince: now,
-		};
-		expect( state ).toEqual( expectedState );
-	} );
-
-	it( 'goes into a state of errored when fetching results have failed', () => {
-		const now = Date.now();
-		const errorMessage = 'An unexpected error has occured';
-		const state = domainSuggestions( initialState, {
-			type: 'RECEIVE_DOMAIN_SUGGESTIONS_ERROR',
-			timeStamp: now,
-			errorMessage,
-		} );
-
-		const expectedState: DomainSuggestionState = {
-			state: DataStatus.Failure,
-			data: undefined,
-			errorMessage: errorMessage,
-			lastUpdated: now,
-			pendingSince: undefined,
-		};
-		expect( state ).toEqual( expectedState );
-	} );
-
-	it( 'goes into a state of success when fetching results have returned results', () => {
-		const queryObject = {
-			include_dotblogsubdomain: false,
-			include_wordpressdotcom: true,
-			locale: 'en',
-			only_wordpressdotcom: false,
-			quantity: 11,
-			query: 'test site',
-			vendor: 'variation4_front',
-		};
-		const suggestions: DomainSuggestion[] = [
-			{
-				domain_name: 'test.site',
-				relevance: 1,
-				supports_privacy: true,
-				vendor: 'donuts',
-				match_reasons: [ 'tld-common', 'tld-exact' ],
-				product_id: 78,
-				product_slug: 'dotsite_domain',
-				cost: '$25.00',
-				raw_price: 25,
-				currency_code: 'USD',
-			},
-			{
-				domain_name: 'hot-test-site.com',
-				relevance: 1,
-				supports_privacy: true,
-				vendor: 'donuts',
-				match_reasons: [ 'tld-common' ],
-				product_id: 6,
-				product_slug: 'domain_reg',
-				cost: '$18.00',
-				raw_price: 18,
-				currency_code: 'USD',
-			},
-		];
-		const now = Date.now();
-		const state = domainSuggestions( initialState, {
-			type: 'RECEIVE_DOMAIN_SUGGESTIONS_SUCCESS',
-			queryObject,
-			suggestions,
-			timeStamp: now,
-		} );
-
-		const expectedState: DomainSuggestionState = {
-			state: DataStatus.Success,
-			data: { [ JSON.stringify( queryObject ) ]: suggestions },
-			errorMessage: null,
-			lastUpdated: now,
-			pendingSince: undefined,
-		};
-		expect( state ).toEqual( expectedState );
-		expect( state.data[ JSON.stringify( queryObject ) ].length ).toEqual( suggestions.length );
-	} );
-} );

package/src/domain-suggestions/test/selectors.ts

@@ -1,127 +0,0 @@
-import { select, subscribe } from '@wordpress/data';
-import wpcomRequest from 'wpcom-proxy-request';
-import { store } from '..';
-import { DataStatus } from '../constants';
-
-jest.mock( 'wpcom-proxy-request', () => ( {
-	__esModule: true,
-	default: jest.fn(),
-	requestAllBlogsAccess: jest.fn( () => Promise.resolve() ),
-} ) );
-
-const options = {
-	category_slug: undefined,
-	include_dotblogsubdomain: false,
-	include_wordpressdotcom: true,
-	locale: 'en',
-	quantity: 11,
-};
-const apiResponse = [
-	{
-		domain_name: 'test.site',
-		relevance: 1,
-		supports_privacy: true,
-		vendor: 'donuts',
-		match_reasons: [ 'tld-common', 'tld-exact' ],
-		product_id: 78,
-		product_slug: 'dotsite_domain',
-		cost: '$25',
-		raw_price: 25,
-		currency_code: 'USD',
-		unavailable: false,
-	},
-	{
-		domain_name: 'hot-test-site.com',
-		relevance: 1,
-		supports_privacy: true,
-		vendor: 'donuts',
-		match_reasons: [ 'tld-common' ],
-		product_id: 6,
-		product_slug: 'domain_reg',
-		cost: '$18',
-		raw_price: 18,
-		currency_code: 'USD',
-		unavailable: false,
-	},
-];
-
-beforeEach( () => {
-	( wpcomRequest as jest.Mock ).mockReset();
-} );
-
-describe( 'getDomainSuggestions', () => {
-	it( 'resolves the state via an API call and caches the resolver on success', async () => {
-		( wpcomRequest as jest.Mock ).mockResolvedValue( apiResponse );
-
-		const query = 'test query one';
-		const listenForStateUpdate = () => {
-			return new Promise< void >( ( resolve ) => {
-				const unsubscribe = subscribe( () => {
-					unsubscribe();
-					resolve();
-				} );
-			} );
-		};
-
-		// Status should be uninitialized before first call
-		expect( select( store ).getDomainState() ).toEqual( DataStatus.Uninitialized );
-
-		// First call returns undefined
-		expect( select( store ).getDomainSuggestions( query, options ) ).toEqual( undefined );
-
-		await listenForStateUpdate();
-
-		// Status should be pending while we wait for the response
-		expect( select( store ).getDomainState() ).toEqual( DataStatus.Pending );
-
-		await listenForStateUpdate();
-
-		// Status should be successful once we get the response
-		expect( select( store ).getDomainState() ).toEqual( DataStatus.Success );
-
-		// By the second call, the resolver will have resolved
-		expect( select( store ).getDomainSuggestions( query, options ) ).toEqual( apiResponse );
-
-		await listenForStateUpdate();
-
-		// The resolver should now be cached with an `isStarting` value of false
-
-		expect(
-			select( 'core/data' ).isResolving( store, 'getDomainSuggestions', [ query, options ] )
-		).toEqual( false );
-	} );
-} );
-
-describe( 'getDomainErrorMessage', () => {
-	it( 'should return null if no error message', () => {
-		expect( select( store ).getDomainErrorMessage() ).toEqual( null );
-	} );
-
-	it( 'should return correct error message if no suggestions are returned', async () => {
-		( wpcomRequest as jest.Mock ).mockResolvedValue( null );
-
-		const query = 'test query two';
-		const listenForStateUpdate = () => {
-			return new Promise< void >( ( resolve ) => {
-				const unsubscribe = subscribe( () => {
-					unsubscribe();
-					resolve();
-				} );
-			} );
-		};
-
-		// The error message should start off as a null value
-		expect( select( store ).getDomainErrorMessage() ).toBeFalsy();
-
-		// First call returns undefined
-		select( store ).getDomainSuggestions( query, options );
-		await listenForStateUpdate();
-
-		// By the second call, the resolver will have resolved
-		select( store ).getDomainSuggestions( query, options );
-		await listenForStateUpdate();
-
-		// The promise resolves null suggestions so we should now have an error message
-		expect( select( store ).getDomainErrorMessage() ).toBeTruthy();
-	} );
-} );