@automattic/data-stores 3.0.0 → 3.1.0-rc.1

package/src/queries/use-bulk-domain-update-status-query.ts

@@ -0,0 +1,125 @@
+import { type UseQueryOptions, useQuery } from '@tanstack/react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+
+export interface BulkDomainUpdateStatus {
+	results: {
+		[ key: string ]: '' | 'success' | 'failed';
+	};
+	action: 'set_auto_renew' | 'update_contact_info';
+	created_at: number;
+	auto_renew?: boolean;
+	whois?: unknown;
+	transfer_lock?: boolean;
+}
+
+export interface BulkDomainUpdateStatusQueryFnData {
+	[ key: string ]: BulkDomainUpdateStatus;
+}
+
+export interface JobStatus {
+	id: string;
+	action: 'set_auto_renew' | 'update_contact_info';
+	created_at: number;
+	success: string[];
+	failed: string[];
+	pending: string[];
+	complete: boolean;
+}
+
+interface DomainUpdateRemoteStatus {
+	status: '' | 'success' | 'failed';
+	action: 'set_auto_renew' | 'update_contact_info';
+	created_at: number;
+	auto_renew?: boolean;
+	whois?: unknown;
+	transfer_lock?: boolean;
+}
+
+interface DomainUpdateDerivedStatus {
+	status: '';
+	message: string;
+	created_at: number;
+}
+
+export type DomainUpdateStatus = DomainUpdateRemoteStatus | DomainUpdateDerivedStatus;
+
+export const getBulkDomainUpdateStatusQueryKey = () => {
+	return [ 'domains', 'bulk-actions' ];
+};
+
+export interface BulkDomainUpdateStatusResult {
+	domainResults: Map< string, DomainUpdateStatus[] >;
+	completedJobs: JobStatus[];
+}
+
+export function useBulkDomainUpdateStatusQuery< TError = unknown >(
+	pollingInterval: number,
+	options: Omit<
+		UseQueryOptions< BulkDomainUpdateStatusQueryFnData, TError, BulkDomainUpdateStatusResult >,
+		'queryKey'
+	> = {}
+) {
+	return useQuery( {
+		queryFn: () =>
+			wpcomRequest< BulkDomainUpdateStatusQueryFnData >( {
+				path: '/domains/bulk-actions',
+				apiNamespace: 'wpcom/v2',
+				apiVersion: '2',
+			} ),
+		select: ( data ): BulkDomainUpdateStatusResult => {
+			// get top-level info about recent jobs
+			const allJobs: JobStatus[] = Object.keys( data ).map( ( jobId ) => {
+				const job = data[ jobId ];
+				const success: string[] = [];
+				const failed: string[] = [];
+				const pending: string[] = [];
+
+				Object.entries( job.results ).forEach( ( entry ) => {
+					if ( entry[ 1 ] === 'success' ) {
+						success.push( entry[ 0 ] );
+					} else if ( entry[ 1 ] === 'failed' ) {
+						failed.push( entry[ 0 ] );
+					} else {
+						pending.push( entry[ 0 ] );
+					}
+				} );
+
+				return {
+					id: jobId,
+					action: job.action,
+					created_at: job.created_at,
+					success,
+					failed,
+					pending,
+					complete: pending.length === 0,
+				};
+			} );
+
+			// get domain-level updates that can be shown inline in the table rows
+			const domainResults = new Map< string, DomainUpdateStatus[] >();
+
+			Object.keys( data ).forEach( ( jobId ) => {
+				// only create domain-level results for jobs that
+				// are still running
+				if ( ! allJobs.find( ( job ) => job.id === jobId )?.complete ) {
+					const entry = data[ jobId ] as BulkDomainUpdateStatus;
+					const { results, ...rest } = entry;
+					Object.keys( results ).forEach( ( domain ) => {
+						if ( ! domainResults.has( domain ) ) {
+							domainResults.set( domain, [] );
+						}
+						const status = results[ domain ];
+						domainResults.get( domain )?.push( { ...rest, status } );
+					} );
+				}
+			} );
+
+			const completedJobs = allJobs.filter( ( job ) => job.complete );
+
+			return { domainResults, completedJobs };
+		},
+		refetchInterval: pollingInterval,
+		...options,
+		queryKey: getBulkDomainUpdateStatusQueryKey(),
+	} );
+}

