@automattic/data-stores 1.0.0-alpha.0 → 3.0.0

package/src/site/types.ts

@@ -0,0 +1,400 @@
+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;
+	blogid: number;
+	blogname: string;
+	site_slug?: string;
+	xmlrpc: string;
+}
+
+export interface NewSiteSuccessResponse {
+	success: boolean;
+	blog_details: NewSiteBlogDetails;
+	is_signup_sandbox?: boolean;
+}
+
+export interface NewSiteErrorResponse {
+	error: string;
+	status: number;
+	statusCode: number;
+	name: string;
+	message: string;
+}
+
+export interface NewSiteErrorCreateBlog {
+	// This has to be `any` as sites/new will return whatever value is passed to it as `$blog_id` if create blog fails.
+	blog_id?: any; // eslint-disable-line @typescript-eslint/no-explicit-any
+}
+
+export type NewSiteResponse =
+	| NewSiteSuccessResponse
+	| NewSiteErrorResponse
+	| NewSiteErrorCreateBlog;
+
+export enum Visibility {
+	PublicIndexed = 1,
+	PublicNotIndexed = 0,
+	Private = -1,
+}
+
+export interface CreateSiteParams {
+	blog_name: string;
+	blog_title?: string;
+	authToken?: string;
+	public?: Visibility;
+	options?: {
+		site_vertical?: string;
+		site_vertical_name?: string;
+		site_vertical_slug?: string;
+		site_information?: {
+			title?: string;
+		};
+		lang_id?: number;
+		site_creation_flow?: string;
+		enable_fse?: boolean;
+		theme?: string;
+		template?: string;
+		timezone_string?: string;
+		font_headings?: string;
+		font_base?: string;
+		use_patterns?: boolean;
+		selected_features?: FeatureId[];
+		wpcom_public_coming_soon?: number;
+		anchor_fm_podcast_id?: string;
+		is_blank_canvas?: boolean;
+	};
+}
+
+export interface SiteDetailsPlan {
+	product_id: number;
+	product_slug: string;
+	product_name: string;
+	product_name_short: string;
+	expired: boolean;
+	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 {
+	ID: number;
+	name: string | undefined;
+	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: {
+		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;
+}
+
+export type SiteResponse = SiteDetails | SiteError;
+
+export interface Cart {
+	blog_id: number;
+	cart_key: number;
+	coupon: string;
+	coupon_discounts: unknown[];
+	coupon_discounts_integer: unknown[];
+	is_coupon_applied: boolean;
+	has_bundle_credit: boolean;
+	next_domain_is_free: boolean;
+	next_domain_condition: string;
+	products: unknown[];
+	total_cost: number;
+	currency: string;
+	total_cost_display: string;
+	total_cost_integer: number;
+	temporary: boolean;
+	tax: unknown;
+	sub_total: number;
+	sub_total_display: string;
+	sub_total_integer: number;
+	total_tax: number;
+	total_tax_display: string;
+	total_tax_integer: number;
+	credits: number;
+	credits_display: string;
+	credits_integer: number;
+	allowed_payment_methods: unknown[];
+	create_new_blog: boolean;
+	messages: Record< 'errors' | 'success', unknown >;
+}
+
+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;
+	domain: string;
+	supports_domain_connect?: any;
+	email_forwards_count: number;
+	expiry: boolean;
+	expiry_soon: boolean;
+	expired: boolean;
+	auto_renewing: boolean;
+	pending_registration: boolean;
+	pending_registration_time: string;
+	has_registration: boolean;
+	points_to_wpcom: boolean;
+	privacy_available: boolean;
+	private_domain: boolean;
+	partner_domain: boolean;
+	wpcom_domain: boolean;
+	has_zone: 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?: any;
+	type: string;
+	registration_date: string;
+	auto_renewal_date: string;
+	google_apps_subscription?: unknown[];
+	titan_mail_subscription?: unknown[];
+	pending_whois_update: boolean;
+	tld_maintenance_end_time?: any;
+	ssl_status?: any;
+	subdomain_part?: 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?: any;
+	redeemable_until?: any;
+	bundled_plan_subscription_id?: any;
+	product_slug?: any;
+	owner: string;
+}
+
+export interface SiteSettings {
+	[ key: string ]: any;
+}
+
+export interface SiteLaunchState {
+	status: SiteLaunchStatus;
+	errorCode: SiteLaunchError | undefined;
+}
+
+export enum SiteLaunchError {
+	INTERNAL = 'internal',
+}
+
+export enum SiteLaunchStatus {
+	UNINITIALIZED = 'unintialized',
+	IN_PROGRESS = 'in_progress',
+	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

@@ -2,6 +2,8 @@
 
 This store includes behavior for checking if a current user is logged in, and creating new user accounts.
 
+To log the user in see the [auth store](../auth/README.md).
+
 ## Usage
 
 Register the user store, passing in a valid client ID and secret:
@@ -23,7 +25,7 @@ Check if a current user is logged in:
 import { useSelect } from '@wordpress/data';
 
 function MyComponent() {
-	const isLoggedIn = useSelect( select => select( USER_STORE ).isCurrentUserLoggedIn() );
+	const isLoggedIn = useSelect( ( select ) => select( USER_STORE ).isCurrentUserLoggedIn() );
 	// …snip
 }
 ```
@@ -48,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… */);
@@ -57,10 +59,10 @@ const USER_STORE = User.register(/* app credentials… */);
 function SignupComponent() {
 	const [ email, setEmail ] = useState( '' );
 
-	const currentUser = useSelect( select => select( USER_STORE ).getCurrentUser() );
-	const newUser = useSelect( select => select( USER_STORE ).getNewUser() );
-	const newUserError = useSelect( select => select( USER_STORE ).getNewUserError() );
-	const isFetchingNewUser = useSelect( select => select( USER_STORE ).isFetchingNewUser() );
+	const currentUser = useSelect( ( select ) => select( USER_STORE ).getCurrentUser() );
+	const newUser = useSelect( ( select ) => select( USER_STORE ).getNewUser() );
+	const newUserError = useSelect( ( select ) => select( USER_STORE ).getNewUserError() );
+	const isFetchingNewUser = useSelect( ( select ) => select( USER_STORE ).isFetchingNewUser() );
 
 	const { createAccount } = useDispatch( USER_STORE );
 
@@ -87,7 +89,7 @@ function SignupComponent() {
 					<TextControl
 						label="Email address"
 						value={ email }
-						onChange={ newEmail => setEmail( newEmail ) }
+						onChange={ ( newEmail ) => setEmail( newEmail ) }
 					/>
 					<Button isPrimary isLarge type="submit" value="Submit">
 						Create Account