@wp-typia/project-tools 0.14.0 → 0.15.1

package/templates/_shared/persistence/core/src/interactivity.ts.mustache

@@ -1,17 +1,23 @@
 import { getContext, store } from '@wordpress/interactivity';
 import { generatePublicWriteRequestId } from '@wp-typia/block-runtime/identifiers';
 
-import { fetchState, writeState } from './api';
-import type { {{pascalCase}}Context, {{pascalCase}}State } from './types';
+import { fetchBootstrap, fetchState, writeState } from './api';
+import type {
+	{{pascalCase}}ClientState,
+	{{pascalCase}}Context,
+	{{pascalCase}}State,
+} from './types';
+import type {
+	{{pascalCase}}WriteStateRequest,
+} from './api-types';
 
 function hasExpiredPublicWriteToken(
-	context: {{pascalCase}}Context
+	expiresAt?: number
 ): boolean {
 	return (
-		context.persistencePolicy === 'public' &&
-		typeof context.publicWriteExpiresAt === 'number' &&
-		context.publicWriteExpiresAt > 0 &&
-		Date.now() >= context.publicWriteExpiresAt * 1000
+		typeof expiresAt === 'number' &&
+		expiresAt > 0 &&
+		Date.now() >= expiresAt * 1000
 	);
 }
 