package/src/queries/use-happiness-engineers-query.ts

@@ -1,4 +1,4 @@
-import { useQuery } from 'react-query';
+import { useQuery } from '@tanstack/react-query';
 import wpcomRequest from 'wpcom-proxy-request';
 
 export const useHappinessEngineersQuery = () =>
@@ -8,11 +8,10 @@ export const useHappinessEngineersQuery = () =>
 			name: string;
 			avatar_URL: string;
 		}[]
-	>(
-		'happinessEngineers',
-		async () => await wpcomRequest( { path: '/meta/happiness-engineers/', apiVersion: '1.1' } ),
-		{
-			refetchOnWindowFocus: false,
-			staleTime: Infinity,
-		}
-	);
+	>( {
+		queryKey: [ 'happinessEngineers' ],
+		queryFn: async () =>
+			await wpcomRequest( { path: '/meta/happiness-engineers/', apiVersion: '1.1' } ),
+		refetchOnWindowFocus: false,
+		staleTime: Infinity,
+	} );

package/src/queries/use-launchpad-navigator.ts

@@ -0,0 +1,56 @@
+import { useQuery } from '@tanstack/react-query';
+import apiFetch, { type APIFetchOptions } from '@wordpress/api-fetch';
+import wpcomRequest, { canAccessWpcomApis } from 'wpcom-proxy-request';
+
+interface AvailableChecklist {
+	slug: string;
+	title: string;
+}
+
+interface AvailableChecklists {
+	[ checklist_slug: string ]: AvailableChecklist;
+}
+
+interface LaunchpadNavigatorResponse {
+	available_checklists: AvailableChecklists;
+	current_checklist: string | null;
+}
+
+const defaultResponse: LaunchpadNavigatorResponse = {
+	available_checklists: {},
+	current_checklist: null,
+};
+
+export const fetchLaunchpadNavigator = (
+	siteSlug: string | null
+): Promise< LaunchpadNavigatorResponse > => {
+	if ( ! siteSlug ) {
+		return Promise.resolve( defaultResponse );
+	}
+	const slug = encodeURIComponent( siteSlug );
+
+	return canAccessWpcomApis()
+		? wpcomRequest( {
+				path: `/sites/${ slug }/launchpad/navigator`,
+				apiNamespace: 'wpcom/v2',
+				apiVersion: '2',
+		  } )
+		: apiFetch( {
+				global: true,
+				path: `/wpcom/v2/launchpad/navigator`,
+		  } as APIFetchOptions );
+};
+
+export const useLaunchpadNavigator = (
+	siteSlug: string | null,
+	current_checklist: string | null
+) => {
+	const key = [ 'launchpad-navigator', siteSlug, current_checklist ];
+
+	return useQuery( {
+		queryKey: key,
+		queryFn: () => fetchLaunchpadNavigator( siteSlug ),
+		retry: 3,
+		initialData: defaultResponse,
+	} );
+};

package/src/queries/use-launchpad.ts

