@automattic/data-stores 2.0.1 → 3.0.0

package/src/site/types.ts

@@ -1,7 +1,10 @@
-/**
- * Internal dependencies
- */
+import type { DispatchFromMap } from '../mapped-types';
 import type { FeatureId } from '../wpcom-features';
+import type { ActionCreators } from './actions';
+
+export interface Dispatch {
+	dispatch: DispatchFromMap< ActionCreators >;
+}
 
 export interface NewSiteBlogDetails {
 	url: string;
@@ -65,6 +68,7 @@ export interface CreateSiteParams {
 		selected_features?: FeatureId[];
 		wpcom_public_coming_soon?: number;
 		anchor_fm_podcast_id?: string;
+		is_blank_canvas?: boolean;
 	};
 }
 
@@ -77,6 +81,16 @@ export interface SiteDetailsPlan {
 	billing_period: string;
 	user_is_owner: boolean;
 	is_free: boolean;
+	features: {
+		active: string[];
+		available: Record< string, string[] >;
+	};
+}
+
+export interface DifmLiteSiteOptions {
+	site_category?: string;
+	is_website_content_submitted?: boolean;
+	selected_page_titles: string[];
 }
 
 export interface SiteDetails {
@@ -85,13 +99,109 @@ export interface SiteDetails {
 	description: string;
 	URL: string;
 	launch_status: string;
+	jetpack: boolean;
+	is_fse_eligible: boolean;
+	is_fse_active: boolean;
+	logo: { id: string; sizes: string[]; url: string };
 	options: {
-		created_at: string;
+		admin_url?: string;
+		advanced_seo_front_page_description?: string;
+		advanced_seo_title_formats?: string[];
+		ak_vp_bundle_enabled?: boolean;
+		allowed_file_types?: string[];
+		anchor_podcast?: boolean;
+		background_color?: boolean;
+		blog_public?: number;
+		created_at?: Date;
+		default_category?: number;
+		default_comment_status?: boolean;
+		default_likes_enabled?: boolean;
+		default_ping_status?: boolean;
+		default_post_format?: string;
+		default_sharing_status?: boolean;
+		design_type?: string;
+		difm_lite_site_options?: DifmLiteSiteOptions;
+		editing_toolkit_is_active?: boolean;
+		featured_images_enabled?: boolean;
+		frame_nonce?: string;
+		gmt_offset?: number;
+		header_image?: boolean;
+		headstart_is_fresh?: boolean;
+		headstart?: boolean;
+		image_default_link_type?: string;
+		image_large_height?: number;
+		image_large_width?: number;
+		image_medium_height?: number;
+		image_medium_width?: number;
+		image_thumbnail_crop?: number;
+		image_thumbnail_height?: number;
+		image_thumbnail_width?: number;
+		import_engine?: string;
+		is_automated_transfer?: boolean;
+		is_cloud_eligible?: boolean;
+		is_difm_lite_in_progress?: boolean;
+		is_domain_only?: boolean;
+		is_mapped_domain?: boolean;
+		is_pending_plan?: boolean;
+		is_redirect?: boolean;
+		is_wpcom_atomic?: boolean;
+		is_wpcom_store?: boolean;
+		is_wpforteams_site?: boolean;
+		jetpack_frame_nonce?: string;
+		login_url?: string;
+		p2_hub_blog_id?: number;
+		page_for_posts?: number;
+		page_on_front?: number;
+		permalink_structure?: string;
+		podcasting_archive?: boolean;
+		post_formats?: string[];
+		publicize_permanently_disabled?: boolean;
+		show_on_front?: string;
+		site_intent?: string;
+		site_segment?: string;
+		site_vertical_id?: string;
+		software_version?: string;
 		selected_features?: FeatureId[];
+		theme_slug?: string;
+		timezone?: string;
+		unmapped_url?: string;
+		upgraded_filetypes_enabled?: boolean;
+		verification_services_codes?: string;
+		videopress_enabled?: boolean;
+		videopress_storage_used?: number;
+		was_created_with_blank_canvas_design?: boolean;
+		woocommerce_is_active?: boolean;
+		wordads?: boolean;
 	};
 	plan?: SiteDetailsPlan;
+	capabilities: {
+		edit_pages: boolean;
+		edit_posts: boolean;
+		edit_others_posts: boolean;
+		edit_others_pages: boolean;
+		delete_posts: boolean;
+		delete_others_posts: boolean;
+		edit_theme_options: boolean;
+		edit_users: boolean;
+		list_users: boolean;
+		manage_categories: boolean;
+		manage_options: boolean;
+		moderate_comments: boolean;
+		activate_wordads: boolean;
+		promote_users: boolean;
+		publish_posts: boolean;
+		upload_files: boolean;
+		delete_users: boolean;
+		remove_users: boolean;
+		own_site: boolean;
+		view_hosting: boolean;
+		view_stats: boolean;
+		activate_plugins: boolean;
+	};
 }
 
+export type SiteOption = keyof SiteDetails[ 'options' ];
+
 export interface SiteError {
 	error: string;
 	message: string;
@@ -134,6 +244,7 @@ export interface Domain {
 	a_records_required_for_mapping?: string[];
 	primary_domain: boolean;
 	blog_id: number;
+	connection_mode?: string;
 	subscription_id?: any;
 	current_user_can_manage: boolean;
 	can_set_as_primary: boolean;
@@ -143,7 +254,6 @@ export interface Domain {
 	expiry: boolean;
 	expiry_soon: boolean;
 	expired: boolean;
-	new_registration: boolean;
 	auto_renewing: boolean;
 	pending_registration: boolean;
 	pending_registration_time: string;
@@ -182,6 +292,10 @@ export interface Domain {
 	owner: string;
 }
 
+export interface SiteSettings {
+	[ key: string ]: any;
+}
+
 export interface SiteLaunchState {
 	status: SiteLaunchStatus;
 	errorCode: SiteLaunchError | undefined;
@@ -197,3 +311,90 @@ export enum SiteLaunchStatus {
 	SUCCESS = 'success',
 	FAILURE = 'failure',
 }
+
+export interface AtomicTransferState {
+	status: AtomicTransferStatus;
+	errorCode: AtomicTransferError | undefined;
+}
+
+export enum AtomicTransferStatus {
+	UNINITIALIZED = 'unintialized',
+	IN_PROGRESS = 'in_progress',
+	SUCCESS = 'success',
+	FAILURE = 'failure',
+}
+
+export enum AtomicTransferError {
+	INTERNAL = 'internal',
+}
+
+export interface LatestAtomicTransfer {
+	atomic_transfer_id: number;
+	blog_id: number;
+	status: string;
+	created_at: string;
+	is_stuck: boolean;
+	is_stuck_reset: boolean;
+	in_lossless_revert: boolean;
+}
+
+export interface LatestAtomicTransferState {
+	status: LatestAtomicTransferStatus;
+	transfer: LatestAtomicTransfer | undefined;
+	errorCode: LatestAtomicTransferError | undefined;
+}
+
+export enum LatestAtomicTransferStatus {
+	UNINITIALIZED = 'unintialized',
+	IN_PROGRESS = 'in_progress',
+	SUCCESS = 'success',
+	FAILURE = 'failure',
+}
+
+export interface LatestAtomicTransferError {
+	name: string; // "NotFoundError"
+	status: number; // 404
+	message: string; // "Transfer not found"
+	code: string; // "no_transfer_record"
+}
+
+export interface AtomicSoftwareStatus {
+	blog_id: number;
+	software_set: Record< string, { path: string; state: string } >;
+	applied: boolean;
+}
+
+export interface AtomicSoftwareStatusError {
+	name: string; // "NotFoundError"
+	status: number; // 404
+	message: string; // "Transfer not found"
+	code: string; // "no_transfer_record"
+}
+
+export type AtomicSoftwareStatusState = Record<
+	string,
+	{
+		status: AtomicSoftwareStatus | undefined;
+		error: AtomicSoftwareStatusError | undefined;
+	}
+>;
+
+export enum AtomicSoftwareInstallStatus {
+	UNINITIALIZED = 'unintialized',
+	IN_PROGRESS = 'in_progress',
+	SUCCESS = 'success',
+	FAILURE = 'failure',
+}
+export type AtomicSoftwareInstallState = Record<
+	string,
+	{
+		status: AtomicSoftwareInstallStatus | undefined;
+		error: AtomicSoftwareInstallError | undefined;
+	}
+>;
+export interface AtomicSoftwareInstallError {
+	name: string;
+	status: number;
+	message: string;
+	code: string;
+}

package/src/starter-designs-queries/types.ts

@@ -0,0 +1,13 @@
+import type { DesignRecipe } from '@automattic/design-picker/src/types';
+
+export interface StarterDesignsGeneratedQueryParams {
+	vertical_id: string;
+	seed?: string;
+	_locale: string;
+}
+
+export interface StarterDesignsGenerated {
+	slug: string;
+	title: string;
+	recipe: DesignRecipe;
+}

package/src/starter-designs-queries/use-starter-designs-generated-query.ts

@@ -0,0 +1,51 @@
+import { stringify } from 'qs';
+import { useQuery, UseQueryResult, QueryOptions } from 'react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+import type { StarterDesignsGenerated, StarterDesignsGeneratedQueryParams } from './types';
+import type { Design } from '@automattic/design-picker/src/types';
+
+interface Options extends QueryOptions< StarterDesignsGenerated[], unknown > {
+	enabled?: boolean;
+}
+
+export function useStarterDesignsGeneratedQuery(
+	queryParams: StarterDesignsGeneratedQueryParams,
+	queryOptions: Options = {}
+): UseQueryResult< Design[] > {
+	return useQuery(
+		[ 'starter-designs-generated', queryParams ],
+		() => fetchStarterDesignsGenerated( queryParams ),
+		{
+			select: ( response: StarterDesignsGenerated[] ) =>
+				response.map( apiStarterDesignsGeneratedToDesign ),
+			refetchOnMount: 'always',
+			staleTime: Infinity,
+			...queryOptions,
+		}
+	);
+}
+
+function fetchStarterDesignsGenerated(
+	queryParams: StarterDesignsGeneratedQueryParams
+): Promise< StarterDesignsGenerated[] > {
+	return wpcomRequest< StarterDesignsGenerated[] >( {
+		apiNamespace: 'wpcom/v2',
+		path: '/starter-designs/generated',
+		query: stringify( queryParams ),
+	} );
+}
+
+function apiStarterDesignsGeneratedToDesign( design: StarterDesignsGenerated ): Design {
+	const { slug, title, recipe } = design;
+
+	return {
+		slug,
+		title,
+		recipe,
+		is_premium: false,
+		categories: [],
+		features: [],
+		template: '',
+		theme: '',
+	};
+}

package/src/support-queries/types.ts

@@ -0,0 +1,28 @@
+interface Availability {
+	presale: boolean;
+	precancellation: boolean;
+}
+
+export interface HappyChatAvailability {
+	locale: string;
+	isUserEligible: boolean;
+	supportLevel:
+		| 'free'
+		| 'personal'
+		| 'personal-with-legacy-chat'
+		| 'premium'
+		| 'pro'
+		| 'business'
+		| 'ecommerce'
+		| 'jetpack-paid'
+		| 'p2-plus';
+	nickname: string;
+	isClosed: boolean;
+	availability: Availability;
+}
+
+export interface OtherSupportAvailability {
+	is_user_eligible_for_upwork: boolean;
+	is_user_eligible_for_kayako: boolean;
+	is_user_eligible_for_directly: boolean;
+}

package/src/support-queries/use-sibyl-query.ts

@@ -0,0 +1,31 @@
+import config from '@automattic/calypso-config';
+import { useQuery } from 'react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+
+type Result = {
+	id: string;
+	title: string;
+	description: string;
+	link: string;
+};
+
+const wpcomSupportBlog = config( 'wpcom_support_blog' ) as string;
+const jetpackSupportBlog = config( 'jetpack_support_blog' ) as string;
+
+export function useSibylQuery( query: string, isJetpackSite: boolean, isAtomic: boolean ) {
+	const site = ! isJetpackSite || isAtomic ? wpcomSupportBlog : jetpackSupportBlog;
+
+	return useQuery< Result[] >(
+		query,
+		async () =>
+			await wpcomRequest( {
+				path: '/help/qanda',
+				apiVersion: '1.1',
+				query: `query=${ encodeURIComponent( query ) }&site=${ encodeURIComponent( site ) }`,
+			} ),
+		{
+			refetchOnWindowFocus: false,
+			keepPreviousData: true,
+		}
+	);
+}

package/src/support-queries/use-submit-forums-topic.ts

@@ -0,0 +1,56 @@
+import { useMutation } from 'react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+import { SiteDetails } from '../site';
+
+type ForumTopic = {
+	site?: SiteDetails;
+	message: string;
+	subject: string;
+	locale: string;
+	hideInfo: boolean;
+	userDeclaredSiteUrl?: string;
+};
+
+type Response = {
+	topic_URL: string;
+};
+
+export function useSubmitForumsMutation() {
+	return useMutation(
+		( { site, message, subject, locale, hideInfo, userDeclaredSiteUrl }: ForumTopic ) => {
+			const blogHelpMessages = [];
+
+			if ( site ) {
+				if ( site.jetpack ) {
+					blogHelpMessages.push( 'WP.com: Unknown' );
+					blogHelpMessages.push( 'Jetpack: Yes' );
+				} else {
+					blogHelpMessages.push( 'WP.com: Yes' );
+				}
+
+				blogHelpMessages.push( 'Correct account: yes' );
+			} else if ( userDeclaredSiteUrl ) {
+				blogHelpMessages.push( `Self-declared URL: ${ userDeclaredSiteUrl }` );
+			}
+
+			const forumMessage = message + '\n\n' + blogHelpMessages.join( '\n' );
+
+			const requestData = {
+				subject,
+				message: forumMessage,
+				locale,
+				client: 'help-center',
+				hide_blog_info: hideInfo,
+				blog_id: site?.ID,
+				blog_url: site?.URL,
+			};
+
+			return wpcomRequest< Response >( {
+				path: '/help/forums/support/topics/new',
+				apiVersion: '1.1',
+				method: 'POST',
+				body: requestData,
+			} );
+		}
+	);
+}

package/src/support-queries/use-submit-support-ticket.ts

@@ -0,0 +1,21 @@
+import { useMutation } from 'react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+
+type Ticket = {
+	subject: string;
+	message: string;
+	locale: string;
+	client: string;
+	is_chat_overflow: boolean;
+};
+
+export function useSubmitTicketMutation() {
+	return useMutation( ( newTicket: Ticket ) =>
+		wpcomRequest( {
+			path: '/help/tickets/kayako/new',
+			apiVersion: '1.1',
+			method: 'POST',
+			body: newTicket,
+		} )
+	);
+}

package/src/support-queries/use-support-availability.ts

@@ -0,0 +1,24 @@
+import { useQuery } from 'react-query';
+import wpcomRequest from 'wpcom-proxy-request';
+import { OtherSupportAvailability, HappyChatAvailability } from './types';
+
+type ResponseType< T extends 'CHAT' | 'OTHER' > = T extends 'CHAT'
+	? HappyChatAvailability
+	: OtherSupportAvailability;
+
+export function useSupportAvailability< SUPPORT_TYPE extends 'CHAT' | 'OTHER' >(
+	supportType: SUPPORT_TYPE
+) {
+	return useQuery< ResponseType< SUPPORT_TYPE >, typeof Error >(
+		supportType === 'OTHER' ? 'otherSupportAvailability' : 'chatSupportAvailability',
+		async () =>
+			await wpcomRequest( {
+				path: supportType === 'OTHER' ? '/help/tickets/all/mine' : '/help/olark/mine',
+				apiVersion: '1.1',
+			} ),
+		{
+			refetchOnWindowFocus: false,
+			keepPreviousData: true,
+		}
+	);
+}

package/src/types.d.ts

@@ -0,0 +1 @@
+declare const __i18n_text_domain__: string;

package/src/user/README.md

@@ -50,8 +50,8 @@ Put altogether, a minimalist signup form can be created with:
 
 ```js
 import { User } from '@automattic/data-stores';
-import { useDispatch, useSelect } from '@wordpress/data';
 import { Button, Notice, Spinner, TextControl } from '@wordpress/components';
+import { useDispatch, useSelect } from '@wordpress/data';
 import React, { useState } from 'react';
 
 const USER_STORE = User.register(/* app credentials… */);

package/src/user/actions.ts

@@ -1,19 +1,12 @@
-/**
- * External dependencies
- */
 import { stringify } from 'qs';
-
-/**
- * Internal dependencies
- */
+import { wpcomRequest, requestAllBlogsAccess, reloadProxy } from '../wpcom-request-controls';
+import type { WpcomClientCredentials } from '../shared-types';
 import type {
 	CurrentUser,
 	CreateAccountParams,
 	NewUserErrorResponse,
 	NewUserSuccessResponse,
 } from './types';
-import { wpcomRequest, requestAllBlogsAccess, reloadProxy } from '../wpcom-request-controls';
-import type { WpcomClientCredentials } from '../shared-types';
 
 export function createActions( clientCreds: WpcomClientCredentials ) {
 	const receiveCurrentUser = ( currentUser: CurrentUser ) => ( {
@@ -46,7 +39,7 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 	function* createAccount( params: CreateAccountParams ) {
 		yield fetchNewUser();
 		try {
-			const newUser = yield wpcomRequest( {
+			const newUser: NewUserSuccessResponse = yield wpcomRequest( {
 				body: {
 					// defaults
 					is_passwordless: true,
@@ -73,8 +66,9 @@ export function createActions( clientCreds: WpcomClientCredentials ) {
 			yield receiveNewUser( newUser );
 
 			return { ok: true } as const;
-		} catch ( newUserError ) {
-			yield receiveNewUserFailed( newUserError );
+		} catch ( error ) {
+			const newUserError: NewUserErrorResponse = error as NewUserErrorResponse;
+			yield receiveNewUserFailed( newUserError as NewUserErrorResponse );
 
 			return { ok: false, newUserError } as const;
 		}

package/src/user/index.ts

@@ -1,17 +1,10 @@
-/**
- * External dependencies
- */
 import { registerStore } from '@wordpress/data';
-
-/**
- * Internal dependencies
- */
+import { controls } from '../wpcom-request-controls';
+import { createActions } from './actions';
 import { STORE_KEY } from './constants';
 import reducer, { State } from './reducer';
-import { createActions } from './actions';
 import { createResolvers } from './resolvers';
 import * as selectors from './selectors';
-import { controls } from '../wpcom-request-controls';
 import type { DispatchFromMap, SelectFromMap } from '../mapped-types';
 import type { WpcomClientCredentials } from '../shared-types';
 

package/src/user/reducer.ts

@@ -1,14 +1,7 @@
-/**
- * External dependencies
- */
-import type { Reducer } from 'redux';
 import { combineReducers } from '@wordpress/data';
-
-/**
- * Internal dependencies
- */
-import type { CurrentUser, NewUser, NewUserErrorResponse } from './types';
 import type { Action } from './actions';
+import type { CurrentUser, NewUser, NewUserErrorResponse } from './types';
+import type { Reducer } from 'redux';
 
 export const currentUser: Reducer< CurrentUser | null | undefined, Action > = ( state, action ) => {
 	switch ( action.type ) {

package/src/user/resolvers.ts

@@ -1,6 +1,3 @@
-/**
- * Internal dependencies
- */
 import { wpcomRequest } from '../wpcom-request-controls';
 import { createActions } from './actions';
 import type { WpcomClientCredentials } from '../shared-types';
@@ -23,7 +20,7 @@ export function createResolvers( clientCreds: WpcomClientCredentials ) {
 			return receiveCurrentUser( window.currentUser );
 		}
 		try {
-			const currentUser = yield wpcomRequest( {
+			const currentUser: CurrentUser = yield wpcomRequest( {
 				path: '/me',
 				apiVersion: '1.1',
 			} );

package/src/user/selectors.ts

@@ -1,6 +1,3 @@
-/**
- * Internal dependencies
- */
 import type { State } from './reducer';
 
 export const getState = ( state: State ) => state;

package/src/user/test/actions.ts

@@ -6,9 +6,6 @@
  * @jest-environment jsdom
  */
 
-/**
- * Internal dependencies
- */
 import { createActions } from '../actions';
 
 const client_id = 'magic_client_id';

package/src/user/test/reducer.ts

@@ -6,11 +6,8 @@
  * @jest-environment jsdom
  */
 
-/**
- * Internal dependencies
- */
-import { currentUser, newUserData, newUserError, isFetchingNewUser } from '../reducer';
 import { createActions } from '../actions';
+import { currentUser, newUserData, newUserError, isFetchingNewUser } from '../reducer';
 
 const {
 	receiveCurrentUser,
@@ -90,11 +87,8 @@ describe( 'newUserData', () => {
 
 	it( 'set username, userId, and bearerToken from a sandboxed response', () => {
 		const state = newUserData( undefined, receiveNewUser( newUserSuccessResponseSandboxed ) );
-		const {
-			signup_sandbox_username,
-			signup_sandbox_user_id,
-			bearer_token,
-		} = newUserSuccessResponseSandboxed;
+		const { signup_sandbox_username, signup_sandbox_user_id, bearer_token } =
+			newUserSuccessResponseSandboxed;
 		expect( state ).toEqual( {
 			username: signup_sandbox_username,
 			userId: signup_sandbox_user_id,

package/src/user/test/resolvers.ts

@@ -6,9 +6,6 @@
  * @jest-environment jsdom
  */
 
-/**
- * Internal dependencies
- */
 import { createResolvers } from '../resolvers';
 
 const { getCurrentUser } = createResolvers( { client_id: '', client_secret: '' } );

package/src/user/types.ts

@@ -1,13 +1,10 @@
-/**
- * External dependencies
- */
 import type { Action } from 'redux';
 
 export interface CurrentUser {
 	ID: number;
 	display_name: string;
 	username: string;
-
+	email: string;
 	/**
 	 * The user's locale slug, e.g. `es`.
 	 */

package/src/verticals/actions.ts

@@ -1,6 +1,3 @@
-/**
- * Internal dependencies
- */
 import type { Vertical } from './types';
 
 export const receiveVerticals = ( verticals: Vertical[] ) => ( {