@automattic/data-stores 3.1.1 → 3.2.0

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();
-	} );
-} );

package/src/domain-suggestions/types.ts

@@ -1,254 +0,0 @@
-import type { DataStatus } from './constants';
-
-export interface DomainSuggestionQuery {
-	/**
-	 * True to include .blog subdomain suggestions
-	 * @example
-	 * example.photo.blog
-	 */
-	include_dotblogsubdomain: boolean;
-
-	/**
-	 * True to include WordPress.com subdomain suggestions
-	 * @example
-	 * example.wordpress.com
-	 */
-	include_wordpressdotcom: boolean;
-
-	/**
-	 * True to include domains registered with wpcom in the response
-	 */
-	include_internal_move_eligible?: boolean;
-
-	/**
-	 * Localizes domain results, e.g., price format
-	 */
-	locale?: string;
-
-	/**
-	 * True to only provide a wordpress.com subdomain
-	 * @example
-	 * example.wordpress.com
-	 */
-	only_wordpressdotcom: boolean;
-
-	/**
-	 * Desired number of results
-	 */
-	quantity: number;
-
-	/**
-	 * Domain search term
-	 */
-	query: string;
-
-	recommendation_context?: string;
-
-	/**
-	 * Vendor
-	 */
-	vendor: string;
-
-	/**
-	 * The vertical id or slug
-	 */
-	vertical?: string;
-
-	/**
-	 * An array of tlds
-	 */
-	tlds?: readonly string[];
-
-	/**
-	 * Domain category slug
-	 */
-	category_slug?: string;
-}
-
-export type DomainName = string;
-
-export interface DomainSuggestion {
-	/**
-	 * The domain name
-	 * @example "example.com"
-	 */
-	domain_name: DomainName;
-
-	/**
-	 * Rendered formatted cost
-	 * @example "Free" or "€15.00"
-	 */
-	cost: string;
-
-	/**
-	 * Raw price
-	 * @example 40
-	 */
-	raw_price: number;
-
-	/**
-	 * Currency code
-	 * @example USD
-	 */
-	currency_code: string;
-
-	/**
-	 * Relevance as a percent: 0 <= relevance <= 1
-	 * @example 0.9
-	 */
-	relevance?: number;
-
-	/**
-	 * Whether the domain supports privacy
-	 */
-	supports_privacy?: boolean;
-
-	/**
-	 * The domain vendor
-	 */
-	vendor?: string;
-
-	/**
-	 * Reasons for suggestion the domain
-	 * @example [ "exact-match" ]
-	 */
-	match_reasons?: readonly string[];
-
-	/**
-	 * The product ID
-	 */
-	product_id?: number;
-
-	/**
-	 * The product slug
-	 */
-	product_slug?: string;
-
-	/**
-	 * Whether the domain is free
-	 */
-	is_free?: boolean;
-
-	/**
-	 * Whether the domain requires HSTS
-	 */
-	hsts_required?: boolean;
-
-	/**
-	 * Whether the domain requires to show the notice for .gay tld
-	 */
-	is_dot_gay_notice_required?: boolean;
-
-	/**
-	 * Whether the domain is unavailable
-	 */
-	unavailable: boolean;
-
-	isRecommended?: boolean;
-	isBestAlternative?: boolean;
-	is_premium?: boolean;
-}
-export interface DomainCategory {
-	/**
-	 * The domain category title
-	 */
-	title: string;
-
-	/**
-	 * The domain category slug
-	 */
-	slug: string;
-
-	/**
-	 * The domain category tier
-	 */
-	tier: number | null;
-}
-
-export interface DomainAvailability {
-	/**
-	 * The domain name the availability was checked for.
-	 */
-	domain_name: string;
-
-	/**
-	 * The mappability status of the domain.
-	 */
-	mappable: string;
-
-	/**
-	 * The availability status of the domain.
-	 */
-	status: string;
-
-	/**
-	 * Whether the domain supports privacy.
-	 */
-	supports_privacy: boolean;
-
-	/**
-	 * ID of the product
-	 */
-	product_id?: number;
-
-	/**
-	 * The product slug
-	 */
-	product_slug?: string;
-
-	/**
-	 * Rendered cost with currency
-	 * @example "€15.00"
-	 */
-	cost?: string;
-
-	/**
-	 * Vendor
-	 */
-	vendor?: string;
-
-	/**
-	 * Whether the domain requires HSTS
-	 */
-	hsts_required?: boolean;
-
-	/**
-	 * Whether the domain requires to show the notice for .gay tld
-	 */
-	is_dot_gay_notice_required?: boolean;
-}
-
-export type TimestampMS = ReturnType< typeof Date.now >;
-
-export type DomainSuggestions = Record< string, DomainSuggestion[] | undefined >;
-
-export interface DomainSuggestionState {
-	/**
-	 * The state of the DomainSuggestions e.g. pending, failure etc
-	 */
-	state: DataStatus;
-
-	/**
-	 * Domain suggestion data typically returned from the API
-	 */
-	data: DomainSuggestions;
-
-	/**
-	 * Error message
-	 */
-	errorMessage: string | null;
-
-	/**
-	 * Timestamp from last updated attempt
-	 */
-	lastUpdated: TimestampMS;
-
-	/**
-	 * Pending timestamp
-	 */
-	pendingSince: TimestampMS | undefined;
-}
-
-export type DomainAvailabilities = Record< string, DomainAvailability | undefined >;
-
-export type DomainSuggestionSelectorOptions = Partial< Exclude< DomainSuggestionQuery, 'query' > >;