@@ -0,0 +1,244 @@
+/* eslint-disable no-restricted-imports */
+import { recordTracksEvent } from '@automattic/calypso-analytics';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import apiFetch from '@wordpress/api-fetch';
+import { addQueryArgs } from '@wordpress/url';
+import wpcomRequest, { canAccessWpcomApis } from 'wpcom-proxy-request';
+import wpcom from 'calypso/lib/wp'; // Import restricted
+
+interface APIFetchOptions {
+	global: boolean;
+	path: string;
+}
+
+interface Task {
+	id: string;
+	completed: boolean;
+	disabled: boolean;
+	title: string;
+	subtitle?: string;
+	badgeText?: string;
+	actionDispatch?: () => void;
+	isLaunchTask?: boolean;
+	warning?: boolean;
+	order?: number;
+}
+
+export interface ChecklistStatuses {
+	links_edited?: boolean;
+	site_edited?: boolean;
+	site_launched?: boolean;
+	first_post_published?: boolean;
+	video_uploaded?: boolean;
+	publish_first_course?: boolean;
+	plan_selected?: boolean;
+	plan_completed?: boolean;
+	domain_upsell_deferred?: boolean;
+}
+
+type LaunchpadScreen = 'full' | 'off' | 'skipped' | 'minimized';
+
+export interface LaunchpadResponse {
+	site_intent?: string | null;
+	launchpad_screen?: LaunchpadScreen | boolean | null | undefined;
+	checklist?: Task[] | null;
+	checklist_statuses?: ChecklistStatuses;
+	is_enabled: boolean;
+	is_dismissed: boolean;
+	is_dismissible: boolean;
+	title?: string | null;
+}
+
+type LaunchpadUpdateSettings = {
+	checklist_statuses?: Record< string, boolean >;
+	is_checklist_dismissed?: {
+		slug: string;
+		is_dismissed?: boolean;
+		dismissed_until?: number | null;
+	};
+	launchpad_screen?: 'off' | 'minimized' | 'full' | 'skipped';
+};
+
+export type UseLaunchpadOptions = {
+	onSuccess?: ( data: LaunchpadResponse ) => LaunchpadResponse;
+};
+
+export const fetchLaunchpad = (
+	siteSlug: SiteSlug,
+	checklistSlug?: string | null,
+	launchpadContext?: string
+): Promise< LaunchpadResponse > => {
+	const slug = encodeURIComponent( siteSlug as string );
+	const checklistSlugEncoded = checklistSlug ? encodeURIComponent( checklistSlug ) : null;
+	const launchpadContextEncoded = launchpadContext ? encodeURIComponent( launchpadContext ) : null;
+
+	const requestUrl = addQueryArgs( `/sites/${ slug }/launchpad?_locale=user`, {
+		...( checklistSlug && { checklist_slug: checklistSlugEncoded } ),
+		...( launchpadContext && { launchpad_context: launchpadContextEncoded } ),
+	} );
+
+	return canAccessWpcomApis()
+		? wpcom.req.get( {
+				path: requestUrl,
+				apiNamespace: 'wpcom/v2',
+				apiVersion: '2',
+		  } )
+		: apiFetch( {
+				global: true,
+				path: `/wpcom/v2${ requestUrl }`,
+		  } as APIFetchOptions );
+};
+
+const getKey = ( siteSlug: SiteSlug, checklistSlug?: string | null ) => {
+	return [ 'launchpad', siteSlug, checklistSlug ];
+};
+
+const addOrderToTask = ( task: Task, index: number ) => {
+	task.order = index;
+	return task;
+};
+
+export function sortLaunchpadTasksByCompletionStatus( response: LaunchpadResponse ) {
+	const tasks = response.checklist || [];
+	const completedTasks = tasks.filter( ( task: Task ) => task.completed );
+	const incompleteTasks = tasks.filter( ( task: Task ) => ! task.completed );
+	response.checklist = [ ...completedTasks, ...incompleteTasks ].map( addOrderToTask );
+	return response;
+}
+
+const defaultSuccessCallback = ( response: LaunchpadResponse ) => {
+	const tasks = response.checklist || [];
+	response.checklist = tasks.map( addOrderToTask );
+
+	return response;
+};
+
+type SiteSlug = string | number | null;
+
+export const useLaunchpad = (
+	siteSlug: SiteSlug,
+	checklistSlug?: string | null,
+	options?: UseLaunchpadOptions,
+	launchpad_context?: string | undefined
+) => {
+	const key = getKey( siteSlug, checklistSlug );
+	const onSuccessCallback = options?.onSuccess || defaultSuccessCallback;
+
+	return useQuery( {
+		queryKey: key,
+		queryFn: () =>
+			fetchLaunchpad( siteSlug, checklistSlug, launchpad_context ).then( onSuccessCallback ),
+		retry: 3,
+		initialData: {
+			site_intent: '',
+			launchpad_screen: undefined,
+			checklist_statuses: {},
+			checklist: null,
+			is_enabled: false,
+			is_dismissed: false,
+			is_dismissible: false,
+			title: null,
+		},
+	} );
+};
+
+export const useSortedLaunchpadTasks = (
+	siteSlug: SiteSlug,
+	checklistSlug?: string | null,
+	launchpadContext?: string
+) => {
+	const launchpadOptions = {
+		onSuccess: sortLaunchpadTasksByCompletionStatus,
+	};
+
+	return useLaunchpad( siteSlug, checklistSlug, launchpadOptions, launchpadContext );
+};
+
+export const updateLaunchpadSettings = (
+	siteSlug: SiteSlug,
+	settings: LaunchpadUpdateSettings = {}
+) => {
+	const slug = siteSlug ? encodeURIComponent( siteSlug ) : null;
+	const requestUrl = `/sites/${ slug }/launchpad`;
+
+	return canAccessWpcomApis()
+		? wpcomRequest( {
+				path: requestUrl,
+				apiNamespace: 'wpcom/v2',
+				method: 'PUT',
+				body: settings,
+		  } )
+		: apiFetch( {
+				global: true,
+				path: `/wpcom/v2${ requestUrl }`,
+				method: 'PUT',
+				data: settings,
+		  } as APIFetchOptions );
+};
+
+export interface PermanentDismiss {
+	isDismissed: boolean;
+}
+export interface TemporaryDismiss {
+	dismissBy: '+ 1 day' | '+ 1 week';
+}
+
+type DismissSettings = PermanentDismiss | TemporaryDismiss;
+
+const isPermanentDismiss = ( settings: DismissSettings ): settings is PermanentDismiss =>
+	'isDismissed' in settings;
+
+const isTemporaryDismiss = ( settings: DismissSettings ): settings is TemporaryDismiss =>
+	'dismissBy' in settings;
+
+const getDismissParams = ( settings: DismissSettings ) => {
+	if ( isPermanentDismiss( settings ) ) {
+		return {
+			is_dismissed: settings.isDismissed,
+		};
+	}
+
+	if ( isTemporaryDismiss( settings ) ) {
+		return {
+			dismiss_by: settings.dismissBy,
+		};
+	}
+};
+
+export const useLaunchpadDismisser = ( siteSlug: SiteSlug, checklistSlug: string ) => {
+	const queryClient = useQueryClient();
+	const key = getKey( siteSlug, checklistSlug );
+
+	return useMutation( {
+		mutationFn: ( settings: DismissSettings ) => {
+			return updateLaunchpadSettings( siteSlug, {
+				is_checklist_dismissed: {
+					slug: checklistSlug,
+					...getDismissParams( settings ),
+				},
+			} );
+		},
+		onMutate: async () => {
+			await queryClient.cancelQueries( { queryKey: key } );
+			const previous = queryClient.getQueryData< LaunchpadResponse >( key );
+
+			queryClient.setQueryData( key, {
+				...previous,
+				is_dismissed: true,
+			} );
+
+			return { previous };
+		},
+		onSuccess: () => {
+			recordTracksEvent( 'calypso_launchpad_dismiss_guide', {
+				checklist_slug: checklistSlug,
+				context: 'customer-home',
+			} );
+		},
+		onError: ( _, _2, context ) => {
+			if ( context?.previous ) {
+				queryClient.setQueryData( key, context?.previous );
+			}
+		},
+	} );
+};

