469 lines
11 KiB
TypeScript
469 lines
11 KiB
TypeScript
/* eslint-disable @woocommerce/dependency-group */
|
|
/* eslint-disable @typescript-eslint/ban-ts-comment */
|
|
/**
|
|
* External dependencies
|
|
*/
|
|
import { __experimentalRequestJetpackToken as requestJetpackToken } from '@woocommerce/ai';
|
|
import apiFetch from '@wordpress/api-fetch';
|
|
import { OPTIONS_STORE_NAME } from '@woocommerce/data';
|
|
import { Sender, assign, createMachine, actions } from 'xstate';
|
|
import { dispatch, resolveSelect } from '@wordpress/data';
|
|
// @ts-ignore No types for this exist yet.
|
|
import { store as coreStore } from '@wordpress/core-data';
|
|
// @ts-ignore No types for this exist yet.
|
|
import { mergeBaseAndUserConfigs } from '@wordpress/edit-site/build-module/components/global-styles/global-styles-provider';
|
|
/**
|
|
* Internal dependencies
|
|
*/
|
|
import { designWithAiStateMachineContext } from './types';
|
|
import { FONT_PAIRINGS } from '../assembler-hub/sidebar/global-styles/font-pairing-variations/constants';
|
|
import { COLOR_PALETTES } from '../assembler-hub/sidebar/global-styles/color-palette-variations/constants';
|
|
import { HOMEPAGE_TEMPLATES } from '../data/homepageTemplates';
|
|
import { updateTemplate } from '../data/actions';
|
|
import { installAndActivateTheme as setTheme } from '../data/service';
|
|
import { THEME_SLUG } from '../data/constants';
|
|
import { trackEvent } from '../tracking';
|
|
import { installPatterns } from '../design-without-ai/services';
|
|
|
|
const { escalate } = actions;
|
|
|
|
const browserPopstateHandler =
|
|
() => ( sendBack: Sender< { type: 'EXTERNAL_URL_UPDATE' } > ) => {
|
|
const popstateHandler = () => {
|
|
sendBack( { type: 'EXTERNAL_URL_UPDATE' } );
|
|
};
|
|
window.addEventListener( 'popstate', popstateHandler );
|
|
return () => {
|
|
window.removeEventListener( 'popstate', popstateHandler );
|
|
};
|
|
};
|
|
|
|
export const getCompletion = async < ValidResponseObject >( {
|
|
queryId,
|
|
prompt,
|
|
version,
|
|
responseValidation,
|
|
retryCount,
|
|
abortSignal = AbortSignal.timeout( 10000 ),
|
|
}: {
|
|
queryId: string;
|
|
prompt: string;
|
|
version: string;
|
|
responseValidation: ( arg0: string ) => ValidResponseObject;
|
|
retryCount: number;
|
|
abortSignal?: AbortSignal;
|
|
} ) => {
|
|
const { token } = await requestJetpackToken();
|
|
let data: {
|
|
completion: string;
|
|
};
|
|
let parsedCompletionJson;
|
|
try {
|
|
const url = new URL(
|
|
'https://public-api.wordpress.com/wpcom/v2/text-completion'
|
|
);
|
|
|
|
url.searchParams.append( 'feature', 'woo_cys' );
|
|
|
|
data = await apiFetch( {
|
|
url: url.toString(),
|
|
method: 'POST',
|
|
data: {
|
|
token,
|
|
prompt,
|
|
_fields: 'completion',
|
|
},
|
|
signal: abortSignal,
|
|
} );
|
|
} catch ( error ) {
|
|
trackEvent( 'customize_your_store_ai_completion_api_error', {
|
|
query_id: queryId,
|
|
version,
|
|
retry_count: retryCount,
|
|
error_type: 'api_request_error',
|
|
} );
|
|
throw error;
|
|
}
|
|
|
|
try {
|
|
parsedCompletionJson = JSON.parse( data.completion );
|
|
} catch {
|
|
trackEvent( 'customize_your_store_ai_completion_response_error', {
|
|
query_id: queryId,
|
|
version,
|
|
retry_count: retryCount,
|
|
error_type: 'json_parse_error',
|
|
response: data.completion,
|
|
} );
|
|
throw new Error(
|
|
`Error validating Jetpack AI text completions response for ${ queryId }`
|
|
);
|
|
}
|
|
|
|
try {
|
|
const validatedResponse = responseValidation( parsedCompletionJson );
|
|
trackEvent( 'customize_your_store_ai_completion_success', {
|
|
query_id: queryId,
|
|
version,
|
|
retry_count: retryCount,
|
|
} );
|
|
return validatedResponse;
|
|
} catch ( error ) {
|
|
trackEvent( 'customize_your_store_ai_completion_response_error', {
|
|
query_id: queryId,
|
|
version,
|
|
retry_count: retryCount,
|
|
error_type: 'valid_json_invalid_values',
|
|
response: data.completion,
|
|
} );
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const queryAiEndpoint = createMachine(
|
|
{
|
|
id: 'query-ai-endpoint',
|
|
predictableActionArguments: true,
|
|
initial: 'init',
|
|
context: {
|
|
// these values are all overwritten by incoming parameters
|
|
prompt: '',
|
|
queryId: '',
|
|
version: '',
|
|
responseValidation: () => true,
|
|
retryCount: 0,
|
|
validatedResponse: {} as unknown,
|
|
},
|
|
states: {
|
|
init: {
|
|
always: 'querying',
|
|
entry: [ 'setRetryCount' ],
|
|
},
|
|
querying: {
|
|
invoke: {
|
|
src: 'getCompletion',
|
|
onDone: {
|
|
target: 'success',
|
|
actions: [ 'handleAiResponse' ],
|
|
},
|
|
onError: {
|
|
target: 'error',
|
|
},
|
|
},
|
|
},
|
|
error: {
|
|
always: [
|
|
{
|
|
cond: ( context ) => context.retryCount >= 3,
|
|
target: 'querying',
|
|
actions: [
|
|
// Throw an error to be caught by the parent machine.
|
|
escalate( () => ( {
|
|
data: 'Max retries exceeded',
|
|
} ) ),
|
|
],
|
|
},
|
|
{
|
|
target: 'querying',
|
|
actions: assign( {
|
|
retryCount: ( context ) => context.retryCount + 1,
|
|
} ),
|
|
},
|
|
],
|
|
},
|
|
success: {
|
|
type: 'final',
|
|
data: ( context ) => {
|
|
return {
|
|
result: 'success',
|
|
response: context.validatedResponse,
|
|
};
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
actions: {
|
|
handleAiResponse: assign( {
|
|
validatedResponse: ( _context, event: unknown ) =>
|
|
( event as { data: unknown } ).data,
|
|
} ),
|
|
setRetryCount: assign( {
|
|
retryCount: 0,
|
|
} ),
|
|
},
|
|
services: {
|
|
getCompletion,
|
|
},
|
|
}
|
|
);
|
|
|
|
const resetPatternsAndProducts = () => async () => {
|
|
await dispatch( OPTIONS_STORE_NAME ).updateOptions( {
|
|
woocommerce_blocks_allow_ai_connection: 'yes',
|
|
} );
|
|
|
|
const response = await apiFetch< {
|
|
is_ai_generated: boolean;
|
|
} >( {
|
|
path: '/wc/private/ai/store-info',
|
|
method: 'GET',
|
|
} );
|
|
|
|
if ( response.is_ai_generated ) {
|
|
return;
|
|
}
|
|
|
|
return Promise.all( [
|
|
apiFetch( {
|
|
path: '/wc/private/ai/patterns',
|
|
method: 'DELETE',
|
|
} ),
|
|
apiFetch( {
|
|
path: '/wc/private/ai/products',
|
|
method: 'DELETE',
|
|
} ),
|
|
] );
|
|
};
|
|
|
|
export const updateStorePatterns = async (
|
|
context: designWithAiStateMachineContext
|
|
) => {
|
|
try {
|
|
// TODO: Probably move this to a more appropriate place with a check. We should set this when the user granted permissions during the onboarding phase.
|
|
await dispatch( OPTIONS_STORE_NAME ).updateOptions( {
|
|
woocommerce_blocks_allow_ai_connection: 'yes',
|
|
} );
|
|
|
|
const { images } = await apiFetch< {
|
|
ai_content_generated: boolean;
|
|
images: { images: Array< unknown >; search_term: string };
|
|
} >( {
|
|
path: '/wc/private/ai/images',
|
|
method: 'POST',
|
|
data: {
|
|
business_description:
|
|
context.businessInfoDescription.descriptionText,
|
|
},
|
|
} );
|
|
|
|
const { is_ai_generated } = await apiFetch< {
|
|
is_ai_generated: boolean;
|
|
} >( {
|
|
path: '/wc/private/ai/store-info',
|
|
method: 'GET',
|
|
} );
|
|
|
|
if ( ! images ) {
|
|
if ( ! is_ai_generated ) {
|
|
throw new Error(
|
|
'AI content not generated: images not available'
|
|
);
|
|
}
|
|
|
|
await resetPatternsAndProducts()();
|
|
return;
|
|
}
|
|
|
|
const [ response ] = await Promise.all< {
|
|
ai_content_generated: boolean;
|
|
product_content: Array< {
|
|
title: string;
|
|
description: string;
|
|
image: {
|
|
src: string;
|
|
alt: string;
|
|
};
|
|
} >;
|
|
additional_errors?: unknown[];
|
|
} >( [
|
|
apiFetch( {
|
|
path: '/wc/private/ai/products',
|
|
method: 'POST',
|
|
data: {
|
|
business_description:
|
|
context.businessInfoDescription.descriptionText,
|
|
images,
|
|
},
|
|
} ),
|
|
apiFetch( {
|
|
path: '/wc/private/ai/patterns',
|
|
method: 'POST',
|
|
data: {
|
|
business_description:
|
|
context.businessInfoDescription.descriptionText,
|
|
images,
|
|
},
|
|
} ),
|
|
] );
|
|
|
|
const productContents = response.product_content.map(
|
|
( product, index ) => {
|
|
return apiFetch( {
|
|
path: '/wc/private/ai/product',
|
|
method: 'POST',
|
|
data: {
|
|
products_information: product,
|
|
last_product:
|
|
index === response.product_content.length - 1,
|
|
},
|
|
} );
|
|
}
|
|
);
|
|
|
|
await Promise.all( [
|
|
...productContents,
|
|
apiFetch( {
|
|
path: '/wc-admin/ai/business-description',
|
|
method: 'POST',
|
|
data: {
|
|
business_description:
|
|
context.businessInfoDescription.descriptionText,
|
|
},
|
|
} ),
|
|
apiFetch( {
|
|
path: '/wc-admin/ai/store-title',
|
|
method: 'POST',
|
|
data: {
|
|
business_description:
|
|
context.businessInfoDescription.descriptionText,
|
|
},
|
|
} ),
|
|
] );
|
|
|
|
if ( ! response.ai_content_generated ) {
|
|
throw new Error(
|
|
'AI content not generated: ' + response.additional_errors
|
|
? JSON.stringify( response.additional_errors )
|
|
: ''
|
|
);
|
|
}
|
|
} catch ( error ) {
|
|
trackEvent( 'customize_your_store_update_store_pattern_api_error', {
|
|
error: error instanceof Error ? error.message : 'unknown',
|
|
} );
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
// Update the current global styles of theme
|
|
const updateGlobalStyles = async ( {
|
|
colorPaletteName = COLOR_PALETTES[ 0 ].title,
|
|
fontPairingName = FONT_PAIRINGS[ 0 ].title,
|
|
}: {
|
|
colorPaletteName: string;
|
|
fontPairingName: string;
|
|
} ) => {
|
|
const colorPalette = COLOR_PALETTES.find(
|
|
( palette ) => palette.title === colorPaletteName
|
|
);
|
|
const fontPairing = FONT_PAIRINGS.find(
|
|
( pairing ) => pairing.title === fontPairingName
|
|
);
|
|
|
|
// @ts-ignore No types for this exist yet.
|
|
const { invalidateResolutionForStoreSelector } = dispatch( coreStore );
|
|
invalidateResolutionForStoreSelector(
|
|
'__experimentalGetCurrentGlobalStylesId'
|
|
);
|
|
|
|
const globalStylesId = await resolveSelect(
|
|
coreStore
|
|
// @ts-ignore No types for this exist yet.
|
|
).__experimentalGetCurrentGlobalStylesId();
|
|
|
|
// @ts-ignore No types for this exist yet.
|
|
const { saveEntityRecord } = dispatch( coreStore );
|
|
|
|
await saveEntityRecord(
|
|
'root',
|
|
'globalStyles',
|
|
{
|
|
id: globalStylesId,
|
|
styles: mergeBaseAndUserConfigs(
|
|
colorPalette?.styles || {},
|
|
fontPairing?.styles || {}
|
|
),
|
|
settings: mergeBaseAndUserConfigs(
|
|
colorPalette?.settings || {},
|
|
fontPairing?.settings || {}
|
|
),
|
|
},
|
|
{
|
|
throwOnError: true,
|
|
}
|
|
);
|
|
};
|
|
|
|
export const assembleSite = async (
|
|
context: designWithAiStateMachineContext
|
|
) => {
|
|
try {
|
|
await updateGlobalStyles( {
|
|
colorPaletteName: context.aiSuggestions.defaultColorPalette.default,
|
|
fontPairingName: context.aiSuggestions.fontPairing,
|
|
} );
|
|
trackEvent( 'customize_your_store_ai_update_global_styles_success' );
|
|
} catch ( error ) {
|
|
// eslint-disable-next-line no-console
|
|
console.error( error );
|
|
trackEvent(
|
|
'customize_your_store_ai_update_global_styles_response_error',
|
|
{
|
|
error: error instanceof Error ? error.message : 'unknown',
|
|
}
|
|
);
|
|
throw error;
|
|
}
|
|
|
|
try {
|
|
await updateTemplate( {
|
|
// TODO: Get from context
|
|
homepageTemplateId: 'template1' as keyof typeof HOMEPAGE_TEMPLATES,
|
|
} );
|
|
trackEvent( 'customize_your_store_ai_update_template_success' );
|
|
} catch ( error ) {
|
|
// eslint-disable-next-line no-console
|
|
console.error( error );
|
|
trackEvent( 'customize_your_store_ai_update_template_response_error', {
|
|
error: error instanceof Error ? error.message : 'unknown',
|
|
} );
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
const installAndActivateTheme = async () => {
|
|
try {
|
|
await setTheme( THEME_SLUG );
|
|
} catch ( error ) {
|
|
trackEvent(
|
|
'customize_your_store_ai_install_and_activate_theme_error',
|
|
{
|
|
theme: THEME_SLUG,
|
|
error: error instanceof Error ? error.message : 'unknown',
|
|
}
|
|
);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
const saveAiResponseToOption = ( context: designWithAiStateMachineContext ) => {
|
|
return dispatch( OPTIONS_STORE_NAME ).updateOptions( {
|
|
woocommerce_customize_store_ai_suggestions: {
|
|
...context.aiSuggestions,
|
|
lookAndFeel: context.lookAndFeel.choice,
|
|
},
|
|
} );
|
|
};
|
|
|
|
export const services = {
|
|
browserPopstateHandler,
|
|
queryAiEndpoint,
|
|
assembleSite,
|
|
updateStorePatterns,
|
|
saveAiResponseToOption,
|
|
installAndActivateTheme,
|
|
resetPatternsAndProducts,
|
|
installPatterns,
|
|
};
|