@@ -20,102 +26,248 @@ function getWriteBlockedMessage(
 ): string {
 	return context.persistencePolicy === 'authenticated'
 		? 'Sign in to persist this counter.'
-		: 'Reload the page to refresh this write token.';
+		: 'Public writes are temporarily unavailable.';
+}
+
+const BOOTSTRAP_MAX_ATTEMPTS = 3;
+const BOOTSTRAP_RETRY_DELAYS_MS = [ 250, 500 ];
+
+async function waitForBootstrapRetry( delayMs: number ): Promise< void > {
+	await new Promise( ( resolve ) => {
+		setTimeout( resolve, delayMs );
+	} );
+}
+
+function getClientState(
+	context: {{pascalCase}}Context
+): {{pascalCase}}ClientState {
+	if ( context.client ) {
+		return context.client;
+	}
+
+	context.client = {
+		bootstrapError: '',
+		writeExpiry: 0,
+		writeNonce: '',
+		writeToken: '',
+	};
+
+	return context.client;
+}
+
+function clearBootstrapError(
+	context: {{pascalCase}}Context,
+	clientState: {{pascalCase}}ClientState
+): void {
+	if ( context.error === clientState.bootstrapError ) {
+		context.error = '';
+	}
+	clientState.bootstrapError = '';
+}
+
+function setBootstrapError(
+	context: {{pascalCase}}Context,
+	clientState: {{pascalCase}}ClientState,
+	message: string
+): void {
+	clientState.bootstrapError = message;
+	context.error = message;
 }
 
 const { actions, state } = store( '{{slugKebabCase}}', {
 	state: {
-		canWrite: false,
-		count: 0,
-		error: undefined,
 		isHydrated: false,
-		isLoading: false,
-		isSaving: false,
-		isVisible: true,
 	} as {{pascalCase}}State,
 
 	actions: {
-		async loadCounter() {
+		async loadState() {
 			const context = getContext< {{pascalCase}}Context >();
 			if ( context.postId <= 0 || ! context.resourceKey ) {
 				return;
 			}
 
-			state.isLoading = true;
-			state.error = undefined;
+			context.isLoading = true;
+			context.error = '';
 
 			try {
 				const result = await fetchState( {
 					postId: context.postId,
 					resourceKey: context.resourceKey,
 				}, {
-					restNonce: context.restNonce,
 					transportTarget: 'frontend',
 				} );
 				if ( ! result.isValid || ! result.data ) {
-					state.error = result.errors[ 0 ]?.expected ?? 'Unable to load counter';
+					context.error = result.errors[ 0 ]?.expected ?? 'Unable to load counter';
 					return;
 				}
 				context.count = result.data.count;
-				context.storage = result.data.storage;
-				state.count = result.data.count;
 			} catch ( error ) {
-				state.error =
+				context.error =
 					error instanceof Error ? error.message : 'Unknown loading error';
 			} finally {
-				state.isLoading = false;
+				context.isLoading = false;
+			}
+		},
+		async loadBootstrap() {
+			const context = getContext< {{pascalCase}}Context >();
+			const clientState = getClientState( context );
+			if ( context.postId <= 0 || ! context.resourceKey ) {
+				context.bootstrapReady = true;
+				context.canWrite = false;
+				clientState.bootstrapError = '';
+				clientState.writeExpiry = 0;
+				clientState.writeNonce = '';
+				clientState.writeToken = '';
+				return;
+			}
+
+			context.isBootstrapping = true;
+
+			let bootstrapSucceeded = false;
+			let lastBootstrapError =
+				'Unable to initialize write access';
+			const includeRestNonce = {{isAuthenticatedPersistencePolicy}};
+
+			for ( let attempt = 1; attempt <= BOOTSTRAP_MAX_ATTEMPTS; attempt += 1 ) {
+				try {
+					const result = await fetchBootstrap( {
+						postId: context.postId,
+						resourceKey: context.resourceKey,
+					}, {
+						transportTarget: 'frontend',
+					} );
+					if ( ! result.isValid || ! result.data ) {
+						lastBootstrapError =
+							result.errors[ 0 ]?.expected ??
+							'Unable to initialize write access';
+						if ( attempt < BOOTSTRAP_MAX_ATTEMPTS ) {
+							await waitForBootstrapRetry(
+								BOOTSTRAP_RETRY_DELAYS_MS[ attempt - 1 ] ?? 750
+							);
+							continue;
+						}
+						break;
+					}
+
+					clientState.writeExpiry =
+						typeof result.data.publicWriteExpiresAt === 'number' &&
+						result.data.publicWriteExpiresAt > 0
+							? result.data.publicWriteExpiresAt
+							: 0;
+					clientState.writeToken =
+						typeof result.data.publicWriteToken === 'string' &&
+						result.data.publicWriteToken.length > 0
+							? result.data.publicWriteToken
+							: '';
+					clientState.writeNonce =
+						includeRestNonce &&
+						'restNonce' in result.data &&
+						typeof result.data.restNonce === 'string' &&
+						result.data.restNonce.length > 0
+							? result.data.restNonce
+							: '';
+					context.bootstrapReady = true;
+					context.canWrite =
+						result.data.canWrite === true &&
+						(
+							context.persistencePolicy === 'authenticated'
+								? clientState.writeNonce.length > 0
+								: clientState.writeToken.length > 0 &&
+									! hasExpiredPublicWriteToken( clientState.writeExpiry )
+						);
+					clearBootstrapError( context, clientState );
+					bootstrapSucceeded = true;
+					break;
+				} catch ( error ) {
+					lastBootstrapError =
+						error instanceof Error ? error.message : 'Unknown bootstrap error';
+					if ( attempt < BOOTSTRAP_MAX_ATTEMPTS ) {
+						await waitForBootstrapRetry(
+							BOOTSTRAP_RETRY_DELAYS_MS[ attempt - 1 ] ?? 750
+						);
+						continue;
+					}
+					break;
+				}
+			}
+
+			if ( ! bootstrapSucceeded ) {
+				context.bootstrapReady = false;
+				context.canWrite = false;
+				clientState.writeExpiry = 0;
+				clientState.writeNonce = '';
+				clientState.writeToken = '';
+				setBootstrapError( context, clientState, lastBootstrapError );
 			}
+			context.isBootstrapping = false;
 		},
 		async increment() {
 			const context = getContext< {{pascalCase}}Context >();
+			const clientState = getClientState( context );
 			if ( context.postId <= 0 || ! context.resourceKey ) {
 				return;
 			}
-			if ( hasExpiredPublicWriteToken( context ) ) {
+			if ( ! context.bootstrapReady ) {
+				await actions.loadBootstrap();
+			}
+			if ( ! context.bootstrapReady ) {
+				context.error = 'Write access is still initializing.';
+				return;
+			}
+			if (
+				context.persistencePolicy === 'public' &&
+				hasExpiredPublicWriteToken( clientState.writeExpiry )
+			) {
+				await actions.loadBootstrap();
+			}
+			if (
+				context.persistencePolicy === 'public' &&
+				hasExpiredPublicWriteToken( clientState.writeExpiry )
+			) {
 				context.canWrite = false;
-				state.canWrite = false;
-				state.error = getWriteBlockedMessage( context );
+				context.error = getWriteBlockedMessage( context );
 				return;
 			}
-			if ( ! context.canWrite || ! state.canWrite ) {
-				state.error = getWriteBlockedMessage( context );
+			if ( ! context.canWrite ) {
+				context.error = getWriteBlockedMessage( context );
 				return;
 			}
 
-			state.isSaving = true;
-			state.error = undefined;
+			context.isSaving = true;
+			context.error = '';
 
 			try {
-				const result = await writeState( {
+				const request = {
 					delta: 1,
 					postId: context.postId,
-					publicWriteRequestId:
-						context.persistencePolicy === 'public'
-							? generatePublicWriteRequestId()
-							: undefined,
-					publicWriteToken:
-						context.persistencePolicy === 'public' &&
-						typeof context.publicWriteToken === 'string' &&
-						context.publicWriteToken.length > 0
-							? context.publicWriteToken
-							: undefined,
 					resourceKey: context.resourceKey,
-				}, {
-					restNonce: context.restNonce,
+				} as {{pascalCase}}WriteStateRequest;
+				if ( {{isPublicPersistencePolicy}} ) {
+					request.publicWriteRequestId =
+						generatePublicWriteRequestId() as {{pascalCase}}WriteStateRequest[ 'publicWriteRequestId' ];
+					if ( clientState.writeToken.length > 0 ) {
+						request.publicWriteToken =
+							clientState.writeToken as {{pascalCase}}WriteStateRequest[ 'publicWriteToken' ];
+					}
+				}
+				const result = await writeState( request, {
+					restNonce:
+						clientState.writeNonce.length > 0
+							? clientState.writeNonce
+							: undefined,
 					transportTarget: 'frontend',
 				} );
 				if ( ! result.isValid || ! result.data ) {
-					state.error = result.errors[ 0 ]?.expected ?? 'Unable to update counter';
+					context.error = result.errors[ 0 ]?.expected ?? 'Unable to update counter';
 					return;
 				}
 				context.count = result.data.count;
 				context.storage = result.data.storage;
-				state.count = result.data.count;
 			} catch ( error ) {
-				state.error =
+				context.error =
 					error instanceof Error ? error.message : 'Unknown update error';
 			} finally {
-				state.isSaving = false;
+				context.isSaving = false;
 			}
 		},
 	},
@@ -123,18 +275,29 @@ const { actions, state } = store( '{{slugKebabCase}}', {
 	callbacks: {
 		init() {
 			const context = getContext< {{pascalCase}}Context >();
-			context.canWrite =
-				context.canWrite && ! hasExpiredPublicWriteToken( context );
-			state.canWrite = context.canWrite;
-			state.isVisible = context.isVisible;
-			state.count = context.count;
+			context.client = {
+				bootstrapError: '',
+				writeExpiry: 0,
+				writeNonce: '',
+				writeToken: '',
+			};
+			context.bootstrapReady = false;
+			context.canWrite = false;
+			context.count = 0;
+			context.error = '';
+			context.isBootstrapping = false;
+			context.isLoading = false;
+			context.isSaving = false;
 		},
 		mounted() {
 			state.isHydrated = true;
 			if ( typeof document !== 'undefined' ) {
 				document.documentElement.dataset[ '{{slugCamelCase}}Hydrated' ] = 'true';
 			}
-			void actions.loadCounter();
+			void Promise.allSettled( [
+				actions.loadState(),
+				actions.loadBootstrap(),
+			] );
 		},
 	},
 } );

package/templates/_shared/persistence/public/{{slugKebabCase}}.php.mustache

@@ -200,6 +200,126 @@ function {{phpPrefix}}_build_state_response( $post_id, $resource_key, $count ) {
 	);
 }
 
+function {{phpPrefix}}_block_tree_has_resource_key( $blocks, $block_name, $resource_key ) {
+	if ( ! is_array( $blocks ) ) {
+		return false;
+	}
+
+	foreach ( $blocks as $block ) {
+		if ( ! is_array( $block ) ) {
+			continue;
+		}
+
+		if ( (string) ( $block['blockName'] ?? '' ) === $block_name ) {
+			$attributes = isset( $block['attrs'] ) && is_array( $block['attrs'] ) ? $block['attrs'] : array();
+			$candidate_resource_key = array_key_exists( 'resourceKey', $attributes )
+				? (string) $attributes['resourceKey']
+				: 'primary';
+			if ( (string) $resource_key === $candidate_resource_key ) {
+				return true;
+			}
+		}
+
+		if (
+			isset( $block['innerBlocks'] ) &&
+			{{phpPrefix}}_block_tree_has_resource_key( $block['innerBlocks'], $block_name, $resource_key )
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function {{phpPrefix}}_get_rendered_block_instance_key( $post_id, $block_name, $resource_key ) {
+	return 'wpt_pri_' . md5( implode( '|', array( (string) $block_name, (int) $post_id, (string) $resource_key ) ) );
+}
+
+function {{phpPrefix}}_record_rendered_block_instance( $post_id, $block_name, $resource_key ) {
+	if ( $post_id <= 0 || '' === (string) $resource_key || '' === (string) $block_name ) {
+		return;
+	}
+
+	set_transient(
+		{{phpPrefix}}_get_rendered_block_instance_key( $post_id, $block_name, $resource_key ),
+		1,
+		5 * MINUTE_IN_SECONDS
+	);
+}
+
+function {{phpPrefix}}_has_rendered_block_instance( $post_id, $resource_key ) {
+	if ( $post_id <= 0 || '' === (string) $resource_key ) {
+		return false;
+	}
+
+	if (
+		false !== get_transient(
+			{{phpPrefix}}_get_rendered_block_instance_key(
+				$post_id,
+				'{{namespace}}/{{slugKebabCase}}',
+				$resource_key
+			)
+		)
+	) {
+		return true;
+	}
+
+	$post = get_post( $post_id );
+	if ( ! ( $post instanceof WP_Post ) ) {
+		return false;
+	}
+
+	if ( ! is_post_publicly_viewable( $post ) ) {
+		return false;
+	}
+
+	return {{phpPrefix}}_block_tree_has_resource_key(
+		parse_blocks( (string) $post->post_content ),
+		'{{namespace}}/{{slugKebabCase}}',
+		(string) $resource_key
+	);
+}
+
+function {{phpPrefix}}_build_bootstrap_response( $post_id, $resource_key ) {
+	$response = array(
+		'canWrite' => false,
+	);
+	$post = get_post( $post_id );
+
+	if (
+		$post_id <= 0 ||
+		! ( $post instanceof WP_Post ) ||
+		! is_post_publicly_viewable( $post ) ||
+		! function_exists( '{{phpPrefix}}_create_public_write_token' ) ||
+		! {{phpPrefix}}_has_rendered_block_instance( (int) $post_id, (string) $resource_key )
+	) {
+		return $response;
+	}
+
+	$public_write = {{phpPrefix}}_create_public_write_token( (int) $post_id, (string) $resource_key );
+	if ( ! is_array( $public_write ) ) {
+		return $response;
+	}
+
+	$token      = isset( $public_write['token'] ) ? (string) $public_write['token'] : '';
+	$expires_at = isset( $public_write['expiresAt'] ) ? (int) $public_write['expiresAt'] : 0;
+	$is_expired = $expires_at > 0 && $expires_at <= time();
+
+	if ( '' !== $token && $expires_at > 0 && ! $is_expired ) {
+		$response['publicWriteToken'] = $token;
+		$response['canWrite']         = true;
+	}
+
+	if ( $expires_at > 0 ) {
+		$response['publicWriteExpiresAt'] = $expires_at;
+		if ( $is_expired ) {
+			$response['canWrite'] = false;
+		}
+	}
+
+	return $response;
+}
+
 // Route handlers are the main product-level extension point for request/response shaping.
 function {{phpPrefix}}_handle_get_state( WP_REST_Request $request ) {
 	$payload = {{phpPrefix}}_validate_and_sanitize_request(
@@ -226,6 +346,33 @@ function {{phpPrefix}}_handle_get_state( WP_REST_Request $request ) {
 	);
 }
 
+function {{phpPrefix}}_handle_get_bootstrap( WP_REST_Request $request ) {
+	$payload = {{phpPrefix}}_validate_and_sanitize_request(
+		array(
+			'postId'      => $request->get_param( 'postId' ),
+			'resourceKey' => $request->get_param( 'resourceKey' ),
+		),
+		{{phpPrefix}}_get_rest_build_dir(),
+		'bootstrap-query',
+		'query'
+	);
+
+	if ( is_wp_error( $payload ) ) {
+		return $payload;
+	}
+
+	$response = rest_ensure_response(
+		{{phpPrefix}}_build_bootstrap_response(
+			(int) $payload['postId'],
+			(string) $payload['resourceKey']
+		)
+	);
+
+	$response->header( 'Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0, s-maxage=0' );
+	$response->header( 'Pragma', 'no-cache' );
+	return $response;
+}
+
 function {{phpPrefix}}_handle_write_state( WP_REST_Request $request ) {
 	$payload = {{phpPrefix}}_validate_and_sanitize_request(
 		$request->get_json_params(),
@@ -290,6 +437,18 @@ function {{phpPrefix}}_register_routes() {
 			),
 		)
 	);
+
+	register_rest_route(
+		'{{namespace}}/v1',
+		'/{{slugKebabCase}}/bootstrap',
+		array(
+			array(
+				'methods'             => WP_REST_Server::READABLE,
+				'callback'            => '{{phpPrefix}}_handle_get_bootstrap',
+				'permission_callback' => '__return_true',
+			),
+		)
+	);
 }
 
 function {{phpPrefix}}_register_block() {

package/templates/_shared/rest-helpers/public/inc/rest-public.php.mustache

@@ -234,7 +234,7 @@ function {{phpPrefix}}_verify_public_write_token( $token, $post_id, $resource_ke
 	if ( time() > $expires_at ) {
 		return new WP_Error(
 			'rest_forbidden',
-			'The public write token has expired. Reload the page and try again.',
+			'The public write token has expired. Refresh write access and try again.',
 			array( 'status' => 403 )
 		);
 	}

package/templates/_shared/workspace/persistence-auth/server.php.mustache

@@ -158,6 +158,105 @@ function {{phpPrefix}}_build_state_response( $post_id, $resource_key, $count ) {
 	);
 }
 
+function {{phpPrefix}}_block_tree_has_resource_key( $blocks, $block_name, $resource_key ) {
+	if ( ! is_array( $blocks ) ) {
+		return false;
+	}
+
+	foreach ( $blocks as $block ) {
+		if ( ! is_array( $block ) ) {
+			continue;
+		}
+
+		if ( (string) ( $block['blockName'] ?? '' ) === $block_name ) {
+			$attributes = isset( $block['attrs'] ) && is_array( $block['attrs'] ) ? $block['attrs'] : array();
+			$candidate_resource_key = array_key_exists( 'resourceKey', $attributes )
+				? (string) $attributes['resourceKey']
+				: 'primary';
+			if ( (string) $resource_key === $candidate_resource_key ) {
+				return true;
+			}
+		}
+
+		if (
+			isset( $block['innerBlocks'] ) &&
+			{{phpPrefix}}_block_tree_has_resource_key( $block['innerBlocks'], $block_name, $resource_key )
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function {{phpPrefix}}_get_rendered_block_instance_key( $post_id, $block_name, $resource_key ) {
+	return 'wpt_pri_' . md5( implode( '|', array( (string) $block_name, (int) $post_id, (string) $resource_key ) ) );
+}
+
+function {{phpPrefix}}_record_rendered_block_instance( $post_id, $block_name, $resource_key ) {
+	if ( $post_id <= 0 || '' === (string) $resource_key || '' === (string) $block_name ) {
+		return;
+	}
+
+	set_transient(
+		{{phpPrefix}}_get_rendered_block_instance_key( $post_id, $block_name, $resource_key ),
+		1,
+		5 * MINUTE_IN_SECONDS
+	);
+}
+
+function {{phpPrefix}}_has_rendered_block_instance( $post_id, $resource_key ) {
+	if ( $post_id <= 0 || '' === (string) $resource_key ) {
+		return false;
+	}
+
+	if (
+		false !== get_transient(
+			{{phpPrefix}}_get_rendered_block_instance_key(
+				$post_id,
+				'{{namespace}}/{{slugKebabCase}}',
+				$resource_key
+			)
+		)
+	) {
+		return true;
+	}
+
+	$post = get_post( $post_id );
+	if ( ! ( $post instanceof WP_Post ) ) {
+		return false;
+	}
+
+	return {{phpPrefix}}_block_tree_has_resource_key(
+		parse_blocks( (string) $post->post_content ),
+		'{{namespace}}/{{slugKebabCase}}',
+		(string) $resource_key
+	);
+}
+
+function {{phpPrefix}}_build_bootstrap_response( $post_id, $resource_key ) {
+	$post          = get_post( $post_id );
+	$can_read_post =
+		$post instanceof WP_Post &&
+		(
+			is_post_publicly_viewable( $post ) ||
+			current_user_can( 'read_post', $post->ID )
+		);
+	$can_write = $post_id > 0 &&
+		is_user_logged_in() &&
+		$can_read_post &&
+		{{phpPrefix}}_has_rendered_block_instance( (int) $post_id, (string) $resource_key );
+	$response  = array(
+		'canWrite' => $can_write,
+	);
+
+	if ( $can_write ) {
+		$response['restNonce'] = wp_create_nonce( 'wp_rest' );
+	}
+
+	return $response;
+}
+
 function {{phpPrefix}}_handle_get_state( WP_REST_Request $request ) {
 	$payload = {{phpPrefix}}_validate_and_sanitize_request(
 		array(
@@ -183,6 +282,34 @@ function {{phpPrefix}}_handle_get_state( WP_REST_Request $request ) {
 	);
 }
 
+function {{phpPrefix}}_handle_get_bootstrap( WP_REST_Request $request ) {
+	$payload = {{phpPrefix}}_validate_and_sanitize_request(
+		array(
+			'postId'      => $request->get_param( 'postId' ),
+			'resourceKey' => $request->get_param( 'resourceKey' ),
+		),
+		{{phpPrefix}}_get_rest_build_dir(),
+		'bootstrap-query',
+		'query'
+	);
+
+	if ( is_wp_error( $payload ) ) {
+		return $payload;
+	}
+
+	$response = rest_ensure_response(
+		{{phpPrefix}}_build_bootstrap_response(
+			(int) $payload['postId'],
+			(string) $payload['resourceKey']
+		)
+	);
+
+	$response->header( 'Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0, s-maxage=0' );
+	$response->header( 'Pragma', 'no-cache' );
+	$response->header( 'Vary', 'Cookie' );
+	return $response;
+}
+
 function {{phpPrefix}}_handle_write_state( WP_REST_Request $request ) {
 	$payload = {{phpPrefix}}_validate_and_sanitize_request(
 		$request->get_json_params(),
@@ -231,6 +358,18 @@ function {{phpPrefix}}_register_routes() {
 			),
 		)
 	);
+
+	register_rest_route(
+		'{{namespace}}/v1',
+		'/{{slugKebabCase}}/bootstrap',
+		array(
+			array(
+				'methods'             => WP_REST_Server::READABLE,
+				'callback'            => '{{phpPrefix}}_handle_get_bootstrap',
+				'permission_callback' => '__return_true',
+			),
+		)
+	);
 }
 
 add_action( 'init', '{{phpPrefix}}_ensure_storage_installed' );