package/src/queries/use-site-domains-query.ts

@@ -0,0 +1,165 @@
+import { UseQueryOptions, useQuery } from '@tanstack/react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+
+interface DnssecRecords {
+	dnskey?: string;
+	dsData?: Array< string >;
+}
+
+export interface DomainData {
+	primary_domain: boolean;
+	blog_name: string;
+	blog_id: number;
+	subscription_id: string;
+	can_manage_dns_records: boolean;
+	can_manage_name_servers: boolean;
+	can_update_contact_info: boolean;
+	cannot_manage_dns_records_reason: unknown;
+	cannot_manage_name_servers_reason: unknown;
+	cannot_update_contact_info_reason: string | null;
+	connection_mode: unknown;
+	current_user_can_add_email: boolean;
+	current_user_can_create_site_from_domain_only: boolean;
+	current_user_cannot_add_email_reason: {
+		errors: {
+			[ key: string ]: string[];
+		};
+	};
+	current_user_can_manage: boolean;
+	current_user_is_owner: boolean;
+	can_set_as_primary: boolean;
+	can_transfer_to_any_user: boolean;
+	can_transfer_to_other_site: boolean;
+	dnssec_records?: DnssecRecords;
+	domain: string;
+	domain_notice_states: unknown;
+	supports_domain_connect: unknown;
+	email_forwards_count: number;
+	expiry: string;
+	expiry_soon: boolean;
+	expired: boolean;
+	auto_renewing: boolean;
+	pending_registration: boolean;
+	pending_registration_time: string;
+	has_registration: boolean;
+	has_email_forward_dns_records: unknown;
+	points_to_wpcom: boolean;
+	privacy_available: boolean;
+	private_domain: boolean;
+	partner_domain: boolean;
+	wpcom_domain: boolean;
+	has_pending_contact_update: boolean;
+	has_zone: boolean;
+	is_dnssec_enabled: boolean;
+	is_dnssec_supported: boolean;
+	is_gravatar_domain: boolean;
+	is_renewable: boolean;
+	is_redeemable: boolean;
+	is_subdomain: boolean;
+	is_eligible_for_inbound_transfer: boolean;
+	is_locked: boolean;
+	is_wpcom_staging_domain: boolean;
+	transfer_away_eligible_at: string;
+	type: 'mapping' | 'wpcom' | 'registered' | 'redirect' | 'transfer';
+	registration_date: string;
+	auto_renewal_date: string;
+	google_apps_subscription: {
+		status: string;
+		is_eligible_for_introductory_offer: boolean;
+		total_user_count: number;
+	};
+	titan_mail_subscription: {
+		status: string;
+		is_eligible_for_introductory_offer: boolean;
+		maximum_mailbox_count: number;
+	};
+	pending_whois_update: boolean;
+	tld_maintenance_end_time: 0;
+	ssl_status: 'active' | 'pending' | 'newly_registered' | 'disabled' | null;
+	gdpr_consent_status: string;
+	supports_gdpr_consent_management: boolean;
+	supports_transfer_approval: boolean;
+	domain_registration_agreement_url: string;
+	contact_info_disclosure_available: boolean;
+	contact_info_disclosed: boolean;
+	renewable_until: string;
+	redeemable_until: string;
+	bundled_plan_subscription_id: string | number | null | undefined;
+	product_slug: string;
+	owner: string;
+	pending_renewal: boolean;
+	aftermarket_auction: boolean;
+	aftermarket_auction_start: unknown;
+	aftermarket_auction_end: string | null;
+	nominet_pending_contact_verification_request: boolean;
+	nominet_domain_suspended: boolean;
+	transfer_status:
+		| 'pending_owner'
+		| 'pending_registry'
+		| 'cancelled'
+		| 'completed'
+		| 'pending_start'
+		| 'pending_async'
+		| null;
+	last_transfer_error: string;
+	has_private_registration: boolean;
+	is_pending_icann_verification: boolean;
+	is_icann_verification_suspended: boolean;
+	manual_transfer_required: boolean;
+	registrar: string;
+	domain_locking_available: boolean;
+	is_premium: boolean;
+	transfer_lock_on_whois_update_optional: boolean;
+	transfer_start_date: string;
+	whois_update_unmodifiable_fields: [];
+	is_whois_editable: boolean;
+	pending_transfer: boolean;
+	has_wpcom_nameservers: boolean;
+	admin_email: string;
+	a_records_required_for_mapping: [];
+	begin_transfer_until_date: string;
+	must_remove_privacy_before_contact_update: boolean;
+	registry_expiry_date: string;
+	subdomain_part: string;
+	auth_code_required: boolean;
+	is_mapped_to_atomic_site: boolean;
+	is_move_to_new_site_pending: boolean;
+	pending_registration_at_registry: boolean;
+	pending_registration_at_registry_url: string;
+	registered_via_trustee: boolean;
+	registered_via_trustee_url: string;
+}
+
+export interface SiteDomainsQueryFnData {
+	domains: DomainData[];
+}
+
+export const getSiteDomainsQueryKey = ( siteIdOrSlug: number | string | null | undefined ) => [
+	'site-domains',
+	siteIdOrSlug,
+];
+
+export function useSiteDomainsQuery< TError = unknown, TData = SiteDomainsQueryFnData >(
+	siteIdOrSlug: number | string | null | undefined,
+	options: Omit< UseQueryOptions< SiteDomainsQueryFnData, TError, TData >, 'queryKey' > = {}
+) {
+	return useQuery( getSiteDomainsQueryObject( siteIdOrSlug, options ) );
+}
+
+export function getSiteDomainsQueryObject< TError = unknown, TData = SiteDomainsQueryFnData >(
+	siteIdOrSlug: number | string | null | undefined,
+	options: Omit< UseQueryOptions< SiteDomainsQueryFnData, TError, TData >, 'queryKey' > = {}
+): UseQueryOptions< SiteDomainsQueryFnData, TError, TData > {
+	return {
+		queryKey: getSiteDomainsQueryKey( siteIdOrSlug ),
+		queryFn: () =>
+			wpcomRequest< SiteDomainsQueryFnData >( {
+				path: `/sites/${ siteIdOrSlug }/domains`,
+				apiVersion: '1.2',
+			} ),
+		staleTime: 1000 * 60 * 5, // 5 minutes
+		...options,
+		meta: { persist: false, ...options.meta },
+		enabled: Boolean( siteIdOrSlug ) && options.enabled,
+	};
+}

package/src/queries/use-site-intent.ts

@@ -1,20 +1,18 @@
-import { useQuery } from 'react-query';
+import { useQuery } from '@tanstack/react-query';
 import wpcomRequest from 'wpcom-proxy-request';
 
 export function useSiteIntent( siteId: string | number | undefined ) {
 	return useQuery< {
 		site_intent: '';
-	} >(
-		'site-intent-' + siteId,
-		async () =>
+	} >( {
+		queryKey: [ 'site-intent', siteId ],
+		queryFn: async () =>
 			await wpcomRequest( {
 				path: `/sites/${ encodeURIComponent( siteId as string ) }/site-intent`,
 				apiNamespace: 'wpcom/v2',
 			} ),
-		{
-			refetchOnWindowFocus: false,
-			staleTime: Infinity,
-			enabled: !! siteId,
-		}
-	);
+		refetchOnWindowFocus: false,
+		staleTime: Infinity,
+		enabled: !! siteId,
+	} );
 }

package/src/queries/use-site-query.ts

@@ -0,0 +1,25 @@
+import { SiteDetails } from '@automattic/data-stores/src/site';
+import { UseQueryOptions, useQuery } from '@tanstack/react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+
+export function useSiteQuery< TError = unknown, TData = SiteDetails >(
+	sourceSiteSlug: string | number | null | undefined,
+	options: Omit< UseQueryOptions< SiteDetails, TError, TData >, 'queryKey' > = {}
+) {
+	return useQuery( {
+		queryFn: () =>
+			wpcomRequest< SiteDetails >( {
+				path: '/sites/' + encodeURIComponent( sourceSiteSlug ?? '' ),
+			} ),
+		meta: {
+			persist: false,
+		},
+		...options,
+		queryKey: getSiteQueryKey( sourceSiteSlug ),
+		enabled: Boolean( sourceSiteSlug ) && options.enabled,
+	} );
+}
+
+export function getSiteQueryKey( sourceSiteSlug: string | number | null | undefined ) {
+	return [ 'site-details', sourceSiteSlug ];
+}

package/src/reader/constants.ts

@@ -1 +1,24 @@
-export const STORE_KEY = 'automattic/reader';
+export enum EmailDeliveryFrequency {
+	Instantly = 'instantly',
+	Daily = 'daily',
+	Weekly = 'weekly',
+}
+
+export enum PostSubscriptionsSortBy {
+	PostName = 'post_name',
+	RecentlyCommented = 'recently_commented',
+	RecentlySubscribed = 'recently_subscribed',
+}
+
+export enum SiteSubscriptionsFilterBy {
+	All = 'all',
+	Paid = 'paid',
+	P2 = 'p2',
+	RSS = 'rss',
+}
+
+export enum SiteSubscriptionsSortBy {
+	SiteName = 'site_name',
+	LastUpdated = 'last_updated',
+	DateSubscribed = 'date_subscribed',
+}

package/src/reader/contexts/index.ts

@@ -0,0 +1,8 @@
+export {
+	UnsubscribedFeedsSearchProvider,
+	useUnsubscribedFeedsSearch,
+} from './unsubscribed-feeds-search';
+export {
+	SiteSubscriptionsQueryPropsProvider,
+	useSiteSubscriptionsQueryProps,
+} from './site-subscriptions-query-props';